@threenative/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1514 @@
+import { AudioListener, Audio, PositionalAudio, Object3D, AnimationMixer, Vector2, Sprite, Raycaster, Plane, Vector3, PerspectiveCamera, OrthographicCamera, Scene as Scene$1 } from 'three';
+import { instancedArray } from 'three/tsl';
+import { RenderPipeline } from 'three/webgpu';
+import { createStore } from 'zustand/vanilla';
+
+// src/audio.ts
+var buses = /* @__PURE__ */ new Set();
+var AudioBus = class {
+  listener;
+  #camera;
+  #gestureTarget;
+  #gesture;
+  #queue = [];
+  #voices = /* @__PURE__ */ new Set();
+  #unlocked = false;
+  #disposed = false;
+  constructor(options) {
+    this.#camera = options.camera;
+    this.listener = options.listener ?? new AudioListener();
+    const source = options.source ?? (() => typeof window === "undefined" ? void 0 : window);
+    this.#gestureTarget = options.gestureTarget ?? source();
+    this.setCamera(options.camera);
+    this.#gesture = () => {
+      void this.unlock().catch(() => void 0);
+    };
+    for (const event2 of ["keydown", "pointerdown", "touchstart"]) {
+      this.#gestureTarget?.addEventListener(event2, this.#gesture);
+    }
+    buses.add(this);
+  }
+  get queued() {
+    return this.#queue.length;
+  }
+  get voices() {
+    return this.#voices.size;
+  }
+  setCamera(camera) {
+    this.#camera = camera;
+    camera.add(this.listener);
+  }
+  reparent(camera) {
+    this.setCamera(camera);
+  }
+  async unlock() {
+    if (this.#disposed || this.#unlocked) return;
+    const context = this.listener.context;
+    if (context.resume !== void 0) await context.resume();
+    this.#unlocked = true;
+    const queued = this.#queue.splice(0);
+    for (const { start } of queued) start();
+  }
+  play(buffer, options = {}) {
+    assertBuffer(buffer);
+    const voice = new Audio(this.listener);
+    configureVoice(voice, options);
+    voice.setBuffer(buffer);
+    this.#queueOrStart(voice, options.fade, options.volume ?? 1);
+    return voice;
+  }
+  playAt(buffer, source, options = {}) {
+    assertBuffer(buffer);
+    const voice = new PositionalAudio(this.listener);
+    configureVoice(voice, options);
+    voice.setBuffer(buffer);
+    if (source instanceof Object3D) source.add(voice);
+    else {
+      voice.position.copy(source);
+      (this.#camera.parent ?? this.#camera).add(voice);
+    }
+    this.#queueOrStart(voice, options.fade, options.volume ?? 1);
+    return voice;
+  }
+  music(buffer, options = {}) {
+    return this.play(buffer, { ...options, loop: options.loop ?? true });
+  }
+  stop() {
+    for (const { voice } of this.#queue) voice.removeFromParent();
+    this.#queue = [];
+    for (const voice of this.#voices) {
+      try {
+        voice.stop();
+      } catch {
+      }
+      voice.removeFromParent();
+    }
+    this.#voices.clear();
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.stop();
+    this.listener.removeFromParent();
+    for (const event2 of ["keydown", "pointerdown", "touchstart"]) {
+      if (this.#gesture !== void 0)
+        this.#gestureTarget?.removeEventListener(event2, this.#gesture);
+    }
+    buses.delete(this);
+  }
+  #queueOrStart(voice, fade, volume) {
+    const start = () => this.#start(voice, fade, volume);
+    if (this.#unlocked) start();
+    else this.#queue.push({ start, voice });
+  }
+  #start(voice, fade, volume) {
+    if (this.#disposed) return;
+    if (fade !== void 0 && fade > 0) {
+      const now = this.listener.context.currentTime;
+      voice.gain.gain.setValueAtTime(0, now);
+      voice.gain.gain.linearRampToValueAtTime(volume, now + fade);
+    }
+    voice.play();
+    this.#voices.add(voice);
+    const source = voice.source;
+    if (source !== null && "onended" in source) {
+      const onended = source.onended;
+      source.onended = () => {
+        onended?.();
+        this.#voices.delete(voice);
+      };
+    }
+  }
+};
+function configureVoice(voice, options) {
+  const volume = options.volume ?? 1;
+  if (!Number.isFinite(volume) || volume < 0)
+    throw new RangeError("volume must be finite and non-negative.");
+  if (options.fade !== void 0 && (!Number.isFinite(options.fade) || options.fade < 0)) {
+    throw new RangeError("fade must be finite and non-negative.");
+  }
+  voice.setLoop(options.loop ?? false);
+  voice.setVolume(options.fade === void 0 || options.fade === 0 ? volume : 0);
+}
+function assertBuffer(buffer) {
+  if (buffer === null || buffer === void 0)
+    throw new TypeError("AudioBus requires a non-null AudioBuffer.");
+}
+
+// src/assets.ts
+function resolvePath(basePath, path) {
+  if (/^(?:[a-z]+:)?\/\//iu.test(path) || path.startsWith("data:")) return path;
+  if (basePath.length === 0) return path;
+  return `${basePath.replace(/\/$/u, "")}/${path.replace(/^\//u, "")}`;
+}
+function loadWith(loader, url) {
+  return new Promise((resolve, reject) => {
+    loader.load(url, resolve, void 0, reject);
+  });
+}
+function createAssetLoader(options = {}) {
+  const basePath = options.basePath ?? "";
+  const cache = /* @__PURE__ */ new Map();
+  const cached = (kind, path, load) => {
+    const url = resolvePath(basePath, path);
+    const key = `${kind}:${url}`;
+    const existing = cache.get(key);
+    if (existing !== void 0) return existing;
+    const promise = load(url);
+    cache.set(key, promise);
+    return promise;
+  };
+  return {
+    audio: (path) => cached("audio", path, async (url) => {
+      if (options.audio !== void 0) return options.audio(url);
+      const { AudioLoader: Loader } = await import('three');
+      return loadWith(new Loader(), url);
+    }),
+    clear: () => cache.clear(),
+    model: (path) => cached("model", path, async (url) => {
+      if (options.model !== void 0) return await options.model(url);
+      const { GLTFLoader } = await import('three/addons/loaders/GLTFLoader.js');
+      return await loadWith(new GLTFLoader(), url);
+    }),
+    release: (kind, path) => cache.delete(`${kind}:${resolvePath(basePath, path)}`),
+    texture: (path) => cached("texture", path, async (url) => {
+      if (options.texture !== void 0) return options.texture(url);
+      const { TextureLoader: Loader } = await import('three');
+      return loadWith(new Loader(), url);
+    })
+  };
+}
+var AnimationPlayer = class {
+  mixer;
+  #actions = /* @__PURE__ */ new Map();
+  #current;
+  #advancedFrames = 0;
+  #fadeFrom;
+  #fadeElapsed = 0;
+  #fadeDuration = 0;
+  constructor(options) {
+    this.mixer = new AnimationMixer(options.root);
+    for (const clip of options.clips) {
+      if (this.#actions.has(clip.name)) throw new Error(`Duplicate animation clip '${clip.name}'.`);
+      const action = this.mixer.clipAction(clip);
+      if (action === null)
+        throw new Error(`Animation clip '${clip.name}' could not create an action.`);
+      this.#actions.set(clip.name, action);
+    }
+  }
+  get current() {
+    return this.#current;
+  }
+  get advancedFrames() {
+    return this.#advancedFrames;
+  }
+  play(name, options = {}) {
+    const next = this.#actions.get(name);
+    if (next === void 0) throw new Error(`Unknown animation clip '${name}'.`);
+    if (this.#current === name) return;
+    const previous = this.#current === void 0 ? void 0 : this.#actions.get(this.#current);
+    const fade = Math.max(0, options.fade ?? 0);
+    for (const action of this.#actions.values()) {
+      if (action !== previous) action.setEffectiveWeight(0).stop();
+    }
+    previous?.setEffectiveWeight(1).play();
+    next.reset().setEffectiveWeight(fade > 0 && previous !== void 0 ? 0 : 1).play();
+    if (previous === void 0 || fade === 0) {
+      previous?.stop();
+      this.#fadeFrom = void 0;
+    } else {
+      previous.play();
+      this.#fadeFrom = previous;
+      this.#fadeElapsed = 0;
+      this.#fadeDuration = fade;
+    }
+    this.#current = name;
+    this.#advancedFrames = 0;
+  }
+  update(dt) {
+    if (!Number.isFinite(dt) || dt < 0)
+      throw new Error("AnimationPlayer.update requires a finite non-negative dt.");
+    const before = this.mixer.time;
+    this.mixer.update(dt);
+    if (this.#fadeFrom !== void 0) {
+      this.#fadeElapsed = Math.min(this.#fadeDuration, this.#fadeElapsed + dt);
+      const progress = this.#fadeDuration === 0 ? 1 : this.#fadeElapsed / this.#fadeDuration;
+      this.#fadeFrom.setEffectiveWeight(1 - progress);
+      this.#actions.get(this.#current ?? "")?.setEffectiveWeight(progress);
+      if (progress >= 1) {
+        this.#fadeFrom.stop();
+        this.#fadeFrom = void 0;
+      }
+    }
+    if (this.#current !== void 0 && this.mixer.time !== before) this.#advancedFrames += 1;
+  }
+  stop() {
+    this.mixer.stopAllAction();
+    this.#current = void 0;
+    this.#advancedFrames = 0;
+    this.#fadeFrom = void 0;
+  }
+  dispose() {
+    this.stop();
+    this.mixer.uncacheRoot(this.mixer.getRoot());
+  }
+};
+
+// src/entities.ts
+function autoFields(entity) {
+  const fields = {};
+  for (const key of Object.keys(entity)) {
+    if (Object.keys(fields).length >= 24) break;
+    const value = entity[key];
+    if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+      fields[key] = value;
+    } else if (value !== null && typeof value === "object" && "toArray" in value) {
+      const toArray = value.toArray;
+      if (typeof toArray === "function") fields[key] = toArray.call(value);
+    }
+  }
+  return fields;
+}
+function disposeEntity(entity) {
+  const dispose = entity.dispose;
+  if (typeof dispose === "function") dispose.call(entity);
+}
+var Registry = class {
+  #named = /* @__PURE__ */ new Map();
+  add(name, entity) {
+    if (this.#named.has(name)) throw new Error(`Entity "${name}" already registered.`);
+    this.#named.set(name, entity);
+    return entity;
+  }
+  get(name) {
+    return this.#named.get(name);
+  }
+  remove(name) {
+    const entity = this.#named.get(name);
+    this.#named.delete(name);
+    if (entity !== void 0) disposeEntity(entity);
+  }
+  clear() {
+    const entities = [...new Set(this.#named.values())];
+    this.#named.clear();
+    for (const entity of entities) disposeEntity(entity);
+  }
+  snapshot() {
+    const result = {};
+    for (const [name, entity] of this.#named) {
+      const debug = entity.debug;
+      const fields = typeof debug === "function" ? debug.call(entity) : autoFields(entity);
+      const tags = entity.tags;
+      result[name] = {
+        ...fields,
+        ...Array.isArray(tags) && tags.every((tag) => typeof tag === "string") ? { tags: [...tags] } : {}
+      };
+    }
+    return result;
+  }
+};
+var DEFAULT_BINDINGS = {
+  move: {
+    down: ["KeyS", "ArrowDown"],
+    left: ["KeyA", "ArrowLeft"],
+    right: ["KeyD", "ArrowRight"],
+    up: ["KeyW", "ArrowUp"]
+  }
+};
+function eventCode(event2) {
+  const candidate = event2;
+  return candidate.code ?? candidate.key;
+}
+var browserGamepads = () => globalThis.navigator?.getGamepads?.() ?? [];
+var InputMap = class {
+  raw;
+  #bindings;
+  #target;
+  #heldKeys = /* @__PURE__ */ new Set();
+  #pointerPosition = new Vector2();
+  #pointerDown = false;
+  #pointerButtons = 0;
+  #gamepadAxes = [];
+  #gamepadButtons = [];
+  #previousPressed = /* @__PURE__ */ new Map();
+  #justPressed = /* @__PURE__ */ new Set();
+  #justReleased = /* @__PURE__ */ new Set();
+  #pointerTarget;
+  #source;
+  #listeners = [];
+  constructor(bindings = DEFAULT_BINDINGS, target = globalThis, pointerTarget = target, source = browserGamepads) {
+    this.#bindings = { ...DEFAULT_BINDINGS, ...bindings };
+    this.#target = target;
+    this.#pointerTarget = pointerTarget;
+    this.#source = source;
+    this.raw = {
+      gamepad: { axes: this.#gamepadAxes, buttons: this.#gamepadButtons },
+      keys: this.#heldKeys,
+      pointer: {
+        buttons: this.#pointerButtons,
+        down: this.#pointerDown,
+        position: this.#pointerPosition
+      }
+    };
+    this.#listen(this.#target, "keydown", (event2) => {
+      const code = eventCode(event2);
+      if (code !== void 0) this.#heldKeys.add(code);
+    });
+    this.#listen(this.#target, "keyup", (event2) => {
+      const code = eventCode(event2);
+      if (code !== void 0) this.#heldKeys.delete(code);
+    });
+    this.#listen(this.#pointerTarget, "pointerdown", (event2) => this.#pointerEvent(event2, true));
+    this.#listen(
+      this.#pointerTarget,
+      "pointermove",
+      (event2) => this.#pointerEvent(event2, this.#pointerDown)
+    );
+    this.#listen(this.#pointerTarget, "pointerup", (event2) => this.#pointerEvent(event2, false));
+    this.#listen(this.#target, "blur", () => this.clear());
+  }
+  vector(name) {
+    const binding = this.#bindings[name];
+    if (binding === void 0) return new Vector2();
+    const vector = new Vector2(
+      this.#isHeld(binding.left) ? -1 : 0,
+      this.#isHeld(binding.down) ? -1 : 0
+    );
+    if (this.#isHeld(binding.right)) vector.x += 1;
+    if (this.#isHeld(binding.up)) vector.y += 1;
+    if (name === "move" && this.#gamepadAxes.length >= 2) {
+      vector.x += this.#gamepadAxes[0] ?? 0;
+      vector.y += -(this.#gamepadAxes[1] ?? 0);
+    }
+    return vector.clampLength(0, 1);
+  }
+  pressed(name) {
+    const binding = this.#bindings[name];
+    if (binding === void 0) return false;
+    return this.#isHeld(binding.down) || this.#isHeld(binding.left) || this.#isHeld(binding.right) || this.#isHeld(binding.up) || binding.pointer === true && this.#pointerDown || (binding.buttons?.some((button) => this.#gamepadButtons[button] === true) ?? false);
+  }
+  justPressed(name) {
+    return this.#justPressed.has(name);
+  }
+  justReleased(name) {
+    return this.#justReleased.has(name);
+  }
+  tick() {
+    const gamepad = this.#source().find((item) => item !== null);
+    this.#gamepadAxes = gamepad?.axes ? Array.from(gamepad.axes) : [];
+    this.#gamepadButtons = gamepad?.buttons.map((button) => button.pressed) ?? [];
+    this.raw.gamepad.axes = this.#gamepadAxes;
+    this.raw.gamepad.buttons = this.#gamepadButtons;
+    this.#justPressed.clear();
+    this.#justReleased.clear();
+    for (const name of Object.keys(this.#bindings)) {
+      const current = this.pressed(name);
+      const previous = this.#previousPressed.get(name) ?? false;
+      if (current && !previous) this.#justPressed.add(name);
+      if (!current && previous) this.#justReleased.add(name);
+      this.#previousPressed.set(name, current);
+    }
+  }
+  clear() {
+    this.#heldKeys.clear();
+    this.#pointerDown = false;
+    this.#pointerButtons = 0;
+    this.#pointerPosition.set(0, 0);
+    this.raw.pointer.buttons = 0;
+    this.raw.pointer.down = false;
+    this.#previousPressed.clear();
+    this.#justPressed.clear();
+    this.#justReleased.clear();
+  }
+  dispose() {
+    for (const [target, type, listener] of this.#listeners)
+      target.removeEventListener(type, listener);
+    this.#listeners = [];
+    this.clear();
+  }
+  #isHeld(codes) {
+    return codes?.some((code) => this.#heldKeys.has(code)) ?? false;
+  }
+  #listen(target, type, listener) {
+    target.addEventListener(type, listener);
+    this.#listeners.push([target, type, listener]);
+  }
+  #pointerEvent(event2, down) {
+    const pointer = event2;
+    this.#pointerDown = down;
+    this.#pointerButtons = pointer.buttons ?? 0;
+    this.#pointerPosition.set(pointer.clientX ?? 0, pointer.clientY ?? 0);
+    this.raw.pointer.buttons = this.#pointerButtons;
+    this.raw.pointer.down = down;
+    const capture = this.#pointerTarget;
+    if (down) capture.setPointerCapture?.(pointer.pointerId ?? 0);
+    else capture.releasePointerCapture?.(pointer.pointerId ?? 0);
+  }
+};
+function input(bindings, target, pointerTarget, source) {
+  return new InputMap(bindings, target, pointerTarget, source);
+}
+
+// src/loop.ts
+var FixedStepLoop = class {
+  step;
+  maxSteps;
+  #onUpdate;
+  #onRender;
+  #requestFrame;
+  #cancelFrame;
+  #accumulator = 0;
+  #lastTime;
+  #frameHandle;
+  #running = false;
+  #fps = 0;
+  #lastRenderTime;
+  constructor(options) {
+    this.step = options.step ?? 1 / 60;
+    this.maxSteps = options.maxSteps ?? 5;
+    this.#onUpdate = options.onUpdate;
+    this.#onRender = options.onRender ?? (() => void 0);
+    this.#requestFrame = options.requestFrame ?? ((callback) => typeof globalThis.requestAnimationFrame === "function" ? globalThis.requestAnimationFrame(callback) : 0);
+    this.#cancelFrame = options.cancelFrame ?? ((handle) => {
+      if (typeof globalThis.cancelAnimationFrame === "function")
+        globalThis.cancelAnimationFrame(handle);
+    });
+  }
+  get running() {
+    return this.#running;
+  }
+  get fps() {
+    return this.#fps;
+  }
+  start(now = globalThis.performance?.now() ?? 0) {
+    if (this.#running) return;
+    this.#running = true;
+    this.#lastTime = now;
+    this.#lastRenderTime = void 0;
+    this.#fps = 0;
+    this.#frameHandle = this.#requestFrame((time) => this.#frame(time));
+  }
+  stop() {
+    this.#running = false;
+    if (this.#frameHandle !== void 0) this.#cancelFrame(this.#frameHandle);
+    this.#frameHandle = void 0;
+    this.#lastTime = void 0;
+    this.#accumulator = 0;
+  }
+  stepFrame(now) {
+    const last = this.#lastTime ?? now;
+    const elapsed = Math.max(0, (now - last) / 1e3);
+    this.#lastTime = now;
+    this.#accumulator += elapsed;
+    let updates = 0;
+    while (this.#accumulator + Number.EPSILON >= this.step && updates < this.maxSteps) {
+      this.#onUpdate(this.step);
+      this.#accumulator -= this.step;
+      updates += 1;
+    }
+    if (updates === this.maxSteps && this.#accumulator >= this.step) this.#accumulator = 0;
+    if (Number.isFinite(now)) {
+      if (this.#lastRenderTime !== void 0) {
+        const frameMs = now - this.#lastRenderTime;
+        if (frameMs > 0) this.#fps += (1e3 / frameMs - this.#fps) * 0.1;
+      }
+      this.#lastRenderTime = now;
+    }
+    this.#onRender();
+    return updates;
+  }
+  advance(ticks) {
+    if (!this.#running) throw new Error("Cannot advance a stopped loop.");
+    if (!Number.isInteger(ticks) || ticks <= 0)
+      throw new Error("advance ticks must be a positive integer.");
+    for (let index = 0; index < ticks; index += 1) {
+      this.#lastTime = (this.#lastTime ?? 0) + this.step * 1e3;
+      this.#onUpdate(this.step);
+    }
+    return ticks;
+  }
+  #frame(time) {
+    if (!this.#running) return;
+    try {
+      this.stepFrame(time);
+    } finally {
+      if (this.#running) {
+        this.#frameHandle = this.#requestFrame((nextTime) => this.#frame(nextTime));
+      }
+    }
+  }
+};
+function computeNode(name, value) {
+  if (value === null || typeof value !== "object" || value.isComputeNode !== true) {
+    throw new Error(`GPUParticles3D.${name} must return a TSL compute node.`);
+  }
+  return value;
+}
+var GPUParticles3D = class extends Sprite {
+  amount;
+  buffers;
+  emitting = true;
+  #start;
+  #process;
+  #renderer;
+  #released = false;
+  constructor(options) {
+    if (!Number.isInteger(options.amount) || options.amount <= 0)
+      throw new Error("GPUParticles3D.amount must be a positive integer.");
+    if (options.material === void 0) throw new Error("GPUParticles3D.material is required.");
+    if (typeof options.start !== "function")
+      throw new Error("GPUParticles3D.start must be a function.");
+    if (typeof options.process !== "function")
+      throw new Error("GPUParticles3D.process must be a function.");
+    super(options.material);
+    this.amount = options.amount;
+    this.buffers = {
+      positions: instancedArray(options.amount, "vec3"),
+      velocities: instancedArray(options.amount, "vec3")
+    };
+    options.material.positionNode = this.buffers.positions.toAttribute();
+    this.count = options.amount;
+    this.frustumCulled = false;
+    this.#start = computeNode("start", options.start(this.buffers));
+    this.#process = computeNode("process", options.process(this.buffers));
+    this.addEventListener("removed", this.#onRemoved);
+  }
+  get released() {
+    return this.#released;
+  }
+  attachRenderer(renderer) {
+    if (this.#released) throw new Error("GPUParticles3D cannot be attached after release.");
+    if (this.#renderer === renderer) return;
+    this.#renderer = renderer;
+    renderer.compute(this.#start);
+  }
+  process(renderer = this.#renderer) {
+    if (this.#released || !this.emitting) return;
+    if (renderer === void 0) throw new Error("GPUParticles3D is not attached to a renderer.");
+    renderer.compute(this.#process);
+  }
+  restart() {
+    if (this.#released) throw new Error("GPUParticles3D cannot restart after release.");
+    if (this.#renderer === void 0)
+      throw new Error("GPUParticles3D is not attached to a renderer.");
+    this.#renderer.compute(this.#start);
+  }
+  detach() {
+    if (this.#released) return;
+    this.#renderer = void 0;
+    this.#start.dispose();
+    this.#process.dispose();
+    this.buffers.positions.value.dispose();
+    this.buffers.velocities.value.dispose();
+    this.#released = true;
+  }
+  #onRemoved = () => this.detach();
+};
+
+// src/random.ts
+function createRandom(seed) {
+  if (seed !== void 0 && !Number.isFinite(seed)) throw new TypeError("seed must be finite.");
+  let state = seed === void 0 ? 0 : seed >>> 0;
+  const deterministic = seed !== void 0;
+  const random = (() => {
+    if (!deterministic) return Math.random();
+    state = Math.imul(1664525, state) + 1013904223 >>> 0;
+    return state / 4294967296;
+  });
+  random.range = (min, max) => {
+    if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) {
+      throw new RangeError("range requires finite bounds with max greater than min.");
+    }
+    return min + random() * (max - min);
+  };
+  random.pick = (items) => {
+    if (items.length === 0) throw new RangeError("pick requires a non-empty list.");
+    return items[Math.floor(random() * items.length)];
+  };
+  Object.defineProperty(random, "state", {
+    get: () => {
+      if (!deterministic) throw new Error("state is unavailable on an unseeded random.");
+      return state;
+    },
+    set: (value) => {
+      if (!deterministic) throw new Error("state is unavailable on an unseeded random.");
+      if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw new TypeError("state must be a finite integer.");
+      }
+      state = value >>> 0;
+    }
+  });
+  return random;
+}
+function readCanvasSize(canvas) {
+  return [
+    Math.max(1, canvas.clientWidth || globalThis.innerWidth || 1),
+    Math.max(1, canvas.clientHeight || globalThis.innerHeight || 1)
+  ];
+}
+function observeCanvasResize(canvas, resize) {
+  if (typeof ResizeObserver !== "undefined") {
+    const observer = new ResizeObserver(resize);
+    observer.observe(canvas);
+    return () => observer.disconnect();
+  }
+  if (typeof globalThis.addEventListener !== "function") return () => void 0;
+  globalThis.addEventListener("resize", resize);
+  return () => globalThis.removeEventListener("resize", resize);
+}
+function wrapRenderer(raw, kind) {
+  let outputPipeline;
+  return {
+    domElement: raw.domElement,
+    kind,
+    raw,
+    compute: (node) => {
+      if (kind !== "webgpu") throw new Error(`compute is unavailable on the ${kind} renderer.`);
+      if (typeof raw.compute !== "function")
+        throw new Error("webgpu renderer does not expose compute().");
+      raw.compute(node);
+    },
+    dispose: () => {
+      outputPipeline?.dispose();
+      outputPipeline = void 0;
+      raw.dispose?.();
+    },
+    render: (scene, camera) => {
+      if (outputPipeline === void 0) raw.render(scene, camera);
+      else outputPipeline.render();
+    },
+    setOutputNode: (node) => {
+      if (kind !== "webgpu")
+        throw new Error(`setOutputNode is unavailable on the ${kind} renderer.`);
+      outputPipeline?.dispose();
+      outputPipeline = new RenderPipeline(
+        raw,
+        node
+      );
+    },
+    setSize: (width, height, updateStyle = false) => raw.setSize(width, height, updateStyle)
+  };
+}
+function addResizeHandling(renderer, source) {
+  const resize = () => {
+    const [width, height] = source?.readSize(renderer.domElement) ?? readCanvasSize(renderer.domElement);
+    renderer.setSize(width, height, false);
+  };
+  resize();
+  return source?.observeResize(renderer.domElement, resize) ?? observeCanvasResize(renderer.domElement, resize);
+}
+async function createRenderer(options = {}) {
+  const source = options.source;
+  const canvas = options.canvas ?? source?.createCanvas() ?? document.createElement("canvas");
+  const preferWebGPU = options.preferWebGPU ?? true;
+  let renderer;
+  if (preferWebGPU && (source?.hasWebGPU() ?? "gpu" in (globalThis.navigator ?? {}))) {
+    try {
+      const raw = options.webgpuFactory ? await options.webgpuFactory(canvas) : new (await import('three/webgpu')).WebGPURenderer({ canvas, antialias: true });
+      const instance = raw;
+      await instance.init?.();
+      renderer = wrapRenderer(instance, "webgpu");
+    } catch {
+      renderer = void 0;
+    }
+  }
+  if (renderer === void 0) {
+    const raw = options.webgl2Factory ? options.webgl2Factory(canvas) : new (await import('three')).WebGLRenderer({ canvas, antialias: true });
+    renderer = wrapRenderer(raw, "webgl2");
+  }
+  const stopResize = addResizeHandling(renderer, source);
+  const dispose = renderer.dispose;
+  renderer.dispose = () => {
+    stopResize();
+    dispose();
+  };
+  return renderer;
+}
+
+// src/schedule.ts
+function createHandle(cancel, active) {
+  const handle = (() => cancel());
+  handle.cancel = handle;
+  Object.defineProperty(handle, "active", { get: active });
+  return handle;
+}
+var Scheduler = class {
+  #entries = /* @__PURE__ */ new Set();
+  get size() {
+    return this.#entries.size;
+  }
+  after(delay, callback) {
+    assertDelay(delay, "delay");
+    let elapsed = 0;
+    const entry = this.#add((dt) => {
+      elapsed += dt;
+      if (elapsed + Number.EPSILON < delay) return;
+      entry.cancel();
+      callback();
+    });
+    return entry.handle;
+  }
+  every(callback) {
+    const entry = this.#add(callback);
+    return entry.handle;
+  }
+  tween(target, properties, duration) {
+    assertDelay(duration, "duration");
+    const values = Object.entries(properties).map(([key, end]) => {
+      if (typeof end !== "number" || !Number.isFinite(end)) {
+        throw new TypeError(`Tween property '${key}' must be a finite number.`);
+      }
+      const start = target[key];
+      if (typeof start !== "number" || !Number.isFinite(start)) {
+        throw new TypeError(`Tween property '${key}' must start as a finite number.`);
+      }
+      return { end, key, start };
+    });
+    if (duration === 0) {
+      for (const { end, key } of values) target[key] = end;
+      return Promise.resolve();
+    }
+    let elapsed = 0;
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    };
+    let resolve;
+    const promise = new Promise((finish) => {
+      resolve = finish;
+    });
+    const entry = this.#add((dt) => {
+      elapsed = Math.min(duration, elapsed + dt);
+      const progress = elapsed / duration;
+      for (const { end, key, start } of values) {
+        target[key] = start + (end - start) * progress;
+      }
+      if (progress >= 1) {
+        entry.cancel();
+        settle();
+      }
+    }, settle);
+    return promise;
+  }
+  tick(dt) {
+    if (!Number.isFinite(dt) || dt < 0)
+      throw new TypeError("Tick duration must be finite and non-negative.");
+    for (const entry of [...this.#entries]) {
+      if (entry.active) entry.tick(dt);
+    }
+  }
+  clear() {
+    for (const entry of [...this.#entries]) entry.cancel();
+  }
+  #add(tick, onCancel) {
+    const entry = {
+      active: true,
+      cancel: () => {
+        if (!entry.active) return;
+        entry.active = false;
+        this.#entries.delete(entry);
+        onCancel?.();
+      },
+      handle: void 0,
+      tick
+    };
+    entry.handle = createHandle(entry.cancel, () => entry.active);
+    this.#entries.add(entry);
+    return entry;
+  }
+};
+function assertDelay(value, label) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(`${label} must be finite and non-negative.`);
+  }
+}
+function createGameStore(initial, intervalMs = 100) {
+  const store = createStore(() => ({ ...initial }));
+  let pending;
+  let timer;
+  const flush = () => {
+    if (pending === void 0) return;
+    const patch = pending;
+    pending = void 0;
+    store.setState(patch);
+  };
+  const gameStore = store;
+  gameStore.set = (patch) => {
+    const next = typeof patch === "function" ? patch(store.getState()) : patch;
+    pending = { ...pending, ...next };
+  };
+  gameStore.flush = flush;
+  gameStore.start = () => {
+    if (timer !== void 0) return;
+    timer = setInterval(flush, intervalMs);
+  };
+  gameStore.stop = () => {
+    if (timer !== void 0) clearInterval(timer);
+    timer = void 0;
+    flush();
+  };
+  return gameStore;
+}
+var Viewport = class {
+  camera;
+  renderer;
+  #source;
+  #listeners = /* @__PURE__ */ new Set();
+  #size = { aspect: 1, height: 1, width: 1 };
+  #stopObserving = () => void 0;
+  #disposed = false;
+  #raycaster = new Raycaster();
+  #plane = new Plane(new Vector3(0, 0, 1));
+  #projected = new Vector3();
+  constructor(options) {
+    this.camera = options.camera;
+    this.renderer = options.renderer;
+    this.#source = options.source;
+    this.#stopObserving = this.#source?.observeResize(this.renderer.domElement, this.#resize) ?? observeCanvasResize(this.renderer.domElement, this.#resize);
+    this.resize();
+  }
+  get size() {
+    return this.#size;
+  }
+  projectPosition(screen, z = 0) {
+    if (!Number.isFinite(z)) throw new Error("Viewport.projectPosition z must be finite.");
+    const ndc = new Vector2(
+      screen.x / this.#size.width * 2 - 1,
+      -(screen.y / this.#size.height * 2 - 1)
+    );
+    this.#raycaster.setFromCamera(ndc, this.camera);
+    this.#plane.constant = -z;
+    const point = this.#raycaster.ray.intersectPlane(this.#plane, this.#projected);
+    if (point === null)
+      throw new Error("Viewport.projectPosition cannot reach the requested z plane.");
+    return point.clone();
+  }
+  unprojectPosition(world) {
+    const ndc = world.clone().project(this.camera);
+    return new Vector2((ndc.x + 1) / 2 * this.#size.width, (1 - ndc.y) / 2 * this.#size.height);
+  }
+  onResize(handler) {
+    if (this.#disposed) return () => void 0;
+    this.#listeners.add(handler);
+    return () => this.#listeners.delete(handler);
+  }
+  resize() {
+    if (this.#disposed) return;
+    let next = this.#source?.readSize(this.renderer.domElement);
+    if (next === void 0) {
+      const [width, height] = readCanvasSize(this.renderer.domElement);
+      next = { aspect: width / height, height, width };
+    }
+    const changed = next.width !== this.#size.width || next.height !== this.#size.height || next.aspect !== this.#size.aspect;
+    this.#size = next;
+    if (this.camera instanceof PerspectiveCamera) {
+      this.camera.aspect = next.aspect;
+      this.camera.updateProjectionMatrix();
+    } else if (this.camera instanceof OrthographicCamera) {
+      const size = (this.camera.top - this.camera.bottom) / 2;
+      this.camera.left = -size * next.aspect;
+      this.camera.right = size * next.aspect;
+      this.camera.top = size;
+      this.camera.bottom = -size;
+      this.camera.updateProjectionMatrix();
+    }
+    if (changed) for (const listener of this.#listeners) listener(next);
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#stopObserving();
+    this.#stopObserving = () => void 0;
+    this.#listeners.clear();
+  }
+  #resize = () => this.resize();
+};
+
+// src/game.ts
+function installDevTools(entities, host) {
+  const isDev = import.meta.env?.DEV === true;
+  if (!isDev || host === void 0) return () => void 0;
+  const devTools = {
+    ...host.__THREENATIVE__,
+    snapshot: () => entities.snapshot()
+  };
+  host.__THREENATIVE__ = devTools;
+  return () => {
+    if (host.__THREENATIVE__ !== devTools) return;
+    const remaining = Object.fromEntries(
+      Object.entries(devTools).filter(([key]) => key !== "snapshot")
+    );
+    host.__THREENATIVE__ = Object.keys(remaining).length === 0 ? void 0 : remaining;
+  };
+}
+function positiveCameraValue(name, value) {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new Error(`camera.${name} must be finite and positive.`);
+  return value;
+}
+function validateCameraConfig(config) {
+  if (config === void 0) return;
+  const near = positiveCameraValue("near", config.near ?? 0.1);
+  const far = positiveCameraValue("far", config.far ?? 2e3);
+  if (far <= near) throw new Error("camera.far must be greater than camera.near.");
+  if (config.projection === "perspective") {
+    const fov = config.fov ?? 60;
+    if (!Number.isFinite(fov) || fov <= 0 || fov >= 180)
+      throw new Error("camera.fov must be finite and between 0 and 180 degrees.");
+    return;
+  }
+  positiveCameraValue("size", config.size);
+}
+function clearScene(scene, particles) {
+  for (const particle of particles) particle.detach();
+  particles.clear();
+  scene.clear();
+  scene.background = null;
+  scene.environment = null;
+  scene.fog = null;
+}
+function createCamera(config) {
+  if (config === void 0) return new PerspectiveCamera(60, 1, 0.1, 2e3);
+  validateCameraConfig(config);
+  const near = config.near ?? 0.1;
+  const far = config.far ?? 2e3;
+  if (config.projection === "perspective")
+    return new PerspectiveCamera(config.fov ?? 60, 1, near, far);
+  const size = config.size;
+  return new OrthographicCamera(-size, size, size, -size, near, far);
+}
+var GameImpl = class {
+  #config;
+  #ctx;
+  #scene;
+  #sceneFrame;
+  #renderer;
+  #viewport;
+  #input;
+  #state;
+  #initialState;
+  #loop;
+  #cleanup = [];
+  #particles = /* @__PURE__ */ new Set();
+  #entities;
+  #random;
+  #scheduler;
+  #activePlugins = [];
+  #disposedPlugins = /* @__PURE__ */ new Set();
+  #pendingStart;
+  #aborted = false;
+  #sceneEntered = false;
+  #paused = false;
+  #started = false;
+  constructor(config) {
+    this.#config = config;
+    validateCameraConfig(config.camera);
+    const startScene = this.#config.scenes[this.#config.start];
+    if (startScene === void 0) throw new Error(`Unknown start scene '${this.#config.start}'.`);
+    const initialState = this.#config.initialState ?? startScene.initialState;
+    if (initialState === void 0) {
+      throw new Error(
+        `Scene '${this.#config.start}' must declare static initialState or provide config.initialState.`
+      );
+    }
+    this.#state = createGameStore(initialState, this.#config.stateFlushMs);
+    this.#initialState = { ...initialState };
+  }
+  get ctx() {
+    return this.#ctx;
+  }
+  get scene() {
+    return this.#scene;
+  }
+  get state() {
+    return this.#state;
+  }
+  goto(name) {
+    if (this.#ctx === void 0) throw new Error("Cannot call game.goto() before start().");
+    this.#state.stop();
+    this.#state.setState({ ...this.#initialState });
+    this.#state.start();
+    return this.#goto(name, this.#ctx);
+  }
+  #goto(name, ctx) {
+    const SceneType = this.#config.scenes[name];
+    if (SceneType === void 0) throw new Error(`Unknown scene '${name}'.`);
+    this.#sceneFrame = void 0;
+    this.#scene?.exit(ctx);
+    this.#sceneEntered = false;
+    this.#scheduler?.clear();
+    this.#entities?.clear();
+    for (const plugin of this.#config.plugins ?? []) {
+      if (typeof plugin !== "function") plugin.sceneExit?.(ctx);
+    }
+    clearScene(ctx.scene, this.#particles);
+    const scene = new SceneType();
+    this.#scene = scene;
+    const loaded = scene.load(ctx);
+    if (loaded === void 0) {
+      this.#enterScene(scene, ctx);
+      return Promise.resolve();
+    }
+    return Promise.resolve(loaded).then(() => this.#enterScene(scene, ctx));
+  }
+  #enterScene(scene, ctx) {
+    const frame = scene.enter(ctx);
+    if (frame !== void 0 && typeof frame !== "function") {
+      throw new Error("Scene.enter() must return a frame function or undefined.");
+    }
+    if (this.#scene !== scene) return;
+    this.#sceneFrame = typeof frame === "function" ? frame : void 0;
+    this.#sceneEntered = true;
+  }
+  start() {
+    if (this.#started) return Promise.resolve();
+    if (this.#pendingStart !== void 0) return this.#pendingStart;
+    this.#aborted = false;
+    const pendingStart = this.#boot();
+    this.#pendingStart = pendingStart;
+    void pendingStart.then(
+      () => {
+        if (this.#pendingStart === pendingStart) this.#pendingStart = void 0;
+      },
+      () => {
+        if (this.#pendingStart === pendingStart) this.#pendingStart = void 0;
+      }
+    );
+    return pendingStart;
+  }
+  async #boot() {
+    const SceneType = this.#config.scenes[this.#config.start];
+    if (SceneType === void 0) throw new Error(`Unknown start scene '${this.#config.start}'.`);
+    const renderer = await createRenderer({
+      ...this.#config.renderer,
+      canvas: this.#config.canvas ?? this.#config.renderer?.canvas,
+      preferWebGPU: this.#config.render?.preferWebGPU ?? this.#config.renderer?.preferWebGPU,
+      source: this.#config.renderer?.source ?? this.#config.platform?.renderer
+    });
+    if (this.#aborted) {
+      renderer.dispose();
+      return;
+    }
+    this.#renderer = renderer;
+    const canvas = renderer.domElement;
+    const platform = this.#config.platform;
+    if (platform !== void 0) platform.mountCanvas(canvas, this.#config.container);
+    else if (this.#config.container !== void 0 && canvas.parentElement !== this.#config.container)
+      this.#config.container.append(canvas);
+    else if (canvas.parentElement === null && typeof document !== "undefined")
+      document.body.append(canvas);
+    const inputTarget = this.#config.inputTarget ?? (platform === void 0 ? typeof window === "undefined" ? canvas : window : platform.inputTarget ?? canvas);
+    this.#input = new InputMap(this.#config.input, inputTarget, canvas, platform?.input);
+    this.#state.start();
+    const threeScene = new Scene$1();
+    const camera = createCamera(this.#config.camera);
+    const viewport = new Viewport({ camera, renderer: this.#renderer, source: platform?.viewport });
+    this.#viewport = viewport;
+    const assets = createAssetLoader(this.#config.assets);
+    const entities = new Registry();
+    const random = createRandom(this.#config.seed);
+    const scheduler = new Scheduler();
+    const loopState = {};
+    const ctx = {
+      add: (object) => {
+        threeScene.add(object);
+        if (object instanceof GPUParticles3D) {
+          const activeRenderer = this.#renderer;
+          if (activeRenderer === void 0)
+            throw new Error("Cannot add particles before the game starts.");
+          object.attachRenderer(activeRenderer);
+          this.#particles.add(object);
+        }
+        return object;
+      },
+      assets,
+      after: (delay, callback) => scheduler.after(delay, callback),
+      camera,
+      entities,
+      every: (callback) => scheduler.every(callback),
+      get fps() {
+        return loopState.current?.fps ?? 0;
+      },
+      goto: (name) => this.#goto(name, ctx),
+      input: this.#input,
+      physics: void 0,
+      random,
+      renderer: this.#renderer,
+      viewport,
+      scene: threeScene,
+      state: this.#state,
+      tween: (target, properties, duration) => scheduler.tween(target, properties, duration)
+    };
+    this.#ctx = ctx;
+    this.#entities = entities;
+    this.#random = random;
+    this.#scheduler = scheduler;
+    const devToolsHost = platform === void 0 ? typeof window === "undefined" ? void 0 : window : platform.devToolsHost;
+    this.#cleanup.push(installDevTools(entities, devToolsHost));
+    this.#scene = new SceneType();
+    const gameLoop = new FixedStepLoop({
+      maxSteps: this.#config.maxSteps,
+      onRender: () => {
+        for (const particle of this.#particles) {
+          if (particle.released || particle.parent === null) {
+            particle.detach();
+            this.#particles.delete(particle);
+          } else {
+            particle.process(this.#renderer);
+          }
+        }
+        renderer.render(threeScene, camera);
+        this.#scene?.render(ctx);
+      },
+      onUpdate: (dt) => {
+        if (this.#paused) return;
+        this.#input?.tick();
+        scheduler.tick(dt);
+        for (const plugin of this.#activePlugins) plugin.beforeUpdate?.(ctx, dt);
+        const scene2 = this.#scene;
+        const frame = this.#sceneFrame;
+        if (frame !== void 0) frame(ctx, dt);
+        else scene2?.update(ctx, dt);
+        if (this.#scene !== scene2 || this.#sceneFrame !== frame) return;
+        for (const plugin of this.#activePlugins) plugin.update?.(ctx, dt);
+      },
+      step: this.#config.step
+    });
+    loopState.current = gameLoop;
+    this.#loop = gameLoop;
+    const runtime = {
+      fixedStep: (ticks) => gameLoop.advance(ticks),
+      random,
+      rapier: null,
+      seed: this.#config.seed ?? null,
+      step: gameLoop.step
+    };
+    for (const plugin of this.#config.plugins ?? []) {
+      const cleanup = typeof plugin === "function" ? plugin(ctx) : await plugin.setup?.(ctx, runtime);
+      if (typeof plugin !== "function") this.#activePlugins.push(plugin);
+      if (this.#aborted) {
+        if (cleanup !== void 0) this.#cleanup.push(cleanup);
+        this.#teardown(ctx);
+        return;
+      }
+      if (cleanup !== void 0) this.#cleanup.push(cleanup);
+    }
+    const scene = this.#scene;
+    if (scene === void 0) {
+      this.#teardown(ctx);
+      return;
+    }
+    await scene.load(ctx);
+    if (this.#aborted) {
+      this.#teardown(ctx);
+      return;
+    }
+    this.#enterScene(scene, ctx);
+    if (this.#aborted) {
+      this.#teardown(ctx);
+      return;
+    }
+    this.#started = true;
+    gameLoop.start();
+  }
+  pause() {
+    this.#paused = true;
+  }
+  resume() {
+    this.#paused = false;
+  }
+  stop() {
+    this.#aborted = true;
+    this.#teardown();
+  }
+  #disposePlugin(plugin, ctx) {
+    if (this.#disposedPlugins.has(plugin)) return;
+    this.#disposedPlugins.add(plugin);
+    plugin.dispose?.(ctx);
+  }
+  #teardown(startingCtx) {
+    const ctx = this.#ctx ?? startingCtx;
+    this.#loop?.stop();
+    if (this.#sceneEntered && ctx !== void 0) this.#scene?.exit(ctx);
+    this.#sceneFrame = void 0;
+    this.#sceneEntered = false;
+    this.#scheduler?.clear();
+    this.#entities?.clear();
+    this.#entities = void 0;
+    if (ctx !== void 0)
+      for (const plugin of this.#activePlugins) this.#disposePlugin(plugin, ctx);
+    this.#activePlugins = [];
+    for (const cleanup of this.#cleanup.splice(0)) cleanup();
+    if (ctx !== void 0) clearScene(ctx.scene, this.#particles);
+    this.#input?.dispose();
+    this.#state.stop();
+    this.#viewport?.dispose();
+    const renderer = this.#renderer;
+    renderer?.dispose();
+    if (renderer !== void 0) {
+      if (this.#config.platform === void 0) renderer.domElement.remove?.();
+      else this.#config.platform.unmountCanvas(renderer.domElement);
+    }
+    this.#renderer = void 0;
+    this.#viewport = void 0;
+    this.#input = void 0;
+    this.#scene = void 0;
+    this.#ctx = void 0;
+    this.#loop = void 0;
+    this.#random = void 0;
+    this.#scheduler = void 0;
+    this.#disposedPlugins.clear();
+    this.#paused = false;
+    this.#started = false;
+  }
+};
+function defineGame(config) {
+  return new GameImpl(config);
+}
+
+// ../playtest/dist/index.js
+var PLAYTEST_CAPABILITY_REGISTRY = [
+  capability("browser.canvas", "Samples canvas pixels and health."),
+  capability("browser.console", "Captures browser console and page errors."),
+  capability("browser.dom", "Reads bounded DOM observations."),
+  capability("browser.input", "Delivers keyboard and pointer input."),
+  capability("browser.network", "Captures failed browser requests."),
+  capability("browser.screenshot", "Captures viewport screenshots."),
+  capability("browser.trace", "Captures a bounded Playwright trace."),
+  capability("camera.observe", "Samples the active camera transform and projection."),
+  capability("entity.bounds", "Projects registered entity bounds into the viewport."),
+  capability("entity.observe", "Samples registered entity transforms and visibility."),
+  capability("entity.setup", "Applies bounded transforms to registered entities."),
+  capability("runtime.animation", "Samples application-owned animation state."),
+  capability("runtime.audio", "Samples application-owned audio runtime state."),
+  capability("runtime.components", "Samples registered JSON-safe component state."),
+  capability("runtime.contacts", "Samples bounded collision and trigger contacts."),
+  capability("runtime.diagnostics", "Samples application-owned runtime diagnostics."),
+  capability("runtime.events", "Drains bounded application event observations."),
+  capability("runtime.fixedStep", "Advances an application-owned deterministic tick."),
+  capability("runtime.physics", "Samples bounded application-owned physics observations."),
+  capability("runtime.resources", "Reads and writes registered JSON-safe application state."),
+  capability("runtime.state", "Samples application-owned state-machine state."),
+  capability("runtime.tags", "Samples bounded application-owned entity tags."),
+  capability("runtime.ui", "Samples registered JSON-safe UI and HUD state."),
+  capability("runtime.world", "Samples bounded runtime world metadata.")
+];
+new Set(PLAYTEST_CAPABILITY_REGISTRY.map(({ name }) => name));
+function capability(name, description) {
+  return { description, name, protocolVersion: 1 };
+}
+function fail(message, code = "TN_REPLAY_INVALID") {
+  throw new Error(`${code}: ${message}`);
+}
+function checked(value, allowed) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("bad object");
+  const result = value;
+  const unknown = Object.keys(result).find((key) => !allowed.includes(key));
+  if (unknown !== void 0) fail(`unknown key '${unknown}'`);
+  return result;
+}
+function validatePointer(value) {
+  const pointer = Array.isArray(value) ? value : [];
+  if (pointer.length !== 5 || !pointer.every(Number.isFinite) || !Number.isInteger(pointer[2]) || pointer[2] < 0 || Math.min(pointer[3], pointer[4]) <= 0)
+    fail("pointer tuple is invalid");
+}
+function parseReplayRecording(value) {
+  const root = checked(value, ["input", "randomState", "runtime", "seed", "ticks", "version"]);
+  if (root.version !== 1 || !Number.isFinite(root.seed) || !Number.isInteger(root.randomState))
+    fail("bad header");
+  const ticks = root.ticks;
+  if (!Number.isInteger(ticks) || ticks < 1) fail("ticks must be positive");
+  const input2 = root.input;
+  if (!Array.isArray(input2) || input2.length === 0) fail("empty input", "TN_REPLAY_EMPTY");
+  const runtime = checked(root.runtime, ["agent", "core", "rapier", "step"]);
+  const step = runtime.step;
+  if (typeof runtime.agent !== "string" || !runtime.agent || typeof runtime.core !== "string" || !runtime.core || runtime.rapier !== null && typeof runtime.rapier !== "string" || !Number.isFinite(step) || step <= 0)
+    fail("runtime fingerprint is invalid");
+  let previousTick = -1;
+  for (const rawSample of input2) {
+    const sample = checked(rawSample, ["keys", "pointer", "tick"]);
+    const tick = sample.tick;
+    if (!Number.isInteger(tick) || tick <= previousTick || tick >= ticks) fail("bad tick");
+    const keys = sample.keys;
+    if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string")) fail("bad keys");
+    if (new Set(keys).size !== keys.length) fail("duplicate keys");
+    if (sample.pointer !== void 0) validatePointer(sample.pointer);
+    previousTick = tick;
+  }
+  return root;
+}
+
+// src/replay.ts
+var CORE_VERSION = "0.1.0";
+var currentAgent = typeof navigator === "undefined" ? "node" : navigator.userAgent;
+var replayDepth = 0;
+function fail2(message, code = "TN_REPLAY_INVALID") {
+  throw new Error(`${code}: ${message}`);
+}
+var event = (type, init) => Object.assign(new Event(type), init);
+var pointerEvent = (type, [clientX, clientY, buttons]) => event(type, { buttons, clientX, clientY, pointerId: 0 });
+function pointerViewport(ctx, point = [0, 0, 0]) {
+  const canvas = ctx.renderer?.domElement;
+  const rect = canvas?.getBoundingClientRect();
+  return [
+    point[0] - (rect?.left ?? 0),
+    point[1] - (rect?.top ?? 0),
+    point[2],
+    canvas?.clientWidth || globalThis.innerWidth || 1,
+    canvas?.clientHeight || globalThis.innerHeight || 1
+  ];
+}
+var pointerType = (previous, next) => previous && !next ? "pointerup" : !previous && next ? "pointerdown" : "pointermove";
+function targetPointerPosition(pointer, target) {
+  const viewport = target;
+  const rect = viewport.getBoundingClientRect?.();
+  const width = viewport.clientWidth || viewport.innerWidth || rect?.width || pointer[3];
+  const height = viewport.clientHeight || viewport.innerHeight || rect?.height || pointer[4];
+  return [
+    pointer[0] * width / pointer[3] + (rect?.left ?? 0),
+    pointer[1] * height / pointer[4] + (rect?.top ?? 0),
+    pointer[2]
+  ];
+}
+function dispatchKeys(target, current, keys) {
+  for (const key of current)
+    if (!keys.includes(key)) target.dispatchEvent(event("keyup", { code: key }));
+  for (const key of keys)
+    if (!current.has(key)) target.dispatchEvent(event("keydown", { code: key }));
+  current.clear();
+  for (const key of keys) current.add(key);
+}
+function releasePointer(pointer, target) {
+  if (pointer[2] === 0) return;
+  const released = [pointer[0], pointer[1], 0, pointer[3], pointer[4]];
+  target.dispatchEvent(pointerEvent("pointerup", targetPointerPosition(released, target)));
+}
+function dispatchPointer(previous, next, target) {
+  if (previous.join() === next.join()) return previous;
+  target.dispatchEvent(
+    pointerEvent(pointerType(previous[2], next[2]), targetPointerPosition(next, target))
+  );
+  return next;
+}
+function replay() {
+  const runId = /* @__PURE__ */ Symbol("replay");
+  const samples = [];
+  let header;
+  let ticks = 0;
+  let previousKeys = [];
+  let previousPointer = [0, 0, 0, 1, 1];
+  return {
+    get recording() {
+      if (header === void 0) return void 0;
+      return {
+        ...header,
+        input: [...samples],
+        ticks
+      };
+    },
+    runId,
+    setup: (ctx, runtime) => {
+      if (runtime?.seed === null || runtime?.seed === void 0)
+        fail2("replay requires a seed", "TN_REPLAY_UNSEEDED");
+      const { rapier, seed, step } = runtime;
+      header = {
+        randomState: ctx.random.state,
+        runtime: { agent: currentAgent, core: CORE_VERSION, rapier: rapier ?? null, step },
+        seed,
+        version: 1
+      };
+      samples.length = ticks = 0;
+      [previousKeys, previousPointer] = [[], pointerViewport(ctx)];
+      return void 0;
+    },
+    beforeUpdate: (ctx) => {
+      if (replayDepth > 0) return;
+      const keys = [...ctx.input.raw.keys].sort();
+      const { position, buttons } = ctx.input.raw.pointer;
+      const pointer = pointerViewport(ctx, [position.x, position.y, buttons]);
+      const pointerChanged = pointer.join() !== previousPointer.join();
+      if (pointerChanged || keys.join() !== previousKeys.join()) {
+        samples.push({ keys, ...pointerChanged ? { pointer } : {}, tick: ticks });
+        [previousKeys, previousPointer] = [keys, pointer];
+      }
+      ticks += 1;
+    }
+  };
+}
+function validateRuntime(runtime, recording) {
+  const random = runtime.random;
+  if (runtime.seed !== recording.seed || runtime.step !== recording.runtime.step || (runtime.rapier ?? null) !== (recording.runtime.rapier ?? null) || recording.runtime.core !== CORE_VERSION || recording.runtime.agent !== currentAgent || random === void 0)
+    fail2("recording runtime does not match the current build", "TN_REPLAY_RUNTIME_MISMATCH");
+  return random;
+}
+function restoreRandomState(random, state) {
+  try {
+    random.state = state;
+    if (random.state !== state) throw new Error();
+  } catch {
+    fail2("runtime random state cannot be restored", "TN_REPLAY_RUNTIME_MISMATCH");
+  }
+  return random;
+}
+function createReplayDriver(recording, target, pointerTarget = target) {
+  const value = parseReplayRecording(recording);
+  const samples = new Map(value.input.map((sample) => [sample.tick, sample]));
+  let preparedRandom;
+  const driver = Object.assign(
+    (runtime) => {
+      const random = validateRuntime(runtime, value);
+      if (preparedRandom !== random) restoreRandomState(random, value.randomState);
+      preparedRandom = void 0;
+      target.dispatchEvent(new Event("blur"));
+      const keys = /* @__PURE__ */ new Set();
+      let pointer = [0, 0, 0, 1, 1];
+      replayDepth += 1;
+      try {
+        for (let tick = 0; tick < value.ticks; tick += 1) {
+          const sample = samples.get(tick);
+          if (sample !== void 0) {
+            dispatchKeys(target, keys, sample.keys);
+            if (sample.pointer !== void 0)
+              pointer = dispatchPointer(pointer, sample.pointer, pointerTarget);
+          }
+          runtime.fixedStep(1);
+        }
+        dispatchKeys(target, keys, []);
+        releasePointer(pointer, pointerTarget);
+        return value.ticks;
+      } finally {
+        replayDepth -= 1;
+      }
+    },
+    {
+      prepare: (runtime) => {
+        preparedRandom = restoreRandomState(validateRuntime(runtime, value), value.randomState);
+      },
+      runId: /* @__PURE__ */ Symbol("replay-driver")
+    }
+  );
+  return driver;
+}
+
+// src/scene.ts
+var Scene = class {
+  static initialState = void 0;
+  load(_ctx) {
+  }
+  enter(_ctx) {
+    return void 0;
+  }
+  exit(_ctx) {
+  }
+  update(_ctx, _dt) {
+  }
+  render(_ctx) {
+  }
+};
+
+// src/index.ts
+var version = "0.1.0";
+
+export { AnimationPlayer, AudioBus, FixedStepLoop, GPUParticles3D, InputMap, Registry, Scene, Scheduler, Viewport, autoFields, createAssetLoader, createGameStore, createRandom, createRenderer, createReplayDriver, defineGame, input, replay, version };