@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-GDB6TCSD.js

@@ -0,0 +1,450 @@
+'use strict';
+
+var chunk7SM6XSPZ_js = require('./chunk-7SM6XSPZ.js');
+var chunk7DQSDKDU_js = require('./chunk-7DQSDKDU.js');
+var chunkX5A5FOWW_js = require('./chunk-X5A5FOWW.js');
+var chunkNZTKLY2W_js = require('./chunk-NZTKLY2W.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/kit/feel/particles.ts
+var SPAWN_X = 0, SPAWN_Y = 1, SPAWN_Z = 2, SPAWN_VX = 3, SPAWN_VY = 4, SPAWN_VZ = 5, SPAWN_LIFE = 6, SPAWN_SIZE = 7, SPAWN_R = 8, SPAWN_G = 9, SPAWN_B = 10, SPAWN_SPIN = 11, SPAWN_END_R = 12, SPAWN_END_G = 13, SPAWN_END_B = 14;
+var Particles = class {
+  constructor(graphics, geometry, material, options) {
+    this.spawn = new Float64Array(15);
+    this.field = new Float64Array(7);
+    this.count = 0;
+    this.visible = 0;
+    this.graphics = graphics, this.options = options, this.state = new Float32Array(options.capacity * 20), this.batch = graphics.instanced({ geometry, material, capacity: options.capacity, colors: true }), graphics.setInstanceCount(this.batch, 0);
+    let f = this.field;
+    f.set(options.gravity, 0);
+    let plane = options.plane;
+    plane !== null && f.set(plane, 3), this.lateral = f[0] !== 0 || f[2] !== 0, this.floor = plane !== null && f[3] === 0 && f[4] === 1 && f[5] === 0, this.slanted = plane !== null && !this.floor, this.liveColor = options.additive || options.tint;
+    let m = this.batch.matrices;
+    for (let i = 0; i < options.capacity; i++) m[i * 16 + 15] = 1;
+  }
+  get live() {
+    return this.count;
+  }
+  emit() {
+    if (this.count >= this.options.capacity) return;
+    let o = this.count * 20, s = this.state, p = this.spawn;
+    s[o + 0] = p[0], s[o + 1] = p[1], s[o + 2] = p[2], s[o + 3] = p[3], s[o + 4] = p[4], s[o + 5] = p[5], s[o + 6] = 0, s[o + 7] = p[6], s[o + 8] = p[7], s[o + 9] = p[11] * p[6], s[o + 10] = p[11];
+    let ax = p[4] - p[5] + 0.37, ay = p[5] - p[3] + 0.11, az = p[3] - p[4] + 0.73, inv = 1 / Math.sqrt(ax * ax + ay * ay + az * az);
+    s[o + 11] = ax * inv, s[o + 12] = ay * inv, s[o + 13] = az * inv, s[o + 14] = p[8], s[o + 15] = p[9], s[o + 16] = p[10], s[o + 17] = p[12], s[o + 18] = p[13], s[o + 19] = p[14];
+    let colors = this.batch.colors;
+    if (!this.liveColor && colors !== null) {
+      let co = this.count * 3;
+      colors[co] = p[8], colors[co + 1] = p[9], colors[co + 2] = p[10];
+    }
+    this.count++;
+  }
+  clear() {
+    this.count = 0;
+  }
+  update(clock, slot, camera, cameraOffset) {
+    let dt = clock[slot], s = this.state, f = this.field, colors = this.batch.colors, moveColor = !this.liveColor && colors !== null, lateral = this.lateral, floor = this.floor, slanted = this.slanted, bounce = this.options.bounce, damping = 1 - this.options.drag * dt, fall = f[1] * dt, ground = -f[6], i = 0;
+    for (; i < this.count; ) {
+      let o = i * 20;
+      if (s[o + 6] += dt, s[o + 6] >= s[o + 7]) {
+        this.count--;
+        let last = this.count * 20;
+        for (let k = 0; k < 20; k++) s[o + k] = s[last + k];
+        if (moveColor && colors !== null) {
+          let to = i * 3, from = this.count * 3;
+          colors[to] = colors[from], colors[to + 1] = colors[from + 1], colors[to + 2] = colors[from + 2];
+        }
+        continue;
+      }
+      if (lateral ? (s[o + 3] = (s[o + 3] + f[0] * dt) * damping, s[o + 5] = (s[o + 5] + f[2] * dt) * damping) : (s[o + 3] *= damping, s[o + 5] *= damping), s[o + 4] = (s[o + 4] + fall) * damping, s[o + 0] += s[o + 3] * dt, s[o + 1] += s[o + 4] * dt, s[o + 2] += s[o + 5] * dt, floor && s[o + 1] < ground)
+        s[o + 1] = ground, s[o + 4] = s[o + 4] < 0 ? -s[o + 4] * bounce : s[o + 4] * bounce, s[o + 3] *= bounce, s[o + 5] *= bounce, s[o + 10] *= bounce;
+      else if (slanted) {
+        let depth = s[o + 0] * f[3] + s[o + 1] * f[4] + s[o + 2] * f[5] + f[6];
+        if (depth < 0) {
+          s[o + 0] -= depth * f[3], s[o + 1] -= depth * f[4], s[o + 2] -= depth * f[5];
+          let into = s[o + 3] * f[3] + s[o + 4] * f[4] + s[o + 5] * f[5], push = into < 0 ? 2 * into : 0;
+          s[o + 3] = (s[o + 3] - push * f[3]) * bounce, s[o + 4] = (s[o + 4] - push * f[4]) * bounce, s[o + 5] = (s[o + 5] - push * f[5]) * bounce, s[o + 10] *= bounce;
+        }
+      }
+      s[o + 9] += s[o + 10] * dt, i++;
+    }
+    this.write(camera, cameraOffset);
+  }
+  write(camera, c) {
+    let s = this.state, m = this.batch.matrices, colors = this.batch.colors, opt = this.options, rx = camera[c], ry = camera[c + 1], rz = camera[c + 2], ux = camera[c + 4], uy = camera[c + 5], uz = camera[c + 6], fx = camera[c + 8], fy = camera[c + 9], fz = camera[c + 10], additive = opt.additive, facing = opt.facing === "camera", aspect = opt.aspect, liveColor = this.liveColor;
+    for (let i = 0; i < this.count; i++) {
+      let o = i * 20, t = s[o + 6] / s[o + 7], fade = t < 0.65 ? 1 : 1 - (t - 0.65) / (1 - 0.65), size = additive ? s[o + 8] : s[o + 8] * fade, w = size, h = size * aspect, cos = Math.cos(s[o + 9]), sin = Math.sin(s[o + 9]), mo = i * 16;
+      if (facing)
+        m[mo] = (rx * cos + ux * sin) * w, m[mo + 1] = (ry * cos + uy * sin) * w, m[mo + 2] = (rz * cos + uz * sin) * w, m[mo + 4] = (ux * cos - rx * sin) * h, m[mo + 5] = (uy * cos - ry * sin) * h, m[mo + 6] = (uz * cos - rz * sin) * h, m[mo + 8] = fx, m[mo + 9] = fy, m[mo + 10] = fz;
+      else {
+        let x = s[o + 11], y = s[o + 12], z = s[o + 13], k = 1 - cos;
+        m[mo] = (cos + x * x * k) * w, m[mo + 1] = (y * x * k + z * sin) * w, m[mo + 2] = (z * x * k - y * sin) * w, m[mo + 4] = (x * y * k - z * sin) * h, m[mo + 5] = (cos + y * y * k) * h, m[mo + 6] = (z * y * k + x * sin) * h, m[mo + 8] = x * z * k + y * sin, m[mo + 9] = y * z * k - x * sin, m[mo + 10] = cos + z * z * k;
+      }
+      if (m[mo + 12] = s[o + 0], m[mo + 13] = s[o + 1], m[mo + 14] = s[o + 2], liveColor && colors !== null) {
+        let co = i * 3, scale = additive ? fade : 1;
+        colors[co] = (s[o + 14] + (s[o + 17] - s[o + 14]) * t) * scale, colors[co + 1] = (s[o + 15] + (s[o + 18] - s[o + 15]) * t) * scale, colors[co + 2] = (s[o + 16] + (s[o + 19] - s[o + 16]) * t) * scale;
+      }
+    }
+    this.count === 0 && this.visible === 0 || (this.visible = this.count, this.graphics.setInstanceCount(this.batch, this.count), this.graphics.markInstancesDirty(this.batch));
+  }
+};
+
+// src/game/kit/feel/spray.ts
+var ORIGIN_X = 0, ORIGIN_Y = 1, ORIGIN_Z = 2, ORIGIN_QX = 3, ORIGIN_QY = 4, ORIGIN_QZ = 5, ORIGIN_QW = 6, ORIGIN_FIELDS = 7, FULL_CELL = [0, 0, 1, 1], MAT4 = 16, BYTE = 255, TAU = Math.PI * 2, SHAPE_POINT = 0, SHAPE_SPHERE = 1, SHAPE_CONE = 2, SHAPE_BOX = 3, SHAPE_DISC = 4, LIFE_MIN = 0, LIFE_MAX = 1, SPEED_MIN = 2, SPEED_MAX = 3, SIZE_MIN = 4, SIZE_MAX = 5, SPIN = 6, SPREAD = 7, RADIUS = 8, BOX_X = 9, BOX_Y = 10, BOX_Z = 11, START_R = 12, START_G = 13, START_B = 14, END_R = 15, END_G = 16, END_B = 17, RATE = 18, OWED = 19, PARAMS = 20, DRAW_U = 0, DRAW_V = 1, DRAW_W = 2, DRAW_SPEED = 3, DRAWS = 4;
+function quad(game, cell) {
+  let [u0, v0, u1, v1] = cell;
+  return game.graphics.createGeometry({
+    attributes: {
+      position: { data: new Float32Array([-0.5, 0.5, 0, 0.5, 0.5, 0, -0.5, -0.5, 0, 0.5, -0.5, 0]), itemSize: 3 },
+      normal: { data: new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]), itemSize: 3 },
+      uv: { data: new Float32Array([u0, v0, u1, v0, u0, v1, u1, v1]), itemSize: 2 }
+    },
+    index: new Uint16Array([0, 2, 1, 2, 3, 1])
+  });
+}
+function shapeCode(desc) {
+  switch (desc.shape?.kind ?? "point") {
+    case "sphere":
+      return (1);
+    case "cone":
+      return (2);
+    case "box":
+      return (3);
+    case "disc":
+      return (4);
+    default:
+      return (0);
+  }
+}
+function channels(hex, out, at) {
+  out[at] = (hex >> 16 & (255)) / (255), out[at + 1] = (hex >> 8 & (255)) / (255), out[at + 2] = (hex & (255)) / (255);
+}
+function planeOf(desc) {
+  let collision = desc.collision;
+  return collision !== void 0 && collision.kind === "plane" ? collision.plane : null;
+}
+var Spray = class {
+  constructor(game, options) {
+    this.origin = new Float64Array((7));
+    this.p = new Float64Array((20));
+    this.draw = new Float64Array((4));
+    this.game = game, this.random = game.random;
+    let g = game.graphics, desc = options.emitter, cell = options.cell ?? FULL_CELL;
+    if (this.entity = game.world.spawn(), game.transforms.add(this.entity, 0, 0, 0), this.origin[(6)] = 1, this.shape = shapeCode(desc), this.configure(desc), this.gpu = g.capabilities.particles === true, this.gpu) {
+      let material = g.createMaterial({
+        ...options.material,
+        textureTransforms: { map: { offset: [cell[0], cell[1]], repeat: [cell[2] - cell[0], cell[3] - cell[1]] } }
+      });
+      this.emitter = g.createEmitter({ ...desc, material }), g.particles(this.entity, this.emitter), this.particles = null;
+      return;
+    }
+    this.emitter = null, this.particles = new Particles(g, quad(game, cell), g.createMaterial(options.material), {
+      capacity: desc.capacity,
+      gravity: desc.gravity ?? [0, 0, 0],
+      drag: desc.drag ?? 0,
+      facing: options.facing ?? "camera",
+      additive: desc.additive === true,
+      tint: desc.color !== void 0 && desc.color[1] !== desc.color[0],
+      aspect: options.aspect ?? 1,
+      plane: planeOf(desc),
+      bounce: desc.collision !== void 0 && desc.collision.kind !== "none" ? desc.collision.bounce ?? 0 : 0
+    });
+  }
+  configure(desc) {
+    let p = this.p;
+    p[(0)] = desc.lifetime?.[0] ?? 1, p[(1)] = desc.lifetime?.[1] ?? p[(0)], p[(2)] = desc.speed?.[0] ?? 1, p[(3)] = desc.speed?.[1] ?? p[(2)], p[(4)] = desc.size?.[0] ?? 0.1, p[(5)] = desc.size?.[1] ?? p[(4)], p[(6)] = desc.spin ?? 0, p[(7)] = desc.spread ?? 0;
+    let shape = desc.shape;
+    shape !== void 0 && ((shape.kind === "sphere" || shape.kind === "disc") && (p[(8)] = shape.radius), shape.kind === "cone" && (p[(7)] += shape.angle, p[(8)] = shape.radius ?? 0), shape.kind === "box" && (p[(9)] = shape.size[0], p[(10)] = shape.size[1], p[(11)] = shape.size[2])), channels(desc.color?.[0] ?? 16777215, p, (12)), channels(desc.color?.[1] ?? desc.color?.[0] ?? 16777215, p, (15)), p[(18)] = desc.rate ?? 0;
+  }
+  burst(count) {
+    if (this.commit(), this.emitter !== null) {
+      this.game.graphics.emit(this.emitter, count);
+      return;
+    }
+    for (let i = 0; i < count; i++) this.spawnOne();
+  }
+  rate(perSecond) {
+    this.p[(18)] !== perSecond && (this.p[(18)] = perSecond, this.emitter !== null && this.game.graphics.setEmitterRate(this.emitter, perSecond));
+  }
+  clear() {
+    this.p[(19)] = 0, this.rate(0), this.particles !== null && this.particles.clear();
+  }
+  update(clock, slot, camera) {
+    let particles = this.particles;
+    if (particles === null) {
+      this.p[(18)] > 0 && this.commit();
+      return;
+    }
+    let p = this.p;
+    if (p[(18)] > 0)
+      for (p[(19)] += p[(18)] * clock[slot]; p[(19)] >= 1; )
+        p[(19)] -= 1, this.spawnOne();
+    let t = this.game.transforms;
+    particles.update(clock, slot, t.store.fields.render, t.row(camera) * (16));
+  }
+  commit() {
+    let o = this.origin, t = this.game.transforms;
+    t.setPosition(this.entity, o[(0)], o[(1)], o[(2)]), t.setRotation(this.entity, o[(3)], o[(4)], o[(5)], o[(6)]);
+  }
+  spawnOne() {
+    let particles = this.particles;
+    if (particles === null) return;
+    let r = this.random, p = this.p, d = this.draw, s = particles.spawn, lx = 0, ly = 0, lz = 0;
+    switch (r.rangeInto(d, (0), 0, 1), r.rangeInto(d, (1), 0, 1), r.rangeInto(d, (2), 0, 1), this.shape) {
+      case (1): {
+        let z = d[(0)] * 2 - 1, ring = Math.sqrt(1 - z * z), a = d[(1)] * TAU, radius = p[(8)] * Math.cbrt(d[(2)]);
+        lx = Math.cos(a) * ring * radius, ly = z * radius, lz = Math.sin(a) * ring * radius;
+        break;
+      }
+      case (2):
+      case (4): {
+        let a = d[(1)] * TAU, radius = p[(8)] * Math.sqrt(d[(0)]);
+        lx = Math.cos(a) * radius, lz = Math.sin(a) * radius;
+        break;
+      }
+      case (3):
+        lx = (d[(0)] - 0.5) * p[(9)], ly = (d[(1)] - 0.5) * p[(10)], lz = (d[(2)] - 0.5) * p[(11)];
+        break;
+    }
+    r.rangeInto(d, (0), 0, 1), r.rangeInto(d, (1), 0, 1);
+    let tilt = Math.acos(1 - d[(0)] * (1 - Math.cos(Math.min(Math.PI, p[(7)])))), turn = d[(1)] * TAU, dx = Math.sin(tilt) * Math.cos(turn), dy = Math.cos(tilt), dz = Math.sin(tilt) * Math.sin(turn);
+    if (this.shape === (1)) {
+      let length = Math.sqrt(lx * lx + ly * ly + lz * lz);
+      length > 0 && (dx = lx / length, dy = ly / length, dz = lz / length);
+    }
+    let o = this.origin, qx = o[(3)], qy = o[(4)], qz = o[(5)], qw = o[(6)];
+    r.rangeInto(d, (3), p[(2)], p[(3)]);
+    for (let pass = 0; pass < 2; pass++) {
+      let vx = pass === 0 ? lx : dx, vy = pass === 0 ? ly : dy, vz = pass === 0 ? lz : dz, tx = 2 * (qy * vz - qz * vy), ty = 2 * (qz * vx - qx * vz), tz = 2 * (qx * vy - qy * vx), wx = vx + qw * tx + (qy * tz - qz * ty), wy = vy + qw * ty + (qz * tx - qx * tz), wz = vz + qw * tz + (qx * ty - qy * tx);
+      pass === 0 ? (s[0] = o[(0)] + wx, s[1] = o[(1)] + wy, s[2] = o[(2)] + wz) : (s[3] = wx * d[(3)], s[4] = wy * d[(3)], s[5] = wz * d[(3)]);
+    }
+    r.rangeInto(s, 6, p[(0)], p[(1)]), r.rangeInto(s, 7, p[(4)], p[(5)]), r.rangeInto(s, 11, -p[(6)], p[(6)]), s[8] = p[(12)], s[9] = p[(13)], s[10] = p[(14)], s[12] = p[(15)], s[13] = p[(16)], s[14] = p[(17)], particles.emit();
+  }
+};
+
+// src/game/kit/host/surface-input.ts
+function attachSurfaceInput(input, surface) {
+  let stopPointer = surface.on_pointer((phase, id, x, y, time) => {
+    switch (phase) {
+      case chunk7DQSDKDU_js.SurfacePointer.down:
+        input.pointerEvent("down", id, x, y, time);
+        return;
+      case chunk7DQSDKDU_js.SurfacePointer.move:
+        input.pointerEvent("move", id, x, y, time);
+        return;
+      default:
+        input.pointerEvent("up", id, x, y, time);
+    }
+  }), stopWheel = surface.on_wheel?.((dx, dy, dz, x, y, time) => input.wheelEvent(dx, dy, dz, x, y, time)) ?? null;
+  return () => {
+    stopPointer(), stopWheel?.();
+  };
+}
+
+// src/game/kit/host/ctx-audio.ts
+var SILENT = -1, MASTER_BUS = "master", BUS_NAMES = ["music", "effects", "voice", "ui"], FALLBACK_BUS = "effects", NO_VOICE = -1, FOREVER = Number.POSITIVE_INFINITY, CTX_SAMPLE_RATE = 48e3, CtxAudioPort = class {
+  constructor(audio, clock, maxVoices = 64) {
+    this.name = "ctx-audio";
+    this.capabilities = chunkX5A5FOWW_js.NO_AUDIO_CAPABILITIES;
+    this.sampleRate = (48e3);
+    this.clips = [];
+    this.busNames = [];
+    this.busGain = [];
+    this.options = { bus: FALLBACK_BUS, volume: 1, loop: false, pan: 0 };
+    this.next = 0;
+    this.master = 1;
+    this.suspended = false;
+    this.audio = audio, this.clock = clock, this.voices = new Int32Array(maxVoices).fill((-1)), this.ends = new Float64Array(maxVoices);
+  }
+  get unlocked() {
+    return this.audio.unlocked;
+  }
+  unlock() {
+    this.audio.unlock();
+  }
+  async decode(source) {
+    if (!("url" in source)) return (-1);
+    try {
+      return this.clips.push(await this.audio.load(source.url)), this.clips.length - 1;
+    } catch {
+      return (-1);
+    }
+  }
+  createBus(name, _parent) {
+    let ctxName = name === MASTER_BUS ? null : BUS_NAMES.indexOf(name) >= 0 ? name : FALLBACK_BUS;
+    return this.busNames.push(ctxName), this.busGain.push(1), this.busNames.length - 1;
+  }
+  setBusGain(bus, gain, _rampSeconds) {
+    let name = this.busNames[bus];
+    if (this.busGain[bus] = gain, name === null) {
+      this.master = gain;
+      for (let b = 0; b < this.busNames.length; b++) {
+        let other = this.busNames[b];
+        other !== null && this.applyBus(other, this.busGain[b]);
+      }
+      return;
+    }
+    name !== void 0 && this.applyBus(name, gain);
+  }
+  applyBus(name, gain) {
+    try {
+      this.audio.bus(name).volume = gain * this.master;
+    } catch {
+      return;
+    }
+  }
+  play(sound, bus, gain, _rate, loop, _spatial) {
+    if (sound === (-1) || this.suspended) return (-1);
+    let clip = this.clips[sound], o = this.options;
+    o.bus = this.busNames[bus] ?? FALLBACK_BUS, o.volume = gain, o.loop = loop, o.pan = 0;
+    let voice;
+    try {
+      voice = this.audio.play(clip, o);
+    } catch {
+      return (-1);
+    }
+    let slot = this.next;
+    return this.next = (this.next + 1) % this.voices.length, this.voices[slot] = voice, this.ends[slot] = loop ? FOREVER : this.clock.now() + clip.duration_ms, slot;
+  }
+  stop(voice, _fadeSeconds) {
+    if (!(voice < 0 || this.voices[voice] === (-1)))
+      try {
+        this.audio.stop(this.voices[voice]);
+      } catch {
+        return;
+      } finally {
+        this.voices[voice] = (-1);
+      }
+  }
+  isPlaying(voice) {
+    return voice >= 0 && this.voices[voice] !== (-1) && this.ends[voice] > this.clock.now();
+  }
+  setVoicePosition(_voice, _matrix, _offset) {
+  }
+  setListener(_matrix, _offset) {
+  }
+  suspend() {
+    this.suspended = true;
+  }
+  resume() {
+    this.suspended = false;
+  }
+  dispose() {
+    for (let v = 0; v < this.voices.length; v++) this.stop(v, 0);
+  }
+  createSound(_samples, _channels, _sampleRate) {
+    throw unsupported("procedural sounds");
+  }
+  setVoiceGain(_voice, _gain, _rampSeconds) {
+  }
+  setVoiceRate(_voice, _rate, _detuneCents) {
+  }
+  setVoiceSpatial(_voice, _params) {
+  }
+  setVoiceLoop(_voice, _loop, _startSeconds, _endSeconds) {
+    throw unsupported("loop points");
+  }
+  setBusFilter(_bus, _kind, _frequency, _q, _gainDb) {
+    throw unsupported("bus filters");
+  }
+  meter(_bus, out) {
+    out[chunkX5A5FOWW_js.METER_PEAK] = 0, out[chunkX5A5FOWW_js.METER_RMS] = 0;
+  }
+  createAnalyser(_bus, _settings) {
+    throw unsupported("the analyser");
+  }
+  readAnalyser(_analyser, _mode, _out) {
+    throw unsupported("the analyser");
+  }
+  createReverb(_parent, _impulse) {
+    throw unsupported("convolution reverb");
+  }
+  setBusSend(_bus, _target, _gain) {
+    throw unsupported("bus sends");
+  }
+  openStream(_source, _bus) {
+    return Promise.reject(unsupported("streaming music"));
+  }
+  playStream(_stream, _gain, _loop) {
+    throw unsupported("streaming music");
+  }
+  pauseStream(_stream) {
+    throw unsupported("streaming music");
+  }
+  seekStream(_stream, _seconds) {
+    throw unsupported("streaming music");
+  }
+  streamTime(_stream) {
+    throw unsupported("streaming music");
+  }
+  streamDuration(_stream) {
+    throw unsupported("streaming music");
+  }
+  closeStream(_stream) {
+    throw unsupported("streaming music");
+  }
+};
+function unsupported(feature) {
+  return new chunk2V7IL4HC_js.GameError("unsupported_feature", `ctx audio has no ${feature}`);
+}
+
+// src/game/kit/host/backend.ts
+var SHADER_PACK_ASSET = "shaders.cspk";
+function listed(assets, asset) {
+  let has = assets.has;
+  return typeof has == "function" && has.call(assets, asset);
+}
+async function installShaderPack(backend, assets) {
+  return assets === void 0 || !(backend.graphics instanceof chunk7SM6XSPZ_js.EngineGraphics) || !listed(assets, SHADER_PACK_ASSET) ? false : (backend.graphics.installShaders(await assets.take(SHADER_PACK_ASSET)), true);
+}
+async function platformBackend(graphics, options = {}) {
+  let platform = await graphics.engine();
+  if (platform.kind === "engine") {
+    let backend = chunk7SM6XSPZ_js.createNativeEngineBackend(chunkNZTKLY2W_js.bindEngineRuntime(platform.runtime), options.engine);
+    return await installShaderPack(backend, options.assets), backend;
+  }
+  if (options.prepared) return options.prepared();
+  throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "this host runs the prepared engine; take platformBackend from @cimplify/sdk/game/kit/canvas");
+}
+
+// src/game/kit/launch.ts
+function firstFrame(next = null) {
+  let release = null;
+  return {
+    reached: new Promise((resolve) => {
+      release = resolve;
+    }),
+    onFrame: (game, nowMs) => {
+      release !== null && (release(), release = null), next?.(game, nowMs);
+    }
+  };
+}
+
+exports.CtxAudioPort = CtxAudioPort;
+exports.ORIGIN_QW = (6);
+exports.ORIGIN_QX = (3);
+exports.ORIGIN_QY = (4);
+exports.ORIGIN_QZ = (5);
+exports.ORIGIN_X = (0);
+exports.ORIGIN_Y = (1);
+exports.ORIGIN_Z = (2);
+exports.Particles = Particles;
+exports.SILENT = (-1);
+exports.SPAWN_B = (10);
+exports.SPAWN_END_B = (14);
+exports.SPAWN_END_G = (13);
+exports.SPAWN_END_R = (12);
+exports.SPAWN_G = (9);
+exports.SPAWN_LIFE = (6);
+exports.SPAWN_R = (8);
+exports.SPAWN_SIZE = (7);
+exports.SPAWN_SPIN = (11);
+exports.SPAWN_VX = (3);
+exports.SPAWN_VY = (4);
+exports.SPAWN_VZ = (5);
+exports.SPAWN_X = (0);
+exports.SPAWN_Y = (1);
+exports.SPAWN_Z = (2);
+exports.Spray = Spray;
+exports.attachSurfaceInput = attachSurfaceInput;
+exports.firstFrame = firstFrame;
+exports.platformBackend = platformBackend;

