@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-TJCAE7RC.mjs

@@ -0,0 +1,1315 @@
+import { Vec3 } from './chunk-XPG3N5CF.mjs';
+import { NO_ENTITY } from './chunk-T3AFF3L7.mjs';
+import { createPickHit } from './chunk-TL2SVO4P.mjs';
+import './chunk-K4UDGE3Z.mjs';
+import { MOE_MIN_EXPERTS, MOE_MAX_EXPERTS, moeBlob, parseMoe, evalMoeLane, MLP_MAX_LAYERS, parseMlp, MLP_ACT_LINEAR, MLP_ACT_RELU, mlpBlob, evalMlp, MLP_ACC_LIMIT, MLP_MULTIPLIER_LIMIT, MLP_MAX_SHIFT } from './chunk-MOBSBXVE.mjs';
+import { MLP_MAX_WIDTH, MLP_MAX_OUTPUTS, sin, cos, tan, asin, acos, atan, atan2, exp, log, log2, pow } from './chunk-SMK6JU2F.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/kernel/train.ts
+var fr = Math.fround, Q_MAX = 127, Q_MIN = -128, INPUT_SPAN = 256, HALF = 0.5, HE_GAIN = 6, SEED_FALLBACK = 2654435769, UNIT_SHIFT = 8, UNIT_SCALE = 2 ** -24, DEFAULT_EPOCHS = 20, DEFAULT_BATCH = 32, DEFAULT_RATE = 0.02, DEFAULT_MOMENTUM = 0.9, DEFAULT_SEED = 1, MLP_MEMORY_MIN = 2, MLP_MEMORY_MAX = 4;
+function invalid(message2) {
+  throw new GameError("invalid_argument", message2);
+}
+function joinMemory(data) {
+  let memory = data.memory;
+  if (memory === void 0) return data;
+  let { samples } = data, width = memory.width;
+  (!Number.isInteger(samples) || samples < 1) && invalid("training needs at least one sample"), (!Number.isInteger(width) || width < (2) || width > (4)) && invalid(`memory carries ${(2)} to ${(4)} values`), (memory.previous.length !== samples * width || memory.next.length !== samples * width) && invalid(`memory needs ${width} previous and ${width} next values for each of the ${samples} samples`), data.inputs.length % samples !== 0 && invalid(`inputs need the same count of numbers for each of the ${samples} samples`), data.targets.length % samples !== 0 && invalid(`targets need the same count of numbers for each of the ${samples} samples`);
+  let features = data.inputs.length / samples, actions = data.targets.length / samples, inputs = new Float32Array(samples * (features + width)), targets = new Float32Array(samples * (actions + width));
+  for (let s = 0; s < samples; s++) {
+    let i = s * (features + width), t = s * (actions + width);
+    for (let k = 0; k < features; k++) inputs[i + k] = data.inputs[s * features + k];
+    for (let k = 0; k < width; k++) inputs[i + features + k] = memory.previous[s * width + k];
+    for (let k = 0; k < actions; k++) targets[t + k] = data.targets[s * actions + k];
+    for (let k = 0; k < width; k++) targets[t + actions + k] = memory.next[s * width + k];
+  }
+  return { samples, inputs, targets };
+}
+function memorySamples(episodes) {
+  let first = episodes.find((e) => e.inputs.length > 0);
+  first === void 0 && invalid("memory training needs at least one episode with a step");
+  let features = first.inputs[0].length, actions = first.targets[0]?.length ?? 0, width = first.memory[0]?.length ?? 0, samples = 0;
+  for (let episode of episodes)
+    (episode.targets.length !== episode.inputs.length || episode.memory.length !== episode.inputs.length + 1) && invalid("each episode has one target row per input row and one more memory row than steps, the first being the starting memory"), samples += episode.inputs.length;
+  let inputs = new Float32Array(samples * features), targets = new Float32Array(samples * actions), previous = new Float32Array(samples * width), next = new Float32Array(samples * width), s = 0, row = (out, values, length, at, what) => {
+    values.length !== length && invalid(`every ${what} row has ${length} numbers`), out.set(values, at * length);
+  };
+  for (let episode of episodes)
+    for (let t = 0; t < episode.inputs.length; t++, s++)
+      row(inputs, episode.inputs[t], features, s, "input"), row(targets, episode.targets[t], actions, s, "target"), row(previous, episode.memory[t], width, s, "memory"), row(next, episode.memory[t + 1], width, s, "memory");
+  return { samples, inputs, targets, memory: { width, previous, next } };
+}
+var Random = class {
+  constructor(seed) {
+    this.state = seed >>> 0 || (2654435769);
+  }
+  next() {
+    let x = this.state;
+    return x ^= x << 13, x >>>= 0, x ^= x >>> 17, x ^= x << 5, this.state = x >>> 0, this.state;
+  }
+  unit() {
+    return (this.next() >>> (8)) * UNIT_SCALE;
+  }
+};
+function roundHalfEven(x) {
+  let r = Math.floor(x), d = x - r;
+  return d > (0.5) ? r + 1 : d < (0.5) || r % 2 === 0 ? r : r + 1;
+}
+function clamp(x, low, high) {
+  return x < low ? low : x > high ? high : x;
+}
+function maxAbs(values) {
+  let m = 0;
+  for (let k = 0; k < values.length; k++) {
+    let a = Math.abs(values[k]);
+    a > m && (m = a);
+  }
+  return m;
+}
+function scaleOf(max) {
+  return max > 0 ? fr(max / (127)) : fr(1 / (127));
+}
+function check(data, widths) {
+  let fail = (message2) => {
+    throw new GameError("invalid_argument", message2);
+  };
+  (widths.length < 2 || widths.length - 1 > MLP_MAX_LAYERS) && fail(`a network has 1 to ${MLP_MAX_LAYERS} layers`), widths.some((w) => !Number.isInteger(w) || w < 1) && fail("every layer width is a whole number of at least 1"), widths.slice(0, -1).some((w) => w > MLP_MAX_WIDTH) && fail(`inputs and hidden layers are at most ${MLP_MAX_WIDTH} wide`), widths[widths.length - 1] > MLP_MAX_OUTPUTS && fail(`a network has at most ${MLP_MAX_OUTPUTS} outputs`), (!Number.isInteger(data.samples) || data.samples < 1) && fail("training needs at least one sample"), data.inputs.length !== data.samples * widths[0] && fail(`inputs need ${widths[0]} numbers for each of the ${data.samples} samples`), data.targets.length !== data.samples * widths[widths.length - 1] && fail(`targets need ${widths[widths.length - 1]} numbers for each of the ${data.samples} samples`);
+}
+function layersOf(widths, random) {
+  let layers = [];
+  for (let l = 0; l + 1 < widths.length; l++) {
+    let inputs = widths[l], outputs = widths[l + 1], limit = fr(Math.sqrt(fr((6) / inputs))), w = new Float32Array(inputs * outputs);
+    for (let k = 0; k < w.length; k++) w[k] = fr(fr(fr(random.unit() * 2) - 1) * limit);
+    let size = inputs * outputs;
+    layers.push({
+      inputs,
+      outputs,
+      w,
+      b: new Float32Array(outputs),
+      vw: new Float32Array(size),
+      vb: new Float32Array(outputs),
+      gw: new Float32Array(size),
+      gb: new Float32Array(outputs),
+      wq: new Float32Array(size),
+      z: new Float32Array(outputs),
+      a: new Float32Array(outputs),
+      da: new Float32Array(inputs),
+      wScale: 1,
+      aScale: 1
+    });
+  }
+  return layers;
+}
+function quantizeWeights(layer) {
+  layer.wScale = scaleOf(maxAbs(layer.w));
+  for (let k = 0; k < layer.w.length; k++) layer.wq[k] = fr(clamp(roundHalfEven(fr(layer.w[k] / layer.wScale)), -(127), (127)) * layer.wScale);
+}
+function quantizeInput(x, scale, unit) {
+  let raw = fr(fr(x) * scale), t = Number.isNaN(raw) ? 0 : clamp(raw, -(256), (256));
+  return fr(clamp(roundHalfEven(t), (-128), (127)) * unit);
+}
+function forward(layers, input, quantizeActs) {
+  let prev = input;
+  layers.forEach((layer, l) => {
+    let last = l + 1 === layers.length;
+    for (let j = 0; j < layer.outputs; j++) {
+      let acc = layer.b[j], row = j * layer.inputs;
+      for (let i = 0; i < layer.inputs; i++) acc = fr(acc + fr(layer.wq[row + i] * prev[i]));
+      if (layer.z[j] = acc, last) layer.a[j] = acc;
+      else {
+        let r = acc > 0 ? acc : 0;
+        layer.a[j] = quantizeActs ? fr(clamp(roundHalfEven(fr(r / layer.aScale)), 0, (127)) * layer.aScale) : r;
+      }
+    }
+    prev = layer.a;
+  });
+}
+function backward(layers, input, error) {
+  let delta = error;
+  for (let l = layers.length - 1; l >= 0; l--) {
+    let layer = layers[l], prev = l === 0 ? input : layers[l - 1].a;
+    layer.da.fill(0);
+    for (let j = 0; j < layer.outputs; j++) {
+      let g = delta[j];
+      if (g === 0) continue;
+      let row = j * layer.inputs;
+      layer.gb[j] = fr(layer.gb[j] + g);
+      for (let i = 0; i < layer.inputs; i++)
+        layer.gw[row + i] = fr(layer.gw[row + i] + fr(g * prev[i])), layer.da[i] = fr(layer.da[i] + fr(g * layer.wq[row + i]));
+    }
+    if (l > 0) {
+      let below = layers[l - 1];
+      for (let i = 0; i < layer.inputs; i++) below.z[i] > 0 || (layer.da[i] = 0);
+    }
+    delta = layer.da;
+  }
+}
+function step(layers, size, momentum) {
+  for (let layer of layers) {
+    for (let k = 0; k < layer.w.length; k++)
+      layer.vw[k] = fr(fr(momentum * layer.vw[k]) - fr(size * layer.gw[k])), layer.w[k] = fr(layer.w[k] + layer.vw[k]);
+    for (let j = 0; j < layer.outputs; j++)
+      layer.vb[j] = fr(fr(momentum * layer.vb[j]) - fr(size * layer.gb[j])), layer.b[j] = fr(layer.b[j] + layer.vb[j]);
+  }
+}
+function begin(layers) {
+  for (let layer of layers)
+    quantizeWeights(layer), layer.gw.fill(0), layer.gb.fill(0);
+}
+function calibrate(layers, data, inputScale2, inputUnit, input) {
+  let peaks = new Float32Array(layers.length);
+  for (let s = 0; s < data.samples; s++) {
+    for (let i = 0; i < input.length; i++) input[i] = quantizeInput(data.inputs[s * input.length + i], inputScale2, inputUnit);
+    forward(layers, input, false);
+    for (let l = 0; l + 1 < layers.length; l++) for (let v of layers[l].a) v > peaks[l] && (peaks[l] = v);
+  }
+  for (let l = 0; l + 1 < layers.length; l++) layers[l].aScale = scaleOf(peaks[l]);
+}
+function shiftFor(m) {
+  for (let shift = MLP_MAX_SHIFT; shift >= 0; shift--) {
+    let multiplier = Math.floor(m * 2 ** shift + (0.5));
+    if (multiplier < MLP_MULTIPLIER_LIMIT) return [multiplier, shift];
+  }
+  return [MLP_MULTIPLIER_LIMIT - 1, 0];
+}
+function exportBlob(layers, inputScale2, inputUnit) {
+  let specs = [], unit = inputUnit;
+  return layers.forEach((layer, l) => {
+    let last = l + 1 === layers.length, accScale = fr(unit * layer.wScale), weights = Array.from(layer.w, (v) => clamp(roundHalfEven(fr(v / layer.wScale)), -(127), (127))), bias = Array.from(layer.b, (v) => clamp(roundHalfEven(fr(v / accScale)), -MLP_ACC_LIMIT, MLP_ACC_LIMIT));
+    if (last) {
+      specs.push({ outputs: layer.outputs, activation: MLP_ACT_LINEAR, multiplier: 0, shift: 0, zero: 0, scale: accScale, bias, weights });
+      return;
+    }
+    let [multiplier, shift] = shiftFor(accScale / layer.aScale);
+    specs.push({ outputs: layer.outputs, activation: MLP_ACT_RELU, multiplier, shift, zero: 0, scale: layer.aScale, bias, weights }), unit = layer.aScale;
+  }), mlpBlob(layers[0].inputs, inputScale2, 0, specs);
+}
+function blobLoss(blob, data, inputs, outputs) {
+  let net = parseMlp(blob, blob.length, inputs, outputs);
+  if (net === null) throw new GameError("invalid_argument", "the trained network did not pack into a valid file");
+  let bits = new Float32Array(inputs), words = new Uint32Array(bits.buffer), out = new Uint32Array(outputs), view = new Float32Array(out.buffer), total = 0;
+  for (let s = 0; s < data.samples; s++) {
+    for (let i = 0; i < inputs; i++) bits[i] = data.inputs[s * inputs + i];
+    evalMlp(net, words, out);
+    for (let j = 0; j < outputs; j++) {
+      let e = fr(view[j] - fr(data.targets[s * outputs + j]));
+      total = fr(total + fr(fr(e * e) * (0.5)));
+    }
+  }
+  return fr(total / data.samples);
+}
+function trainMlp(source, options) {
+  let data = joinMemory(source), widths = options.widths;
+  check(data, widths);
+  let epochs = options.epochs ?? (20), batch = Math.max(1, Math.floor(options.batch ?? (32))), rate = fr(options.learningRate ?? (0.02)), momentum = fr(options.momentum ?? (0.9)), random = new Random(options.seed ?? (1)), inputs = widths[0], outputs = widths[widths.length - 1], layers = layersOf(widths, random), peak = 0;
+  for (let k = 0; k < data.inputs.length; k++) {
+    let a = Math.abs(fr(data.inputs[k]));
+    a > peak && (peak = a);
+  }
+  let inputScale2 = peak > 0 ? fr((127) / peak) : 1, inputUnit = fr(1 / inputScale2), input = new Float32Array(inputs), error = new Float32Array(outputs), order = Uint32Array.from({ length: data.samples }, (_, k) => k), loss = new Float32Array(epochs);
+  for (let epoch = 0; epoch < epochs; epoch++) {
+    for (let layer of layers) quantizeWeights(layer);
+    calibrate(layers, data, inputScale2, inputUnit, input);
+    for (let k = data.samples - 1; k > 0; k--) {
+      let j = random.next() % (k + 1), t = order[k];
+      order[k] = order[j], order[j] = t;
+    }
+    let total = 0;
+    for (let start = 0; start < data.samples; start += batch) {
+      let end = Math.min(start + batch, data.samples);
+      begin(layers);
+      for (let k = start; k < end; k++) {
+        let s = order[k];
+        for (let i = 0; i < inputs; i++) input[i] = quantizeInput(data.inputs[s * inputs + i], inputScale2, inputUnit);
+        forward(layers, input, true);
+        let top = layers[layers.length - 1];
+        for (let j = 0; j < outputs; j++) {
+          let e = fr(top.a[j] - fr(data.targets[s * outputs + j]));
+          error[j] = e, total = fr(total + fr(fr(e * e) * (0.5)));
+        }
+        backward(layers, input, error);
+      }
+      step(layers, fr(rate / (end - start)), momentum);
+    }
+    loss[epoch] = fr(total / data.samples);
+  }
+  for (let layer of layers) quantizeWeights(layer);
+  calibrate(layers, data, inputScale2, inputUnit, input);
+  let blob = exportBlob(layers, inputScale2, inputUnit);
+  return { blob, loss, blobLoss: blobLoss(blob, data, inputs, outputs) };
+}
+var MOE_DEFAULT_BALANCE = 0.5;
+function halfSquared(y, data, at) {
+  let total = 0;
+  for (let j = 0; j < y.length; j++) {
+    let e = fr(y[j] - fr(data.targets[at + j]));
+    total = fr(total + fr(fr(e * e) * (0.5)));
+  }
+  return total;
+}
+function topOf(values) {
+  let best = 0;
+  for (let j = 1; j < values.length; j++) values[j] > values[best] && (best = j);
+  return best;
+}
+function assign(errors, counts, len, balance) {
+  let experts = errors.length, best = 0, low = Number.POSITIVE_INFINITY;
+  for (let e = 0; e < experts; e++) {
+    let load = fr(fr(counts[e] * experts) / len), score = fr(errors[e] * fr(1 + fr(balance * load)));
+    score < low && (low = score, best = e);
+  }
+  return best;
+}
+function lastOf(layers) {
+  return layers[layers.length - 1];
+}
+function trainMoe(source, options) {
+  let data = joinMemory(source), count = options.experts;
+  (!Number.isInteger(count) || count < MOE_MIN_EXPERTS || count > MOE_MAX_EXPERTS) && invalid(`a mixture has ${MOE_MIN_EXPERTS} to ${MOE_MAX_EXPERTS} experts`), (!Number.isInteger(data.samples) || data.samples < 1) && invalid("training needs at least one sample");
+  let inputs = data.inputs.length / data.samples, outputs = data.targets.length / data.samples, routerWidths = [inputs, ...options.router ?? [], count], expertWidths = [inputs, ...options.expert ?? [], outputs];
+  check(data, expertWidths), check({ samples: data.samples, inputs: data.inputs, targets: new Float32Array(data.samples * count) }, routerWidths);
+  let epochs = options.epochs ?? (20), batch = Math.max(1, Math.floor(options.batch ?? (32))), rate = fr(options.learningRate ?? (0.02)), momentum = fr(options.momentum ?? (0.9)), balance = fr(options.balance ?? (0.5)), random = new Random(options.seed ?? (1)), router = layersOf(routerWidths, random), experts = Array.from({ length: count }, () => layersOf(expertWidths, random)), peak = 0;
+  for (let k = 0; k < data.inputs.length; k++) {
+    let a = Math.abs(fr(data.inputs[k]));
+    a > peak && (peak = a);
+  }
+  let inputScale2 = peak > 0 ? fr((127) / peak) : 1, inputUnit = fr(1 / inputScale2), input = new Float32Array(inputs), error = new Float32Array(outputs), routeError = new Float32Array(count), errors = new Float32Array(count), counts = new Uint32Array(count), order = Uint32Array.from({ length: data.samples }, (_, k) => k), loss = new Float32Array(epochs), all = [router, ...experts];
+  for (let epoch = 0; epoch < epochs; epoch++) {
+    for (let layers of all) for (let layer of layers) quantizeWeights(layer);
+    for (let layers of all) calibrate(layers, data, inputScale2, inputUnit, input);
+    for (let k = data.samples - 1; k > 0; k--) {
+      let j = random.next() % (k + 1), t = order[k];
+      order[k] = order[j], order[j] = t;
+    }
+    let total = 0;
+    for (let start = 0; start < data.samples; start += batch) {
+      let end = Math.min(start + batch, data.samples), len = end - start;
+      for (let layers of all) begin(layers);
+      counts.fill(0);
+      for (let k = start; k < end; k++) {
+        let s = order[k];
+        for (let i = 0; i < inputs; i++) input[i] = quantizeInput(data.inputs[s * inputs + i], inputScale2, inputUnit);
+        for (let e = 0; e < count; e++)
+          forward(experts[e], input, true), errors[e] = halfSquared(lastOf(experts[e]).a, data, s * outputs);
+        forward(router, input, true), total = fr(total + errors[topOf(lastOf(router).a)]);
+        let best = assign(errors, counts, len, balance);
+        counts[best]++;
+        let top = lastOf(experts[best]).a;
+        for (let j = 0; j < outputs; j++) error[j] = fr(top[j] - fr(data.targets[s * outputs + j]));
+        backward(experts[best], input, error);
+        let z = lastOf(router).a;
+        for (let j = 0; j < count; j++) routeError[j] = fr(z[j] - (j === best ? 1 : 0));
+        backward(router, input, routeError);
+      }
+      step(router, fr(rate / len), momentum);
+      for (let e = 0; e < count; e++) step(experts[e], fr(rate / Math.max(counts[e], 1)), momentum);
+    }
+    loss[epoch] = fr(total / data.samples);
+  }
+  for (let layers of all) for (let layer of layers) quantizeWeights(layer);
+  for (let layers of all) calibrate(layers, data, inputScale2, inputUnit, input);
+  let blob = moeBlob(inputs, outputs, exportBlob(router, inputScale2, inputUnit), experts.map((e) => exportBlob(e, inputScale2, inputUnit))), net = parseMoe(blob, blob.length, inputs, outputs);
+  if (net === null) throw new GameError("invalid_argument", "the trained mixture did not pack into a valid file");
+  let usage = new Uint32Array(count), bits = new Float32Array(inputs), words = new Uint32Array(bits.buffer), out = new Uint32Array(outputs), view = new Float32Array(out.buffer), shipped = 0;
+  for (let s = 0; s < data.samples; s++) {
+    for (let i = 0; i < inputs; i++) bits[i] = data.inputs[s * inputs + i];
+    usage[evalMoeLane(net, words, 0, 1, out)]++;
+    for (let j = 0; j < outputs; j++) {
+      let e = fr(view[j] - fr(data.targets[s * outputs + j]));
+      shipped = fr(shipped + fr(fr(e * e) * (0.5)));
+    }
+  }
+  return { blob, loss, blobLoss: fr(shipped / data.samples), usage };
+}
+
+// src/game/kernel/import.ts
+var fr2 = Math.fround, Q_MAX2 = 127, IMPORT_DEFAULT_SAMPLES = 256, IMPORT_DEFAULT_RANGE = 1, IMPORT_DEFAULT_SEED = 1, IMPORT_DEFAULT_MAX_DRIFT = 0.05, IMPORT_SUPPORTED_OPS = "Gemm, MatMul, Add, Relu, Tanh and Clip", WIRE_VARINT = 0, WIRE_FIXED64 = 1, WIRE_BYTES = 2, WIRE_FIXED32 = 5, WIRE_MASK = 7, WIRE_SHIFT = 8, VARINT_PAYLOAD = 127, VARINT_CONTINUE = 128, VARINT_STEP = 128, VARINT_MAX_BYTES = 10, F32_BYTES = 4, FIXED64_BYTES = 8, MODEL_GRAPH = 7, GRAPH_NODE = 1, GRAPH_INITIALIZER = 5, GRAPH_INPUT = 11, GRAPH_OUTPUT = 12, NODE_INPUT = 1, NODE_OUTPUT = 2, NODE_OP = 4, NODE_ATTRIBUTE = 5, ATTRIBUTE_NAME = 1, ATTRIBUTE_FLOAT = 2, ATTRIBUTE_INT = 3, TENSOR_DIMS = 1, TENSOR_TYPE = 2, TENSOR_FLOATS = 4, TENSOR_NAME = 8, TENSOR_RAW = 9, VALUE_NAME = 1, ONNX_FLOAT = 1, MATRIX_DIMS = 2, TANH_LIMIT = 9, TANH_RANGE = 1, decoder = new TextDecoder("utf-8", { fatal: true }), ImportError = class extends GameError {
+  constructor(message2) {
+    super("invalid_argument", message2), this.name = "ImportError";
+  }
+};
+function malformed(what) {
+  throw new ImportError(`the model file is malformed: ${what}`);
+}
+function unsupported(what) {
+  throw new ImportError(`${what}; the importer reads ${IMPORT_SUPPORTED_OPS}`);
+}
+function shape(what) {
+  throw new ImportError(what);
+}
+function varint(bytes, at) {
+  let value = 0, scale = 1;
+  for (let n = 0; n < (10); n++) {
+    at.k >= bytes.length && malformed("a number runs past the end");
+    let byte = bytes[at.k++];
+    if (value += (byte & (127)) * scale, (byte & (128)) === 0) return value;
+    scale *= (128);
+  }
+  malformed("a number is too long");
+}
+function take(bytes, at, len) {
+  (len < 0 || at.k + len > bytes.length) && malformed("a field runs past the end");
+  let out = bytes.subarray(at.k, at.k + len);
+  return at.k += len, out;
+}
+function fields(bytes) {
+  let out = [], at = { k: 0 };
+  for (; at.k < bytes.length; ) {
+    let key = varint(bytes, at), number = Math.floor(key / (8));
+    switch (key % (8) & (7)) {
+      case (0):
+        out.push({ number, wire: { t: "varint", v: varint(bytes, at) } });
+        break;
+      case (1):
+        take(bytes, at, (8)), out.push({ number, wire: { t: "fixed64" } });
+        break;
+      case (2):
+        out.push({ number, wire: { t: "bytes", b: take(bytes, at, varint(bytes, at)) } });
+        break;
+      case (5): {
+        let b = take(bytes, at, (4));
+        out.push({ number, wire: { t: "fixed32", w: new DataView(b.buffer, b.byteOffset, (4)).getUint32(0, true) } });
+        break;
+      }
+      default:
+        malformed("a field has an unknown wire type");
+    }
+  }
+  return out;
+}
+function text(field) {
+  field.wire.t !== "bytes" && malformed("a name is not a string");
+  try {
+    return decoder.decode(field.wire.b);
+  } catch {
+    malformed("a name is not UTF-8");
+  }
+}
+function message(field) {
+  return field.wire.t !== "bytes" && malformed("a message field is not length-delimited"), field.wire.b;
+}
+function floatBits(word) {
+  return new Float32Array(Uint32Array.of(word).buffer)[0];
+}
+function floats(b) {
+  let view = new DataView(b.buffer, b.byteOffset, b.byteLength), out = [];
+  for (let k = 0; k + (4) <= b.byteLength; k += (4)) out.push(view.getFloat32(k, true));
+  return out;
+}
+function tensor(bytes) {
+  let name = "", dims = [], values = [], kind = (1), raw = null;
+  for (let f of fields(bytes))
+    if (f.number === (1) && f.wire.t === "varint") dims.push(f.wire.v);
+    else if (f.number === (1) && f.wire.t === "bytes") {
+      let at = { k: 0 };
+      for (; at.k < f.wire.b.length; ) dims.push(varint(f.wire.b, at));
+    } else f.number === (2) && f.wire.t === "varint" ? kind = f.wire.v : f.number === (4) && f.wire.t === "fixed32" ? values.push(floatBits(f.wire.w)) : f.number === (4) && f.wire.t === "bytes" ? values.push(...floats(f.wire.b)) : f.number === (8) ? name = text(f) : f.number === (9) && f.wire.t === "bytes" && (raw = f.wire.b);
+  return kind !== (1) && unsupported(`tensor ${name} is not float32`), raw !== null && (raw.byteLength % (4) !== 0 && malformed("raw tensor data is not whole float32 values"), values = floats(raw)), dims.reduce((a, b) => a * b, 1) !== values.length && shape(`tensor ${name} holds ${values.length} values for dimensions [${dims.join(", ")}]`), [name, { dims, values: Float32Array.from(values) }];
+}
+function node(bytes) {
+  let n = { inputs: [], outputs: [], op: "", floats: /* @__PURE__ */ new Map(), ints: /* @__PURE__ */ new Map() };
+  for (let f of fields(bytes))
+    if (f.number === (1)) n.inputs.push(text(f));
+    else if (f.number === (2)) n.outputs.push(text(f));
+    else if (f.number === (4)) n.op = text(f);
+    else if (f.number === (5)) {
+      let name = "", float = null, int = null;
+      for (let a of fields(message(f)))
+        a.number === (1) ? name = text(a) : a.number === (2) && a.wire.t === "fixed32" ? float = floatBits(a.wire.w) : a.number === (3) && a.wire.t === "varint" && (int = a.wire.v);
+      float !== null && n.floats.set(name, float), int !== null && n.ints.set(name, int);
+    }
+  return n;
+}
+function clipActivation(low, high) {
+  if (low === 0 && high === Number.POSITIVE_INFINITY) return { kind: "relu" };
+  if (Number.isFinite(high) && high > 0 && (low === 0 || low === -high)) return { kind: "clip", low, high };
+  unsupported(`Clip(${low}, ${high}) has no int8 form; clip at 0 and a positive bound, or at -b and b`);
+}
+function readOnnx(bytes) {
+  let graphField = fields(bytes).find((f) => f.number === (7)) ?? malformed("no graph"), nodes = [], initializers = /* @__PURE__ */ new Map(), inputs = [], outputs = [];
+  for (let f of fields(message(graphField)))
+    if (f.number === (1)) nodes.push(node(message(f)));
+    else if (f.number === (5)) {
+      let [name, t] = tensor(message(f));
+      initializers.set(name, t);
+    } else if (f.number === (11) || f.number === (12)) {
+      let nameField = fields(message(f)).find((v) => v.number === (1)), name = nameField === void 0 ? "" : text(nameField);
+      (f.number === (11) ? inputs : outputs).push(name);
+    }
+  let sources = inputs.filter((n) => !initializers.has(n));
+  (sources.length !== 1 || outputs.length !== 1) && unsupported(`the graph has ${sources.length} inputs and ${outputs.length} outputs; one of each is supported (put memory columns at the end of both)`);
+  let matrix = (name) => {
+    name === void 0 && malformed("a layer has no weights");
+    let t = initializers.get(name) ?? unsupported(`weights ${name} are computed, not constant`);
+    return t.dims.length !== (2) && shape(`weights ${name} have dimensions [${t.dims.join(", ")}], not a matrix`), t;
+  }, scalar = (name) => {
+    if (name === void 0 || name === "") return null;
+    let t = initializers.get(name);
+    return (t === void 0 || t.values.length !== 1) && unsupported(`Clip bound ${name} is not a constant scalar`), t.values[0];
+  }, layers = [], current = sources[0], awaitingBias = false, activated = false;
+  for (let n of nodes) {
+    let reads = () => {
+      n.inputs[0] !== current && unsupported(`${n.op} reads ${n.inputs[0]}, not the running layer chain ${current}; only a single chain of layers is supported`);
+    }, output = () => n.outputs[0] ?? malformed("a node has no output");
+    if (n.op === "Gemm" || n.op === "MatMul") {
+      reads();
+      let gemm = n.op === "Gemm";
+      gemm && (n.ints.get("transA") ?? 0) !== 0 && unsupported("Gemm with transA");
+      let transposed = gemm && (n.ints.get("transB") ?? 0) !== 0, w = matrix(n.inputs[1]), [ins, outs] = transposed ? [w.dims[1], w.dims[0]] : [w.dims[0], w.dims[1]], prev = layers[layers.length - 1];
+      prev !== void 0 && prev.outputs !== ins && shape(`a layer takes ${ins} inputs after one with ${prev.outputs} outputs`);
+      let alpha = gemm ? fr2(n.floats.get("alpha") ?? 1) : 1, weights = new Float32Array(ins * outs);
+      for (let j = 0; j < outs; j++)
+        for (let i = 0; i < ins; i++) {
+          let v = transposed ? w.values[j * ins + i] : w.values[i * outs + j];
+          weights[j * ins + i] = alpha === 1 ? v : fr2(v * alpha);
+        }
+      let bias = new Float32Array(outs), c = gemm ? n.inputs[2] : void 0;
+      if (c !== void 0 && c !== "") {
+        let t = initializers.get(c) ?? unsupported(`bias ${c} is computed, not constant`);
+        t.values.length !== outs && shape(`bias ${c} holds ${t.values.length} values for ${outs} outputs`);
+        let beta = fr2(n.floats.get("beta") ?? 1);
+        for (let j = 0; j < outs; j++) bias[j] = beta === 1 ? t.values[j] : fr2(t.values[j] * beta);
+      }
+      layers.push({ inputs: ins, outputs: outs, weights, bias, activation: { kind: "linear" } }), awaitingBias = !gemm, activated = false, current = output();
+    } else if (n.op === "Add") {
+      let layer = awaitingBias ? layers[layers.length - 1] : void 0;
+      layer === void 0 && unsupported("Add that is not the bias of a MatMul");
+      let other = n.inputs.find((i) => i !== current) ?? unsupported("Add without a constant bias");
+      n.inputs.includes(current) || unsupported("Add that is off the layer chain");
+      let t = initializers.get(other) ?? unsupported(`bias ${other} is computed, not constant`);
+      t.values.length !== layer.outputs && shape(`bias ${other} holds ${t.values.length} values for ${layer.outputs} outputs`), layer.bias.set(t.values), awaitingBias = false, current = output();
+    } else if (n.op === "Relu" || n.op === "Tanh" || n.op === "Clip") {
+      reads();
+      let layer = activated ? void 0 : layers[layers.length - 1];
+      layer === void 0 && unsupported(`${n.op} that does not follow a layer`), n.op === "Relu" ? layer.activation = { kind: "relu" } : n.op === "Tanh" ? layer.activation = { kind: "tanh" } : layer.activation = clipActivation(scalar(n.inputs[1]) ?? n.floats.get("min") ?? Number.NEGATIVE_INFINITY, scalar(n.inputs[2]) ?? n.floats.get("max") ?? Number.POSITIVE_INFINITY), activated = true, awaitingBias = false, current = output();
+    } else unsupported(`operator ${n.op} is not supported`);
+  }
+  current !== outputs[0] && unsupported(`the graph output ${outputs[0]} is not the end of the layer chain ${current}`);
+  let net = { layers };
+  return checkNet(net), net;
+}
+var inputsOf = (net) => net.layers[0]?.inputs ?? 0, outputsOf = (net) => net.layers[net.layers.length - 1]?.outputs ?? 0;
+function checkNet(net) {
+  let count = net.layers.length;
+  (count === 0 || count > MLP_MAX_LAYERS) && shape(`a network has 1 to ${MLP_MAX_LAYERS} layers, this one ${count}`), net.layers.forEach((layer, l) => {
+    let last = l + 1 === count;
+    (layer.inputs === 0 || layer.inputs > MLP_MAX_WIDTH || layer.outputs === 0 || layer.outputs > (last ? MLP_MAX_OUTPUTS : MLP_MAX_WIDTH)) && shape(`layer ${l} is ${layer.inputs}x${layer.outputs}; inputs and hidden layers are at most ${MLP_MAX_WIDTH} wide and outputs at most ${MLP_MAX_OUTPUTS}`), (layer.weights.length !== layer.inputs * layer.outputs || layer.bias.length !== layer.outputs) && shape(`layer ${l} has ${layer.weights.length} weights and ${layer.bias.length} biases for ${layer.inputs}x${layer.outputs}`), l > 0 && net.layers[l - 1].outputs !== layer.inputs && shape(`layer ${l} takes ${layer.inputs} inputs after ${net.layers[l - 1].outputs} outputs`), last && layer.activation.kind !== "linear" && layer.activation.kind !== "relu" && unsupported("a Clip or Tanh on the last layer has no int8 form; clamp in the kernel after mlp()"), [...layer.weights, ...layer.bias].some((v) => !Number.isFinite(v)) && shape(`layer ${l} holds a weight that is not finite`);
+  });
+}
+function generatedSamples(inputs, count = (256), range = (1), seed = (1)) {
+  let random = new Random(seed), out = new Float32Array(inputs * count), r = fr2(range);
+  for (let k = 0; k < out.length; k++) out[k] = fr2(fr2(fr2(random.unit() * 2) - 1) * r);
+  return out;
+}
+function tanh(x) {
+  let c = clamp(x, -(9), (9)), e = exp(fr2(2 * c));
+  return fr2(fr2(e - 1) / fr2(e + 1));
+}
+function deployed(y, a) {
+  switch (a.kind) {
+    case "linear":
+      return y;
+    case "relu":
+      return y > 0 ? y : 0;
+    case "clip":
+      return clamp(y, a.low, a.high);
+    case "tanh":
+      return clamp(y, -(1), (1));
+  }
+}
+function floatActivation(y, a) {
+  return a.kind === "tanh" ? tanh(y) : deployed(y, a);
+}
+function layerForward(layer, weights, input, out, activate) {
+  for (let j = 0; j < layer.outputs; j++) {
+    let acc = layer.bias[j], row = j * layer.inputs;
+    for (let i = 0; i < layer.inputs; i++) acc = fr2(acc + fr2(weights[row + i] * input[i]));
+    out[j] = activate(acc);
+  }
+}
+function floatEval(net, input, out) {
+  let a = new Float32Array(MLP_MAX_WIDTH), b = new Float32Array(MLP_MAX_WIDTH);
+  for (let i = 0; i < input.length; i++) a[i] = input[i];
+  for (let layer of net.layers) {
+    layerForward(layer, layer.weights, a, b, (y) => floatActivation(y, layer.activation));
+    let t = a;
+    a = b, b = t;
+  }
+  out.set(a.subarray(0, outputsOf(net)));
+}
+function fixedScale(a) {
+  return a.kind === "clip" ? fr2(a.high / (127)) : a.kind === "tanh" ? fr2((1) / (127)) : null;
+}
+function intActivation(a) {
+  return a.kind === "relu" || a.kind === "clip" && a.low === 0 ? MLP_ACT_RELU : MLP_ACT_LINEAR;
+}
+function quantizeNet(net, index, samples, scale, reports) {
+  let unit0 = fr2(1 / scale), inputs = inputsOf(net), rows = samples.length / inputs, wScales = net.layers.map((l) => scaleOf(maxAbs(l.weights))), wq = net.layers.map((l, k) => Float32Array.from(l.weights, (w) => fr2(clamp(roundHalfEven(fr2(w / wScales[k])), -(127), (127)) * wScales[k]))), peaks = new Float32Array(net.layers.length), a = new Float32Array(MLP_MAX_WIDTH), b = new Float32Array(MLP_MAX_WIDTH);
+  for (let r = 0; r < rows; r++) {
+    for (let i = 0; i < inputs; i++) a[i] = quantizeInput(samples[r * inputs + i], scale, unit0);
+    net.layers.forEach((layer, l) => {
+      layerForward(layer, wq[l], a, b, (y) => deployed(y, layer.activation));
+      let peak = peaks[l];
+      for (let j = 0; j < layer.outputs; j++) {
+        let m = layer.activation.kind === "relu" ? b[j] : Math.abs(b[j]);
+        m > peak && (peak = m);
+      }
+      peaks[l] = peak;
+      let t = a;
+      a = b, b = t;
+    });
+  }
+  let count = net.layers.length, specs = [], unit = unit0;
+  return net.layers.forEach((layer, l) => {
+    let last = l + 1 === count, accScale = fr2(unit * wScales[l]), weights = Array.from(layer.weights, (v) => clamp(roundHalfEven(fr2(v / wScales[l])), -(127), (127))), bias = Array.from(layer.bias, (v) => clamp(roundHalfEven(fr2(v / accScale)), -MLP_ACC_LIMIT, MLP_ACC_LIMIT)), activation = intActivation(layer.activation), spec, aScale;
+    if (last)
+      spec = { outputs: layer.outputs, activation, multiplier: 0, shift: 0, zero: 0, scale: accScale, bias, weights }, aScale = accScale;
+    else {
+      aScale = fixedScale(layer.activation) ?? scaleOf(peaks[l]);
+      let [multiplier, shift] = shiftFor(accScale / aScale);
+      spec = { outputs: layer.outputs, activation, multiplier, shift, zero: 0, scale: aScale, bias, weights };
+    }
+    reports.push({ net: index, layer: l, inputs: layer.inputs, outputs: layer.outputs, activation, weightScale: wScales[l], activationScale: aScale, multiplier: spec.multiplier, shift: spec.shift }), specs.push(spec), unit = aScale;
+  }), mlpBlob(inputs, scale, 0, specs);
+}
+function inputScale(samples) {
+  let peak = maxAbs(samples);
+  return peak > 0 ? fr2((127) / peak) : 1;
+}
+function drift(rows, outputs, bound, row) {
+  let float = new Float32Array(outputs), int = new Uint32Array(outputs), view = new Float32Array(int.buffer), maxError = 0, peak = 0;
+  for (let r = 0; r < rows; r++) {
+    row(r, float, int);
+    for (let j = 0; j < outputs; j++) {
+      let e = Math.abs(fr2(view[j] - float[j]));
+      maxError = Number.isNaN(e) ? Number.POSITIVE_INFINITY : e > maxError ? e : maxError;
+      let m = Math.abs(float[j]);
+      m > peak && (peak = m);
+    }
+  }
+  let relative = peak > 0 ? fr2(maxError / peak) : maxError;
+  if (Number.isNaN(relative) || relative > bound) throw new ImportError(`the int8 network drifts ${relative} from the float model (largest error over the largest output), over the ${bound} bound`);
+  return { samples: rows, maxError, peak, relative, bound };
+}
+function rowsOf(samples, inputs) {
+  return (inputs === 0 || samples.length === 0 || samples.length % inputs !== 0) && shape(`samples hold ${samples.length} numbers, not whole rows of ${inputs} inputs`), samples.length / inputs;
+}
+function memoryFits(memory, inputs, outputs) {
+  memory > 0 && (memory > inputs || memory > outputs || memory < (2) || memory > (4)) && shape(`${memory} memory columns do not fit ${inputs} inputs and ${outputs} outputs (memory is ${(2)} to ${(4)} columns at the end of both)`);
+}
+function samplesFor(inputs, options) {
+  return options.samples ?? generatedSamples(inputs);
+}
+function importMlp(net, options = {}) {
+  checkNet(net);
+  let inputs = inputsOf(net), outputs = outputsOf(net), memory = options.memory ?? 0;
+  memoryFits(memory, inputs, outputs);
+  let samples = samplesFor(inputs, options), rows = rowsOf(samples, inputs), bound = fr2(options.maxDrift ?? (0.05)), scale = inputScale(samples), layers = [], blob = quantizeNet(net, 0, samples, scale, layers), parsed = parseMlp(blob, blob.length, inputs, outputs) ?? shape("the quantized network did not pack"), bits = new Float32Array(inputs), words = new Uint32Array(bits.buffer), report = drift(rows, outputs, bound, (r, float, int) => {
+    let row = samples.subarray(r * inputs, (r + 1) * inputs);
+    floatEval(net, row, float), bits.set(row), evalMlp(parsed, words, int);
+  });
+  return { blob, inputScale: scale, layers, drift: report, memory };
+}
+function importMoe(router, experts, options = {}) {
+  checkNet(router), (experts.length < MOE_MIN_EXPERTS || experts.length > MOE_MAX_EXPERTS || outputsOf(router) !== experts.length) && shape(`a mixture has ${MOE_MIN_EXPERTS} to ${MOE_MAX_EXPERTS} experts and a router with one output each; this one has ${experts.length} experts and ${outputsOf(router)} router outputs`);
+  let inputs = inputsOf(router), outputs = outputsOf(experts[0]);
+  experts.forEach((expert, e) => {
+    checkNet(expert), (inputsOf(expert) !== inputs || outputsOf(expert) !== outputs) && shape(`expert ${e} is ${inputsOf(expert)}->${outputsOf(expert)}, the mixture ${inputs}->${outputs}`);
+  });
+  let memory = options.memory ?? 0;
+  memoryFits(memory, inputs, outputs);
+  let samples = samplesFor(inputs, options), rows = rowsOf(samples, inputs), bound = fr2(options.maxDrift ?? (0.05)), scale = inputScale(samples), layers = [], routerWords = quantizeNet(router, 0, samples, scale, layers), parts = experts.map((x, e) => quantizeNet(x, e + 1, samples, scale, layers)), blob = moeBlob(inputs, outputs, routerWords, parts), parsed = parseMoe(blob, blob.length, inputs, outputs) ?? shape("the quantized mixture did not pack"), bits = new Float32Array(inputs), words = new Uint32Array(bits.buffer), route = new Float32Array(experts.length), report = drift(rows, outputs, bound, (r, float, int) => {
+    let row = samples.subarray(r * inputs, (r + 1) * inputs);
+    floatEval(router, row, route);
+    let best = 0;
+    for (let j = 1; j < route.length; j++) route[j] > route[best] && (best = j);
+    floatEval(experts[best], row, float), bits.set(row), evalMoeLane(parsed, words, 0, 1, int);
+  });
+  return { blob, inputScale: scale, layers, drift: report, memory };
+}
+function plainNet(layers) {
+  let net = { layers: layers.map((layer, l) => {
+    let outputs = layer.weights.length, inputs = layer.weights[0]?.length ?? 0;
+    layer.weights.some((row) => row.length !== inputs) && shape(`layer ${l} has rows of different lengths`);
+    let activation = layer.activation;
+    return {
+      inputs,
+      outputs,
+      weights: Float32Array.from(layer.weights.flat()),
+      bias: Float32Array.from(layer.bias ?? new Array(outputs).fill(0)),
+      activation: activation === void 0 || activation === "linear" ? { kind: "linear" } : activation === "relu" ? { kind: "relu" } : activation === "tanh" ? { kind: "tanh" } : clipActivation(activation.clip[0], activation.clip[1])
+    };
+  }) };
+  return checkNet(net), net;
+}
+
+// src/game/render/helpers.ts
+var TAU = Math.PI * 2, BOX_EDGES = 12, BOX_CORNERS = 8, AXES_SEGMENTS = 3, ARROW_SEGMENTS = 5, ARROW_HEAD_SPOKES = 4, DEFAULT_HEAD_LENGTH = 0.2, DEFAULT_HEAD_WIDTH = 0.1, DEFAULT_CIRCLE_SEGMENTS = 32, SPHERE_CIRCLES = 3;
+var FRUSTUM_EDGES = 12, FRUSTUM_CONE = 4, PLANE_SEGMENTS = 6, DIRECTIONAL_SEGMENTS = 5, SPOT_SPOKES = 5, HEMISPHERE_SEGMENTS = 16, AUDIO_CONE_SPOKES = 8, NEAR_FAR_NDC = 1, PARALLEL_LIMIT = 0.99, MATRIX_FLOATS = 16, AXIS_X_COLOR = 16726832, AXIS_Y_COLOR = 3458905, AXIS_Z_COLOR = 689407, GRID_CENTER_COLOR = 4473924, GRID_COLOR = 8947848, HELPER_COLOR = 16776960, FRUSTUM_COLOR = 16755200, SKELETON_COLOR = 65535, NORMAL_COLOR = 16711935, BOX_EDGE_CORNERS = new Uint8Array([0, 1, 1, 3, 3, 2, 2, 0, 4, 5, 5, 7, 7, 6, 6, 4, 0, 4, 1, 5, 2, 6, 3, 7]);
+function srgbToLinear(channel) {
+  return channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+}
+var LineWriter = class {
+  constructor(capacity) {
+    this.count = 0;
+    this.dropped = 0;
+    this.hex = -1;
+    this.r = 1;
+    this.g = 1;
+    this.b = 1;
+    this.a = 1;
+    this.corners = new Float64Array((8) * 3);
+    this.basis = new Float64Array(6);
+    this.matrix = new Float64Array((16));
+    this.transformed = false;
+    this.capacity = capacity, this.positions = new Float32Array(capacity * 2 * 3), this.colors = new Float32Array(capacity * 2 * 4);
+  }
+  get vertexCount() {
+    return this.count * 2;
+  }
+  clear() {
+    this.count = 0, this.dropped = 0;
+  }
+  color(hex, alpha = 1) {
+    return this.a = alpha, hex === this.hex ? this : (this.hex = hex, this.r = srgbToLinear((hex >> 16 & 255) / 255), this.g = srgbToLinear((hex >> 8 & 255) / 255), this.b = srgbToLinear((hex & 255) / 255), this);
+  }
+  setMatrix(m, mo = 0) {
+    if (m === null)
+      return this.transformed = false, this;
+    for (let i = 0; i < (16); i++) this.matrix[i] = m[mo + i];
+    return this.transformed = true, this;
+  }
+  segment(ax, ay, az, bx, by, bz) {
+    if (this.count >= this.capacity)
+      return this.dropped++, false;
+    if (this.transformed) {
+      let m = this.matrix, tax = m[0] * ax + m[4] * ay + m[8] * az + m[12], tay = m[1] * ax + m[5] * ay + m[9] * az + m[13], taz = m[2] * ax + m[6] * ay + m[10] * az + m[14], tbx = m[0] * bx + m[4] * by + m[8] * bz + m[12], tby = m[1] * bx + m[5] * by + m[9] * bz + m[13], tbz = m[2] * bx + m[6] * by + m[10] * bz + m[14];
+      ax = tax, ay = tay, az = taz, bx = tbx, by = tby, bz = tbz;
+    }
+    let v = this.count * 2, p = this.positions, o = v * 3;
+    p[o] = ax, p[o + 1] = ay, p[o + 2] = az, p[o + 3] = bx, p[o + 4] = by, p[o + 5] = bz;
+    let c = this.colors, q = v * 4;
+    return c[q] = this.r, c[q + 1] = this.g, c[q + 2] = this.b, c[q + 3] = this.a, c[q + 4] = this.r, c[q + 5] = this.g, c[q + 6] = this.b, c[q + 7] = this.a, this.count++, true;
+  }
+  axes(m, mo, size) {
+    let ox = m ? m[mo + 12] : 0, oy = m ? m[mo + 13] : 0, oz = m ? m[mo + 14] : 0;
+    for (let axis = 0; axis < (3); axis++) {
+      let c = mo + axis * 4, dx = m ? m[c] : axis === 0 ? 1 : 0, dy = m ? m[c + 1] : axis === 1 ? 1 : 0, dz = m ? m[c + 2] : axis === 2 ? 1 : 0;
+      this.color(axis === 0 ? (16726832) : axis === 1 ? (3458905) : (689407)), this.segment(ox, oy, oz, ox + dx * size, oy + dy * size, oz + dz * size);
+    }
+    return this;
+  }
+  axesAt(px, py, pz, qx, qy, qz, qw, size) {
+    for (let axis = 0; axis < (3); axis++) {
+      let vx = axis === 0 ? 1 : 0, vy = axis === 1 ? 1 : 0, vz = axis === 2 ? 1 : 0, ix = qw * vx + qy * vz - qz * vy, iy = qw * vy + qz * vx - qx * vz, iz = qw * vz + qx * vy - qy * vx, iw = -qx * vx - qy * vy - qz * vz, rx = ix * qw + iw * -qx + iy * -qz - iz * -qy, ry = iy * qw + iw * -qy + iz * -qx - ix * -qz, rz = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+      this.color(axis === 0 ? (16726832) : axis === 1 ? (3458905) : (689407)), this.segment(px, py, pz, px + rx * size, py + ry * size, pz + rz * size);
+    }
+    return this;
+  }
+  box(minX, minY, minZ, maxX, maxY, maxZ, m = null, mo = 0) {
+    let k = this.corners;
+    for (let i = 0; i < (8); i++) {
+      let x = i & 1 ? maxX : minX, y = i & 2 ? maxY : minY, z = i & 4 ? maxZ : minZ, o = i * 3;
+      m ? (k[o] = m[mo] * x + m[mo + 4] * y + m[mo + 8] * z + m[mo + 12], k[o + 1] = m[mo + 1] * x + m[mo + 5] * y + m[mo + 9] * z + m[mo + 13], k[o + 2] = m[mo + 2] * x + m[mo + 6] * y + m[mo + 10] * z + m[mo + 14]) : (k[o] = x, k[o + 1] = y, k[o + 2] = z);
+    }
+    return this.cornerEdges();
+  }
+  frustum(inverseViewProjection, io, apex = null) {
+    let k = this.corners, m = inverseViewProjection;
+    for (let i = 0; i < (8); i++) {
+      let x = i & 1 ? (1) : -(1), y = i & 2 ? (1) : -(1), z = i & 4 ? (1) : -(1), w = m[io + 3] * x + m[io + 7] * y + m[io + 11] * z + m[io + 15], inv = w !== 0 ? 1 / w : 1, o = i * 3;
+      k[o] = (m[io] * x + m[io + 4] * y + m[io + 8] * z + m[io + 12]) * inv, k[o + 1] = (m[io + 1] * x + m[io + 5] * y + m[io + 9] * z + m[io + 13]) * inv, k[o + 2] = (m[io + 2] * x + m[io + 6] * y + m[io + 10] * z + m[io + 14]) * inv;
+    }
+    if (this.cornerEdges(), apex)
+      for (let i = 0; i < (4); i++) {
+        let o = i * 3;
+        this.segment(apex[0], apex[1], apex[2], k[o], k[o + 1], k[o + 2]);
+      }
+    return this;
+  }
+  circle(cx, cy, cz, radius, nx, ny, nz, segments = (32)) {
+    let b = this.basisFor(nx, ny, nz), px = cx + b[0] * radius, py = cy + b[1] * radius, pz = cz + b[2] * radius;
+    for (let s = 1; s <= segments; s++) {
+      let t = s / segments * TAU, c = Math.cos(t) * radius, sn = Math.sin(t) * radius, x = cx + b[0] * c + b[3] * sn, y = cy + b[1] * c + b[4] * sn, z = cz + b[2] * c + b[5] * sn;
+      this.segment(px, py, pz, x, y, z), px = x, py = y, pz = z;
+    }
+    return this;
+  }
+  sphere(cx, cy, cz, radius, segments = (32)) {
+    return this.circle(cx, cy, cz, radius, 1, 0, 0, segments), this.circle(cx, cy, cz, radius, 0, 1, 0, segments), this.circle(cx, cy, cz, radius, 0, 0, 1, segments);
+  }
+  cross(x, y, z, size) {
+    let h = size * 0.5;
+    return this.segment(x - h, y, z, x + h, y, z), this.segment(x, y - h, z, x, y + h, z), this.segment(x, y, z - h, x, y, z + h), this;
+  }
+  arrow(ox, oy, oz, dx, dy, dz, length, headLength = length * (0.2), headWidth = length * (0.1)) {
+    let len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (len === 0) return this;
+    let ux = dx / len, uy = dy / len, uz = dz / len, tx = ox + ux * length, ty = oy + uy * length, tz = oz + uz * length;
+    this.segment(ox, oy, oz, tx, ty, tz);
+    let b = this.basisFor(ux, uy, uz), bx = tx - ux * headLength, by = ty - uy * headLength, bz = tz - uz * headLength, r = headWidth * 0.5;
+    for (let s = 0; s < (4); s++) {
+      let t = s / (4) * TAU, c = Math.cos(t) * r, sn = Math.sin(t) * r;
+      this.segment(tx, ty, tz, bx + b[0] * c + b[3] * sn, by + b[1] * c + b[4] * sn, bz + b[2] * c + b[5] * sn);
+    }
+    return this;
+  }
+  grid(size, divisions, centerColor = (4473924), gridColor = (8947848), y = 0) {
+    let step2 = size / divisions, half = size / 2, center = divisions / 2;
+    for (let i = 0; i <= divisions; i++) {
+      let k = -half + i * step2;
+      this.color(i === center ? centerColor : gridColor), this.segment(-half, y, k, half, y, k), this.segment(k, y, -half, k, y, half);
+    }
+    return this;
+  }
+  polarGrid(radius, sectors, rings, divisions, sectorColor = (4473924), ringColor = (8947848), y = 0) {
+    this.color(sectorColor);
+    for (let i = 0; i < sectors; i++) {
+      let t = i / sectors * TAU;
+      this.segment(0, y, 0, Math.sin(t) * radius, y, Math.cos(t) * radius);
+    }
+    this.color(ringColor);
+    for (let i = 1; i <= rings; i++) this.circle(0, y, 0, radius * i / rings, 0, 1, 0, divisions);
+    return this;
+  }
+  plane(nx, ny, nz, constant, size) {
+    let len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1, ux = nx / len, uy = ny / len, uz = nz / len, cx = -ux * constant, cy = -uy * constant, cz = -uz * constant, b = this.basisFor(ux, uy, uz), h = size * 0.5, ax = b[0] * h, ay = b[1] * h, az = b[2] * h, vx = b[3] * h, vy = b[4] * h, vz = b[5] * h;
+    return this.segment(cx - ax - vx, cy - ay - vy, cz - az - vz, cx + ax - vx, cy + ay - vy, cz + az - vz), this.segment(cx + ax - vx, cy + ay - vy, cz + az - vz, cx + ax + vx, cy + ay + vy, cz + az + vz), this.segment(cx + ax + vx, cy + ay + vy, cz + az + vz, cx - ax + vx, cy - ay + vy, cz - az + vz), this.segment(cx - ax + vx, cy - ay + vy, cz - az + vz, cx - ax - vx, cy - ay - vy, cz - az - vz), this.segment(cx - ax - vx, cy - ay - vy, cz - az - vz, cx + ax + vx, cy + ay + vy, cz + az + vz), this.segment(cx, cy, cz, cx + ux * h, cy + uy * h, cz + uz * h), this;
+  }
+  path(points, count, closed = false, stride = 3) {
+    for (let i = 1; i < count; i++) {
+      let a = (i - 1) * stride, b = i * stride;
+      this.segment(points[a], points[a + 1], points[a + 2], points[b], points[b + 1], points[b + 2]);
+    }
+    if (closed && count > 2) {
+      let b = (count - 1) * stride;
+      this.segment(points[b], points[b + 1], points[b + 2], points[0], points[1], points[2]);
+    }
+    return this;
+  }
+  skeleton(parents, worlds, count, offset = 0) {
+    for (let i = 0; i < count; i++) {
+      let parent = parents[i];
+      if (parent < 0 || parent >= count) continue;
+      let c = offset + i * 16, p = offset + parent * 16;
+      this.segment(worlds[p + 12], worlds[p + 13], worlds[p + 14], worlds[c + 12], worlds[c + 13], worlds[c + 14]);
+    }
+    return this;
+  }
+  normals(positions, normals, vertices, size) {
+    for (let i = 0; i < vertices; i++) {
+      let o = i * 3, x = positions[o], y = positions[o + 1], z = positions[o + 2];
+      this.segment(x, y, z, x + normals[o] * size, y + normals[o + 1] * size, z + normals[o + 2] * size);
+    }
+    return this;
+  }
+  directionalLight(size, length) {
+    let h = size * 0.5;
+    return this.segment(-h, h, 0, h, h, 0), this.segment(h, h, 0, h, -h, 0), this.segment(h, -h, 0, -h, -h, 0), this.segment(-h, -h, 0, -h, h, 0), this.segment(0, 0, 0, 0, 0, -length), this;
+  }
+  spotLight(angle, distance, segments = (32)) {
+    let radius = Math.tan(angle) * distance;
+    this.segment(0, 0, 0, 0, 0, -distance);
+    for (let s = 0; s < (5) - 1; s++) {
+      let t = s / ((5) - 1) * TAU;
+      this.segment(0, 0, 0, Math.cos(t) * radius, Math.sin(t) * radius, -distance);
+    }
+    return this.circle(0, 0, -distance, radius, 0, 0, 1, segments);
+  }
+  hemisphere(size, skyColor, groundColor) {
+    return this.color(skyColor), this.circle(0, 0, 0, size, 0, 1, 0, (16)), this.halfCircle(size, 1), this.color(groundColor), this.halfCircle(size, -1);
+  }
+  audioCone(innerAngle, outerAngle, range, innerColor = (16776960), outerColor = (16755200)) {
+    return this.color(innerColor), this.cone(innerAngle * 0.5, range), this.color(outerColor), this.cone(outerAngle * 0.5, range);
+  }
+  cone(halfAngle, range) {
+    let clamped = Math.min(halfAngle, Math.PI), radius = Math.sin(clamped) * range, depth = Math.cos(clamped) * range;
+    for (let s = 0; s < (8); s++) {
+      let t = s / (8) * TAU;
+      this.segment(0, 0, 0, Math.cos(t) * radius, Math.sin(t) * radius, depth);
+    }
+    return this.circle(0, 0, depth, radius, 0, 0, 1, (32));
+  }
+  halfCircle(size, sign) {
+    let px = size, py = 0;
+    for (let s = 1; s <= (16) / 2; s++) {
+      let t = s / (16) * TAU, x = Math.cos(t) * size, y = Math.sin(t) * size * sign;
+      this.segment(px, py, 0, x, y, 0), px = x, py = y;
+    }
+    return this;
+  }
+  cornerEdges() {
+    let k = this.corners;
+    for (let e = 0; e < (12); e++) {
+      let a = BOX_EDGE_CORNERS[e * 2] * 3, b = BOX_EDGE_CORNERS[e * 2 + 1] * 3;
+      this.segment(k[a], k[a + 1], k[a + 2], k[b], k[b + 1], k[b + 2]);
+    }
+    return this;
+  }
+  basisFor(nx, ny, nz) {
+    let len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1, x = nx / len, y = ny / len, z = nz / len, rx = 0, ry = 1, rz = 0;
+    Math.abs(y) > (0.99) && (rx = 1, ry = 0);
+    let ax = ry * z - rz * y, ay = rz * x - rx * z, az = rx * y - ry * x, al = Math.sqrt(ax * ax + ay * ay + az * az) || 1;
+    ax /= al, ay /= al, az /= al;
+    let b = this.basis;
+    return b[0] = ax, b[1] = ay, b[2] = az, b[3] = y * az - z * ay, b[4] = z * ax - x * az, b[5] = x * ay - y * ax, b;
+  }
+};
+function lineGeometry(writer, dynamic = false) {
+  return {
+    attributes: {
+      position: { data: writer.positions, itemSize: 3, dynamic },
+      color: { data: writer.colors, itemSize: 4, dynamic }
+    }
+  };
+}
+function build(segments, write) {
+  let writer = new LineWriter(segments);
+  return writer.color((16776960)), write(writer), lineGeometry(writer);
+}
+function axesHelper(size = 1) {
+  return build((3), (w) => w.axes(null, 0, size));
+}
+function gridHelper(size = 10, divisions = 10, centerColor = (4473924), gridColor = (8947848)) {
+  return build((divisions + 1) * 2, (w) => w.grid(size, divisions, centerColor, gridColor));
+}
+function polarGridHelper(radius = 10, sectors = 16, rings = 8, divisions = 64, sectorColor = (4473924), ringColor = (8947848)) {
+  return build(sectors + rings * divisions, (w) => w.polarGrid(radius, sectors, rings, divisions, sectorColor, ringColor));
+}
+function arrowHelper(direction, length = 1, color = (16776960), headLength, headWidth) {
+  return build((5), (w) => w.color(color).arrow(0, 0, 0, direction[0], direction[1], direction[2], length, headLength, headWidth));
+}
+function boxHelper(min, max, color = (16776960)) {
+  return build((12), (w) => w.color(color).box(min[0], min[1], min[2], max[0], max[1], max[2]));
+}
+function cameraHelper(projectionInverse, color = (16755200)) {
+  let apex = new Float64Array(3);
+  return build((12) + (4), (w) => w.color(color).frustum(projectionInverse, 0, apex));
+}
+function directionalLightHelper(size = 1, length = size * 2, color = (16776960)) {
+  return build((5), (w) => w.color(color).directionalLight(size, length));
+}
+function spotLightHelper(angle, distance = 5, color = (16776960), segments = (32)) {
+  return build((5) + segments, (w) => w.color(color).spotLight(angle, distance, segments));
+}
+function pointLightHelper(radius = 0.5, color = (16776960), segments = (32)) {
+  return build((3) * segments, (w) => w.color(color).sphere(0, 0, 0, radius, segments));
+}
+function hemisphereLightHelper(size = 1, skyColor = 8900331, groundColor = 9132587) {
+  return build((16) * 2, (w) => w.hemisphere(size, skyColor, groundColor));
+}
+function planeHelper(normal, constant = 0, size = 1, color = (16776960)) {
+  return build((6), (w) => w.color(color).plane(normal[0], normal[1], normal[2], constant, size));
+}
+function skeletonHelper(parents, worlds, color = (65535)) {
+  let bones = parents.length;
+  return build(Math.max(1, bones), (w) => w.color(color).skeleton(parents, worlds, bones));
+}
+function vertexNormalsHelper(positions, normals, size = 0.1, color = (16711935)) {
+  let vertices = Math.floor(positions.length / 3);
+  return build(Math.max(1, vertices), (w) => w.color(color).normals(positions, normals, vertices, size));
+}
+function positionalAudioHelper(innerAngle, outerAngle, range = 1, innerColor = (16776960), outerColor = (16755200)) {
+  return build(((8) + (32)) * 2, (w) => w.audioCone(innerAngle, outerAngle, range, innerColor, outerColor));
+}
+function helperSegments(desc) {
+  return desc.attributes.position.data.length / 6;
+}
+var DEFAULT_DEBUG_CIRCLE_SEGMENTS = (32);
+
+// src/game/render/debug.ts
+var DEFAULT_DEBUG_SEGMENTS = 8192, SEGMENT_VERTICES = 2, CONTACT_CROSS = 0.1, COMPOUND_ORIGIN = [0, 0, 0], SHAPE_RIBS = 4, TRIANGLE_EDGES = 3, DEFAULT_GRID_SIZE = 10, DEFAULT_GRID_DIVISIONS = 10, DEFAULT_AXES = 1, CONTACT_COLOR = 16723285, NAV_COLOR = 3199320, SHAPE_COLOR = 6607615, DebugDraw = class {
+  constructor(graphics, options = {}) {
+    this.flushed = 0;
+    this.visible = true;
+    this.a = new Vec3();
+    this.b = new Vec3();
+    this.graphics = graphics, this.writer = new LineWriter(options.capacity ?? (8192)), this.geometry = graphics.createGeometry(lineGeometry(this.writer, true)), this.material = graphics.createMaterial({
+      kind: "lines",
+      vertexColors: true,
+      transparent: false,
+      depthTest: options.depthTest ?? true,
+      depthWrite: false
+    }), this.node = graphics.createDetached({ kind: "lines", geometry: this.geometry, material: this.material, segments: true, renderOrder: options.renderOrder ?? 0 }), graphics.setLayers(this.node, options.layers ?? 2147483647), graphics.setDrawRange(this.geometry, 0, 0);
+  }
+  get segments() {
+    return this.writer.count;
+  }
+  get dropped() {
+    return this.writer.dropped;
+  }
+  get capacity() {
+    return this.writer.capacity;
+  }
+  setLayers(mask) {
+    this.graphics.setLayers(this.node, mask);
+  }
+  setVisible(visible) {
+    visible !== this.visible && (this.visible = visible, this.graphics.setVisible(this.node, visible));
+  }
+  clear() {
+    this.writer.clear(), this.writer.setMatrix(null);
+  }
+  color(hex, alpha = 1) {
+    return this.writer.color(hex, alpha), this;
+  }
+  transform(matrix, offset = 0) {
+    return this.writer.setMatrix(matrix, offset), this;
+  }
+  line(ax, ay, az, bx, by, bz, color = (16776960)) {
+    return this.writer.color(color).segment(ax, ay, az, bx, by, bz), this;
+  }
+  ray(ox, oy, oz, dx, dy, dz, length, color = (16776960)) {
+    return this.writer.color(color).segment(ox, oy, oz, ox + dx * length, oy + dy * length, oz + dz * length), this;
+  }
+  arrow(ox, oy, oz, dx, dy, dz, length, color = (16776960)) {
+    return this.writer.color(color).arrow(ox, oy, oz, dx, dy, dz, length), this;
+  }
+  box(minX, minY, minZ, maxX, maxY, maxZ, color = (16776960)) {
+    return this.writer.color(color).box(minX, minY, minZ, maxX, maxY, maxZ), this;
+  }
+  boxTransformed(minX, minY, minZ, maxX, maxY, maxZ, matrix, offset = 0, color = (16776960)) {
+    return this.writer.color(color).box(minX, minY, minZ, maxX, maxY, maxZ, matrix, offset), this;
+  }
+  sphere(x, y, z, radius, color = (16776960), segments = DEFAULT_DEBUG_CIRCLE_SEGMENTS) {
+    return this.writer.color(color).sphere(x, y, z, radius, segments), this;
+  }
+  circle(x, y, z, radius, nx, ny, nz, color = (16776960), segments = DEFAULT_DEBUG_CIRCLE_SEGMENTS) {
+    return this.writer.color(color).circle(x, y, z, radius, nx, ny, nz, segments), this;
+  }
+  axes(matrix, offset = 0, size = (1)) {
+    return this.writer.axes(matrix, offset, size), this;
+  }
+  axesAt(px, py, pz, qx, qy, qz, qw, size = (1)) {
+    return this.writer.axesAt(px, py, pz, qx, qy, qz, qw, size), this;
+  }
+  grid(size = (10), divisions = (10), y = 0) {
+    return this.writer.grid(size, divisions, void 0, void 0, y), this;
+  }
+  polarGrid(radius, sectors, rings, divisions = DEFAULT_DEBUG_CIRCLE_SEGMENTS, y = 0) {
+    return this.writer.polarGrid(radius, sectors, rings, divisions, void 0, void 0, y), this;
+  }
+  frustum(projection, color = (16776960)) {
+    return this.writer.color(color).frustum(projection.viewProjectionInverse, 0, null), this;
+  }
+  frustumMatrix(inverseViewProjection, offset = 0, color = (16776960)) {
+    return this.writer.color(color).frustum(inverseViewProjection, offset, null), this;
+  }
+  plane(nx, ny, nz, constant, size, color = (16776960)) {
+    return this.writer.color(color).plane(nx, ny, nz, constant, size), this;
+  }
+  point(x, y, z, size, color = (16776960)) {
+    return this.writer.color(color).cross(x, y, z, size), this;
+  }
+  skeleton(parents, worlds, count = parents.length, color = (16776960)) {
+    return this.writer.color(color).skeleton(parents, worlds, count), this;
+  }
+  path(points, count, color = (16776960), closed = false) {
+    return this.writer.color(color).path(points, count, closed), this;
+  }
+  navPath(path, color = (3199320), marker = (0.1)) {
+    this.writer.color(color).path(path.points, path.count);
+    let p = path.points;
+    for (let i = 0; i < path.count; i++) this.writer.cross(p[i * 3], p[i * 3 + 1], p[i * 3 + 2], marker);
+    return this;
+  }
+  contacts(source, positions, color = (16723285), startedColor = (16776960)) {
+    let n = source.contactCount();
+    for (let i = 0; i < n; i++) {
+      positions.position(source.contactEntityA(i), this.a), positions.position(source.contactEntityB(i), this.b);
+      let a = this.a, b = this.b;
+      this.writer.color(source.contactStarted(i) ? startedColor : color), this.writer.segment(a.x, a.y, a.z, b.x, b.y, b.z), this.writer.cross((a.x + b.x) * 0.5, (a.y + b.y) * 0.5, (a.z + b.z) * 0.5, (0.1));
+    }
+    return this;
+  }
+  shape(shape2, matrix, offset = 0, color = (6607615)) {
+    let w = this.writer.color(color).setMatrix(matrix, offset);
+    switch (shape2.kind) {
+      case "ball":
+        w.sphere(0, 0, 0, shape2.radius);
+        break;
+      case "cuboid": {
+        let h = shape2.halfExtents;
+        w.box(-h[0], -h[1], -h[2], h[0], h[1], h[2]);
+        break;
+      }
+      case "capsule":
+        this.tube(shape2.radius, shape2.radius, shape2.halfHeight), w.circle(0, shape2.halfHeight, 0, shape2.radius, 1, 0, 0), w.circle(0, shape2.halfHeight, 0, shape2.radius, 0, 0, 1), w.circle(0, -shape2.halfHeight, 0, shape2.radius, 1, 0, 0), w.circle(0, -shape2.halfHeight, 0, shape2.radius, 0, 0, 1);
+        break;
+      case "cylinder":
+        this.tube(shape2.radius, shape2.radius, shape2.halfHeight);
+        break;
+      case "cone":
+        this.tube(0, shape2.radius, shape2.halfHeight);
+        break;
+      case "round_cuboid": {
+        let h = shape2.halfExtents, b = shape2.border;
+        w.box(-h[0] - b, -h[1] - b, -h[2] - b, h[0] + b, h[1] + b, h[2] + b);
+        break;
+      }
+      case "round_cylinder":
+        this.tube(shape2.radius + shape2.border, shape2.radius + shape2.border, shape2.halfHeight + shape2.border);
+        break;
+      case "round_cone":
+        this.tube(shape2.border, shape2.radius + shape2.border, shape2.halfHeight + shape2.border);
+        break;
+      case "round_convex_hull": {
+        let p = shape2.points;
+        for (let i = 0; i + 2 < p.length; i += 3) w.cross(p[i], p[i + 1], p[i + 2], (0.1) + shape2.border);
+        break;
+      }
+      case "compound":
+        for (let part of shape2.parts) {
+          let at = part.offset ?? COMPOUND_ORIGIN;
+          w.cross(at[0], at[1], at[2], (0.1));
+        }
+        break;
+      case "trimesh": {
+        let v = shape2.vertices, idx = shape2.indices;
+        for (let t = 0; t + 2 < idx.length; t += (3))
+          for (let e = 0; e < (3); e++) {
+            let i0 = idx[t + e] * 3, i1 = idx[t + (e + 1) % (3)] * 3;
+            w.segment(v[i0], v[i0 + 1], v[i0 + 2], v[i1], v[i1 + 1], v[i1 + 2]);
+          }
+        break;
+      }
+      case "convex_hull": {
+        let p = shape2.points;
+        for (let i = 0; i + 2 < p.length; i += 3) w.cross(p[i], p[i + 1], p[i + 2], (0.1));
+        break;
+      }
+      case "heightfield": {
+        let { rows, columns, heights, scale } = shape2, sx = scale[0] / Math.max(1, columns - 1), sz = scale[2] / Math.max(1, rows - 1), ox = -scale[0] * 0.5, oz = -scale[2] * 0.5;
+        for (let r = 0; r < rows; r++)
+          for (let c = 0; c < columns; c++) {
+            let y = heights[r * columns + c] * scale[1];
+            c + 1 < columns && w.segment(ox + c * sx, y, oz + r * sz, ox + (c + 1) * sx, heights[r * columns + c + 1] * scale[1], oz + r * sz), r + 1 < rows && w.segment(ox + c * sx, y, oz + r * sz, ox + c * sx, heights[(r + 1) * columns + c] * scale[1], oz + (r + 1) * sz);
+          }
+        break;
+      }
+    }
+    return w.setMatrix(null), this;
+  }
+  flush() {
+    let vertices = this.writer.count * (2);
+    vertices > 0 && (this.graphics.markGeometryDirty(this.geometry, "position", 0, vertices * 3), this.graphics.markGeometryDirty(this.geometry, "color", 0, vertices * 4)), vertices !== this.flushed && (this.graphics.setDrawRange(this.geometry, 0, vertices), this.flushed = vertices);
+  }
+  tube(radiusTop, radiusBottom, halfHeight) {
+    let w = this.writer;
+    radiusTop > 0 && w.circle(0, halfHeight, 0, radiusTop, 0, 1, 0), radiusBottom > 0 && w.circle(0, -halfHeight, 0, radiusBottom, 0, 1, 0);
+    for (let i = 0; i < (4); i++) {
+      let t = i / (4) * Math.PI * 2, c = Math.cos(t), s = Math.sin(t);
+      w.segment(c * radiusTop, halfHeight, s * radiusTop, c * radiusBottom, -halfHeight, s * radiusBottom);
+    }
+  }
+};
+
+// src/game/ui/labels.ts
+var DEFAULT_LABEL_CAPACITY = 64, VEC3 = 3, OCCLUSION_EPSILON = 1e-3, OPACITY_STEPS = 32, NO_SLOT = -1, VISIBLE = 1, HIDDEN = 0, ScreenLabels = class {
+  constructor(options = {}) {
+    this.count = 0;
+    this.world = new Vec3();
+    this.ndc = new Vec3();
+    this.hit = createPickHit();
+    this.origin = new Float32Array((3));
+    this.direction = new Float32Array((3));
+    let n = options.capacity ?? (64);
+    this.capacity = n, this.x = new Float32Array(n), this.y = new Float32Array(n), this.depth = new Float32Array(n), this.distance = new Float32Array(n), this.opacity = new Float32Array(n), this.visible = new Uint8Array(n), this.offscreen = new Uint8Array(n), this.occluded = new Uint8Array(n), this.live = new Uint8Array(n), this.entities = new Uint32Array(n).fill(NO_ENTITY), this.points = new Float32Array(n * (3)), this.offsets = new Float32Array(n * (3)), this.occludes = new Uint8Array(n), this.nodes = new Uint32Array(n), this.labelEntity = new Uint32Array(n).fill(NO_ENTITY), this.shownOpacity = new Float32Array(n).fill(-1), this.shown = new Uint8Array(n).fill((1)), this.hudX = new Int32Array(n).fill((-1)), this.hudY = new Int32Array(n).fill((-1)), this.hudVisible = new Int32Array(n).fill((-1)), this.hudOpacity = new Int32Array(n).fill((-1)), this.styles = new Array(n).fill(null), this.anchors = options.anchors ?? null, this.ui = options.ui ?? null, this.engine = options.engineText ?? null, this.occluder = options.occluder ?? null, this.occlusionLayers = options.occlusionLayers ?? 4294967295, this.fadeNear = options.fadeNear ?? 0, this.fadeFar = options.fadeFar ?? 0, this.clampToEdge = options.clampToEdge ?? false, this.margin = options.margin ?? 0;
+  }
+  get size() {
+    return this.count;
+  }
+  add(desc) {
+    let label = -1;
+    for (let i = 0; i < this.capacity; i++)
+      if (this.live[i] === 0) {
+        label = i;
+        break;
+      }
+    if (label < 0) throw new GameError("capacity_exceeded", `at most ${this.capacity} screen labels`);
+    if (desc.entity === void 0 && desc.point === void 0) throw new GameError("invalid_argument", "a label needs an entity or a point");
+    this.live[label] = 1, this.count++, this.entities[label] = desc.entity ?? NO_ENTITY;
+    let p = label * (3);
+    this.points[p] = desc.point?.[0] ?? 0, this.points[p + 1] = desc.point?.[1] ?? 0, this.points[p + 2] = desc.point?.[2] ?? 0, this.offsets[p] = desc.offset?.[0] ?? 0, this.offsets[p + 1] = desc.offset?.[1] ?? 0, this.offsets[p + 2] = desc.offset?.[2] ?? 0, this.occludes[label] = desc.occlude === false ? 0 : 1, this.shownOpacity[label] = -1, this.shown[label] = (1);
+    let name = desc.name ?? `label${label}`;
+    desc.hud && this.ui && (this.hudX[label] = this.ui.hudNumber(`${name}.x`), this.hudY[label] = this.ui.hudNumber(`${name}.y`), this.hudVisible[label] = this.ui.hudNumber(`${name}.visible`), this.hudOpacity[label] = this.ui.hudNumber(`${name}.opacity`, 1));
+    let engine = this.engine;
+    if (engine && desc.text !== void 0) {
+      let style = { ...desc.style, opacity: desc.style?.opacity ?? 1 };
+      this.styles[label] = style;
+      let entity = engine.spawner.spawn();
+      engine.add?.(entity), this.nodes[label] = engine.text.create(entity, { ...style, kind: "text2d", text: desc.text }), this.labelEntity[label] = entity;
+    }
+    return label;
+  }
+  textEntity(label) {
+    return this.labelEntity[label];
+  }
+  node(label) {
+    return this.nodes[label];
+  }
+  setPoint(label, x, y, z) {
+    let p = label * (3);
+    this.points[p] = x, this.points[p + 1] = y, this.points[p + 2] = z;
+  }
+  setText(label, text2) {
+    this.engine && this.styles[label] !== null && this.engine.text.setText(this.nodes[label], text2);
+  }
+  remove(label) {
+    this.live[label] !== 0 && (this.live[label] = 0, this.count--, this.visible[label] = (0), this.engine && this.styles[label] !== null && this.engine.text.setVisible(this.nodes[label], false), this.styles[label] = null, this.entities[label] = NO_ENTITY);
+  }
+  update(projection) {
+    let width = projection.width, height = projection.height, fade = this.fadeFar > this.fadeNear;
+    for (let i = 0; i < this.capacity; i++) {
+      if (this.live[i] === 0) continue;
+      this.anchor(i);
+      let distance = projection.position.distanceTo(this.world);
+      this.distance[i] = distance;
+      let inside = projection.worldToNdc(this.world, this.ndc), front = projection.w > 0, nx = this.ndc.x, ny = this.ndc.y, show = inside, off = 0;
+      if (!inside && this.clampToEdge) {
+        front || (nx = -nx, ny = -ny);
+        let extent = Math.max(Math.abs(nx), Math.abs(ny));
+        if (extent > 1 || !front) {
+          let s = extent > 0 ? 1 / extent : 1;
+          nx *= s, ny *= s;
+        }
+        show = true, off = 1;
+      }
+      let px = (nx + 1) * 0.5 * width, py = (1 - ny) * 0.5 * height;
+      off === 1 && (px = Math.min(width - this.margin, Math.max(this.margin, px)), py = Math.min(height - this.margin, Math.max(this.margin, py)));
+      let occluded = 0;
+      show && off === 0 && this.occluder && this.occludes[i] === 1 && distance > (1e-3) && (occluded = this.occludedBy(projection, distance) ? 1 : 0, occluded === 1 && (show = false));
+      let alpha = show ? 1 : 0;
+      if (show && fade) {
+        let t = Math.min(1, Math.max(0, (distance - this.fadeNear) / (this.fadeFar - this.fadeNear)));
+        alpha = 1 - t * t * (3 - 2 * t), alpha <= 0 && (show = false);
+      }
+      this.x[i] = px, this.y[i] = py, this.depth[i] = this.ndc.z, this.opacity[i] = alpha, this.visible[i] = show ? (1) : (0), this.offscreen[i] = off, this.occluded[i] = occluded, this.publish(i, show, px, py, alpha);
+    }
+  }
+  anchor(i) {
+    let p = i * (3), entity = this.entities[i];
+    entity !== NO_ENTITY && this.anchors ? this.anchors.renderPosition(entity, this.world) : this.world.set(this.points[p], this.points[p + 1], this.points[p + 2]), this.world.set(this.world.x + this.offsets[p], this.world.y + this.offsets[p + 1], this.world.z + this.offsets[p + 2]);
+  }
+  occludedBy(projection, distance) {
+    let occluder = this.occluder, o = projection.position, inv = 1 / distance;
+    return this.origin[0] = o.x, this.origin[1] = o.y, this.origin[2] = o.z, this.direction[0] = (this.world.x - o.x) * inv, this.direction[1] = (this.world.y - o.y) * inv, this.direction[2] = (this.world.z - o.z) * inv, occluder.raycast(this.origin, this.direction, this.hit, distance, this.occlusionLayers) ? this.hit.distance < distance - (1e-3) : false;
+  }
+  publish(i, show, px, py, alpha) {
+    let ui = this.ui;
+    ui && this.hudX[i] !== (-1) && (ui.setNumber(this.hudX[i], px), ui.setNumber(this.hudY[i], py), ui.setNumber(this.hudVisible[i], show ? (1) : (0)), ui.setNumber(this.hudOpacity[i], Math.round(alpha * (32)) / (32)));
+    let engine = this.engine, style = this.styles[i];
+    if (!engine || style === null) return;
+    let node2 = this.nodes[i], shown = show ? (1) : (0);
+    if (shown !== this.shown[i] && (this.shown[i] = shown, engine.text.setVisible(node2, show)), !show) return;
+    engine.placement.setPosition(this.labelEntity[i], px, py, 0);
+    let stepped = Math.round(alpha * (32)) / (32);
+    stepped !== this.shownOpacity[i] && (this.shownOpacity[i] = stepped, style.opacity = stepped, engine.text.setTextStyle(node2, style));
+  }
+};
+function engineLabelText(graphics, transforms, world) {
+  return {
+    text: graphics,
+    placement: transforms,
+    spawner: world,
+    add: (entity) => {
+      transforms.add(entity);
+    }
+  };
+}
+
+// src/game/kernel/std/intrinsics.ts
+var fround = Math.fround, TWO_32 = 2 ** 32, LOW_16 = 65535, TWO_16 = 65536;
+function fsin(x) {
+  return sin(fround(x));
+}
+function fcos(x) {
+  return cos(fround(x));
+}
+function ftan(x) {
+  return tan(fround(x));
+}
+function fasin(x) {
+  return asin(fround(x));
+}
+function facos(x) {
+  return acos(fround(x));
+}
+function fatan(x) {
+  return atan(fround(x));
+}
+function fatan2(y, x) {
+  return atan2(fround(y), fround(x));
+}
+function fexp(x) {
+  return exp(fround(x));
+}
+function flog(x) {
+  return log(fround(x));
+}
+function flog2(x) {
+  return log2(fround(x));
+}
+function fpow(x, y) {
+  return pow(fround(x), fround(y));
+}
+function umulhi(a, b) {
+  let x = a >>> 0, y = b >>> 0, xl = x & (65535), xh = x >>> 16, yl = y & (65535), yh = y >>> 16, lh = xl * yh, hl = xh * yl, mid = (xl * yl >>> 16) + (lh & (65535)) + (hl & (65535));
+  return xh * yh + (lh >>> 16) + (hl >>> 16) + Math.floor(mid / (65536)) >>> 0;
+}
+function uaddCarry(a, b, carry) {
+  return (a >>> 0) + (b >>> 0) + (carry & 1) >= TWO_32 ? 1 : 0;
+}
+function usubBorrow(a, b, borrow) {
+  return a >>> 0 < (b >>> 0) + (borrow & 1) ? 1 : 0;
+}
+
+// src/game/scenes/catalogue.ts
+var SCENE_CATALOGUE_VERSION = 1, STARTER_CATALOGUE = {
+  bench: { footprint: [1.6, 0.6], height: 0.9, size: "medium", tags: ["street", "seat", "rest"], up: "+y", forward: "+z", solid: true, anchors: { seat: [0, 0.45, 0.05], front: [0, 0, 0.6], edge: [0.8, 0.45, 0] } },
+  street_lamp: { footprint: [0.4, 0.4], height: 4.5, size: "tiny", tags: ["street", "light"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 4.5, 0], front: [0, 0, 0.5] } },
+  bus_stop: { footprint: [3.5, 1.5], height: 2.6, size: "medium", tags: ["street", "transit", "shelter"], up: "+y", forward: "+z", solid: true, anchors: { seat: [0, 0.45, -0.3], front: [0, 0, 1.2], top: [0, 2.6, 0] } },
+  trash_bin: { footprint: [0.5, 0.5], height: 1, size: "small", tags: ["street", "utility"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 0.5], top: [0, 1, 0] } },
+  bollard: { footprint: [0.25, 0.25], height: 1, size: "tiny", tags: ["street", "barrier"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 1, 0] } },
+  fire_hydrant: { footprint: [0.4, 0.4], height: 0.8, size: "tiny", tags: ["street", "utility"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 0.5] } },
+  mailbox: { footprint: [0.5, 0.5], height: 1.2, size: "small", tags: ["street", "utility"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 0.6], top: [0, 1.2, 0] } },
+  bike_rack: { footprint: [2, 0.6], height: 0.9, size: "medium", tags: ["street", "transit"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 1], edge: [1, 0.5, 0] } },
+  planter: { footprint: [1.2, 1.2], height: 0.8, size: "small", tags: ["street", "plant"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 0.8, 0], edge: [0.6, 0.5, 0] } },
+  fountain: { footprint: [4, 4], height: 2.2, size: "large", tags: ["street", "landmark", "water"], up: "+y", forward: "+z", solid: true, anchors: { edge: [2, 0.5, 0], front: [0, 0, 2.4] } },
+  kiosk: { footprint: [2.5, 2.5], height: 3, size: "medium", tags: ["street", "shop"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 1.6], door: [0, 0, 1.25], top: [0, 3, 0] } },
+  parked_car: { footprint: [1.9, 4.5], height: 1.5, size: "large", tags: ["street", "vehicle"], up: "+y", forward: "+z", solid: true, anchors: { door: [1, 0, 0.3], front: [0, 0, 2.6], back: [0, 0, -2.6] } },
+  spawn_point: { footprint: [0.8, 0.8], height: 0, size: "small", tags: ["street", "marker", "gameplay"], up: "+y", forward: "+z", solid: false, anchors: { front: [0, 0, 0] } },
+  waypoint: { footprint: [0.5, 0.5], height: 0, size: "small", tags: ["street", "marker", "gameplay"], up: "+y", forward: "+z", solid: false, anchors: { front: [0, 0, 0] } },
+  market_stall: { footprint: [3, 2], height: 2.6, size: "medium", tags: ["market", "shop", "shelter"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 1.3], edge: [0, 0.9, 0.9], top: [0, 0.9, 0.2], back: [0, 0, -1.2] } },
+  crate_stack: { footprint: [1.2, 1.2], height: 1.4, size: "small", tags: ["market", "storage"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 1.4, 0] } },
+  barrel: { footprint: [0.7, 0.7], height: 1, size: "small", tags: ["market", "storage"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 1, 0] } },
+  produce_table: { footprint: [2, 1], height: 0.9, size: "medium", tags: ["market", "shop", "table"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 0.9, 0], front: [0, 0, 0.8], edge: [0, 0.9, 0.5] } },
+  parasol: { footprint: [2.4, 2.4], height: 2.5, size: "medium", tags: ["market", "shade"], up: "+y", forward: "+z", solid: false, anchors: { top: [0, 2.5, 0] } },
+  cart: { footprint: [1.2, 2.2], height: 1.3, size: "medium", tags: ["market", "vehicle", "shop"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 0.9, 0], front: [0, 0, 1.4] } },
+  goal: { footprint: [7.3, 2], height: 2.44, size: "large", tags: ["sports", "football"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 1.5], edge: [3.65, 1.2, 0] } },
+  basketball_hoop: { footprint: [1.8, 2], height: 3.95, size: "medium", tags: ["sports", "basketball"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 2.2], top: [0, 3.05, 1.2] } },
+  bleacher: { footprint: [8, 3], height: 2.4, size: "large", tags: ["sports", "seat", "crowd"], up: "+y", forward: "+z", solid: true, anchors: { seat: [0, 1.2, 0], front: [0, 0, 1.8] } },
+  scoreboard: { footprint: [4, 0.6], height: 5, size: "large", tags: ["sports", "display"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 1] } },
+  corner_flag: { footprint: [0.2, 0.2], height: 1.5, size: "tiny", tags: ["sports", "football", "marker"], up: "+y", forward: "+z", solid: false, anchors: { top: [0, 1.5, 0] } },
+  ball_rack: { footprint: [1.5, 0.6], height: 1.1, size: "medium", tags: ["sports", "storage"], up: "+y", forward: "+z", solid: true, anchors: { front: [0, 0, 0.7], top: [0, 1.1, 0] } },
+  table: { footprint: [1.6, 0.9], height: 0.75, size: "medium", tags: ["interior", "table"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 0.75, 0], edge: [0, 0.75, 0.45], front: [0, 0, 0.9] } },
+  chair: { footprint: [0.5, 0.5], height: 0.9, size: "small", tags: ["interior", "seat"], up: "+y", forward: "+z", solid: true, anchors: { seat: [0, 0.45, 0], front: [0, 0, 0.5] } },
+  sofa: { footprint: [2.2, 0.9], height: 0.85, size: "medium", tags: ["interior", "seat", "rest"], up: "+y", forward: "+z", solid: true, anchors: { seat: [0, 0.45, 0.1], front: [0, 0, 0.9] } },
+  bed: { footprint: [1.6, 2.1], height: 0.6, size: "medium", tags: ["interior", "rest"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 0.6, 0], edge: [0.8, 0.5, 0], front: [0.95, 0, 0] } },
+  shelf: { footprint: [1.2, 0.4], height: 2, size: "small", tags: ["interior", "storage"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 2, 0], front: [0, 0, 0.6] } },
+  counter: { footprint: [3, 0.8], height: 1.05, size: "medium", tags: ["interior", "shop", "table"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 1.05, 0], front: [0, 0, 0.9], back: [0, 0, -0.9] } },
+  door: { footprint: [1, 0.2], height: 2.1, size: "small", tags: ["interior", "passage"], up: "+y", forward: "+z", solid: false, anchors: { door: [0, 0, 0], front: [0, 0, 0.6], back: [0, 0, -0.6] } },
+  rug: { footprint: [2, 3], height: 0.02, size: "medium", tags: ["interior", "decor", "flat"], up: "+y", forward: "+z", solid: false, anchors: { top: [0, 0.02, 0] } },
+  lamp: { footprint: [0.3, 0.3], height: 0.5, size: "tiny", tags: ["interior", "light"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 0.5, 0] } },
+  tree: { footprint: [1, 1], height: 7, size: "small", tags: ["nature", "plant", "shade"], up: "+y", forward: "+z", solid: true, anchors: { edge: [0.5, 0, 0] } },
+  bush: { footprint: [1.4, 1.4], height: 1.2, size: "small", tags: ["nature", "plant"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 1.2, 0] } },
+  rock: { footprint: [1.6, 1.2], height: 0.9, size: "medium", tags: ["nature", "stone"], up: "+y", forward: "+z", solid: true, anchors: { top: [0, 0.9, 0], seat: [0, 0.6, 0.3] } },
+  log: { footprint: [2.5, 0.5], height: 0.5, size: "medium", tags: ["nature", "seat", "wood"], up: "+y", forward: "+z", solid: true, anchors: { seat: [0, 0.5, 0], front: [0, 0, 0.6] } },
+  flower_bed: { footprint: [2, 1], height: 0.4, size: "medium", tags: ["nature", "plant", "flat"], up: "+y", forward: "+z", solid: false, anchors: { edge: [1, 0.2, 0] } }
+};
+function extendCatalogue(extra, base = STARTER_CATALOGUE) {
+  return Object.freeze({ ...base, ...extra });
+}
+
+export { DEFAULT_DEBUG_SEGMENTS, DEFAULT_LABEL_CAPACITY, DebugDraw, IMPORT_DEFAULT_MAX_DRIFT, IMPORT_DEFAULT_SAMPLES, ImportError, LineWriter, MLP_MEMORY_MAX, MLP_MEMORY_MIN, MOE_DEFAULT_BALANCE, SCENE_CATALOGUE_VERSION, STARTER_CATALOGUE, ScreenLabels, arrowHelper, axesHelper, boxHelper, cameraHelper, checkNet, directionalLightHelper, engineLabelText, extendCatalogue, facos, fasin, fatan, fatan2, fcos, fexp, floatEval, flog, flog2, fpow, fsin, ftan, generatedSamples, gridHelper, helperSegments, hemisphereLightHelper, importMlp, importMoe, joinMemory, lineGeometry, memorySamples, plainNet, planeHelper, pointLightHelper, polarGridHelper, positionalAudioHelper, readOnnx, skeletonHelper, spotLightHelper, trainMlp, trainMoe, uaddCarry, umulhi, usubBorrow, vertexNormalsHelper };