@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-6DATW7TB.mjs

@@ -0,0 +1,420 @@
+import { createNativeEngineBackend, EngineGraphics } from './chunk-Y65LXQGA.mjs';
+import { SurfacePointer } from './chunk-3GXH2NFD.mjs';
+import { NO_AUDIO_CAPABILITIES, METER_PEAK, METER_RMS } from './chunk-5YFBGGCK.mjs';
+import { bindEngineRuntime } from './chunk-GHS6MIL6.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// 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 SurfacePointer.down:
+        input.pointerEvent("down", id, x, y, time);
+        return;
+      case 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 = 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[METER_PEAK] = 0, out[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 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 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 = createNativeEngineBackend(bindEngineRuntime(platform.runtime), options.engine);
+    return await installShaderPack(backend, options.assets), backend;
+  }
+  if (options.prepared) return options.prepared();
+  throw new 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);
+    }
+  };
+}
+
+export { CtxAudioPort, ORIGIN_QW, ORIGIN_QX, ORIGIN_QY, ORIGIN_QZ, ORIGIN_X, ORIGIN_Y, ORIGIN_Z, Particles, SILENT, SPAWN_B, SPAWN_END_B, SPAWN_END_G, SPAWN_END_R, SPAWN_G, SPAWN_LIFE, SPAWN_R, SPAWN_SIZE, SPAWN_SPIN, SPAWN_VX, SPAWN_VY, SPAWN_VZ, SPAWN_X, SPAWN_Y, SPAWN_Z, Spray, attachSurfaceInput, firstFrame, platformBackend };