package/dist/chunk-GDCV4IWO.mjs

@@ -0,0 +1,21 @@
+// src/game/backends/engine/wasi.ts
+var WASI_IMPORTS = "wasi_snapshot_preview1", REACTOR_INITIALIZE = "_initialize";
+function wasiStubs(memory) {
+  return {
+    clock_time_get(_id, _precision, out) {
+      return new DataView(memory().buffer).setBigUint64(out, 0n, true), 0;
+    },
+    fd_close: () => 8,
+    fd_seek: () => 8,
+    fd_write: () => 8
+  };
+}
+function importsWasi(module) {
+  return WebAssembly.Module.imports(module).some((entry) => entry.module === WASI_IMPORTS);
+}
+function initializeReactor(exports) {
+  let initialize = exports[REACTOR_INITIALIZE];
+  typeof initialize == "function" && initialize();
+}
+
+export { WASI_IMPORTS, importsWasi, initializeReactor, wasiStubs };

package/dist/chunk-GDZT5LZ5.js

@@ -0,0 +1,170 @@
+'use strict';
+
+var chunk4ZDR72SG_js = require('./chunk-4ZDR72SG.js');
+
+// src/interactives/runtime/tree.ts
+var TreeError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "TreeError";
+  }
+}, NO_PROPS = "", EMPTY = [];
+function childrenOf(node) {
+  return node.children ?? EMPTY;
+}
+var Budget = class {
+  constructor() {
+    this.nodes = 0;
+  }
+  admit(depth) {
+    if (this.nodes += 1, this.nodes > chunk4ZDR72SG_js.BRIDGE_LIMITS.max_tree_nodes)
+      throw new TreeError(`a tree may hold at most ${chunk4ZDR72SG_js.BRIDGE_LIMITS.max_tree_nodes} nodes`);
+    if (depth > chunk4ZDR72SG_js.BRIDGE_LIMITS.max_tree_depth)
+      throw new TreeError(`a tree may nest at most ${chunk4ZDR72SG_js.BRIDGE_LIMITS.max_tree_depth} levels`);
+  }
+};
+function shadowOf(node, depth, budget) {
+  if (typeof node != "object" || node === null || typeof node.type != "string")
+    throw new TreeError("every tree node needs a string type");
+  budget.admit(depth);
+  let shadows = childrenOf(node).map((child) => shadowOf(child, depth + 1, budget));
+  return {
+    type: node.type,
+    key: node.key ?? null,
+    props: node.props === void 0 ? NO_PROPS : JSON.stringify(node.props),
+    children: shadows
+  };
+}
+function sameIdentity(a, b) {
+  return a.type === b.type && a.key === b.key;
+}
+var TreeDiffer = class {
+  constructor() {
+    this.shadow = null;
+  }
+  diff(next) {
+    let patches = [];
+    if (next === null)
+      return this.shadow !== null && patches.push({ op: "root", node: null }), this.shadow = null, patches;
+    let shadow = shadowOf(next, 0, new Budget()), previous = this.shadow;
+    return this.shadow = shadow, previous === null || !sameIdentity(previous, shadow) ? (patches.push({ op: "root", node: next }), patches) : (walk(previous, shadow, next, [], patches), patches);
+  }
+};
+function walk(previous, current, node, at, patches) {
+  previous.props !== current.props && patches.push({ op: "props", at: at.slice(), props: node.props ?? null });
+  let before = previous.children, after = current.children, nodes = childrenOf(node), head = 0, shortest = before.length < after.length ? before.length : after.length;
+  for (; head < shortest && sameIdentity(before[head], after[head]); ) head++;
+  let tail = 0;
+  for (; tail < shortest - head && sameIdentity(before[before.length - 1 - tail], after[after.length - 1 - tail]); )
+    tail++;
+  for (let i = 0; i < head; i++)
+    at.push(i), walk(before[i], after[i], nodes[i], at, patches), at.pop();
+  let removed = before.length - head - tail, inserted = after.length - head - tail;
+  if (removed > 0 || inserted > 0) {
+    let insert = nodes.slice(head, head + inserted);
+    patches.push({ op: "splice", at: at.slice(), start: head, remove: removed, insert });
+  }
+  for (let i = 0; i < tail; i++) {
+    let was = before.length - tail + i, now = after.length - tail + i;
+    at.push(now), walk(before[was], after[now], nodes[now], at, patches), at.pop();
+  }
+}
+function withChildren(node, children) {
+  let out = { type: node.type };
+  return node.key !== void 0 && (out.key = node.key), node.props !== void 0 && (out.props = node.props), children.length > 0 && (out.children = children), out;
+}
+function update(node, at, depth, change) {
+  if (depth === at.length) return change(node);
+  let children = childrenOf(node), index = at[depth];
+  if (index < 0 || index >= children.length) throw new TreeError("a patch names a node that does not exist");
+  let next = children.slice();
+  return next[index] = update(children[index], at, depth + 1, change), withChildren(node, next);
+}
+var TreeMirror = class {
+  constructor() {
+    this.current = null;
+  }
+  get root() {
+    return this.current;
+  }
+  apply(patches) {
+    let root = this.current;
+    for (let patch of patches) {
+      if (patch.op === "root") {
+        root = patch.node;
+        continue;
+      }
+      if (root === null) throw new TreeError("a patch arrived before the first tree");
+      root = update(root, patch.at, 0, (target) => {
+        switch (patch.op) {
+          case "replace":
+            return patch.node;
+          case "props": {
+            let out = { type: target.type };
+            return target.key !== void 0 && (out.key = target.key), patch.props !== null && (out.props = patch.props), target.children !== void 0 && (out.children = target.children), out;
+          }
+          case "splice": {
+            let children = childrenOf(target).slice();
+            return children.splice(patch.start, patch.remove, ...patch.insert), withChildren(target, children);
+          }
+        }
+      });
+    }
+    return this.current = root, root;
+  }
+};
+
+// src/interactives/runtime/clip-wire.ts
+var DEFAULT_CLIP_WINDOW_MS = 15e3, DEFAULT_CLIP_FPS = 30, DEFAULT_CLIP_VIDEO_BITS = 4e6, DEFAULT_CLIP_LONG_EDGE = 1280, DEFAULT_CLIP_ARM = {
+  window_ms: (15e3),
+  fps: (30),
+  video_bits_per_second: (4e6),
+  audio: true,
+  max_long_edge: (1280)
+}, ClipStatus = { saved: 0, empty: 1, unavailable: 2 }, CLIP_PAUSE_BYTES = chunk4ZDR72SG_js.TAG_BYTES + 1, CLIP_SAVE_BYTES = chunk4ZDR72SG_js.TAG_BYTES + 8, SAVED_ID = chunk4ZDR72SG_js.TAG_BYTES, SAVED_STATUS = SAVED_ID + 4, SAVED_DURATION = SAVED_STATUS + 1, SAVED_WIDTH = SAVED_DURATION + 4, SAVED_HEIGHT = SAVED_WIDTH + 2, SAVED_TYPE_LENGTH = SAVED_HEIGHT + 2, CLIP_SAVED_HEADER_BYTES = SAVED_TYPE_LENGTH + 1;
+var LITTLE_ENDIAN = true, REPLAY_HEADER_BYTES = chunk4ZDR72SG_js.TAG_BYTES + 1, REPLAY_WATCH = 0, REPLAY_PLAY = 1;
+function replayMessage(replay, mode) {
+  let out = new Uint8Array(REPLAY_HEADER_BYTES + replay.length);
+  return out[0] = chunk4ZDR72SG_js.MessageTag.replay, out[chunk4ZDR72SG_js.TAG_BYTES] = mode === "play" ? (1) : (0), out.set(replay, REPLAY_HEADER_BYTES), out;
+}
+function readReplayMessage(bytes) {
+  return bytes.length < REPLAY_HEADER_BYTES || bytes[0] !== chunk4ZDR72SG_js.MessageTag.replay ? null : { replay: bytes.slice(REPLAY_HEADER_BYTES), mode: bytes[chunk4ZDR72SG_js.TAG_BYTES] === (1) ? "play" : "watch" };
+}
+function writeClipPause(out, paused) {
+  return out[0] = chunk4ZDR72SG_js.MessageTag.clip_pause, out[chunk4ZDR72SG_js.TAG_BYTES] = paused ? 1 : 0, CLIP_PAUSE_BYTES;
+}
+function writeClipSave(out, id, keep_ms) {
+  let view = new DataView(out.buffer, out.byteOffset, CLIP_SAVE_BYTES);
+  return out[0] = chunk4ZDR72SG_js.MessageTag.clip_save, view.setUint32(chunk4ZDR72SG_js.TAG_BYTES, id >>> 0, (true)), view.setUint32(chunk4ZDR72SG_js.TAG_BYTES + 4, Math.max(0, Math.round(keep_ms)) >>> 0, (true)), CLIP_SAVE_BYTES;
+}
+function readClipSaved(bytes) {
+  if (bytes.length < CLIP_SAVED_HEADER_BYTES || bytes[0] !== chunk4ZDR72SG_js.MessageTag.clip_saved) return null;
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), length = view.getUint8(SAVED_TYPE_LENGTH), bodyAt = CLIP_SAVED_HEADER_BYTES + length;
+  if (bytes.length < bodyAt) return null;
+  let type = "";
+  for (let i = 0; i < length; i++) type += String.fromCharCode(bytes[CLIP_SAVED_HEADER_BYTES + i]);
+  let status = view.getUint8(SAVED_STATUS);
+  return {
+    header: {
+      id: view.getUint32(SAVED_ID, (true)),
+      status: status <= ClipStatus.unavailable ? status : ClipStatus.unavailable,
+      duration_ms: view.getUint32(SAVED_DURATION, (true)),
+      width: view.getUint16(SAVED_WIDTH, (true)),
+      height: view.getUint16(SAVED_HEIGHT, (true)),
+      type
+    },
+    body: bytes.subarray(bodyAt)
+  };
+}
+
+exports.CLIP_PAUSE_BYTES = CLIP_PAUSE_BYTES;
+exports.CLIP_SAVE_BYTES = CLIP_SAVE_BYTES;
+exports.ClipStatus = ClipStatus;
+exports.DEFAULT_CLIP_ARM = DEFAULT_CLIP_ARM;
+exports.TreeDiffer = TreeDiffer;
+exports.TreeError = TreeError;
+exports.TreeMirror = TreeMirror;
+exports.readClipSaved = readClipSaved;
+exports.readReplayMessage = readReplayMessage;
+exports.replayMessage = replayMessage;
+exports.writeClipPause = writeClipPause;
+exports.writeClipSave = writeClipSave;