@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-ME6HGG4I.mjs

@@ -0,0 +1,1338 @@
+import { TARGET_HZ, FLOW_WORDS, PrefetchLayer, FLOW_BACKLOG, FLOW_DELIVERED, SMOOTH_SHARE, STUTTER_SHARE, HOT_BUSY_SHARE, HOT_PRESSURE, WARM_BUSY_SHARE, WARM_PRESSURE, isCalibrated, passCauses, MEMORY_CEILING_BYTES, rankCauses, TIGHT_MEMORY_SHARE, calibrationFor } from './chunk-5BYDGGWO.mjs';
+import { HEAP_MEMORY } from './chunk-7SXOHAIR.mjs';
+import { MediumVolume } from './chunk-ATAWRACV.mjs';
+import { entityIndex, NO_ENTITY } from './chunk-T3AFF3L7.mjs';
+import { SH_COEFFICIENT_FLOATS, GPU_PASS_NAMES, createGpuStats } from './chunk-TL2SVO4P.mjs';
+import { FRAME_SECONDS_SLOT } from './chunk-IDLW4NWA.mjs';
+import { SCENERY_REGISTER, createVectorSurfaceStats } from './chunk-E65WCTIG.mjs';
+import './chunk-K4UDGE3Z.mjs';
+import { reusingDefinitions } from './chunk-K46SMZ66.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/ecs/component.ts
+var SIZE = 0, VERSION = 1, STORE_COUNTERS = 2, nextComponentId = 0, definedByName = /* @__PURE__ */ new Map();
+function sameSchema(a, b) {
+  let keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  for (let key of keys) {
+    let x = a[key], y = b[key];
+    if (typeof x == "string" || typeof y == "string") {
+      if (x !== y) return false;
+    } else if (y === void 0 || x[0] !== y[0] || x[1] !== y[1]) return false;
+  }
+  return true;
+}
+function defineComponent(name, schema) {
+  let existing = definedByName.get(name);
+  if (existing !== void 0 && reusingDefinitions() && sameSchema(existing.schema, schema)) return existing;
+  let type = { id: nextComponentId++, name, schema };
+  return definedByName.set(name, type), type;
+}
+function fieldArity(spec) {
+  return typeof spec == "string" ? 1 : spec[1];
+}
+function fieldScalar(spec) {
+  return typeof spec == "string" ? spec : spec[0];
+}
+var ComponentStore = class {
+  constructor(type, capacity, entityCapacity, memory = HEAP_MEMORY) {
+    this.counters = new Uint32Array((2));
+    this.type = type, this.capacity = capacity, this.entities = memory.allocate("u32", capacity), this.sparse = memory.allocate("i32", entityCapacity).fill(-1);
+    let keys = Object.keys(type.schema);
+    this.arrays = [], this.arities = new Int32Array(keys.length);
+    let fields = {};
+    for (let i = 0; i < keys.length; i++) {
+      let spec = type.schema[keys[i]], arity = fieldArity(spec), array = memory.allocate(fieldScalar(spec), capacity * arity);
+      this.arrays.push(array), this.arities[i] = arity, fields[keys[i]] = array;
+    }
+    this.fields = fields, this.views = [this.counters, this.entities, this.sparse, ...this.arrays];
+  }
+  get count() {
+    return this.counters[(0)];
+  }
+  get version() {
+    return this.counters[(1)];
+  }
+  rollbackViews() {
+    return this.views;
+  }
+  row(entity) {
+    let index = entityIndex(entity);
+    if (index >= this.sparse.length) return -1;
+    let row = this.sparse[index];
+    return row !== -1 && this.entities[row] === entity ? row : -1;
+  }
+  has(entity) {
+    return this.row(entity) !== -1;
+  }
+  require(entity) {
+    let row = this.row(entity);
+    if (row === -1)
+      throw new GameError("missing_component", `entity ${entity} has no ${this.type.name}`);
+    return row;
+  }
+  add(entity) {
+    let existing = this.row(entity);
+    if (existing !== -1) return existing;
+    let c = this.counters;
+    if (c[(0)] >= this.capacity)
+      throw new GameError(
+        "capacity_exceeded",
+        `component ${this.type.name} capacity ${this.capacity} reached`
+      );
+    let row = c[(0)]++;
+    this.entities[row] = entity, this.sparse[entityIndex(entity)] = row;
+    for (let i = 0; i < this.arrays.length; i++) {
+      let arity = this.arities[i];
+      this.arrays[i].fill(0, row * arity, row * arity + arity);
+    }
+    return c[(1)]++, row;
+  }
+  remove(entity) {
+    let row = this.row(entity);
+    if (row === -1) return false;
+    let c = this.counters, last = --c[(0)];
+    if (row !== last) {
+      let moved = this.entities[last];
+      this.entities[row] = moved, this.sparse[entityIndex(moved)] = row;
+      for (let i = 0; i < this.arrays.length; i++) {
+        let arity = this.arities[i];
+        this.arrays[i].copyWithin(row * arity, last * arity, last * arity + arity);
+      }
+    }
+    return this.sparse[entityIndex(entity)] = -1, c[(1)]++, true;
+  }
+  entityAt(row) {
+    return this.entities[row];
+  }
+};
+
+// src/game/scenery/scenery.ts
+var DEFAULT_MOTION_OFFSET = ["dx", "dy", "dz"], DEFAULT_MOTION_REST = ["rx", "ry", "rz"], MILLIMETRES_PER_METRE = 1e3, NO_RIG = 0, SCENERY_MANIFEST_MAGIC = 1297109827, SCENERY_MANIFEST_VERSION = 1, SCENERY_MANIFEST_VERSION_PARTS = 2, SCENERY_PART_WHOLE = 255, SCENERY_PART_COARSE = 0, SCENERY_PART_MIDDLE = 1, SCENERY_PART_FINE = 2, PART_FIELD = 20, PART_MASK = 255, GROUP_SHIFT = 8, SCENERY_LEVEL_STEP = 3, SCENERY_CHUNK_EXTENSION = ".cspl", HEADER_BYTES = 32, ENTRY_BYTES = 80, DIGEST_OFFSET = 48, DIGEST_BYTES = 32, VERSION_FIELD = 4, COUNT_FIELD = 8, CELL_SIZE_FIELD = 12, ORIGIN_X_FIELD = 16, ORIGIN_Z_FIELD = 20, COLS_FIELD = 24, ROWS_FIELD = 28, KIB = 1024, HEX_RADIX = 16, BYTE_VALUES = 256, ABSOLUTE = /^[a-z][a-z0-9+.-]*:/i, HEX = Array.from({ length: (256) }, (_, i) => i.toString((16)).padStart(2, "0")), CLOSED_REGISTERS = new Uint32Array(20);
+function sceneryPartDrawLevel(part) {
+  return part === (1) ? 1 : part === (2) ? 0 : 2;
+}
+function sceneryPartReach(part, radii) {
+  let level = sceneryPartDrawLevel(part);
+  return level === 0 ? radii.near : level === 1 ? radii.near * (3) : radii.far;
+}
+function sceneryEntryRows(manifest, count) {
+  let rows = Array.from({ length: count }, (_, i) => i), groups = manifest.groups, parts = manifest.parts;
+  return groups !== void 0 && parts !== void 0 && rows.sort((a, b) => groups[a] - groups[b] || parts[a] - parts[b] || a - b), Int32Array.from(rows);
+}
+var ENTRY_BYTES_FIELD = 16, ENTRY_MIN_FIELD = 24, BOUND_FLOATS = 6, SCENERY_LOAD_SHARE = 1.1, SCENERY_UNLOAD_SHARE = 1.35, SCENERY_NEED_SHARE = 3, SCENERY_TIER_RADII = [
+  { near: 40, far: 600 },
+  { near: 25, far: 350 },
+  { near: 14, far: 180 }
+];
+function sceneryTierRadii(tier) {
+  return SCENERY_TIER_RADII[Math.min(SCENERY_TIER_RADII.length - 1, Math.max(0, tier))];
+}
+function sceneryPrefetchItems(manifest, paths, radii = SCENERY_TIER_RADII[0]) {
+  let items = [], b = manifest.bounds, rows = sceneryEntryRows(manifest, paths.length), start = 0;
+  for (; start < rows.length; ) {
+    let group = manifest.groups?.[rows[start]] ?? rows[start], end = start + 1;
+    for (; end < rows.length && manifest.groups !== void 0 && manifest.groups[rows[end]] === group; ) end++;
+    let lo = [1 / 0, 1 / 0, 1 / 0], hi = [-1 / 0, -1 / 0, -1 / 0], levels = [];
+    for (let k = start; k < end; k++) {
+      let row = rows[k];
+      for (let axis = 0; axis < 3; axis++)
+        lo[axis] = Math.min(lo[axis], b[row * (6) + axis]), hi[axis] = Math.max(hi[axis], b[row * (6) + 3 + axis]);
+      let part = manifest.parts?.[row] ?? (255), fine = part === (1) || part === (2);
+      levels.push(fine ? { path: paths[row], bytes: manifest.bytes[row], within: sceneryPartReach(part, radii) * (1.1) } : { path: paths[row], bytes: manifest.bytes[row] });
+    }
+    let dx = hi[0] - lo[0], dy = hi[1] - lo[1], dz = hi[2] - lo[2];
+    items.push({
+      center: [(lo[0] + hi[0]) * 0.5, (lo[1] + hi[1]) * 0.5, (lo[2] + hi[2]) * 0.5],
+      radius: Math.sqrt(dx * dx + dy * dy + dz * dz) * 0.5,
+      bytes: manifest.bytes[rows[start]],
+      levels
+    }), start = end;
+  }
+  return items;
+}
+function sceneryFirstView(manifest, paths, view, radius) {
+  let items = sceneryPrefetchItems(manifest, paths), near = [];
+  for (let item of items) {
+    let gap = Math.hypot(item.center[0] - view[0], item.center[1] - view[1], item.center[2] - view[2]) - (item.radius ?? 0);
+    gap <= radius && near.push({ path: item.levels[0].path, gap });
+  }
+  return near.sort((a, b) => a.gap - b.gap || (a.path < b.path ? -1 : 1)), near.map((entry) => entry.path);
+}
+function malformed(reason) {
+  return new GameError("invalid_argument", `the scenery manifest is malformed: ${reason}`);
+}
+function digestName(bytes, at) {
+  let out = "";
+  for (let i = 0; i < (32); i++) out += HEX[bytes[at + i]];
+  return out + SCENERY_CHUNK_EXTENSION;
+}
+function parseSceneryManifest(bytes) {
+  if (bytes.byteLength < (32)) throw malformed("too short");
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(0, true) !== (1297109827)) throw malformed("not a CSPM file");
+  let version = view.getUint32((4), true);
+  if (version !== (1) && version !== (2)) throw malformed(`version ${version} is not supported`);
+  let count = view.getUint32((8), true);
+  if (bytes.byteLength < (32) + count * (80)) throw malformed(`${count} entries do not fit`);
+  let chunks = Array.from({ length: count }, (_, i) => digestName(bytes, (32) + i * (80) + (48))), bounds = new Float32Array(count * (6)), sizes = new Uint32Array(count), parts = new Uint8Array(count).fill((255)), groups = new Uint32Array(count);
+  for (let i = 0; i < count; i++) {
+    let at = (32) + i * (80);
+    sizes[i] = view.getUint32(at + (16), true);
+    for (let k = 0; k < (6); k++) bounds[i * (6) + k] = view.getFloat32(at + (24) + 4 * k, true);
+    if (groups[i] = i, version !== (2)) continue;
+    let tag = view.getUint32(at + (20), true), part = tag & (255);
+    if (part > (2)) throw malformed(`entry ${i} has part ${part}`);
+    parts[i] = part, groups[i] = tag >>> (8);
+  }
+  return {
+    bounds,
+    bytes: sizes,
+    parts,
+    groups,
+    grid: {
+      cellSize: view.getFloat32((12), true),
+      origin: [view.getFloat32((16), true), view.getFloat32((20), true)],
+      cols: view.getUint32((24), true),
+      rows: view.getUint32((28), true)
+    },
+    chunks
+  };
+}
+function sibling(manifest, name) {
+  if (ABSOLUTE.test(manifest)) return new URL(name, manifest).href;
+  let slash = manifest.lastIndexOf("/");
+  return slash < 0 ? name : manifest.slice(0, slash + 1) + name;
+}
+async function fetchBytes(url) {
+  let response = await fetch(url);
+  if (!response.ok) throw new GameError("asset_load_failed", `scenery ${url} failed with ${response.status}`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+var DEFAULT_CACHE_BYTES = 8 * 1024 * 1024, ENGINE_ABSENT = 0, ENGINE_REQUESTED = 1, ENGINE_PROVIDED = 2, SWEEP_PER_FRAME = 256, SPHERE_FLOATS = 4, PRIORITY_NOW = 0, PRIORITY_SOON = 1, BUDGET_REASON = "budget";
+function overBudget(error) {
+  return typeof error == "object" && error !== null && error.reason === BUDGET_REASON;
+}
+var SceneryChunks = class {
+  constructor(assets, cacheBytes = DEFAULT_CACHE_BYTES) {
+    this.assets = assets;
+    this.cacheBytes = cacheBytes;
+    this.kept = /* @__PURE__ */ new Map();
+    this.cache = /* @__PURE__ */ new Map();
+    this.cached = 0;
+  }
+  lazy(path) {
+    let assets = this.assets;
+    return assets !== null && assets.requests?.() === true && assets.lazy?.(path) === true;
+  }
+  read(path, priority = (0)) {
+    let assets = this.assets;
+    if (assets === null) return fetchBytes(path);
+    if (!this.lazy(path)) return this.retained(assets, path);
+    let hit = this.cache.get(path);
+    return hit !== void 0 ? (this.cache.delete(path), this.cache.set(path, hit), Promise.resolve(hit)) : assets.take(path, priority, false).catch((error) => {
+      if (!overBudget(error) || !this.reclaim()) throw error;
+      return assets.take(path, priority, false);
+    });
+  }
+  holds(path) {
+    return this.cache.has(path);
+  }
+  get reader() {
+    return this.assets;
+  }
+  retained(assets, path) {
+    let known = this.kept.get(path);
+    if (known !== void 0) return known;
+    let taken = assets.take(path);
+    return this.kept.set(path, taken), taken.catch(() => this.kept.delete(path)), taken;
+  }
+  delivered(path, bytes) {
+    if (!(!this.lazy(path) || this.cache.has(path)))
+      for (this.cache.set(path, bytes), this.cached += bytes.byteLength; this.cached > this.cacheBytes && this.cache.size > 0; ) this.evictColdest();
+  }
+  reclaim() {
+    let target = Math.floor(this.cache.size / 2);
+    if (this.cache.size === 0) return false;
+    for (; this.cache.size > target; ) this.evictColdest();
+    return true;
+  }
+  evictColdest() {
+    for (let [path, bytes] of this.cache) {
+      this.cache.delete(path), this.cached -= bytes.byteLength, this.assets?.release?.(path);
+      return;
+    }
+  }
+  get cachedBytes() {
+    return this.cached;
+  }
+  close() {
+    for (; this.cache.size > 0; ) this.evictColdest();
+    this.kept.clear();
+  }
+}, Stats = class {
+  constructor(read) {
+    this.read = read;
+  }
+  get chunks() {
+    return this.read()[SCENERY_REGISTER.chunks];
+  }
+  get resident() {
+    return this.read()[SCENERY_REGISTER.resident];
+  }
+  get requested() {
+    return this.read()[SCENERY_REGISTER.requested];
+  }
+  get installed() {
+    return this.read()[SCENERY_REGISTER.installed];
+  }
+  get evicted() {
+    return this.read()[SCENERY_REGISTER.evicted];
+  }
+  get deferred() {
+    return this.read()[SCENERY_REGISTER.deferred];
+  }
+  get failed() {
+    return this.read()[SCENERY_REGISTER.failed];
+  }
+  get installedBytes() {
+    return this.read()[SCENERY_REGISTER.installedKib] * (1024);
+  }
+  get residentSplats() {
+    return this.read()[SCENERY_REGISTER.residentSplats];
+  }
+  get drawnSplats() {
+    return this.read()[SCENERY_REGISTER.drawnSplats];
+  }
+  get listedPages() {
+    return this.read()[SCENERY_REGISTER.listedPages];
+  }
+  get poolCapacity() {
+    return this.read()[SCENERY_REGISTER.poolCapacity];
+  }
+  get poolFreePages() {
+    return this.read()[SCENERY_REGISTER.poolFreePages];
+  }
+  get tier() {
+    return this.read()[SCENERY_REGISTER.tier];
+  }
+  get updates() {
+    return this.read()[SCENERY_REGISTER.updates];
+  }
+  get heroSplats() {
+    return this.read()[SCENERY_REGISTER.heroSplats];
+  }
+  get heroShed() {
+    return this.read()[SCENERY_REGISTER.heroShed];
+  }
+  get standIn() {
+    return this.read()[SCENERY_REGISTER.standIn] !== 0;
+  }
+  get deformedSplats() {
+    return this.read()[SCENERY_REGISTER.deformedSplats];
+  }
+}, Scenery = class {
+  constructor(port, handle, manifest, chunkPaths, chunks, owner, options = {}) {
+    this.port = port;
+    this.handle = handle;
+    this.chunkPaths = chunkPaths;
+    this.chunks = chunks;
+    this.owner = owner;
+    this.requests = new Uint32Array(8);
+    this.transform = new Float32Array(8);
+    this.lastEye = new Float64Array(3);
+    this.registers = null;
+    this.predictor = null;
+    this.hasEye = false;
+    this.sweep = 0;
+    this.waiting = 0;
+    this.flow = new Float64Array(FLOW_WORDS);
+    this.closed = false;
+    this.editValues = new Float32Array(3);
+    this.standing = false;
+    this.kernel = null;
+    if (this.regionNames = options.regions ?? {}, this.standInTarget = options.standIn ?? null, options.heroBudget !== void 0) {
+      let caps = new Uint32Array(3);
+      caps.set(options.heroBudget), this.bodyPort().heroBudget(handle, caps);
+    }
+    this.grid = manifest.grid, this.stats = new Stats(() => this.view());
+    let rows = chunkPaths.length;
+    this.engineState = new Uint8Array(rows), this.entryRow = sceneryEntryRows(manifest, rows), this.rowBytes = manifest.bytes, this.rowPart = manifest.parts ?? new Uint8Array(rows).fill((255)), this.rowSphere = new Float32Array(rows * (4));
+    for (let i = 0; i < rows; i++) {
+      let b = manifest.bounds, at = i * (6), dx = b[at + 3] - b[at], dy = b[at + 4] - b[at + 1], dz = b[at + 5] - b[at + 2];
+      this.rowSphere[i * (4)] = (b[at] + b[at + 3]) * 0.5, this.rowSphere[i * (4) + 1] = (b[at + 1] + b[at + 4]) * 0.5, this.rowSphere[i * (4) + 2] = (b[at + 2] + b[at + 5]) * 0.5, this.rowSphere[i * (4) + 3] = Math.sqrt(dx * dx + dy * dy + dz * dz) * 0.5;
+    }
+    let radii = sceneryTierRadii(port.registers(handle)[SCENERY_REGISTER.tier] ?? 0);
+    this.layer = new PrefetchLayer({
+      name: "scenery",
+      items: sceneryPrefetchItems(manifest, chunkPaths, radii),
+      radius: () => sceneryTierRadii(this.tier()).far * (1.1),
+      need: () => sceneryTierRadii(this.tier()).near * (3),
+      cellSize: manifest.grid.cellSize > 0 ? manifest.grid.cellSize : void 0,
+      held: (entry) => {
+        let row = this.entryRow[entry];
+        return this.engineState[row] !== (0) || this.chunks.holds(this.chunkPaths[row]);
+      },
+      busy: () => this.waiting > 0,
+      flow: this.flow
+    });
+  }
+  tier() {
+    return this.closed ? 0 : this.view()[SCENERY_REGISTER.tier];
+  }
+  get prefetcher() {
+    return this.predictor;
+  }
+  stream(prefetch) {
+    if (this.predictor !== null || this.closed) return;
+    let reader = this.chunks.reader;
+    reader === null || reader.prefetch === void 0 || (this.predictor = prefetch.stream(this.layer, { stalled: () => this.stalled(), assets: reader }));
+  }
+  stalled() {
+    if (this.closed || !this.hasEye) return false;
+    let layer = this.layer, eye = this.lastEye, need = layer.needRadius() / layer.scale, cell = layer.cellSize, c0 = Math.max(0, Math.floor((eye[0] - need - layer.maxRadius - layer.originX) / cell)), c1 = Math.min(layer.cols - 1, Math.floor((eye[0] + need + layer.maxRadius - layer.originX) / cell)), r0 = Math.max(0, Math.floor((eye[2] - need - layer.maxRadius - layer.originZ) / cell)), r1 = Math.min(layer.rows - 1, Math.floor((eye[2] + need + layer.maxRadius - layer.originZ) / cell));
+    for (let row = r0; row <= r1; row++)
+      for (let col = c0; col <= c1; col++) {
+        let c = row * layer.cols + col;
+        for (let k = layer.cellStart[c]; k < layer.cellStart[c + 1]; k++) {
+          let item = layer.cellItems[k];
+          if (this.engineState[this.entryRow[layer.entryStart[item]]] === (2)) continue;
+          let dx = layer.x[item] - eye[0], dy = layer.y[item] - eye[1], dz = layer.z[item] - eye[2];
+          if (Math.sqrt(dx * dx + dy * dy + dz * dz) - layer.radius[item] <= need) return true;
+        }
+      }
+    return false;
+  }
+  /** True once `remove()` has run. */
+  get removed() {
+    return this.closed;
+  }
+  /** Places the scenery in the world: translation, rotation (normalised by the engine) and a uniform scale above zero. */
+  setTransform(position, rotation, scale = 1) {
+    if (this.closed) return;
+    if (!(scale > 0)) throw new GameError("invalid_argument", `scenery scale must be above zero, got ${scale}`);
+    let t = this.transform;
+    t[0] = position.x, t[1] = position.y, t[2] = position.z, t[3] = rotation?.x ?? 0, t[4] = rotation?.y ?? 0, t[5] = rotation?.z ?? 0, t[6] = rotation?.w ?? 1, t[7] = scale, this.port.setTransform(this.handle, t), this.layer.setPlacement(t);
+  }
+  bodyPort() {
+    let bodies = this.port.bodies;
+    if (bodies == null) throw new GameError("unsupported_feature", "this engine build does not move or edit splats");
+    return bodies;
+  }
+  regionOf(region) {
+    let id = typeof region == "string" ? this.regionNames[region] : region;
+    if (id === void 0 || !Number.isInteger(id) || id < 0 || id >= 256) throw new GameError("invalid_argument", `no splat region ${String(region)}`);
+    return id;
+  }
+  /** Recolours one baked region without recapture: hue in radians, saturation and gain as multipliers. */
+  edit(region, edit) {
+    if (this.closed) return;
+    let v = this.editValues;
+    if (v[0] = edit.hue ?? 0, v[1] = edit.saturation ?? 1, v[2] = edit.gain ?? 1, !(v[1] >= 0) || !(v[2] >= 0) || !Number.isFinite(v[0])) throw new GameError("invalid_argument", "a splat edit needs a finite hue and non-negative saturation and gain");
+    this.bodyPort().edit(this.handle, this.regionOf(region), v);
+  }
+  /** Drives this body from a model's pose on the rig it was baked against; null returns it to rest. Throws when the rig differs. */
+  bind(rig) {
+    this.closed || this.bodyPort().bind(this.handle, rig ?? (0));
+  }
+  /** Splats in garment region `region` follow `cloth`, which must use the mesh the region was baked with. It may be called at any point in the cloth's run. */
+  drape(cloth, region, options = {}) {
+    if (this.closed) return;
+    let host = cloth.engineHost;
+    if (host === null) throw new GameError("unsupported_feature", "this cloth is not simulated by the engine");
+    this.bodyPort().drape(this.handle, host, cloth.id, this.regionOf(region), options.rest ?? null);
+  }
+  /** Rows a motion table needs: one for every splat in the manifest, across all levels of detail. */
+  get motionRows() {
+    return this.closed ? 0 : this.bodyPort().motionRows(this.handle);
+  }
+  /**
+   * Runs a per-splat program. `kernel` is called once a frame, normally `() => game.kernels.run(wave, table, time)`;
+   * the engine reads what it writes before deforming, and pays only for the channels named here. Pass null to stop.
+   */
+  motion(kernel, options) {
+    if (this.closed) return;
+    let bodies = this.bodyPort();
+    if (kernel === null || options === void 0) {
+      this.kernel = null, bodies.motion(this.handle, 0, null, 0, 0);
+      return;
+    }
+    let table = options.table, named = options.rotation !== void 0 || options.colour !== void 0 || options.opacity !== void 0, offset = options.offset ?? (named ? void 0 : DEFAULT_MOTION_OFFSET), mask = 0, names = [...options.rest ?? DEFAULT_MOTION_REST], channel = (bit, fields) => {
+      fields !== void 0 && (mask |= bit, names.push(...fields));
+    };
+    channel(1, offset), channel(2, options.rotation), channel(4, options.colour), channel(8, options.opacity === void 0 ? void 0 : [options.opacity]);
+    let columns = new Uint32Array(14);
+    if (names.forEach((name, k) => {
+      columns[k] = table.column(name);
+    }), !(options.reach >= 0)) throw new GameError("invalid_argument", "a splat motion reach must not be negative");
+    bodies.motion(this.handle, table.id, columns, Math.ceil(options.reach * (1e3)), mask), this.kernel = () => kernel(table);
+  }
+  follow() {
+    this.kernel?.();
+    let target = this.standInTarget;
+    if (target === null) return;
+    let wanted = this.view()[SCENERY_REGISTER.standIn] !== 0;
+    wanted !== this.standing && (this.standing = wanted, wanted ? target.show() : target.hide());
+  }
+  /** Closes the scenery and frees its engine resources. Later calls on the handle do nothing. */
+  remove() {
+    this.closed || (this.closed = true, this.registers = null, this.predictor !== null && this.owner.unstream(this.predictor), this.predictor = null, this.owner.release(this), this.port.close(this.handle), this.chunks.close());
+  }
+  update(eye) {
+    if (this.closed) return;
+    let n = this.port.update(this.handle, eye, this.requests);
+    for (let i = 0; i < n; i++) this.fetch(this.requests[i], i === 0 ? (0) : (1));
+    this.layer.toLocal(eye, this.lastEye, 0, true), this.hasEye = true, this.forget(), this.follow();
+  }
+  forget() {
+    let layer = this.layer, eye = this.lastEye, radii = sceneryTierRadii(this.tier()), scale = layer.scale, states = this.engineState, sphere = this.rowSphere, sweep = this.sweep, end = Math.min(states.length, sweep + (256));
+    for (let row = sweep; row < end; row++) {
+      if (states[row] !== (2)) continue;
+      let at = row * (4), dx = sphere[at] - eye[0], dy = sphere[at + 1] - eye[1], dz = sphere[at + 2] - eye[2], unload = sceneryPartReach(this.rowPart[row], radii) * (1.35) / scale;
+      Math.sqrt(dx * dx + dy * dy + dz * dz) - sphere[at + 3] > unload && (states[row] = (0));
+    }
+    this.sweep = end >= states.length ? 0 : end;
+  }
+  fetch(index, priority) {
+    let path = this.chunkPaths[index];
+    if (path === void 0) {
+      this.port.fail(this.handle, index);
+      return;
+    }
+    this.mark(index, (1));
+    let reader = this.chunks.reader;
+    if (reader?.progressive !== void 0 && reader.isProgressive?.(path) === true && !this.chunks.holds(path)) {
+      let first = true;
+      reader.progressive(
+        path,
+        (output) => {
+          first ? (first = false, this.deliver(index, path, output, false)) : this.upgrade(index, output);
+        },
+        priority
+      ).done.then(
+        (bytes) => this.chunks.delivered(path, bytes),
+        () => {
+          first && this.failed(index);
+        }
+      );
+      return;
+    }
+    this.chunks.read(path, priority).then(
+      (bytes) => this.deliver(index, path, bytes, true),
+      () => this.failed(index)
+    );
+  }
+  deliver(index, path, bytes, cache) {
+    if (!this.closed) {
+      try {
+        this.port.provide(this.handle, index, bytes);
+      } catch {
+        this.failed(index);
+        return;
+      }
+      this.mark(index, (2)), cache && this.chunks.delivered(path, bytes);
+    }
+  }
+  upgrade(index, bytes) {
+    if (!(this.closed || this.engineState[index] !== (2)))
+      try {
+        this.port.provide(this.handle, index, bytes);
+      } catch {
+        return;
+      }
+  }
+  failed(index) {
+    this.closed || (this.mark(index, (0)), this.port.fail(this.handle, index));
+  }
+  mark(index, state) {
+    let previous = this.engineState[index], bytes = this.rowBytes[index];
+    previous === (1) && (this.waiting--, this.flow[FLOW_BACKLOG] -= bytes), state === (1) && (this.waiting++, this.flow[FLOW_BACKLOG] += bytes), previous === (1) && state === (2) && (this.flow[FLOW_DELIVERED] += bytes), this.engineState[index] = state;
+  }
+  view() {
+    if (this.closed) return CLOSED_REGISTERS;
+    let registers = this.registers;
+    return registers !== null && registers.byteLength > 0 ? registers : (this.registers = this.port.registers(this.handle), this.registers);
+  }
+}, GraphicsScenery = class {
+  constructor(port, eye) {
+    this.port = port;
+    this.eye = eye;
+    this.live = [];
+    this.eyeBuffer = new Float32Array(3);
+    this.prefetch = null;
+  }
+  attachPrefetch(prefetch) {
+    if (this.prefetch = prefetch, prefetch !== null) for (let i = 0; i < this.live.length; i++) this.live[i].stream(prefetch);
+  }
+  unstream(predictor) {
+    this.prefetch?.removeStream(predictor);
+  }
+  /** False when this backend or engine build cannot draw splat scenery; `load` then throws. */
+  get supported() {
+    return this.port !== null;
+  }
+  /**
+   * Opens the scenery whose manifest is at `source` (a `splats.cspm` URL or, with `options.assets`, a package path).
+   * Chunk files `<sha256>.cspl` are read from the manifest's folder on demand.
+   * Throws `unsupported_feature` when `supported` is false.
+   */
+  load(source, options = {}) {
+    let port = this.port;
+    if (port === null) throw new GameError("unsupported_feature", "this backend does not draw splat scenery");
+    let manifest = typeof source == "string" ? source : source.href, assets = options.assets;
+    return this.open(port, manifest, new SceneryChunks(assets ?? null, options.cacheBytes), options);
+  }
+  /** Loads a splat body baked against a rig and binds it, so it follows that model's animation. */
+  async splatBody(options) {
+    let body = await this.load(options.manifest, options);
+    return body.bind(options.rig), body;
+  }
+  async open(port, location, chunks, options) {
+    let bytes = await chunks.read(location), manifest = parseSceneryManifest(bytes), paths = manifest.chunks.map((name) => sibling(location, name)), handle = port.open(bytes), scenery = new Scenery(port, handle, manifest, paths, chunks, this, options);
+    return this.live.push(scenery), this.prefetch !== null && scenery.stream(this.prefetch), scenery;
+  }
+  /** Number of scenery handles currently loaded. */
+  get count() {
+    return this.live.length;
+  }
+  release(scenery) {
+    let index = this.live.indexOf(scenery);
+    index >= 0 && this.live.splice(index, 1);
+  }
+  frame() {
+    let live = this.live;
+    if (!(live.length === 0 || !this.eye(this.eyeBuffer)))
+      for (let i = 0; i < live.length; i++) live[i].update(this.eyeBuffer);
+  }
+  dispose() {
+    for (let i = this.live.length - 1; i >= 0; i--) this.live[i].remove();
+  }
+};
+
+// src/game/render/graphics.ts
+var CUBE_FACE_COUNT = 6, MAT4_TRANSLATION_X = 12, MAT4_TRANSLATION_Y = 13, MAT4_TRANSLATION_Z = 14, QUALITY_TIER_FULL = 0, QUALITY_TIER_REDUCED = 1, QUALITY_TIER_MINIMUM = 2, Renderable = defineComponent("renderable", { node: "u32" }), FEED_NO_COLUMN = 4294967295, FEED_AXES = 3, MAX_PALETTE_FRAMES = 1024;
+function scalarColumn(table, field) {
+  if (table.schema[field] !== "f32") throw new GameError("invalid_argument", `instance feeds read f32 fields; ${field} is not one`);
+  return table.column(field);
+}
+function wordColumn(table, field) {
+  if (field === void 0) return (4294967295);
+  if (table.schema[field] !== "u32") throw new GameError("invalid_argument", `instance rotation and animation read packed u32 fields; ${field} is not one`);
+  return table.column(field);
+}
+function poseColumns(table, fields) {
+  if (!(fields.rotation === void 0 && fields.animation === void 0))
+    return [wordColumn(table, fields.rotation), wordColumn(table, fields.animation)];
+}
+function feedFields(fields) {
+  let named = typeof fields.position == "string" ? [fields.position] : [...fields.position];
+  return fields.scale !== void 0 && named.push(fields.scale), fields.rotation !== void 0 && named.push(fields.rotation), fields.animation !== void 0 && named.push(fields.animation), named;
+}
+function feedColumns(table, fields) {
+  let columns = [];
+  if (typeof fields.position == "string") {
+    if (table.schema[fields.position] !== "vec3") throw new GameError("invalid_argument", `instance feed position ${fields.position} must be a vec3 field`);
+    for (let k = 0; k < (3); k++) columns.push(table.column(fields.position, k));
+  } else
+    for (let field of fields.position) columns.push(scalarColumn(table, field));
+  return columns.push(fields.scale === void 0 ? (4294967295) : scalarColumn(table, fields.scale)), columns;
+}
+var Graphics = class {
+  constructor(port, world, transforms, scenery = null) {
+    this.fed = /* @__PURE__ */ new Map();
+    this.presentedByFeeds = /* @__PURE__ */ new Set();
+    this.cameraMatrix = new Float32Array(16);
+    this.activeCamera = null;
+    this.port = port, this.world = world, this.transforms = transforms, this.renderables = world.register(Renderable), this.nodeIds = new Uint32Array(this.renderables.capacity), this.matrixRows = new Int32Array(this.renderables.capacity), this.scenery = new GraphicsScenery(scenery, (out) => this.readCameraEye(out)), world.onDespawn(this);
+  }
+  readCameraEye(out) {
+    let camera = this.activeCamera;
+    if (camera === null) return false;
+    let m = this.cameraMatrix;
+    return this.port.readNodeMatrix(camera, m, 0), out[0] = m[(12)], out[1] = m[(13)], out[2] = m[(14)], true;
+  }
+  get capabilities() {
+    return this.port.capabilities;
+  }
+  get gpu() {
+    return this.port.gpu;
+  }
+  attach(surface) {
+    return this.port.attach(surface);
+  }
+  resize(width, height, pixelRatio) {
+    this.port.resize(width, height, pixelRatio);
+  }
+  createGeometry(desc) {
+    return this.port.createGeometry(desc);
+  }
+  geometryAttribute(geometry, name) {
+    return this.port.geometryAttribute(geometry, name);
+  }
+  markGeometryDirty(geometry, name, start = 0, count = -1) {
+    this.port.markGeometryDirty(geometry, name, start, count);
+  }
+  setDrawRange(geometry, start, count) {
+    this.port.setDrawRange(geometry, start, count);
+  }
+  destroyGeometry(geometry) {
+    this.port.destroyGeometry(geometry);
+  }
+  createTexture(desc) {
+    return this.port.createTexture(desc);
+  }
+  loadTexture(source) {
+    return this.port.loadTexture(source);
+  }
+  upgradeTexture(texture, source) {
+    return this.port.upgradeTexture || this.unsupported("texture upgrades"), this.port.upgradeTexture(texture, source);
+  }
+  upgradeModel(model, source) {
+    return this.port.upgradeModel || this.unsupported("model upgrades"), this.port.upgradeModel(model, source);
+  }
+  markTextureDirty(texture, region) {
+    this.port.markTextureDirty(texture, region);
+  }
+  pushVideoFrame(texture, frame, width, height) {
+    return this.port.pushVideoFrame || this.unsupported("video textures"), this.port.pushVideoFrame(texture, frame, width, height);
+  }
+  readRenderTarget(target, rect, slice = 0) {
+    return this.port.readRenderTarget || this.unsupported("render target readback"), this.port.readRenderTarget(target, rect, slice);
+  }
+  vectorPort() {
+    let port = this.port.vectorSurfaces;
+    return port == null && this.unsupported("vector surfaces"), port;
+  }
+  get vectorSurfaceCap() {
+    return this.port.vectorSurfaces?.cap ?? 0;
+  }
+  loadVector(bytes) {
+    return this.vectorPort().load(bytes);
+  }
+  unloadVector(asset) {
+    this.vectorPort().unload(asset);
+  }
+  vectorSurface(desc) {
+    return this.port.capabilities.renderTargets || this.unsupported("render targets"), this.vectorPort().create(desc);
+  }
+  destroyVectorSurface(surface) {
+    this.vectorPort().destroy(surface);
+  }
+  setVectorSurfaceNode(surface, node) {
+    this.vectorPort().setNode(surface, node);
+  }
+  playVectorSurface(surface, kind, index = 0) {
+    this.vectorPort().play(surface, kind, index);
+  }
+  seekVectorSurface(surface, kind, index, seconds) {
+    let port = this.vectorPort();
+    port.seek || this.unsupported("vector surface seeking"), port.seek(surface, kind, index, seconds);
+  }
+  vectorSurfaceInput(surface, name) {
+    return this.vectorPort().inputIndex(surface, name);
+  }
+  setVectorSurfaceInput(surface, input, value) {
+    this.vectorPort().setInput(surface, input, typeof value == "boolean" ? Number(value) : value);
+  }
+  vectorSurfaceData(surface, path) {
+    return this.vectorPort().dataIndex(surface, path);
+  }
+  setVectorSurfaceData(surface, handle, kind, value = 0) {
+    this.vectorPort().setData(surface, handle, kind, value);
+  }
+  vectorSurfacePointer(surface, phase, u, v) {
+    return this.vectorPort().pointer(surface, phase, u, v);
+  }
+  pickVectorSurface(origin, direction, phase, far = 1e3) {
+    return this.vectorPort().pick(origin, direction, far, phase);
+  }
+  vectorSurfaceEvents(out = []) {
+    return this.vectorPort().events(out), out;
+  }
+  vectorSurfaceStats(out = createVectorSurfaceStats()) {
+    return this.vectorPort().stats(out), out;
+  }
+  setVectorSurfaceTier(tier) {
+    this.vectorPort().setTier(tier);
+  }
+  createMaterial(desc) {
+    return desc.kind === "shader" && this.checkShader(desc.shader.glsl !== void 0), this.port.createMaterial(desc);
+  }
+  setMaterialColor(material, color) {
+    this.port.setMaterialColor(material, (color >> 16 & 255) / 255, (color >> 8 & 255) / 255, (color & 255) / 255);
+  }
+  setMaterialRgb(material, r, g, b) {
+    this.port.setMaterialColor(material, r, g, b);
+  }
+  setMaterialOpacity(material, opacity) {
+    this.port.setMaterialOpacity(material, opacity);
+  }
+  setMaterialTexture(material, slot, texture) {
+    this.port.setMaterialTexture(material, slot, texture);
+  }
+  setUniform(material, name, value) {
+    this.port.setMaterialScalar(material, name, value);
+  }
+  setUniformVector(material, name, value) {
+    this.port.setMaterialVector(material, name, value);
+  }
+  setUniformTexture(material, name, texture) {
+    this.port.setMaterialUniformTexture(material, name, texture);
+  }
+  setMaterialState(material, state) {
+    this.port.setMaterialState(material, state);
+  }
+  createEmitter(desc) {
+    return this.port.capabilities.particles || this.unsupported("particles"), this.port.createEmitter(desc);
+  }
+  particles(entity, emitter) {
+    return this.create(entity, { kind: "particles", emitter });
+  }
+  emit(emitter, count) {
+    this.port.emit(emitter, count);
+  }
+  setEmitterRate(emitter, rate) {
+    this.port.setEmitterRate(emitter, rate);
+  }
+  clearEmitter(emitter) {
+    this.port.clearEmitter(emitter);
+  }
+  destroyEmitter(emitter) {
+    this.port.destroyEmitter(emitter);
+  }
+  setRenderOrder(node, order) {
+    this.port.setRenderOrder(node, order);
+  }
+  setShadow(light, shadow) {
+    this.port.setShadow(light, shadow);
+  }
+  setLod(node, near, far, hysteresis = 0) {
+    if (near < 0 || far > 0 && far <= near || hysteresis < 0)
+      throw new GameError("invalid_argument", `lod range ${near}..${far} with hysteresis ${hysteresis} is invalid`);
+    this.port.setLod(node, near, far, hysteresis);
+  }
+  lodLevels(levels, hysteresis = 0) {
+    for (let i = 0; i < levels.length; i++) {
+      let next = i + 1 < levels.length ? levels[i + 1].distance : 0;
+      this.setLod(levels[i].node, levels[i].distance, next, hysteresis);
+    }
+  }
+  setSprite(node, rotation, centerX = 0.5, centerY = 0.5) {
+    this.port.setSprite(node, rotation, centerX, centerY);
+  }
+  setProbeCoefficients(light, sh) {
+    if (sh.length < SH_COEFFICIENT_FLOATS)
+      throw new GameError("invalid_argument", `light probes take ${SH_COEFFICIENT_FLOATS} coefficients (9 RGB)`);
+    this.port.setProbeCoefficients(light, sh);
+  }
+  decal(entity, material, options = {}) {
+    return this.port.capabilities.decals || this.unsupported("decals"), this.create(entity, { kind: "decal", material, ...options });
+  }
+  setProjectionMatrix(camera, matrix, near, far) {
+    if (matrix !== null && matrix.length < 16) throw new GameError("invalid_argument", "projection matrices hold 16 floats");
+    this.port.capabilities.customProjection || this.unsupported("custom projections"), this.port.setProjectionMatrix(camera, matrix, near, far);
+  }
+  setViewOffset(camera, offset) {
+    if (offset !== null && (offset.fullWidth <= 0 || offset.fullHeight <= 0 || offset.width <= 0 || offset.height <= 0))
+      throw new GameError("invalid_argument", "view offsets need positive sizes");
+    this.port.capabilities.customProjection || this.unsupported("view offsets"), this.port.setViewOffset(camera, offset);
+  }
+  gpuStats(out) {
+    return this.port.gpuStats(out);
+  }
+  attachNode(entity, node) {
+    this.transforms.row(entity);
+    let row = this.world.add(entity, Renderable);
+    return this.renderables.fields.node[row] = node, node;
+  }
+  create(entity, desc) {
+    return this.attachNode(entity, this.createDetached(desc));
+  }
+  createDetached(desc) {
+    return this.checkNode(desc), this.port.createNode(desc);
+  }
+  mesh(entity, geometry, material) {
+    return this.create(entity, { kind: "mesh", geometry, material, castShadow: true, receiveShadow: true });
+  }
+  camera(entity, fov = 60, near = 0.1, far = 1e3) {
+    let node = this.create(entity, { kind: "camera", projection: "perspective", fov, near, far });
+    return this.port.setActiveCamera(node), this.activeCamera = node, node;
+  }
+  instanced(desc) {
+    this.port.capabilities.instancing || this.unsupported("instancing");
+    let node = this.port.createNode({ kind: "instanced", ...desc });
+    return {
+      node,
+      capacity: desc.capacity,
+      matrices: this.port.instanceMatrices(node),
+      colors: this.port.instanceColors(node)
+    };
+  }
+  batchedDraw(desc) {
+    if (!this.port.capabilities.instancing || desc.slots <= 0) return null;
+    let { slots, ...rest } = desc, node = this.port.createNode({ kind: "instanced", ...rest, batchSlots: slots }), buffers = this.port.batchBuffers(node);
+    return buffers === null ? (this.port.destroyNode(node), null) : {
+      node,
+      capacity: desc.capacity,
+      matrices: this.port.instanceMatrices(node),
+      colors: this.port.instanceColors(node),
+      slots: buffers.slots,
+      ranges: buffers.ranges
+    };
+  }
+  markBatch(batch) {
+    this.port.markBatch(batch.node);
+  }
+  setInstanceCount(batch, count) {
+    if (count < 0 || count > batch.capacity)
+      throw new GameError("invalid_argument", `instance count ${count} exceeds ${batch.capacity}`);
+    this.port.setInstanceCount(batch.node, count);
+  }
+  markInstancesDirty(batch) {
+    this.port.markInstancesDirty(batch.node);
+  }
+  feedInstances(batch, table, fields, options = {}) {
+    if (!table.native || this.port.setInstanceFeed === void 0) return false;
+    let columns = feedColumns(table, fields), pose = poseColumns(table, fields), hostReads = options.hostReads === true;
+    return this.port.setInstanceFeed(batch.node, table.id, columns, hostReads, pose) ? (this.forget(batch.node), this.world.presentsKernels(table) || (this.world.presentKernels(table), this.presentedByFeeds.add(table)), this.fed.set(batch.node, table), hostReads && this.world.hostReads(table, feedFields(fields)), true) : false;
+  }
+  setInstancePalette(batch, model, desc) {
+    if (this.port.setInstancePalette === void 0) return false;
+    if (desc === null) return this.port.setInstancePalette(batch.node, model, 0, 0, 0, 0);
+    let skin = desc.skin ?? 0, firstClip = desc.firstClip ?? 0, whole = (value) => Number.isInteger(value) && value >= 0;
+    if (!whole(skin) || !whole(firstClip) || !whole(desc.clips) || desc.clips < 1 || !whole(desc.frames) || desc.frames < 1 || desc.frames > (1024))
+      throw new GameError("invalid_argument", `an instance palette needs whole clips of at least 1 and 1 to ${(1024)} frames per clip`);
+    return this.port.setInstancePalette(batch.node, model, skin, firstClip, desc.clips, desc.frames);
+  }
+  stopFeedingInstances(batch) {
+    this.fed.has(batch.node) && this.port.clearInstanceFeed?.(batch.node), this.forget(batch.node);
+  }
+  forget(node) {
+    let table = this.fed.get(node);
+    if (table !== void 0) {
+      this.fed.delete(node);
+      for (let other of this.fed.values()) if (other === table) return;
+      this.presentedByFeeds.delete(table) && this.world.presentKernels(table, false);
+    }
+  }
+  morphWeights(node) {
+    return this.port.capabilities.morphTargets || this.unsupported("morph targets"), this.port.morphWeights(node);
+  }
+  markMorphWeightsDirty(node) {
+    this.port.markMorphWeightsDirty(node);
+  }
+  skeletonPose(node) {
+    return this.port.capabilities.skinning || this.unsupported("skinning"), this.port.skeletonPose(node);
+  }
+  markSkeletonDirty(node) {
+    this.port.markSkeletonDirty(node);
+  }
+  setVisible(node, visible) {
+    this.port.setNodeVisible(node, visible);
+  }
+  setLayers(node, mask) {
+    this.port.setNodeLayers(node, mask);
+  }
+  setNodeMaterial(node, material) {
+    this.port.setNodeMaterial(node, material);
+  }
+  setText(node, text) {
+    this.port.setNodeText(node, text);
+  }
+  loadFont(source, family) {
+    return this.port.capabilities.text || this.unsupported("text"), this.port.loadFont(source, family);
+  }
+  text3d(entity, font, text, style = {}) {
+    return this.create(entity, { ...style, kind: "text3d", font, text });
+  }
+  setTextStyle(node, style) {
+    this.port.setTextStyle(node, style);
+  }
+  textBounds(node, out) {
+    this.port.textBounds(node, out);
+  }
+  raycast(origin, direction, out, far = 0, layers = 4294967295) {
+    return this.port.capabilities.picking || this.unsupported("picking"), this.port.raycast(origin, direction, far, layers, out);
+  }
+  batchHandle() {
+    return this.port.capabilities.picking ? this.port.batchHandle?.() ?? 0 : 0;
+  }
+  governorPressure() {
+    return this.port.governorPressure?.() ?? 0;
+  }
+  /** Pins the renderer's quality tier (0 full, 1 reduced, 2 minimum), or returns it to the governor with null. False when this renderer has no governor. */
+  forceQualityTier(tier) {
+    if (tier !== null && !(Number.isInteger(tier) && tier >= (0) && tier <= (2)))
+      throw new GameError("invalid_argument", `quality tiers run from ${(0)} to ${(2)}`);
+    return this.port.forceQualityTier?.(tier) ?? false;
+  }
+  qualityTier() {
+    return this.port.qualityTier?.() ?? (0);
+  }
+  setPerspective(camera, fovDegrees, near, far) {
+    this.port.setCameraPerspective(camera, fovDegrees, near, far);
+  }
+  setPerspectiveFrom(camera, values, offset = 0) {
+    this.port.setCameraPerspectiveFrom(camera, values, offset);
+  }
+  setOrthographic(camera, height, near, far) {
+    this.port.setCameraOrthographic(camera, height, near, far);
+  }
+  setActiveCamera(camera) {
+    this.port.setActiveCamera(camera), this.activeCamera = camera;
+  }
+  setLight(light, color, intensity) {
+    this.port.setLight(light, color, intensity);
+  }
+  setEnvironment(desc) {
+    this.port.setEnvironment(desc);
+  }
+  createRenderTarget(desc) {
+    return this.port.capabilities.renderTargets || this.unsupported("render targets"), this.port.createRenderTarget(desc);
+  }
+  renderTargetTexture(target) {
+    return this.port.renderTargetTexture(target);
+  }
+  renderTargetAttachment(target, attachment) {
+    return attachment === 0 ? this.port.renderTargetTexture(target) : (this.port.renderTargetAttachment || this.unsupported("multiple render target attachments"), this.port.renderTargetAttachment(target, attachment));
+  }
+  captureCube(target, camera) {
+    return Array.from(
+      { length: (6) },
+      (_, slice) => this.port.createRenderPass({ camera, target, slice, cubeFace: true, once: true })
+    );
+  }
+  createReflector(target, camera, plane, order = -1) {
+    return this.port.createRenderPass({ camera, target, reflect: plane, order });
+  }
+  renderTargetDepthTexture(target) {
+    return this.port.renderTargetDepthTexture || this.unsupported("sampled render target depth"), this.port.renderTargetDepthTexture(target);
+  }
+  resizeRenderTarget(target, width, height) {
+    this.port.resizeRenderTarget(target, width, height);
+  }
+  createPostChain(desc) {
+    this.port.capabilities.postProcessing || this.unsupported("post-processing");
+    for (let effect of desc.effects)
+      effect.kind === "shader" && this.checkShader(effect.shader.glsl !== void 0);
+    return this.port.createPostChain(desc);
+  }
+  setPostChain(chain) {
+    this.port.setPostChain(chain);
+  }
+  setWeather(state) {
+    this.port.setWeather(state);
+  }
+  setTimeOfDay(hours, latitude, dayOfYear) {
+    this.port.setTimeOfDay(hours, latitude, dayOfYear);
+  }
+  mediaVolume(desc) {
+    let port = this.port, { createMedium, setMedium, mediumTexels, markMedium, destroyMedium } = port;
+    if (createMedium === void 0 || setMedium === void 0 || mediumTexels === void 0 || markMedium === void 0 || destroyMedium === void 0)
+      throw new GameError("unsupported_feature", "media volumes need the native engine with feature media_volume_1");
+    let media = {
+      createMedium: createMedium.bind(port),
+      setMedium: setMedium.bind(port),
+      mediumTexels: mediumTexels.bind(port),
+      markMedium: markMedium.bind(port),
+      destroyMedium: destroyMedium.bind(port)
+    };
+    return new MediumVolume(media, media.createMedium(desc), desc);
+  }
+  setPostUniform(chain, effect, name, value) {
+    this.port.setPostScalar(chain, effect, name, value);
+  }
+  createRenderPass(desc) {
+    return desc.target !== null && !this.port.capabilities.renderTargets && this.unsupported("render targets"), this.port.createRenderPass(desc);
+  }
+  setRenderPassEnabled(pass, enabled) {
+    this.port.setRenderPassEnabled(pass, enabled);
+  }
+  loadModel(source) {
+    return this.port.capabilities.models || this.unsupported("models"), this.port.loadModel(source);
+  }
+  loadClips(root, source, options) {
+    return this.port.loadClips || this.unsupported("animation clip import"), this.port.loadClips(root, source, options);
+  }
+  setTint(node, tint) {
+    this.port.setTint || this.unsupported("kit tints"), this.port.setTint(node, tint);
+  }
+  instantiate(entity, model) {
+    return this.attachNode(entity, this.port.instantiateModel(model));
+  }
+  findNode(root, name) {
+    return this.port.findNode(root, name);
+  }
+  playClip(root, clip, loop = true, fadeSeconds = 0, speed = 1) {
+    return this.port.playClip(root, clip, loop, fadeSeconds, speed);
+  }
+  setClipWeight(action, weight) {
+    this.port.setClipWeight(action, weight);
+  }
+  clipIndex(root, clip) {
+    return this.port.clipIndex?.(root, clip) ?? -1;
+  }
+  playClipIndex(root, clip, loop, fadeSeconds, speed) {
+    return this.port.playClipIndex === void 0 && this.unsupported("clip playback by index"), this.port.playClipIndex(root, clip, loop, fadeSeconds, speed);
+  }
+  setIkTarget(chain, x, y, z, weight) {
+    this.clips.setIkTarget(chain, x, y, z, weight);
+  }
+  instanceBuffer(node, colours) {
+    try {
+      return colours ? this.port.instanceColors(node) : this.port.instanceMatrices(node);
+    } catch {
+      return null;
+    }
+  }
+  markInstances(node) {
+    this.port.markInstancesDirty(node);
+  }
+  stopClip(action, fadeSeconds = 0) {
+    this.port.stopClip(action, fadeSeconds);
+  }
+  get clips() {
+    return this.port.clips ?? this.unsupported("clip animation (actions, masks, blend spaces, IK, retargeting, root motion)");
+  }
+  get hasClipAnimation() {
+    return this.port.clips !== void 0;
+  }
+  nodeOf(entity) {
+    let row = this.renderables.row(entity);
+    return row === -1 ? null : this.renderables.fields.node[row];
+  }
+  entityOfNode(node) {
+    let nodes = this.renderables.fields.node, n = this.renderables.count;
+    for (let row = 0; row < n; row++) if (nodes[row] === node) return this.renderables.entities[row];
+    return NO_ENTITY;
+  }
+  readNodeMatrix(node, out, offset = 0) {
+    this.port.readNodeMatrix(node, out, offset);
+  }
+  stats(out) {
+    this.port.stats(out);
+  }
+  onDespawn(entity) {
+    let row = this.renderables.row(entity);
+    if (row === -1) return;
+    let node = this.renderables.fields.node[row];
+    node === this.activeCamera && (this.activeCamera = null), this.forget(node), this.port.destroyNode(node);
+  }
+  sync(time) {
+    let store = this.renderables, transforms = this.transforms.store, n = store.count, count = 0;
+    for (let r = 0; r < n; r++) {
+      let row = transforms.row(store.entities[r]);
+      row !== -1 && (this.nodeIds[count] = store.fields.node[r], this.matrixRows[count] = row, count++);
+    }
+    this.port.writeNodeMatrices(this.nodeIds, transforms.fields.render, this.matrixRows, count), this.port.advanceAnimations(time);
+  }
+  render(time) {
+    this.scenery.frame(), this.port.render(time);
+  }
+  checkNode(desc) {
+    let caps = this.port.capabilities;
+    if (desc.kind === "skinned" && !caps.skinning && this.unsupported("skinning"), desc.kind === "instanced" && !caps.instancing && this.unsupported("instancing"), desc.kind === "particles" && !caps.particles && this.unsupported("particles"), desc.kind === "decal" && !caps.decals && this.unsupported("decals"), desc.kind === "camera" && desc.projection === "custom" && !caps.customProjection && this.unsupported("custom projections"), desc.kind === "light" && desc.light === "probe" && desc.sh !== void 0 && desc.sh.length < SH_COEFFICIENT_FLOATS)
+      throw new GameError("invalid_argument", `light probes take ${SH_COEFFICIENT_FLOATS} coefficients (9 RGB)`);
+  }
+  checkShader(hasGlsl) {
+    if (!(this.port.capabilities.shaderLanguages.indexOf("wgsl") >= 0) && !hasGlsl)
+      throw new GameError(
+        "shader_requires_translation",
+        "this backend draws with WebGL2; the shader needs its admitted GLSL translation"
+      );
+  }
+  unsupported(feature) {
+    throw new GameError("unsupported_feature", `${this.port.capabilities.backend} does not support ${feature}`);
+  }
+};
+
+// src/interactives/meters/frames.ts
+var FRAME_WINDOW = 600, NO_MOMENT = 65535, MAX_MOMENTS = 64, MS_PER_SECOND = 1e3, NS_PER_MS = 1e6, P50 = 0.5, P95 = 0.95, P99 = 0.99;
+function percentile(sorted, share) {
+  return sorted.length === 0 ? 0 : sorted[Math.min(sorted.length - 1, Math.floor(share * sorted.length))];
+}
+function smoothVerdict(fps, target = TARGET_HZ) {
+  let share = fps / target;
+  return share >= SMOOTH_SHARE ? "smooth" : share >= STUTTER_SHARE ? "slight" : "stutters";
+}
+function heatVerdict(busyShare, pressure) {
+  return busyShare >= HOT_BUSY_SHARE || pressure >= HOT_PRESSURE ? "hot" : busyShare >= WARM_BUSY_SHARE || pressure >= WARM_PRESSURE ? "warm" : "cool";
+}
+var FrameRecorder = class {
+  constructor() {
+    this.frameMs = new Float64Array((600));
+    this.moments = new Uint16Array((600));
+    this.passNs = new Float64Array(GPU_PASS_NAMES.length);
+    this.labels = [];
+    this.head = 0;
+    this.count = 0;
+    this.moment = (65535);
+    this.gpuFrames = 0;
+    this.busyNs = 0;
+    this.spanNs = 0;
+    this.pressure = 0;
+  }
+  mark(label) {
+    if (label === null) {
+      this.moment = (65535);
+      return;
+    }
+    let index = this.labels.indexOf(label);
+    index < 0 && this.labels.length < (64) && (index = this.labels.push(label) - 1), this.moment = index < 0 ? (65535) : index;
+  }
+  frame(seconds) {
+    !(seconds > 0) || !Number.isFinite(seconds) || (this.frameMs[this.head] = seconds * (1e3), this.moments[this.head] = this.moment, this.head = (this.head + 1) % (600), this.count < (600) && this.count++, this.spanNs += seconds * (1e3) * (1e6));
+  }
+  gpu(lastNs, passNs, pressure) {
+    lastNs > 0 && (this.busyNs += lastNs, this.gpuFrames++);
+    for (let i = 0; i < this.passNs.length && i < passNs.length; i++) this.passNs[i] += passNs[i];
+    pressure > this.pressure && (this.pressure = pressure);
+  }
+  reset() {
+    this.head = 0, this.count = 0, this.gpuFrames = 0, this.busyNs = 0, this.spanNs = 0, this.pressure = 0, this.passNs.fill(0);
+  }
+  get frames() {
+    return this.count;
+  }
+  heat() {
+    let samples = this.gpuFrames, average = this.count === 0 ? 0 : this.spanNs / this.count, busyShare = samples === 0 || average === 0 ? 0 : Math.min(1, this.busyNs / samples / average);
+    return { busyShare, pressure: this.pressure, heat: heatVerdict(busyShare, this.pressure) };
+  }
+  meter(tier, calibration = null, target = TARGET_HZ) {
+    let scale = isCalibrated(calibration) ? calibration.frameScale : 1, sorted = this.frameMs.slice(0, this.count).sort();
+    for (let i = 0; i < sorted.length; i++) sorted[i] *= scale;
+    let p95 = percentile(sorted, (0.95)), fps = p95 > 0 ? Math.min(target, (1e3) / p95) : target;
+    return {
+      tier,
+      frames: this.count,
+      p50Ms: percentile(sorted, (0.5)),
+      p95Ms: p95,
+      p99Ms: percentile(sorted, (0.99)),
+      fps,
+      targetFps: target,
+      smooth: smoothVerdict(fps, target),
+      worstMoment: this.worstMoment(),
+      causes: passCauses(this.passNs),
+      calibrated: isCalibrated(calibration),
+      device: isCalibrated(calibration) ? calibration.device : null
+    };
+  }
+  worstMoment() {
+    let worst = (65535), worstMs = 0;
+    for (let m = 0; m < this.labels.length; m++) {
+      let mine = [];
+      for (let i = 0; i < this.count; i++) this.moments[i] === m && mine.push(this.frameMs[i]);
+      if (mine.length === 0) continue;
+      mine.sort((a, b) => a - b);
+      let ms = mine[Math.min(mine.length - 1, Math.floor((0.95) * mine.length))];
+      ms > worstMs && (worstMs = ms, worst = m);
+    }
+    return worst === (65535) ? null : this.labels[worst];
+  }
+};
+
+// src/interactives/meters/memory.ts
+var MemoryPeak = class {
+  constructor() {
+    this.script = 0;
+    this.engine = 0;
+    this.graphics = 0;
+  }
+  note(sample) {
+    sample.scriptBytes > this.script && (this.script = sample.scriptBytes), sample.engineBytes > this.engine && (this.engine = sample.engineBytes), sample.graphicsBytes > this.graphics && (this.graphics = sample.graphicsBytes);
+  }
+  noteScript(bytes) {
+    bytes > this.script && (this.script = bytes);
+  }
+  noteEngine(bytes) {
+    bytes > this.engine && (this.engine = bytes);
+  }
+  noteGraphics(bytes) {
+    bytes > this.graphics && (this.graphics = bytes);
+  }
+  reset() {
+    this.script = 0, this.engine = 0, this.graphics = 0;
+  }
+  get peak() {
+    return { scriptBytes: this.script, engineBytes: this.engine, graphicsBytes: this.graphics };
+  }
+};
+function memoryMeter(sample, tier, calibration = null) {
+  let scale = isCalibrated(calibration) ? calibration.memoryScale : 1, bytes = (sample.scriptBytes + sample.engineBytes + sample.graphicsBytes) * scale, ceiling = MEMORY_CEILING_BYTES[tier];
+  return {
+    tier,
+    bytes,
+    ceilingBytes: ceiling,
+    memory: bytes > ceiling ? "too_much" : bytes > ceiling * TIGHT_MEMORY_SHARE ? "tight" : "fits",
+    causes: rankCauses([
+      { label: "Game code and data", cost: sample.scriptBytes },
+      { label: "World, physics and sound", cost: sample.engineBytes },
+      { label: "Pictures, models and screens", cost: sample.graphicsBytes }
+    ]),
+    calibrated: isCalibrated(calibration)
+  };
+}
+
+// src/interactives/meters/live.ts
+var GPU_SAMPLE_FRAMES = 30, QUALITY_FOR_TIER = {
+  low: (2),
+  mid: (1),
+  high: (0)
+}, GameMeters = class {
+  constructor(game, tier, calibrations = []) {
+    this.game = game;
+    this.calibrations = calibrations;
+    this.recorder = new FrameRecorder();
+    this.memory = new MemoryPeak();
+    this.stats = createGpuStats();
+    this.forced = false;
+    this.sinceGpu = 0;
+    this.tier = tier;
+  }
+  get playingAs() {
+    return this.tier;
+  }
+  get simulating() {
+    return this.forced;
+  }
+  playAs(tier) {
+    let graphics = this.game.graphics;
+    if (tier === null)
+      return graphics.forceQualityTier(null), this.forced = false, this.reset(), true;
+    let pinned = graphics.forceQualityTier(QUALITY_FOR_TIER[tier]);
+    return this.forced = pinned, pinned && (this.tier = tier), this.reset(), pinned;
+  }
+  measureAs(tier, pin) {
+    return pin ? this.playAs(tier) : (this.forced && this.game.graphics.forceQualityTier(null), this.forced = false, this.tier = tier, this.reset(), true);
+  }
+  moment(label) {
+    this.recorder.mark(label);
+  }
+  update() {
+    if (this.recorder.frame(this.game.clock[FRAME_SECONDS_SLOT]), ++this.sinceGpu < (30)) return;
+    this.sinceGpu = 0;
+    let graphics = this.game.graphics;
+    graphics.gpuStats(this.stats) && (this.recorder.gpu(this.stats.gpuP50Ns, this.stats.passNs, graphics.governorPressure()), this.memory.noteGraphics(this.stats.gpuBytes));
+  }
+  noteInspector(readout) {
+    this.memory.noteEngine(readout.arena.highWaterBytes);
+  }
+  noteScriptHeap(bytes) {
+    this.memory.noteScript(bytes);
+  }
+  reset() {
+    this.recorder.reset(), this.memory.reset(), this.sinceGpu = 0;
+  }
+  read() {
+    let calibration = calibrationFor(this.calibrations, this.tier);
+    return {
+      tier: this.tier,
+      asTier: this.forced,
+      frames: this.recorder.meter(this.tier, calibration),
+      heat: this.recorder.heat(),
+      memory: memoryMeter(this.memory.peak, this.tier, calibration)
+    };
+  }
+};
+
+export { ComponentStore, FRAME_WINDOW, FrameRecorder, GPU_SAMPLE_FRAMES, GameMeters, Graphics, GraphicsScenery, MAX_MOMENTS, MemoryPeak, QUALITY_FOR_TIER, Renderable, SCENERY_CHUNK_EXTENSION, SCENERY_LOAD_SHARE, SCENERY_MANIFEST_MAGIC, SCENERY_MANIFEST_VERSION, SCENERY_MANIFEST_VERSION_PARTS, SCENERY_NEED_SHARE, SCENERY_PART_COARSE, SCENERY_PART_FINE, SCENERY_PART_MIDDLE, SCENERY_PART_WHOLE, SCENERY_TIER_RADII, Scenery, defineComponent, heatVerdict, memoryMeter, parseSceneryManifest, sceneryEntryRows, sceneryFirstView, sceneryPartDrawLevel, sceneryPartReach, sceneryPrefetchItems, sceneryTierRadii, smoothVerdict };