@zylem/game-lib 0.6.4 → 0.7.0

package/dist/entities.js

@@ -1,4986 +0,0 @@
-// src/lib/entities/box.ts
-import { Vector3 as Vector39 } from "three";
-
-// src/lib/entities/entity.ts
-import { Mesh, ShaderMaterial, Group } from "three";
-
-// src/lib/systems/transformable.system.ts
-import {
-  defineSystem,
-  defineQuery,
-  defineComponent,
-  Types,
-  removeQuery
-} from "bitecs";
-import { Quaternion } from "three";
-var position = defineComponent({
-  x: Types.f32,
-  y: Types.f32,
-  z: Types.f32
-});
-var rotation = defineComponent({
-  x: Types.f32,
-  y: Types.f32,
-  z: Types.f32,
-  w: Types.f32
-});
-var scale = defineComponent({
-  x: Types.f32,
-  y: Types.f32,
-  z: Types.f32
-});
-var _tempQuaternion = new Quaternion();
-
-// src/lib/core/flags.ts
-var DEBUG_FLAG = import.meta.env.VITE_DEBUG_FLAG === "true";
-
-// src/lib/core/base-node.ts
-import { nanoid } from "nanoid";
-var BaseNode = class _BaseNode {
-  parent = null;
-  children = [];
-  options;
-  eid = 0;
-  uuid = "";
-  name = "";
-  markedForRemoval = false;
-  /**
-   * Lifecycle callback arrays - use onSetup(), onUpdate(), etc. to add callbacks
-   * Uses `any` for the type parameter to avoid invariance issues when subclasses
-   * are assigned to BaseNode references. Type safety is enforced by the public
-   * onSetup/onUpdate/etc. methods which are typed with `this`.
-   */
-  lifecycleCallbacks = {
-    setup: [],
-    loaded: [],
-    update: [],
-    destroy: [],
-    cleanup: []
-  };
-  trackLifecycleRegistrations = false;
-  userLifecycleRegistrations = [];
-  constructor(args = []) {
-    const options = args.filter((arg) => !(arg instanceof _BaseNode)).reduce((acc, opt) => ({ ...acc, ...opt }), {});
-    this.options = options;
-    this.uuid = nanoid();
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Fluent API for adding lifecycle callbacks
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Add setup callbacks to be executed in order during nodeSetup
-   */
-  onSetup(...callbacks) {
-    this.lifecycleCallbacks.setup.push(...callbacks);
-    this.recordLifecycleRegistration("onSetup", callbacks);
-    return this;
-  }
-  /**
-   * Add loaded callbacks to be executed in order during nodeLoaded
-   */
-  onLoaded(...callbacks) {
-    this.lifecycleCallbacks.loaded.push(...callbacks);
-    this.recordLifecycleRegistration("onLoaded", callbacks);
-    return this;
-  }
-  /**
-   * Add update callbacks to be executed in order during nodeUpdate
-   */
-  onUpdate(...callbacks) {
-    this.lifecycleCallbacks.update.push(...callbacks);
-    this.recordLifecycleRegistration("onUpdate", callbacks);
-    return this;
-  }
-  /**
-   * Add destroy callbacks to be executed in order during nodeDestroy
-   */
-  onDestroy(...callbacks) {
-    this.lifecycleCallbacks.destroy.push(...callbacks);
-    this.recordLifecycleRegistration("onDestroy", callbacks);
-    return this;
-  }
-  /**
-   * Add cleanup callbacks to be executed in order during nodeCleanup
-   */
-  onCleanup(...callbacks) {
-    this.lifecycleCallbacks.cleanup.push(...callbacks);
-    this.recordLifecycleRegistration("onCleanup", callbacks);
-    return this;
-  }
-  /**
-   * Prepend setup callbacks (run before existing ones)
-   */
-  prependSetup(...callbacks) {
-    this.lifecycleCallbacks.setup.unshift(...callbacks);
-    this.recordLifecycleRegistration("prependSetup", callbacks);
-    return this;
-  }
-  /**
-   * Prepend update callbacks (run before existing ones)
-   */
-  prependUpdate(...callbacks) {
-    this.lifecycleCallbacks.update.unshift(...callbacks);
-    this.recordLifecycleRegistration("prependUpdate", callbacks);
-    return this;
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Tree structure
-  // ─────────────────────────────────────────────────────────────────────────────
-  setParent(parent) {
-    this.parent = parent;
-  }
-  getParent() {
-    return this.parent;
-  }
-  add(baseNode) {
-    this.children.push(baseNode);
-    baseNode.setParent(this);
-  }
-  remove(baseNode) {
-    const index = this.children.indexOf(baseNode);
-    if (index !== -1) {
-      this.children.splice(index, 1);
-      baseNode.setParent(null);
-    }
-  }
-  getChildren() {
-    return this.children;
-  }
-  isComposite() {
-    return this.children.length > 0;
-  }
-  enableUserLifecycleTracking() {
-    this.trackLifecycleRegistrations = true;
-  }
-  replayUserLifecycleRegistrationsTo(target, wrap) {
-    for (const registration of this.userLifecycleRegistrations) {
-      const callbacks = wrap ? registration.callbacks.map((callback) => wrap(callback)) : [...registration.callbacks];
-      switch (registration.method) {
-        case "onSetup":
-          target.onSetup(...callbacks);
-          break;
-        case "onLoaded":
-          target.onLoaded(...callbacks);
-          break;
-        case "onUpdate":
-          target.onUpdate(...callbacks);
-          break;
-        case "onDestroy":
-          target.onDestroy(...callbacks);
-          break;
-        case "onCleanup":
-          target.onCleanup(...callbacks);
-          break;
-        case "prependSetup":
-          target.prependSetup(...callbacks);
-          break;
-        case "prependUpdate":
-          target.prependUpdate(...callbacks);
-          break;
-      }
-    }
-  }
-  cloneChildrenInto(target) {
-    for (const child of this.children) {
-      target.add(cloneNode(child));
-    }
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Node lifecycle execution - runs internal + callback arrays
-  // ─────────────────────────────────────────────────────────────────────────────
-  nodeSetup(params) {
-    if (DEBUG_FLAG) {
-    }
-    this.markedForRemoval = false;
-    if (typeof this._setup === "function") {
-      this._setup(params);
-    }
-    for (const callback of this.lifecycleCallbacks.setup) {
-      callback(params);
-    }
-    this.children.forEach((child) => child.nodeSetup(params));
-  }
-  nodeUpdate(params) {
-    if (this.markedForRemoval) {
-      return;
-    }
-    if (typeof this._update === "function") {
-      this._update(params);
-    }
-    if (typeof this._tickActions === "function") {
-      this._tickActions(params.delta);
-    }
-    for (const callback of this.lifecycleCallbacks.update) {
-      callback(params);
-    }
-    this.children.forEach((child) => child.nodeUpdate(params));
-  }
-  nodeDestroy(params) {
-    if (this.markedForRemoval) return;
-    this.children.forEach((child) => child.nodeDestroy(params));
-    for (const callback of this.lifecycleCallbacks.destroy) {
-      callback(params);
-    }
-    if (typeof this._destroy === "function") {
-      this._destroy(params);
-    }
-    this.markedForRemoval = true;
-    for (const callback of this.lifecycleCallbacks.cleanup) {
-      callback(params);
-    }
-    if (typeof this._cleanup === "function") {
-      this._cleanup(params);
-    }
-  }
-  async nodeLoaded(params) {
-    if (typeof this._loaded === "function") {
-      await this._loaded(params);
-    }
-    for (const callback of this.lifecycleCallbacks.loaded) {
-      callback(params);
-    }
-  }
-  nodeCleanup(params) {
-    this.children.forEach((child) => child.nodeCleanup?.(params));
-    for (const callback of this.lifecycleCallbacks.cleanup) {
-      callback(params);
-    }
-    if (typeof this._cleanup === "function") {
-      this._cleanup(params);
-    }
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Options
-  // ─────────────────────────────────────────────────────────────────────────────
-  getOptions() {
-    return this.options;
-  }
-  setOptions(options) {
-    this.options = { ...this.options, ...options };
-  }
-  recordLifecycleRegistration(method, callbacks) {
-    if (!this.trackLifecycleRegistrations || callbacks.length === 0) {
-      return;
-    }
-    this.userLifecycleRegistrations.push({
-      method,
-      callbacks: [...callbacks]
-    });
-  }
-};
-function cloneNode(node) {
-  const maybeClone = node?.clone;
-  if (typeof maybeClone !== "function") {
-    throw new Error(
-      `Cannot clone child node "${node.name || node.uuid || "unknown"}": missing clone() support.`
-    );
-  }
-  return maybeClone.call(node);
-}
-
-// ../../node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
-function mitt_default(n) {
-  return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
-    var i = n.get(t);
-    i ? i.push(e) : n.set(t, [e]);
-  }, off: function(t, e) {
-    var i = n.get(t);
-    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
-  }, emit: function(t, e) {
-    var i = n.get(t);
-    i && i.slice().map(function(n2) {
-      n2(e);
-    }), (i = n.get("*")) && i.slice().map(function(n2) {
-      n2(t, e);
-    });
-  } };
-}
-
-// src/lib/events/event-emitter-delegate.ts
-var EventEmitterDelegate = class {
-  emitter;
-  unsubscribes = [];
-  constructor() {
-    this.emitter = mitt_default();
-  }
-  /**
-   * Dispatch an event to all listeners.
-   */
-  dispatch(event, payload) {
-    this.emitter.emit(event, payload);
-  }
-  /**
-   * Subscribe to an event. Returns an unsubscribe function.
-   */
-  listen(event, handler) {
-    this.emitter.on(event, handler);
-    const unsub = () => this.emitter.off(event, handler);
-    this.unsubscribes.push(unsub);
-    return unsub;
-  }
-  /**
-   * Subscribe to all events.
-   */
-  listenAll(handler) {
-    this.emitter.on("*", handler);
-    const unsub = () => this.emitter.off("*", handler);
-    this.unsubscribes.push(unsub);
-    return unsub;
-  }
-  /**
-   * Clean up all subscriptions.
-   */
-  dispose() {
-    this.unsubscribes.forEach((fn) => fn());
-    this.unsubscribes = [];
-    this.emitter.all.clear();
-  }
-};
-
-// src/lib/events/zylem-events.ts
-var zylemEventBus = mitt_default();
-
-// src/lib/actions/capabilities/transform-store.ts
-import { proxy } from "valtio";
-function createTransformStore(initial) {
-  const defaultState = {
-    position: { x: 0, y: 0, z: 0 },
-    rotation: { x: 0, y: 0, z: 0, w: 1 },
-    velocity: { x: 0, y: 0, z: 0 },
-    angularVelocity: { x: 0, y: 0, z: 0 },
-    velocityChannels: {},
-    dirty: {
-      position: false,
-      rotation: false,
-      velocity: false,
-      velocityX: false,
-      velocityY: false,
-      velocityZ: false,
-      velocityChannels: false,
-      angularVelocity: false
-    }
-  };
-  return proxy({
-    ...defaultState,
-    ...initial,
-    // Ensure dirty flags are properly initialized even if partial initial state
-    dirty: {
-      ...defaultState.dirty,
-      ...initial?.dirty
-    }
-  });
-}
-
-// src/lib/actions/capabilities/moveable.ts
-import { Vector3 } from "three";
-
-// src/lib/actions/capabilities/velocity-intents.ts
-function setVelocityIntent(store, sourceId, vector, options = {}) {
-  const prev = store.velocityChannels[sourceId];
-  const mode = options.mode ?? prev?.mode ?? "replace";
-  const priority = options.priority ?? prev?.priority ?? 0;
-  const isAdditiveMerge = mode === "add" && prev?.mode === "add";
-  const x = vector.x == null ? prev?.x : isAdditiveMerge ? (prev?.x ?? 0) + vector.x : vector.x;
-  const y = vector.y == null ? prev?.y : isAdditiveMerge ? (prev?.y ?? 0) + vector.y : vector.y;
-  const z = vector.z == null ? prev?.z : isAdditiveMerge ? (prev?.z ?? 0) + vector.z : vector.z;
-  store.velocityChannels[sourceId] = {
-    x,
-    y,
-    z,
-    mode,
-    priority
-  };
-  store.dirty.velocityChannels = true;
-}
-function clearVelocityIntent(store, sourceId) {
-  if (!(sourceId in store.velocityChannels)) return;
-  delete store.velocityChannels[sourceId];
-  store.dirty.velocityChannels = true;
-}
-
-// src/lib/actions/capabilities/moveable.ts
-function moveX(entity, delta) {
-  if (!entity.transformStore) return;
-  setVelocityIntent(entity.transformStore, "actions", { x: delta }, { mode: "replace" });
-}
-function moveY(entity, delta) {
-  if (!entity.transformStore) return;
-  setVelocityIntent(entity.transformStore, "actions", { y: delta }, { mode: "replace" });
-}
-function moveZ(entity, delta) {
-  if (!entity.transformStore) return;
-  setVelocityIntent(entity.transformStore, "actions", { z: delta }, { mode: "replace" });
-}
-function moveXY(entity, deltaX, deltaY) {
-  if (!entity.transformStore) return;
-  setVelocityIntent(
-    entity.transformStore,
-    "actions",
-    { x: deltaX, y: deltaY },
-    { mode: "replace" }
-  );
-}
-function moveXZ(entity, deltaX, deltaZ) {
-  if (!entity.transformStore) return;
-  setVelocityIntent(
-    entity.transformStore,
-    "actions",
-    { x: deltaX, z: deltaZ },
-    { mode: "replace" }
-  );
-}
-function move(entity, vector) {
-  if (!entity.transformStore) return;
-  setVelocityIntent(
-    entity.transformStore,
-    "actions",
-    { x: vector.x, y: vector.y, z: vector.z },
-    { mode: "add" }
-  );
-}
-function resetVelocity(entity) {
-  if (!entity.body) return;
-  entity.body.setLinvel(new Vector3(0, 0, 0), true);
-  entity.body.setLinearDamping(5);
-}
-function moveForwardXY(entity, delta, rotation2DAngle) {
-  const deltaX = Math.sin(-rotation2DAngle) * delta;
-  const deltaY = Math.cos(-rotation2DAngle) * delta;
-  moveXY(entity, deltaX, deltaY);
-}
-function getPosition(entity) {
-  if (!entity.body) return null;
-  return entity.body.translation();
-}
-function getVelocity(entity) {
-  if (!entity.body) return null;
-  return entity.body.linvel();
-}
-function setPosition(entity, x, y, z) {
-  if (!entity.body) return;
-  entity.body.setTranslation({ x, y, z }, true);
-}
-function setPositionX(entity, x) {
-  if (!entity.body) return;
-  const { y, z } = entity.body.translation();
-  entity.body.setTranslation({ x, y, z }, true);
-}
-function setPositionY(entity, y) {
-  if (!entity.body) return;
-  const { x, z } = entity.body.translation();
-  entity.body.setTranslation({ x, y, z }, true);
-}
-function setPositionZ(entity, z) {
-  if (!entity.body) return;
-  const { x, y } = entity.body.translation();
-  entity.body.setTranslation({ x, y, z }, true);
-}
-function wrapAroundXY(entity, boundsX, boundsY) {
-  const position2 = getPosition(entity);
-  if (!position2) return;
-  const { x, y } = position2;
-  const newX = x > boundsX ? -boundsX : x < -boundsX ? boundsX : x;
-  const newY = y > boundsY ? -boundsY : y < -boundsY ? boundsY : y;
-  if (newX !== x || newY !== y) {
-    setPosition(entity, newX, newY, 0);
-  }
-}
-function wrapAround3D(entity, boundsX, boundsY, boundsZ) {
-  const position2 = getPosition(entity);
-  if (!position2) return;
-  const { x, y, z } = position2;
-  const newX = x > boundsX ? -boundsX : x < -boundsX ? boundsX : x;
-  const newY = y > boundsY ? -boundsY : y < -boundsY ? boundsY : y;
-  const newZ = z > boundsZ ? -boundsZ : z < -boundsZ ? boundsZ : z;
-  if (newX !== x || newY !== y || newZ !== z) {
-    setPosition(entity, newX, newY, newZ);
-  }
-}
-function makeMoveable(entity) {
-  const moveable = entity;
-  if (!moveable.transformStore) {
-    moveable.transformStore = createTransformStore();
-  }
-  moveable.moveX = (delta) => moveX(entity, delta);
-  moveable.moveY = (delta) => moveY(entity, delta);
-  moveable.moveZ = (delta) => moveZ(entity, delta);
-  moveable.moveXY = (deltaX, deltaY) => moveXY(entity, deltaX, deltaY);
-  moveable.moveXZ = (deltaX, deltaZ) => moveXZ(entity, deltaX, deltaZ);
-  moveable.move = (vector) => move(entity, vector);
-  moveable.resetVelocity = () => resetVelocity(entity);
-  moveable.moveForwardXY = (delta, rotation2DAngle) => moveForwardXY(entity, delta, rotation2DAngle);
-  moveable.getPosition = () => getPosition(entity);
-  moveable.getVelocity = () => getVelocity(entity);
-  moveable.setPosition = (x, y, z) => setPosition(entity, x, y, z);
-  moveable.setPositionX = (x) => setPositionX(entity, x);
-  moveable.setPositionY = (y) => setPositionY(entity, y);
-  moveable.setPositionZ = (z) => setPositionZ(entity, z);
-  moveable.wrapAroundXY = (boundsX, boundsY) => wrapAroundXY(entity, boundsX, boundsY);
-  moveable.wrapAround3D = (boundsX, boundsY, boundsZ) => wrapAround3D(entity, boundsX, boundsY, boundsZ);
-  return moveable;
-}
-
-// src/lib/actions/capabilities/rotatable.ts
-import { Euler, Vector3 as Vector32, MathUtils, Quaternion as Quaternion2 } from "three";
-function syncImmediateRotation(entity) {
-  if (!entity.group || !entity.transformStore) return;
-  entity.group.setRotationFromQuaternion(
-    new Quaternion2(
-      entity.transformStore.rotation.x,
-      entity.transformStore.rotation.y,
-      entity.transformStore.rotation.z,
-      entity.transformStore.rotation.w
-    )
-  );
-}
-function rotateInDirection(entity, moveVector) {
-  if (!entity.body) return;
-  const rotate = Math.atan2(-moveVector.x, moveVector.z);
-  rotateYEuler(entity, rotate);
-}
-function rotateYEuler(entity, amount) {
-  rotateEuler(entity, new Vector32(0, -amount, 0));
-}
-function rotateEuler(entity, rotation2) {
-  if (!entity.transformStore) return;
-  const quat = new Quaternion2().setFromEuler(
-    new Euler(rotation2.x, rotation2.y, rotation2.z)
-  );
-  entity.transformStore.rotation.w = quat.w;
-  entity.transformStore.rotation.x = quat.x;
-  entity.transformStore.rotation.y = quat.y;
-  entity.transformStore.rotation.z = quat.z;
-  entity.transformStore.dirty.rotation = true;
-  syncImmediateRotation(entity);
-}
-function rotateY(entity, delta) {
-  if (!entity.transformStore) return;
-  const halfAngle = delta / 2;
-  const deltaW = Math.cos(halfAngle);
-  const deltaY = Math.sin(halfAngle);
-  const q = entity.transformStore.rotation;
-  const newW = q.w * deltaW - q.y * deltaY;
-  const newX = q.x * deltaW + q.z * deltaY;
-  const newY = q.y * deltaW + q.w * deltaY;
-  const newZ = q.z * deltaW - q.x * deltaY;
-  entity.transformStore.rotation.w = newW;
-  entity.transformStore.rotation.x = newX;
-  entity.transformStore.rotation.y = newY;
-  entity.transformStore.rotation.z = newZ;
-  entity.transformStore.dirty.rotation = true;
-  syncImmediateRotation(entity);
-}
-function rotateX(entity, delta) {
-  if (!entity.transformStore) return;
-  const halfAngle = delta / 2;
-  const deltaW = Math.cos(halfAngle);
-  const deltaX = Math.sin(halfAngle);
-  const q = entity.transformStore.rotation;
-  const newW = q.w * deltaW - q.x * deltaX;
-  const newX = q.x * deltaW + q.w * deltaX;
-  const newY = q.y * deltaW + q.z * deltaX;
-  const newZ = q.z * deltaW - q.y * deltaX;
-  entity.transformStore.rotation.w = newW;
-  entity.transformStore.rotation.x = newX;
-  entity.transformStore.rotation.y = newY;
-  entity.transformStore.rotation.z = newZ;
-  entity.transformStore.dirty.rotation = true;
-  syncImmediateRotation(entity);
-}
-function rotateZ(entity, delta) {
-  if (!entity.transformStore) return;
-  const halfAngle = delta / 2;
-  const deltaW = Math.cos(halfAngle);
-  const deltaZ = Math.sin(halfAngle);
-  const q = entity.transformStore.rotation;
-  const newW = q.w * deltaW - q.z * deltaZ;
-  const newX = q.x * deltaW - q.y * deltaZ;
-  const newY = q.y * deltaW + q.x * deltaZ;
-  const newZ = q.z * deltaW + q.w * deltaZ;
-  entity.transformStore.rotation.w = newW;
-  entity.transformStore.rotation.x = newX;
-  entity.transformStore.rotation.y = newY;
-  entity.transformStore.rotation.z = newZ;
-  entity.transformStore.dirty.rotation = true;
-  entity._rotation2DAngle = (entity._rotation2DAngle ?? 0) + delta;
-  syncImmediateRotation(entity);
-}
-function setRotationY(entity, y) {
-  if (!entity.transformStore) return;
-  const halfAngle = y / 2;
-  const w = Math.cos(halfAngle);
-  const yComponent = Math.sin(halfAngle);
-  entity.transformStore.rotation.w = w;
-  entity.transformStore.rotation.x = 0;
-  entity.transformStore.rotation.y = yComponent;
-  entity.transformStore.rotation.z = 0;
-  entity.transformStore.dirty.rotation = true;
-  syncImmediateRotation(entity);
-}
-function setRotationDegreesY(entity, y) {
-  if (!entity.body) return;
-  setRotationY(entity, MathUtils.degToRad(y));
-}
-function setRotationX(entity, x) {
-  if (!entity.transformStore) return;
-  const halfAngle = x / 2;
-  const w = Math.cos(halfAngle);
-  const xComponent = Math.sin(halfAngle);
-  entity.transformStore.rotation.w = w;
-  entity.transformStore.rotation.x = xComponent;
-  entity.transformStore.rotation.y = 0;
-  entity.transformStore.rotation.z = 0;
-  entity.transformStore.dirty.rotation = true;
-  syncImmediateRotation(entity);
-}
-function setRotationDegreesX(entity, x) {
-  if (!entity.body) return;
-  setRotationX(entity, MathUtils.degToRad(x));
-}
-function setRotationZ(entity, z) {
-  if (!entity.transformStore) return;
-  const halfAngle = z / 2;
-  const w = Math.cos(halfAngle);
-  const zComponent = Math.sin(halfAngle);
-  entity.transformStore.rotation.w = w;
-  entity.transformStore.rotation.x = 0;
-  entity.transformStore.rotation.y = 0;
-  entity.transformStore.rotation.z = zComponent;
-  entity.transformStore.dirty.rotation = true;
-  entity._rotation2DAngle = z;
-  syncImmediateRotation(entity);
-}
-function setRotationDegreesZ(entity, z) {
-  if (!entity.body) return;
-  setRotationZ(entity, MathUtils.degToRad(z));
-}
-function setRotation(entity, x, y, z) {
-  if (!entity.transformStore) return;
-  const quat = new Quaternion2().setFromEuler(new Euler(x, y, z));
-  entity.transformStore.rotation.w = quat.w;
-  entity.transformStore.rotation.x = quat.x;
-  entity.transformStore.rotation.y = quat.y;
-  entity.transformStore.rotation.z = quat.z;
-  entity.transformStore.dirty.rotation = true;
-  entity._rotation2DAngle = z;
-  syncImmediateRotation(entity);
-}
-function setRotationDegrees(entity, x, y, z) {
-  if (!entity.body) return;
-  setRotation(entity, MathUtils.degToRad(x), MathUtils.degToRad(y), MathUtils.degToRad(z));
-}
-function getRotation(entity) {
-  if (!entity.body) return null;
-  return entity.body.rotation();
-}
-function makeRotatable(entity) {
-  const rotatableEntity = entity;
-  if (!rotatableEntity.transformStore) {
-    rotatableEntity.transformStore = createTransformStore();
-  }
-  rotatableEntity.rotateInDirection = (moveVector) => rotateInDirection(entity, moveVector);
-  rotatableEntity.rotateYEuler = (amount) => rotateYEuler(entity, amount);
-  rotatableEntity.rotateEuler = (rotation2) => rotateEuler(entity, rotation2);
-  rotatableEntity.rotateX = (delta) => rotateX(entity, delta);
-  rotatableEntity.rotateY = (delta) => rotateY(entity, delta);
-  rotatableEntity.rotateZ = (delta) => rotateZ(entity, delta);
-  rotatableEntity.setRotationY = (y) => setRotationY(entity, y);
-  rotatableEntity.setRotationX = (x) => setRotationX(entity, x);
-  rotatableEntity.setRotationZ = (z) => setRotationZ(entity, z);
-  rotatableEntity.setRotationDegreesY = (y) => setRotationDegreesY(entity, y);
-  rotatableEntity.setRotationDegreesX = (x) => setRotationDegreesX(entity, x);
-  rotatableEntity.setRotationDegreesZ = (z) => setRotationDegreesZ(entity, z);
-  rotatableEntity.setRotationDegrees = (x, y, z) => setRotationDegrees(entity, x, y, z);
-  rotatableEntity.setRotation = (x, y, z) => setRotation(entity, x, y, z);
-  rotatableEntity.getRotation = () => getRotation(entity);
-  return rotatableEntity;
-}
-
-// src/lib/actions/capabilities/transformable.ts
-function makeTransformable(entity) {
-  const withMovement = makeMoveable(entity);
-  const withRotation = makeRotatable(withMovement);
-  return withRotation;
-}
-
-// src/lib/entities/parts/collision-factories.ts
-import {
-  ActiveCollisionTypes as ActiveCollisionTypes2,
-  ColliderDesc as ColliderDesc2,
-  RigidBodyDesc as RigidBodyDesc2,
-  RigidBodyType as RigidBodyType2
-} from "@dimforge/rapier3d-compat";
-import { Vector3 as Vector35 } from "three";
-
-// src/lib/collision/collision-builder.ts
-import { ActiveCollisionTypes, ColliderDesc, RigidBodyDesc, RigidBodyType, Vector3 as Vector33 } from "@dimforge/rapier3d-compat";
-var typeToGroup = /* @__PURE__ */ new Map();
-var nextGroupId = 0;
-function getOrCreateCollisionGroupId(type) {
-  let groupId = typeToGroup.get(type);
-  if (groupId === void 0) {
-    groupId = nextGroupId++ % 16;
-    typeToGroup.set(type, groupId);
-  }
-  return groupId;
-}
-function createCollisionFilter(allowedTypes) {
-  let filter = 0;
-  allowedTypes.forEach((type) => {
-    const groupId = getOrCreateCollisionGroupId(type);
-    filter |= 1 << groupId;
-  });
-  return filter;
-}
-var CollisionBuilder = class {
-  static = false;
-  sensor = false;
-  gravity = new Vector33(0, 0, 0);
-  build(options) {
-    const bodyDesc = this.bodyDesc({
-      isDynamicBody: !this.static
-    });
-    const collider = this.collider(options);
-    const type = options.collisionType;
-    if (type) {
-      let groupId = getOrCreateCollisionGroupId(type);
-      let filter = 65535;
-      if (options.collisionFilter) {
-        filter = createCollisionFilter(options.collisionFilter);
-      }
-      collider.setCollisionGroups(groupId << 16 | filter);
-    }
-    const { KINEMATIC_FIXED, DEFAULT } = ActiveCollisionTypes;
-    collider.activeCollisionTypes = this.sensor ? KINEMATIC_FIXED : DEFAULT;
-    return [bodyDesc, collider];
-  }
-  withCollision(collisionOptions) {
-    this.sensor = collisionOptions?.sensor ?? this.sensor;
-    this.static = collisionOptions?.static ?? this.static;
-    return this;
-  }
-  collider(options) {
-    const size = options.size ?? new Vector33(1, 1, 1);
-    const half = { x: size.x / 2, y: size.y / 2, z: size.z / 2 };
-    let colliderDesc = ColliderDesc.cuboid(half.x, half.y, half.z);
-    return colliderDesc;
-  }
-  bodyDesc({ isDynamicBody = true }) {
-    const type = isDynamicBody ? RigidBodyType.Dynamic : RigidBodyType.Fixed;
-    const bodyDesc = new RigidBodyDesc(type).setTranslation(0, 0, 0).setGravityScale(1).setCanSleep(false).setCcdEnabled(true);
-    return bodyDesc;
-  }
-};
-
-// src/lib/core/clone-utils.ts
-import { Color, Vector2, Vector3 as Vector34 } from "three";
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function deepCloneValue(value) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (typeof value === "function" || typeof value !== "object") {
-    return value;
-  }
-  if (value instanceof Color || value instanceof Vector2 || value instanceof Vector34) {
-    return value.clone();
-  }
-  if (value instanceof Float32Array) {
-    return new Float32Array(value);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => deepCloneValue(item));
-  }
-  if (isPlainObject(value)) {
-    const cloned = {};
-    for (const [key, entry] of Object.entries(value)) {
-      if (key === "_builders") {
-        continue;
-      }
-      cloned[key] = deepCloneValue(entry);
-    }
-    return cloned;
-  }
-  return value;
-}
-function deepMergeValues(base, overrides) {
-  const clonedBase = deepCloneValue(base);
-  if (!overrides) {
-    return clonedBase;
-  }
-  if (!isPlainObject(clonedBase) || !isPlainObject(overrides)) {
-    return deepCloneValue(overrides);
-  }
-  const result = clonedBase;
-  for (const [key, overrideValue] of Object.entries(overrides)) {
-    if (key === "_builders" || overrideValue === void 0) {
-      continue;
-    }
-    const currentValue = result[key];
-    if (isPlainObject(currentValue) && isPlainObject(overrideValue)) {
-      result[key] = deepMergeValues(currentValue, overrideValue);
-      continue;
-    }
-    result[key] = deepCloneValue(overrideValue);
-  }
-  return result;
-}
-
-// src/lib/entities/parts/collision-factories.ts
-function isCollisionComponent(obj) {
-  return obj && obj.__kind === "collision";
-}
-function cloneCollisionComponent(component) {
-  return component.cloneComponent();
-}
-function buildBodyDesc(isStatic) {
-  const type = isStatic ? RigidBodyType2.Fixed : RigidBodyType2.Dynamic;
-  return new RigidBodyDesc2(type).setTranslation(0, 0, 0).setGravityScale(1).setCanSleep(false).setCcdEnabled(true);
-}
-function applyCollisionOptions(colliderDesc, opts) {
-  if (opts.offset) {
-    colliderDesc.setTranslation(opts.offset.x, opts.offset.y, opts.offset.z);
-  }
-  if (opts.sensor) {
-    colliderDesc.setSensor(true);
-    colliderDesc.activeCollisionTypes = ActiveCollisionTypes2.KINEMATIC_FIXED;
-  }
-  if (opts.collisionType) {
-    const groupId = getOrCreateCollisionGroupId(opts.collisionType);
-    let filter = 65535;
-    if (opts.collisionFilter) {
-      filter = createCollisionFilter(opts.collisionFilter);
-    }
-    colliderDesc.setCollisionGroups(groupId << 16 | filter);
-  }
-}
-function makeComponent(colliderDesc, opts, cloneComponentFactory) {
-  applyCollisionOptions(colliderDesc, opts);
-  return {
-    __kind: "collision",
-    bodyDesc: buildBodyDesc(opts.static ?? false),
-    colliderDesc,
-    cloneComponent: cloneComponentFactory
-  };
-}
-function boxCollision(opts = {}) {
-  const size = opts.size ?? { x: 1, y: 1, z: 1 };
-  const desc = ColliderDesc2.cuboid(size.x / 2, size.y / 2, size.z / 2);
-  const clonedOpts = deepCloneValue(opts);
-  return makeComponent(desc, opts, () => boxCollision(clonedOpts));
-}
-function sphereCollision(opts = {}) {
-  const desc = ColliderDesc2.ball(opts.radius ?? 1);
-  const clonedOpts = deepCloneValue(opts);
-  return makeComponent(desc, opts, () => sphereCollision(clonedOpts));
-}
-function coneCollision(opts = {}) {
-  const radius = opts.radius ?? 1;
-  const height = opts.height ?? 2;
-  const desc = ColliderDesc2.cone(height / 2, radius);
-  const clonedOpts = deepCloneValue(opts);
-  return makeComponent(desc, opts, () => coneCollision(clonedOpts));
-}
-function pyramidCollision(opts = {}) {
-  const radius = opts.radius ?? 1;
-  const height = opts.height ?? 2;
-  const desc = ColliderDesc2.cone(height / 2, radius);
-  const clonedOpts = deepCloneValue(opts);
-  return makeComponent(desc, opts, () => pyramidCollision(clonedOpts));
-}
-function cylinderCollision(opts = {}) {
-  const radius = Math.max(opts.radiusTop ?? 1, opts.radiusBottom ?? 1);
-  const height = opts.height ?? 2;
-  const desc = ColliderDesc2.cylinder(height / 2, radius);
-  const clonedOpts = deepCloneValue(opts);
-  return makeComponent(desc, opts, () => cylinderCollision(clonedOpts));
-}
-function pillCollision(opts = {}) {
-  const radius = opts.radius ?? 0.5;
-  const length = opts.length ?? 1;
-  const desc = ColliderDesc2.capsule(length / 2, radius);
-  const clonedOpts = deepCloneValue(opts);
-  return makeComponent(desc, opts, () => pillCollision(clonedOpts));
-}
-function zoneCollision(opts = {}) {
-  const size = opts.size ?? { x: 1, y: 1, z: 1 };
-  const desc = ColliderDesc2.cuboid(size.x / 2, size.y / 2, size.z / 2);
-  desc.setSensor(true);
-  desc.activeCollisionTypes = ActiveCollisionTypes2.KINEMATIC_FIXED;
-  const effectiveOpts = { ...opts, static: opts.static ?? true, sensor: true };
-  const clonedOpts = deepCloneValue(effectiveOpts);
-  return makeComponent(desc, effectiveOpts, () => zoneCollision(clonedOpts));
-}
-
-// src/lib/entities/common.ts
-import { Color as Color2, Vector3 as Vector36 } from "three";
-
-// src/lib/graphics/shaders/vertex/object.shader.ts
-var objectVertexShader = `
-uniform vec2 uvScale;
-varying vec2 vUv;
-
-void main() {
-	vUv = uv;
-	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-	gl_Position = projectionMatrix * mvPosition;
-}
-`;
-
-// src/lib/graphics/shaders/standard.shader.ts
-var fragment = `
-uniform sampler2D tDiffuse;
-varying vec2 vUv;
-
-void main() {
-	vec4 texel = texture2D( tDiffuse, vUv );
-
-	gl_FragColor = texel;
-}
-`;
-var standardShader = {
-  vertex: objectVertexShader,
-  fragment
-};
-
-// src/lib/entities/common.ts
-var commonDefaults = {
-  position: new Vector36(0, 0, 0),
-  material: {
-    color: new Color2("#ffffff"),
-    shader: standardShader
-  },
-  collision: {
-    static: false
-  }
-};
-function mergeArgs(args, defaults) {
-  const configArgs = args.filter(
-    (arg) => !(arg instanceof BaseNode)
-  );
-  let merged = { ...defaults };
-  for (const opt of configArgs) {
-    merged = { ...merged, ...opt };
-  }
-  return merged;
-}
-
-// src/lib/entities/entity.ts
-function isCollisionRegistrationOptions(value) {
-  return value != null && typeof value === "object";
-}
-function normalizeCollisionRegistrationOptions(options) {
-  return {
-    phase: options?.phase ?? "stay",
-    cooldownMs: options?.cooldownMs
-  };
-}
-function getCollisionNowMs() {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-}
-var GameEntity = class extends BaseNode {
-  behaviors = [];
-  group;
-  mesh;
-  materials;
-  bodyDesc = null;
-  body = null;
-  physicsAttached = false;
-  colliderDesc;
-  collider;
-  custom = {};
-  // Compound entity support: multiple colliders and meshes
-  /** All collider descriptions for this entity (including primary) */
-  colliderDescs = [];
-  /** All colliders attached to this entity's rigid body */
-  colliders = [];
-  /** Additional meshes for compound visual entities (added via add()) */
-  compoundMeshes = [];
-  debugInfo = {};
-  debugMaterial;
-  collisionDelegate = {
-    collision: [],
-    cooldowns: /* @__PURE__ */ new Map(),
-    nextId: 0
-  };
-  collisionType;
-  // Instancing support
-  /** Batch key for instanced rendering (null if not instanced) */
-  batchKey = null;
-  /** Index within the instanced mesh batch */
-  instanceId = -1;
-  /** Whether this entity uses instanced rendering */
-  isInstanced = false;
-  // Event delegate for dispatch/listen API
-  eventDelegate = new EventEmitterDelegate();
-  // Behavior references (new ECS pattern)
-  behaviorRefs = [];
-  cloneFactory = null;
-  trackAddedComponents = false;
-  trackedComponents = [];
-  // Transform store for batched physics updates (auto-created in create())
-  transformStore;
-  // Movement & rotation methods are assigned at runtime by makeTransformable.
-  // The `implements` clause above ensures the type contract; declarations below
-  // satisfy the compiler while the constructor fills them in.
-  moveX;
-  moveY;
-  moveZ;
-  moveXY;
-  moveXZ;
-  move;
-  resetVelocity;
-  moveForwardXY;
-  getPosition;
-  getVelocity;
-  setPosition;
-  setPositionX;
-  setPositionY;
-  setPositionZ;
-  wrapAroundXY;
-  wrapAround3D;
-  rotateInDirection;
-  rotateYEuler;
-  rotateEuler;
-  rotateX;
-  rotateY;
-  rotateZ;
-  setRotationY;
-  setRotationX;
-  setRotationZ;
-  setRotationDegrees;
-  setRotationDegreesY;
-  setRotationDegreesX;
-  setRotationDegreesZ;
-  setRotation;
-  getRotation;
-  constructor() {
-    super();
-    this.transformStore = createTransformStore();
-    makeTransformable(this);
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Composable add() - accepts Mesh, CollisionComponent, or child entities
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Add meshes, collision components, or child entities to this entity.
-   * Supports fluent chaining: `entity.add(boxMesh()).add(boxCollision())`.
-   *
-   * - `Mesh`: First mesh becomes the primary mesh; subsequent meshes are
-   *   compound meshes grouped together.
-   * - `CollisionComponent`: First sets bodyDesc + colliderDesc; subsequent
-   *   add extra colliders to the same rigid body.
-   * - `NodeInterface`: Added as a child entity (delegates to BaseNode.add).
-   */
-  add(...components) {
-    for (const component of components) {
-      if (component instanceof Mesh) {
-        this.addMeshComponent(component);
-        this.trackComponent(component);
-      } else if (isCollisionComponent(component)) {
-        this.addCollisionComponent(component);
-        this.trackComponent(component);
-      } else {
-        super.add(component);
-      }
-    }
-    return this;
-  }
-  addMeshComponent(mesh) {
-    if (!this.mesh) {
-      this.mesh = mesh;
-      if (!this.materials) {
-        this.materials = [];
-      }
-      if (mesh.material) {
-        const mat = mesh.material;
-        if (Array.isArray(mat)) {
-          this.materials.push(...mat);
-        } else {
-          this.materials.push(mat);
-        }
-      }
-    } else {
-      this.compoundMeshes.push(mesh);
-      if (!this.group) {
-        this.group = new Group();
-        this.group.add(this.mesh);
-      }
-      this.group.add(mesh);
-    }
-  }
-  addCollisionComponent(collision) {
-    if (!this.bodyDesc) {
-      this.bodyDesc = collision.bodyDesc;
-      this.colliderDesc = collision.colliderDesc;
-      this.colliderDescs.push(collision.colliderDesc);
-      const pos = this.options?.position ?? { x: 0, y: 0, z: 0 };
-      this.bodyDesc.setTranslation(pos.x, pos.y, pos.z);
-    } else {
-      this.colliderDescs.push(collision.colliderDesc);
-    }
-  }
-  trackComponent(component) {
-    if (!this.trackAddedComponents) {
-      return;
-    }
-    if (component instanceof Mesh) {
-      this.trackedComponents.push({
-        kind: "mesh",
-        component: cloneMeshComponent(component)
-      });
-      return;
-    }
-    this.trackedComponents.push({
-      kind: "collision",
-      component: cloneCollisionComponent(component)
-    });
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Actions API -- entity-scoped, self-contained stateful actions
-  // ─────────────────────────────────────────────────────────────────────────────
-  _actions = [];
-  /**
-   * Run a fire-and-forget action. Auto-removed when done.
-   * @example `me.runAction(moveBy({ x: 10, duration: 0.3 }))`
-   */
-  runAction(action) {
-    this._actions.push(action);
-    return action;
-  }
-  /**
-   * Register a persistent action (throttle, onPress). Not removed when done.
-   * @example `const press = entity.action(onPress())`
-   */
-  action(action) {
-    action.persistent = true;
-    this._actions.push(action);
-    return action;
-  }
-  /**
-   * Tick all registered actions. Called automatically before user onUpdate callbacks.
-   *
-   * Resets velocity/angularVelocity accumulation before ticking so that
-   * actions can compose via `+=` without cross-frame build-up.
-   * (The existing move helpers like `moveXY` use `=` which doesn't accumulate,
-   * but action composition needs additive writes on a clean slate each frame.)
-   */
-  _tickActions(delta) {
-    if (this._actions.length === 0) return;
-    const store = this.transformStore;
-    store.velocity.x = 0;
-    store.velocity.y = 0;
-    store.velocity.z = 0;
-    clearVelocityIntent(store, "actions");
-    store.angularVelocity.x = 0;
-    store.angularVelocity.y = 0;
-    store.angularVelocity.z = 0;
-    store.dirty.angularVelocity = false;
-    for (let i = this._actions.length - 1; i >= 0; i--) {
-      const act = this._actions[i];
-      act.tick(this, delta);
-      if (act.done && !act.persistent) {
-        this._actions.splice(i, 1);
-      }
-    }
-    if (this._actions.length === 0) {
-      store.velocity.x = 0;
-      store.velocity.y = 0;
-      store.velocity.z = 0;
-      clearVelocityIntent(store, "actions");
-      store.angularVelocity.x = 0;
-      store.angularVelocity.y = 0;
-      store.angularVelocity.z = 0;
-      store.dirty.angularVelocity = false;
-    }
-  }
-  create() {
-    const { position: setupPosition } = this.options;
-    const { x, y, z } = setupPosition || { x: 0, y: 0, z: 0 };
-    this.behaviors = [
-      { component: position, values: { x, y, z } },
-      { component: scale, values: { x: 0, y: 0, z: 0 } },
-      { component: rotation, values: { x: 0, y: 0, z: 0, w: 0 } }
-    ];
-    this.name = this.options.name || "";
-    return this;
-  }
-  clone(overrides) {
-    if (!this.cloneFactory) {
-      throw new Error(
-        `Cannot clone ${this.constructor.name}: clone() is only supported for entities created by official factory helpers.`
-      );
-    }
-    const clone = this.cloneFactory(
-      deepMergeValues(this.options, overrides)
-    );
-    const behaviorAliases = this.copyBehaviorRefsTo(clone);
-    const wrapCallback = (callback) => wrapBehaviorCallback(callback, behaviorAliases);
-    this.replayUserLifecycleRegistrationsTo(clone, wrapCallback);
-    const collisionRegistrations = this.getCollisionRegistrations();
-    if (collisionRegistrations.length > 0) {
-      for (const registration of collisionRegistrations) {
-        clone.onCollision(
-          wrapCallback(registration.callback),
-          registration.options
-        );
-      }
-    }
-    for (const trackedComponent of this.trackedComponents) {
-      if (trackedComponent.kind === "mesh") {
-        clone.add(cloneMeshComponent(trackedComponent.component));
-        continue;
-      }
-      clone.add(cloneCollisionComponent(trackedComponent.component));
-    }
-    this.cloneChildrenInto(clone);
-    return clone;
-  }
-  finalizeCloneSupport(factory) {
-    this.cloneFactory = factory;
-    this.enableUserLifecycleTracking();
-    this.trackAddedComponents = true;
-    return this;
-  }
-  onCollision(...args) {
-    const existing = [...this.collisionDelegate.collision ?? []];
-    let nextId = this.collisionDelegate.nextId ?? 0;
-    if (args.length === 1 || args.length === 2 && (args[1] == null || isCollisionRegistrationOptions(args[1]))) {
-      const callback = args[0];
-      if (!callback) {
-        return this;
-      }
-      const options = args[1];
-      existing.push({
-        id: nextId,
-        callback,
-        options: normalizeCollisionRegistrationOptions(options)
-      });
-      nextId += 1;
-      this.collisionDelegate.collision = existing;
-      this.collisionDelegate.nextId = nextId;
-      return this;
-    }
-    for (const callback of args) {
-      existing.push({
-        id: nextId,
-        callback,
-        options: normalizeCollisionRegistrationOptions()
-      });
-      nextId += 1;
-    }
-    this.collisionDelegate.collision = existing;
-    this.collisionDelegate.nextId = nextId;
-    return this;
-  }
-  /**
-   * Use a behavior on this entity via typed descriptor.
-   * Behaviors will be auto-registered as systems when the entity is spawned.
-   * @param descriptor The behavior descriptor (import from behaviors module)
-   * @param options Optional overrides for the behavior's default options
-   * @returns BehaviorHandle with behavior-specific methods for lazy FSM access
-   */
-  use(descriptor, options) {
-    const behaviorRef = {
-      descriptor,
-      options: { ...descriptor.defaultOptions, ...options }
-    };
-    this.behaviorRefs.push(behaviorRef);
-    const baseHandle = {
-      getFSM: () => behaviorRef.fsm ?? null,
-      getOptions: () => behaviorRef.options,
-      ref: behaviorRef
-    };
-    const customMethods = descriptor.createHandle?.(behaviorRef) ?? {};
-    return {
-      ...baseHandle,
-      ...customMethods
-    };
-  }
-  /**
-   * Get all behavior references attached to this entity.
-   * Used by the stage to auto-register required systems.
-   */
-  getBehaviorRefs() {
-    return this.behaviorRefs;
-  }
-  getCollisionCallbacks() {
-    return this.getCollisionRegistrations().map((registration) => registration.callback);
-  }
-  getCollisionRegistrations() {
-    return (this.collisionDelegate.collision ?? []).map((registration) => ({
-      id: registration.id,
-      callback: registration.callback,
-      options: { ...registration.options }
-    }));
-  }
-  copyBehaviorRefsTo(target) {
-    const aliases = /* @__PURE__ */ new Map();
-    for (const ref of this.behaviorRefs) {
-      target.use(ref.descriptor, deepCloneValue(ref.options));
-      const targetRef = target.getBehaviorRefs().at(-1);
-      if (targetRef) {
-        aliases.set(ref, targetRef);
-      }
-    }
-    return aliases;
-  }
-  /**
-   * Entity-specific setup - resets actions for a fresh stage session.
-   * (User callbacks are handled by BaseNode's lifecycleCallbacks.setup)
-   */
-  _setup(params) {
-    for (let i = this._actions.length - 1; i >= 0; i--) {
-      const act = this._actions[i];
-      if (act.done && !act.persistent) {
-        this._actions.splice(i, 1);
-      } else {
-        act.reset();
-      }
-    }
-  }
-  async _loaded(_params) {
-  }
-  /**
-   * Entity-specific update - updates materials.
-   * Transform changes are applied by the stage after all update callbacks complete.
-   * (User callbacks are handled by BaseNode's lifecycleCallbacks.update)
-   */
-  _update(params) {
-    this.updateMaterials(params);
-  }
-  /**
-   * Entity-specific destroy -- reserved for consumer game logic.
-   * Engine-internal resource disposal runs in _cleanup() instead.
-   */
-  _destroy(params) {
-  }
-  /**
-   * Engine-internal resource cleanup -- runs automatically after destroy.
-   * Disposes GPU/DOM resources (meshes, materials, debug material).
-   *
-   * Note: actions, collision callbacks, and behavior refs are intentionally
-   * NOT cleared here -- they are registered by consumer code at module level
-   * and must persist across stage reloads. Actions are reset in _setup().
-   */
-  _cleanup(_params) {
-    this.disposeEvents();
-    for (const m of this.compoundMeshes) {
-      m.geometry?.dispose();
-      if (Array.isArray(m.material)) {
-        m.material.forEach((mat) => mat.dispose());
-      } else {
-        m.material?.dispose();
-      }
-    }
-    this.compoundMeshes.length = 0;
-    this.debugMaterial?.dispose();
-    this.debugMaterial = void 0;
-    this.group?.removeFromParent();
-  }
-  _collision(other, globals, dispatch = {
-    phase: "stay",
-    nowMs: getCollisionNowMs()
-  }) {
-    if (!this.collisionDelegate.collision?.length) {
-      return;
-    }
-    const cooldowns = this.collisionDelegate.cooldowns ?? /* @__PURE__ */ new Map();
-    this.collisionDelegate.cooldowns = cooldowns;
-    for (const registration of this.collisionDelegate.collision) {
-      if (registration.options.phase !== dispatch.phase) {
-        continue;
-      }
-      const cooldownMs = registration.options.cooldownMs;
-      if (cooldownMs != null) {
-        const cooldownKey = `${registration.id}:${other.uuid}`;
-        const lastTriggeredAt = cooldowns.get(cooldownKey);
-        if (lastTriggeredAt != null && dispatch.nowMs - lastTriggeredAt < cooldownMs) {
-          continue;
-        }
-        cooldowns.set(cooldownKey, dispatch.nowMs);
-      }
-      registration.callback({ entity: this, other, globals });
-    }
-  }
-  updateMaterials(params) {
-    if (!this.materials?.length) {
-      return;
-    }
-    for (const material of this.materials) {
-      if (material instanceof ShaderMaterial) {
-        if (material.uniforms) {
-          material.uniforms.iTime && (material.uniforms.iTime.value += params.delta);
-        }
-      }
-    }
-  }
-  buildInfo() {
-    const info = {};
-    info.name = this.name;
-    info.uuid = this.uuid;
-    info.eid = this.eid.toString();
-    return info;
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Events API
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Dispatch an event from this entity.
-   * Events are emitted both locally and to the global event bus.
-   */
-  dispatch(event, payload) {
-    this.eventDelegate.dispatch(event, payload);
-    zylemEventBus.emit(event, payload);
-  }
-  /**
-   * Listen for events on this entity instance.
-   * @returns Unsubscribe function
-   */
-  listen(event, handler) {
-    return this.eventDelegate.listen(event, handler);
-  }
-  /**
-   * Clean up entity event subscriptions.
-   */
-  disposeEvents() {
-    this.eventDelegate.dispose();
-  }
-};
-function cloneMeshComponent(mesh) {
-  const clonedMesh = mesh.clone(true);
-  const originalNodes = [];
-  const clonedNodes = [];
-  mesh.traverse((node) => originalNodes.push(node));
-  clonedMesh.traverse((node) => clonedNodes.push(node));
-  for (let i = 0; i < originalNodes.length; i++) {
-    const originalNode = originalNodes[i];
-    const clonedNode = clonedNodes[i];
-    if (originalNode?.geometry?.clone) {
-      clonedNode.geometry = originalNode.geometry.clone();
-    }
-    if (originalNode?.material) {
-      clonedNode.material = Array.isArray(originalNode.material) ? originalNode.material.map((material) => material.clone()) : originalNode.material.clone();
-    }
-  }
-  return clonedMesh;
-}
-function wrapBehaviorCallback(callback, aliases) {
-  if (aliases.size === 0) {
-    return callback;
-  }
-  return ((...args) => {
-    const previousValues = Array.from(aliases.entries()).map(([sourceRef, targetRef]) => ({
-      sourceRef,
-      options: sourceRef.options,
-      fsm: sourceRef.fsm,
-      hasFSM: Object.prototype.hasOwnProperty.call(sourceRef, "fsm"),
-      targetRef
-    }));
-    for (const entry of previousValues) {
-      entry.sourceRef.options = entry.targetRef.options;
-      if (entry.targetRef.fsm === void 0) {
-        delete entry.sourceRef.fsm;
-      } else {
-        entry.sourceRef.fsm = entry.targetRef.fsm;
-      }
-    }
-    try {
-      return callback(...args);
-    } finally {
-      for (let i = previousValues.length - 1; i >= 0; i--) {
-        const entry = previousValues[i];
-        entry.sourceRef.options = entry.options;
-        if (!entry.hasFSM) {
-          delete entry.sourceRef.fsm;
-        } else {
-          entry.sourceRef.fsm = entry.fsm;
-        }
-      }
-    }
-  });
-}
-function finalizeEntityCloneSupport(entity, factory) {
-  entity.finalizeCloneSupport(factory);
-  return entity;
-}
-
-// src/lib/entities/delegates/debug.ts
-import { MeshStandardMaterial, MeshBasicMaterial, MeshPhongMaterial } from "three";
-function hasDebugInfo(obj) {
-  return obj && typeof obj.getDebugInfo === "function";
-}
-var DebugDelegate = class {
-  entity;
-  constructor(entity) {
-    this.entity = entity;
-  }
-  /**
-   * Get formatted position string
-   */
-  getPositionString() {
-    if (this.entity.mesh) {
-      const { x: x2, y: y2, z: z2 } = this.entity.mesh.position;
-      return `${x2.toFixed(2)}, ${y2.toFixed(2)}, ${z2.toFixed(2)}`;
-    }
-    const { x, y, z } = this.entity.options.position || { x: 0, y: 0, z: 0 };
-    return `${x.toFixed(2)}, ${y.toFixed(2)}, ${z.toFixed(2)}`;
-  }
-  /**
-   * Get formatted rotation string (in degrees)
-   */
-  getRotationString() {
-    if (this.entity.mesh) {
-      const { x: x2, y: y2, z: z2 } = this.entity.mesh.rotation;
-      const toDeg2 = (rad) => (rad * 180 / Math.PI).toFixed(1);
-      return `${toDeg2(x2)}\xB0, ${toDeg2(y2)}\xB0, ${toDeg2(z2)}\xB0`;
-    }
-    const { x, y, z } = this.entity.options.rotation || { x: 0, y: 0, z: 0 };
-    const toDeg = (rad) => (rad * 180 / Math.PI).toFixed(1);
-    return `${toDeg(x)}\xB0, ${toDeg(y)}\xB0, ${toDeg(z)}\xB0`;
-  }
-  /**
-   * Get material information
-   */
-  getMaterialInfo() {
-    if (!this.entity.mesh || !this.entity.mesh.material) {
-      return { type: "none" };
-    }
-    const material = Array.isArray(this.entity.mesh.material) ? this.entity.mesh.material[0] : this.entity.mesh.material;
-    const info = {
-      type: material.type
-    };
-    if (material instanceof MeshStandardMaterial || material instanceof MeshBasicMaterial || material instanceof MeshPhongMaterial) {
-      info.color = `#${material.color.getHexString()}`;
-      info.opacity = material.opacity;
-      info.transparent = material.transparent;
-    }
-    if ("roughness" in material) {
-      info.roughness = material.roughness;
-    }
-    if ("metalness" in material) {
-      info.metalness = material.metalness;
-    }
-    return info;
-  }
-  getPhysicsInfo() {
-    if (!this.entity.body) {
-      return null;
-    }
-    const info = {
-      type: this.entity.body.bodyType(),
-      mass: this.entity.body.mass(),
-      isEnabled: this.entity.body.isEnabled(),
-      isSleeping: this.entity.body.isSleeping()
-    };
-    const velocity = this.entity.body.linvel();
-    info.velocity = `${velocity.x.toFixed(2)}, ${velocity.y.toFixed(2)}, ${velocity.z.toFixed(2)}`;
-    return info;
-  }
-  buildDebugInfo() {
-    const defaultInfo = {
-      name: this.entity.name || this.entity.uuid,
-      uuid: this.entity.uuid,
-      position: this.getPositionString(),
-      rotation: this.getRotationString(),
-      material: this.getMaterialInfo()
-    };
-    const physicsInfo = this.getPhysicsInfo();
-    if (physicsInfo) {
-      defaultInfo.physics = physicsInfo;
-    }
-    if (this.entity.behaviors.length > 0) {
-      defaultInfo.behaviors = this.entity.behaviors.map((b) => b.constructor.name);
-    }
-    if (hasDebugInfo(this.entity)) {
-      const customInfo = this.entity.getDebugInfo();
-      return { ...defaultInfo, ...customInfo };
-    }
-    return defaultInfo;
-  }
-};
-
-// src/lib/entities/parts/mesh-factories.ts
-import {
-  BoxGeometry,
-  CapsuleGeometry,
-  ConeGeometry,
-  CylinderGeometry,
-  Mesh as Mesh3,
-  MeshStandardMaterial as MeshStandardMaterial3,
-  SphereGeometry
-} from "three";
-
-// src/lib/graphics/material.ts
-import { Color as Color4, Vector2 as Vector23, Vector3 as Vector38 } from "three";
-import {
-  MeshPhongMaterial as MeshPhongMaterial2,
-  MeshStandardMaterial as MeshStandardMaterial2,
-  RepeatWrapping as RepeatWrapping2,
-  ShaderMaterial as ShaderMaterial2
-} from "three";
-import {
-  MeshBasicNodeMaterial,
-  MeshStandardNodeMaterial
-} from "three/webgpu";
-
-// src/lib/core/utility/strings.ts
-function sortedStringify(obj) {
-  const sortedObj = Object.keys(obj).sort().reduce((acc, key) => {
-    acc[key] = obj[key];
-    return acc;
-  }, {});
-  return JSON.stringify(sortedObj);
-}
-function shortHash(objString) {
-  let hash = 0;
-  for (let i = 0; i < objString.length; i++) {
-    hash = Math.imul(31, hash) + objString.charCodeAt(i) | 0;
-  }
-  return hash.toString(36);
-}
-
-// src/lib/core/asset-manager.ts
-import { LoadingManager, Cache } from "three";
-
-// src/lib/core/loaders/texture-loader.ts
-import { TextureLoader, RepeatWrapping } from "three";
-var TextureLoaderAdapter = class {
-  loader;
-  constructor() {
-    this.loader = new TextureLoader();
-  }
-  isSupported(url) {
-    const ext = url.split(".").pop()?.toLowerCase();
-    return ["png", "jpg", "jpeg", "gif", "webp", "bmp", "tga"].includes(ext || "");
-  }
-  async load(url, options) {
-    const texture = await this.loader.loadAsync(url, (event) => {
-      if (options?.onProgress && event.lengthComputable) {
-        options.onProgress(event.loaded / event.total);
-      }
-    });
-    if (options?.repeat) {
-      texture.repeat.copy(options.repeat);
-    }
-    texture.wrapS = options?.wrapS ?? RepeatWrapping;
-    texture.wrapT = options?.wrapT ?? RepeatWrapping;
-    return texture;
-  }
-  /**
-   * Clone a texture for independent usage
-   */
-  clone(texture) {
-    const cloned = texture.clone();
-    cloned.needsUpdate = true;
-    return cloned;
-  }
-};
-
-// src/lib/core/loaders/gltf-loader.ts
-import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
-import { DRACOLoader } from "three/addons/loaders/DRACOLoader.js";
-
-// src/lib/core/loaders/model-clone.ts
-import { Mesh as Mesh2 } from "three";
-import { clone as cloneSkeleton } from "three/addons/utils/SkeletonUtils.js";
-function cloneModelObject(object) {
-  const clonedObject = cloneSkeleton(object);
-  const originalNodes = [];
-  const clonedNodes = [];
-  object.traverse((node) => originalNodes.push(node));
-  clonedObject.traverse((node) => clonedNodes.push(node));
-  for (let i = 0; i < originalNodes.length; i++) {
-    const originalNode = originalNodes[i];
-    const clonedNode = clonedNodes[i];
-    if (!(originalNode instanceof Mesh2) || !(clonedNode instanceof Mesh2)) {
-      continue;
-    }
-    if (originalNode.geometry?.clone) {
-      clonedNode.geometry = originalNode.geometry.clone();
-    }
-    if (!originalNode.material) {
-      continue;
-    }
-    clonedNode.material = Array.isArray(originalNode.material) ? originalNode.material.map((material) => material.clone()) : originalNode.material.clone();
-  }
-  return clonedObject;
-}
-
-// src/lib/core/loaders/gltf-loader.ts
-var DRACO_DECODER_PATH = "https://www.gstatic.com/draco/v1/decoders/";
-var GLTFLoaderAdapter = class {
-  loader;
-  dracoLoader;
-  constructor() {
-    this.dracoLoader = new DRACOLoader();
-    this.dracoLoader.setDecoderPath(DRACO_DECODER_PATH);
-    this.loader = new GLTFLoader();
-    this.loader.setDRACOLoader(this.dracoLoader);
-  }
-  isSupported(url) {
-    const ext = url.split(".").pop()?.toLowerCase();
-    return ["gltf", "glb"].includes(ext || "");
-  }
-  async load(url, options) {
-    if (options?.useAsyncFetch) {
-      return this.loadWithAsyncFetch(url, options);
-    }
-    return this.loadMainThread(url, options);
-  }
-  /**
-   * Load using native fetch + parseAsync
-   * Both fetch and parsing are async, keeping the main thread responsive
-   */
-  async loadWithAsyncFetch(url, options) {
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
-      }
-      const buffer = await response.arrayBuffer();
-      const gltf = await this.loader.parseAsync(buffer, url);
-      return {
-        object: gltf.scene,
-        animations: gltf.animations,
-        gltf
-      };
-    } catch (error) {
-      console.error(`Async fetch GLTF load failed for ${url}, falling back to loader.load():`, error);
-      return this.loadMainThread(url, options);
-    }
-  }
-  async loadMainThread(url, options) {
-    return new Promise((resolve, reject) => {
-      this.loader.load(
-        url,
-        (gltf) => {
-          resolve({
-            object: gltf.scene,
-            animations: gltf.animations,
-            gltf
-          });
-        },
-        (event) => {
-          if (options?.onProgress && event.lengthComputable) {
-            options.onProgress(event.loaded / event.total);
-          }
-        },
-        (error) => reject(error)
-      );
-    });
-  }
-  /**
-   * Clone a loaded GLTF scene for reuse
-   */
-  clone(result) {
-    return {
-      object: cloneModelObject(result.object),
-      animations: result.animations?.map((anim) => anim.clone()),
-      gltf: result.gltf
-    };
-  }
-};
-
-// src/lib/core/loaders/fbx-loader.ts
-import { FBXLoader } from "three/addons/loaders/FBXLoader.js";
-var FBXLoaderAdapter = class {
-  loader;
-  constructor() {
-    this.loader = new FBXLoader();
-  }
-  isSupported(url) {
-    const ext = url.split(".").pop()?.toLowerCase();
-    return ext === "fbx";
-  }
-  async load(url, options) {
-    if (options?.useAsyncFetch) {
-      return this.loadWithAsyncFetch(url, options);
-    }
-    return this.loadMainThread(url, options);
-  }
-  /**
-   * Load using native fetch + parse
-   */
-  async loadWithAsyncFetch(url, _options) {
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
-      }
-      const buffer = await response.arrayBuffer();
-      const object = this.loader.parse(buffer, url);
-      return {
-        object,
-        animations: object.animations || []
-      };
-    } catch (error) {
-      console.error(`Async fetch FBX load failed for ${url}, falling back to loader.load():`, error);
-      return this.loadMainThread(url, _options);
-    }
-  }
-  async loadMainThread(url, options) {
-    return new Promise((resolve, reject) => {
-      this.loader.load(
-        url,
-        (object) => {
-          resolve({
-            object,
-            animations: object.animations || []
-          });
-        },
-        (event) => {
-          if (options?.onProgress && event.lengthComputable) {
-            options.onProgress(event.loaded / event.total);
-          }
-        },
-        (error) => reject(error)
-      );
-    });
-  }
-  /**
-   * Clone a loaded FBX object for reuse
-   */
-  clone(result) {
-    return {
-      object: cloneModelObject(result.object),
-      animations: result.animations?.map((anim) => anim.clone())
-    };
-  }
-};
-
-// src/lib/core/loaders/obj-loader.ts
-import { OBJLoader } from "three/addons/loaders/OBJLoader.js";
-import { MTLLoader } from "three/addons/loaders/MTLLoader.js";
-var OBJLoaderAdapter = class {
-  loader;
-  mtlLoader;
-  constructor() {
-    this.loader = new OBJLoader();
-    this.mtlLoader = new MTLLoader();
-  }
-  isSupported(url) {
-    const ext = url.split(".").pop()?.toLowerCase();
-    return ext === "obj";
-  }
-  async load(url, options) {
-    if (options?.mtlPath) {
-      await this.loadMTL(options.mtlPath);
-    }
-    return new Promise((resolve, reject) => {
-      this.loader.load(
-        url,
-        (object) => {
-          resolve({
-            object,
-            animations: []
-          });
-        },
-        (event) => {
-          if (options?.onProgress && event.lengthComputable) {
-            options.onProgress(event.loaded / event.total);
-          }
-        },
-        (error) => reject(error)
-      );
-    });
-  }
-  async loadMTL(url) {
-    return new Promise((resolve, reject) => {
-      this.mtlLoader.load(
-        url,
-        (materials) => {
-          materials.preload();
-          this.loader.setMaterials(materials);
-          resolve();
-        },
-        void 0,
-        (error) => reject(error)
-      );
-    });
-  }
-  /**
-   * Clone a loaded OBJ object for reuse
-   */
-  clone(result) {
-    return {
-      object: cloneModelObject(result.object),
-      animations: []
-    };
-  }
-};
-
-// src/lib/core/loaders/audio-loader.ts
-import { AudioLoader } from "three";
-var AudioLoaderAdapter = class {
-  loader;
-  constructor() {
-    this.loader = new AudioLoader();
-  }
-  isSupported(url) {
-    const ext = url.split(".").pop()?.toLowerCase();
-    return ["mp3", "ogg", "wav", "flac", "aac", "m4a"].includes(ext || "");
-  }
-  async load(url, options) {
-    return new Promise((resolve, reject) => {
-      this.loader.load(
-        url,
-        (buffer) => resolve(buffer),
-        (event) => {
-          if (options?.onProgress && event.lengthComputable) {
-            options.onProgress(event.loaded / event.total);
-          }
-        },
-        (error) => reject(error)
-      );
-    });
-  }
-};
-
-// src/lib/core/loaders/file-loader.ts
-import { FileLoader } from "three";
-var FileLoaderAdapter = class {
-  loader;
-  constructor() {
-    this.loader = new FileLoader();
-  }
-  isSupported(_url) {
-    return true;
-  }
-  async load(url, options) {
-    const responseType = options?.responseType ?? "text";
-    this.loader.setResponseType(responseType);
-    return new Promise((resolve, reject) => {
-      this.loader.load(
-        url,
-        (data) => resolve(data),
-        (event) => {
-          if (options?.onProgress && event.lengthComputable) {
-            options.onProgress(event.loaded / event.total);
-          }
-        },
-        (error) => reject(error)
-      );
-    });
-  }
-};
-var JsonLoaderAdapter = class {
-  fileLoader;
-  constructor() {
-    this.fileLoader = new FileLoaderAdapter();
-  }
-  isSupported(url) {
-    const ext = url.split(".").pop()?.toLowerCase();
-    return ext === "json";
-  }
-  async load(url, options) {
-    const data = await this.fileLoader.load(url, { ...options, responseType: "json" });
-    return data;
-  }
-};
-
-// src/lib/core/asset-manager.ts
-var AssetManager = class _AssetManager {
-  static instance = null;
-  // Caches for different asset types
-  textureCache = /* @__PURE__ */ new Map();
-  modelCache = /* @__PURE__ */ new Map();
-  audioCache = /* @__PURE__ */ new Map();
-  fileCache = /* @__PURE__ */ new Map();
-  jsonCache = /* @__PURE__ */ new Map();
-  // Loaders
-  textureLoader;
-  gltfLoader;
-  fbxLoader;
-  objLoader;
-  audioLoader;
-  fileLoader;
-  jsonLoader;
-  // Loading manager for progress tracking
-  loadingManager;
-  // Event emitter
-  events;
-  // Stats
-  stats = {
-    texturesLoaded: 0,
-    modelsLoaded: 0,
-    audioLoaded: 0,
-    filesLoaded: 0,
-    cacheHits: 0,
-    cacheMisses: 0
-  };
-  constructor() {
-    this.textureLoader = new TextureLoaderAdapter();
-    this.gltfLoader = new GLTFLoaderAdapter();
-    this.fbxLoader = new FBXLoaderAdapter();
-    this.objLoader = new OBJLoaderAdapter();
-    this.audioLoader = new AudioLoaderAdapter();
-    this.fileLoader = new FileLoaderAdapter();
-    this.jsonLoader = new JsonLoaderAdapter();
-    this.loadingManager = new LoadingManager();
-    this.loadingManager.onProgress = (url, loaded, total) => {
-      this.events.emit("batch:progress", { loaded, total });
-    };
-    this.events = mitt_default();
-    Cache.enabled = true;
-  }
-  /**
-   * Get the singleton instance
-   */
-  static getInstance() {
-    if (!_AssetManager.instance) {
-      _AssetManager.instance = new _AssetManager();
-    }
-    return _AssetManager.instance;
-  }
-  /**
-   * Reset the singleton (useful for testing)
-   */
-  static resetInstance() {
-    if (_AssetManager.instance) {
-      _AssetManager.instance.clearCache();
-      _AssetManager.instance = null;
-    }
-  }
-  // ==================== TEXTURE LOADING ====================
-  /**
-   * Load a texture with caching
-   */
-  async loadTexture(url, options) {
-    return this.loadWithCache(
-      url,
-      "texture" /* TEXTURE */,
-      this.textureCache,
-      () => this.textureLoader.load(url, options),
-      options,
-      (texture) => {
-        if (!options?.clone) return texture;
-        const cloned = this.textureLoader.clone(texture);
-        if (options.repeat) {
-          cloned.repeat.copy(options.repeat);
-        }
-        if (options.wrapS !== void 0) {
-          cloned.wrapS = options.wrapS;
-        }
-        if (options.wrapT !== void 0) {
-          cloned.wrapT = options.wrapT;
-        }
-        return cloned;
-      }
-    );
-  }
-  // ==================== MODEL LOADING ====================
-  /**
-   * Load a GLTF/GLB model with caching
-   */
-  async loadGLTF(url, options) {
-    return this.loadWithCache(
-      url,
-      "gltf" /* GLTF */,
-      this.modelCache,
-      () => this.gltfLoader.load(url, options),
-      options,
-      (result) => options?.clone ? this.gltfLoader.clone(result) : result
-    );
-  }
-  /**
-   * Load an FBX model with caching
-   */
-  async loadFBX(url, options) {
-    return this.loadWithCache(
-      url,
-      "fbx" /* FBX */,
-      this.modelCache,
-      () => this.fbxLoader.load(url, options),
-      options,
-      (result) => options?.clone ? this.fbxLoader.clone(result) : result
-    );
-  }
-  /**
-   * Load an OBJ model with caching
-   */
-  async loadOBJ(url, options) {
-    const cacheKey = options?.mtlPath ? `${url}:${options.mtlPath}` : url;
-    return this.loadWithCache(
-      cacheKey,
-      "obj" /* OBJ */,
-      this.modelCache,
-      () => this.objLoader.load(url, options),
-      options,
-      (result) => options?.clone ? this.objLoader.clone(result) : result
-    );
-  }
-  /**
-   * Auto-detect model type and load
-   */
-  async loadModel(url, options) {
-    const ext = url.split(".").pop()?.toLowerCase();
-    switch (ext) {
-      case "gltf":
-      case "glb":
-        return this.loadGLTF(url, options);
-      case "fbx":
-        return this.loadFBX(url, options);
-      case "obj":
-        return this.loadOBJ(url, options);
-      default:
-        throw new Error(`Unsupported model format: ${ext}`);
-    }
-  }
-  // ==================== AUDIO LOADING ====================
-  /**
-   * Load an audio buffer with caching
-   */
-  async loadAudio(url, options) {
-    return this.loadWithCache(
-      url,
-      "audio" /* AUDIO */,
-      this.audioCache,
-      () => this.audioLoader.load(url, options),
-      options
-    );
-  }
-  // ==================== FILE LOADING ====================
-  /**
-   * Load a raw file with caching
-   */
-  async loadFile(url, options) {
-    const cacheKey = options?.responseType ? `${url}:${options.responseType}` : url;
-    return this.loadWithCache(
-      cacheKey,
-      "file" /* FILE */,
-      this.fileCache,
-      () => this.fileLoader.load(url, options),
-      options
-    );
-  }
-  /**
-   * Load a JSON file with caching
-   */
-  async loadJSON(url, options) {
-    return this.loadWithCache(
-      url,
-      "json" /* JSON */,
-      this.jsonCache,
-      () => this.jsonLoader.load(url, options),
-      options
-    );
-  }
-  // ==================== BATCH LOADING ====================
-  /**
-   * Load multiple assets in parallel
-   */
-  async loadBatch(items) {
-    const results = /* @__PURE__ */ new Map();
-    const promises = items.map(async (item) => {
-      try {
-        let result;
-        switch (item.type) {
-          case "texture" /* TEXTURE */:
-            result = await this.loadTexture(item.url, item.options);
-            break;
-          case "gltf" /* GLTF */:
-            result = await this.loadGLTF(item.url, item.options);
-            break;
-          case "fbx" /* FBX */:
-            result = await this.loadFBX(item.url, item.options);
-            break;
-          case "obj" /* OBJ */:
-            result = await this.loadOBJ(item.url, item.options);
-            break;
-          case "audio" /* AUDIO */:
-            result = await this.loadAudio(item.url, item.options);
-            break;
-          case "file" /* FILE */:
-            result = await this.loadFile(item.url, item.options);
-            break;
-          case "json" /* JSON */:
-            result = await this.loadJSON(item.url, item.options);
-            break;
-          default:
-            throw new Error(`Unknown asset type: ${item.type}`);
-        }
-        results.set(item.url, result);
-      } catch (error) {
-        this.events.emit("asset:error", {
-          url: item.url,
-          type: item.type,
-          error
-        });
-        throw error;
-      }
-    });
-    await Promise.all(promises);
-    this.events.emit("batch:complete", { urls: items.map((i) => i.url) });
-    return results;
-  }
-  /**
-   * Preload assets without returning results
-   */
-  async preload(items) {
-    await this.loadBatch(items);
-  }
-  // ==================== CACHE MANAGEMENT ====================
-  /**
-   * Check if an asset is cached
-   */
-  isCached(url) {
-    return this.textureCache.has(url) || this.modelCache.has(url) || this.audioCache.has(url) || this.fileCache.has(url) || this.jsonCache.has(url);
-  }
-  /**
-   * Clear all caches or a specific URL
-   */
-  clearCache(url) {
-    if (url) {
-      this.textureCache.delete(url);
-      this.modelCache.delete(url);
-      this.audioCache.delete(url);
-      this.fileCache.delete(url);
-      this.jsonCache.delete(url);
-    } else {
-      this.textureCache.clear();
-      this.modelCache.clear();
-      this.audioCache.clear();
-      this.fileCache.clear();
-      this.jsonCache.clear();
-      Cache.clear();
-    }
-  }
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    return { ...this.stats };
-  }
-  // ==================== EVENTS ====================
-  /**
-   * Subscribe to asset manager events
-   */
-  on(event, handler) {
-    this.events.on(event, handler);
-  }
-  /**
-   * Unsubscribe from asset manager events
-   */
-  off(event, handler) {
-    this.events.off(event, handler);
-  }
-  // ==================== PRIVATE HELPERS ====================
-  /**
-   * Generic cache wrapper for loading assets
-   */
-  async loadWithCache(url, type, cache, loader, options, cloner) {
-    if (options?.forceReload) {
-      cache.delete(url);
-    }
-    const cached = cache.get(url);
-    if (cached) {
-      this.stats.cacheHits++;
-      this.events.emit("asset:loaded", { url, type, fromCache: true });
-      const result = await cached.promise;
-      return cloner ? cloner(result) : result;
-    }
-    this.stats.cacheMisses++;
-    this.events.emit("asset:loading", { url, type });
-    const promise = loader();
-    const entry = {
-      promise,
-      loadedAt: Date.now()
-    };
-    cache.set(url, entry);
-    try {
-      const result = await promise;
-      entry.result = result;
-      this.updateStats(type);
-      this.events.emit("asset:loaded", { url, type, fromCache: false });
-      return cloner ? cloner(result) : result;
-    } catch (error) {
-      cache.delete(url);
-      this.events.emit("asset:error", { url, type, error });
-      throw error;
-    }
-  }
-  updateStats(type) {
-    switch (type) {
-      case "texture" /* TEXTURE */:
-        this.stats.texturesLoaded++;
-        break;
-      case "gltf" /* GLTF */:
-      case "fbx" /* FBX */:
-      case "obj" /* OBJ */:
-        this.stats.modelsLoaded++;
-        break;
-      case "audio" /* AUDIO */:
-        this.stats.audioLoaded++;
-        break;
-      case "file" /* FILE */:
-      case "json" /* JSON */:
-        this.stats.filesLoaded++;
-        break;
-    }
-  }
-};
-var assetManager = AssetManager.getInstance();
-
-// src/lib/graphics/material.ts
-import {
-  uniform,
-  uv,
-  time,
-  vec3,
-  vec4,
-  float,
-  Fn
-} from "three/tsl";
-function isTSLShader(shader) {
-  return "colorNode" in shader;
-}
-function isGLSLShader(shader) {
-  return "fragment" in shader && "vertex" in shader;
-}
-var MaterialBuilder = class _MaterialBuilder {
-  static batchMaterialMap = /* @__PURE__ */ new Map();
-  /**
-   * Clear the static batch material cache.
-   * Should be called during game disposal to prevent stale material references
-   * from persisting across demo/stage switches.
-   */
-  static clearBatchCache() {
-    _MaterialBuilder.batchMaterialMap.clear();
-  }
-  materials = [];
-  /** Whether to use TSL/NodeMaterial (for WebGPU compatibility) */
-  useTSL;
-  constructor(useTSL = false) {
-    this.useTSL = useTSL;
-  }
-  batchMaterial(options, entityType) {
-    const batchKey = shortHash(sortedStringify(options));
-    const mappedObject = _MaterialBuilder.batchMaterialMap.get(batchKey);
-    if (mappedObject) {
-      const count = mappedObject.geometryMap.get(entityType);
-      if (count) {
-        mappedObject.geometryMap.set(entityType, count + 1);
-      } else {
-        mappedObject.geometryMap.set(entityType, 1);
-      }
-    } else {
-      _MaterialBuilder.batchMaterialMap.set(batchKey, {
-        geometryMap: /* @__PURE__ */ new Map([[entityType, 1]]),
-        material: this.materials[0]
-      });
-    }
-  }
-  build(options, entityType) {
-    const { path, normalMap, repeat, color, shader, opacity, useTSL } = options;
-    const shouldUseTSL = useTSL ?? this.useTSL;
-    if (shader) {
-      if (isTSLShader(shader)) {
-        this.setTSLShader(shader, opacity);
-      } else if (isGLSLShader(shader)) {
-        if (shouldUseTSL) {
-          console.warn("MaterialBuilder: GLSL shader provided but TSL mode requested. Using GLSL.");
-        }
-        this.setShader(shader, opacity);
-      }
-    } else if (path) {
-      this.setTexture(path, repeat, shouldUseTSL, opacity);
-    }
-    if (color) {
-      this.withColor(color, shouldUseTSL, opacity);
-    }
-    if (this.materials.length === 0) {
-      this.setColor(new Color4("#ffffff"), shouldUseTSL, opacity);
-    }
-    if (normalMap && this.materials.length > 0) {
-      this.setNormalMap(normalMap, repeat);
-    }
-    this.batchMaterial(options, entityType);
-  }
-  withColor(color, useTSL = false, opacity) {
-    this.setColor(color, useTSL, opacity);
-    return this;
-  }
-  withShader(shader, opacity) {
-    this.setShader(shader, opacity);
-    return this;
-  }
-  withTSLShader(shader, opacity) {
-    this.setTSLShader(shader, opacity);
-    return this;
-  }
-  applyOpacity(material, opacity, forceTransparent = false) {
-    if (opacity !== void 0) {
-      material.opacity = opacity;
-    }
-    material.transparent = forceTransparent || opacity !== void 0 && opacity < 1;
-    material.needsUpdate = true;
-  }
-  /**
-   * Set texture - loads in background (deferred).
-   * Material is created immediately with null map, texture applies when loaded.
-   */
-  setTexture(texturePath = null, repeat = new Vector23(1, 1), useTSL = false, opacity) {
-    if (!texturePath) {
-      return;
-    }
-    if (useTSL) {
-      const material = new MeshStandardNodeMaterial();
-      this.applyOpacity(material, opacity);
-      this.materials.push(material);
-      assetManager.loadTexture(texturePath, {
-        clone: true,
-        repeat
-      }).then((texture) => {
-        texture.wrapS = RepeatWrapping2;
-        texture.wrapT = RepeatWrapping2;
-        material.map = texture;
-        material.needsUpdate = true;
-      });
-    } else {
-      const material = new MeshPhongMaterial2({
-        map: null,
-        opacity: opacity ?? 1,
-        transparent: opacity !== void 0 && opacity < 1
-      });
-      this.materials.push(material);
-      assetManager.loadTexture(texturePath, {
-        clone: true,
-        repeat
-      }).then((texture) => {
-        texture.wrapS = RepeatWrapping2;
-        texture.wrapT = RepeatWrapping2;
-        material.map = texture;
-        material.needsUpdate = true;
-      });
-    }
-  }
-  /**
-   * Set normal map for the current material
-   */
-  setNormalMap(normalMapPath, repeat = new Vector23(1, 1)) {
-    const material = this.materials[this.materials.length - 1];
-    if (!material) return;
-    assetManager.loadTexture(normalMapPath, {
-      clone: true,
-      repeat
-    }).then((texture) => {
-      texture.wrapS = RepeatWrapping2;
-      texture.wrapT = RepeatWrapping2;
-      if (material instanceof MeshStandardMaterial2 || material instanceof MeshPhongMaterial2 || material instanceof MeshStandardNodeMaterial) {
-        material.normalMap = texture;
-        material.needsUpdate = true;
-      } else if (material instanceof ShaderMaterial2) {
-        if (material.uniforms.tNormal) {
-          material.uniforms.tNormal.value = texture;
-          material.needsUpdate = true;
-        }
-        if (material.uniforms.normalMap) {
-          material.uniforms.normalMap.value = texture;
-          material.needsUpdate = true;
-        }
-      }
-    });
-  }
-  setColor(color, useTSL = false, opacity) {
-    if (useTSL) {
-      const material = new MeshStandardNodeMaterial();
-      material.color = color;
-      this.applyOpacity(material, opacity);
-      this.materials.push(material);
-    } else {
-      const material = new MeshStandardMaterial2({
-        color,
-        emissiveIntensity: 0.5,
-        lightMapIntensity: 0.5,
-        fog: true,
-        opacity: opacity ?? 1,
-        transparent: opacity !== void 0 && opacity < 1
-      });
-      this.materials.push(material);
-    }
-  }
-  /**
-   * Set GLSL shader (WebGL only)
-   */
-  setShader(customShader, opacity) {
-    const { fragment: fragment2, vertex } = customShader ?? standardShader;
-    const shader = new ShaderMaterial2({
-      uniforms: {
-        iResolution: { value: new Vector38(1, 1, 1) },
-        iTime: { value: 0 },
-        tDiffuse: { value: null },
-        tDepth: { value: null },
-        tNormal: { value: null },
-        normalMap: { value: null },
-        lightDir: { value: new Vector38(1, 1, 1) },
-        normalStrength: { value: 1 }
-      },
-      vertexShader: vertex,
-      fragmentShader: fragment2,
-      transparent: true,
-      opacity: opacity ?? 1
-    });
-    this.materials.push(shader);
-  }
-  /**
-   * Set TSL shader (WebGPU compatible)
-   */
-  setTSLShader(tslShader, opacity) {
-    const material = new MeshBasicNodeMaterial();
-    material.colorNode = tslShader.colorNode;
-    this.applyOpacity(
-      material,
-      opacity,
-      tslShader.transparent
-    );
-    this.materials.push(material);
-  }
-};
-
-// src/lib/entities/parts/mesh-factories.ts
-function buildMaterial(opts, entityType = /* @__PURE__ */ Symbol("mesh")) {
-  if (opts.material || opts.color) {
-    const builder = new MaterialBuilder();
-    builder.build(
-      { ...opts.material, color: opts.color ?? opts.material?.color },
-      entityType
-    );
-    if (builder.materials.length > 0) {
-      return builder.materials;
-    }
-  }
-  return [new MeshStandardMaterial3()];
-}
-function finalizeMesh(mesh, opts) {
-  if (opts.position) {
-    mesh.position.set(opts.position.x, opts.position.y, opts.position.z);
-  }
-  mesh.castShadow = true;
-  mesh.receiveShadow = true;
-  return mesh;
-}
-function boxMesh(opts = {}) {
-  const size = opts.size ?? { x: 1, y: 1, z: 1 };
-  const geometry = new BoxGeometry(size.x, size.y, size.z);
-  const materials = buildMaterial(opts);
-  return finalizeMesh(new Mesh3(geometry, materials.at(-1)), opts);
-}
-function sphereMesh(opts = {}) {
-  const geometry = new SphereGeometry(opts.radius ?? 1);
-  const materials = buildMaterial(opts);
-  return finalizeMesh(new Mesh3(geometry, materials.at(-1)), opts);
-}
-function coneMesh(opts = {}) {
-  const geometry = new ConeGeometry(
-    opts.radius ?? 1,
-    opts.height ?? 2,
-    opts.radialSegments ?? 32
-  );
-  const materials = buildMaterial(opts);
-  return finalizeMesh(new Mesh3(geometry, materials.at(-1)), opts);
-}
-function pyramidMesh(opts = {}) {
-  const geometry = new ConeGeometry(opts.radius ?? 1, opts.height ?? 2, 4);
-  const materials = buildMaterial(opts);
-  return finalizeMesh(new Mesh3(geometry, materials.at(-1)), opts);
-}
-function cylinderMesh(opts = {}) {
-  const geometry = new CylinderGeometry(
-    opts.radiusTop ?? 1,
-    opts.radiusBottom ?? 1,
-    opts.height ?? 2,
-    opts.radialSegments ?? 32
-  );
-  const materials = buildMaterial(opts);
-  return finalizeMesh(new Mesh3(geometry, materials.at(-1)), opts);
-}
-function pillMesh(opts = {}) {
-  const geometry = new CapsuleGeometry(
-    opts.radius ?? 0.5,
-    opts.length ?? 1,
-    opts.capSegments ?? 10,
-    opts.radialSegments ?? 20
-  );
-  const materials = buildMaterial(opts);
-  return finalizeMesh(new Mesh3(geometry, materials.at(-1)), opts);
-}
-
-// src/lib/entities/box.ts
-var boxDefaults = {
-  ...commonDefaults,
-  size: new Vector39(1, 1, 1)
-};
-var BOX_TYPE = /* @__PURE__ */ Symbol("Box");
-var ZylemBox = class _ZylemBox extends GameEntity {
-  static type = BOX_TYPE;
-  constructor(options) {
-    super();
-    this.options = { ...boxDefaults, ...options };
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    const { x: sizeX, y: sizeY, z: sizeZ } = this.options.size ?? { x: 1, y: 1, z: 1 };
-    return {
-      ...baseInfo,
-      type: String(_ZylemBox.type),
-      size: `${sizeX}, ${sizeY}, ${sizeZ}`
-    };
-  }
-};
-function createBox(...args) {
-  const options = mergeArgs(args, boxDefaults);
-  const entity = new ZylemBox(options);
-  entity.add(
-    boxMesh({ size: options.size, material: options.material, color: options.color }),
-    boxCollision({
-      size: options.size,
-      static: options.collision?.static,
-      sensor: options.collision?.sensor,
-      collisionType: options.collisionType,
-      collisionFilter: options.collisionFilter
-    })
-  );
-  return finalizeEntityCloneSupport(
-    entity,
-    (cloneOptions) => createBox(cloneOptions ?? {})
-  );
-}
-
-// src/lib/entities/sphere.ts
-var sphereDefaults = {
-  ...commonDefaults,
-  radius: 1
-};
-var SPHERE_TYPE = /* @__PURE__ */ Symbol("Sphere");
-var ZylemSphere = class _ZylemSphere extends GameEntity {
-  static type = SPHERE_TYPE;
-  constructor(options) {
-    super();
-    this.options = { ...sphereDefaults, ...options };
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    const radius = this.options.radius ?? 1;
-    return {
-      ...baseInfo,
-      type: String(_ZylemSphere.type),
-      radius: radius.toFixed(2)
-    };
-  }
-};
-function createSphere(...args) {
-  const options = mergeArgs(args, sphereDefaults);
-  const entity = new ZylemSphere(options);
-  entity.add(
-    sphereMesh({ radius: options.radius, material: options.material, color: options.color }),
-    sphereCollision({
-      radius: options.radius,
-      static: options.collision?.static,
-      sensor: options.collision?.sensor,
-      collisionType: options.collisionType,
-      collisionFilter: options.collisionFilter
-    })
-  );
-  return finalizeEntityCloneSupport(
-    entity,
-    (cloneOptions) => createSphere(cloneOptions ?? {})
-  );
-}
-
-// src/lib/entities/sprite.ts
-import { ColliderDesc as ColliderDesc3 } from "@dimforge/rapier3d-compat";
-import { Euler as Euler2, Group as Group3, Quaternion as Quaternion3, Vector3 as Vector310 } from "three";
-import {
-  TextureLoader as TextureLoader2,
-  SpriteMaterial,
-  Sprite as ThreeSprite
-} from "three";
-
-// src/lib/entities/builder.ts
-import { BufferGeometry as BufferGeometry2, Mesh as Mesh5, Color as Color5 } from "three";
-
-// src/lib/graphics/mesh.ts
-import { Mesh as Mesh4 } from "three";
-var MeshBuilder = class {
-  _build(meshOptions, geometry, materials) {
-    const { batched, material } = meshOptions;
-    if (batched) {
-      console.warn("warning: mesh batching is not implemented");
-    }
-    const mesh = new Mesh4(geometry, materials.at(-1));
-    mesh.position.set(0, 0, 0);
-    mesh.castShadow = true;
-    mesh.receiveShadow = true;
-    return mesh;
-  }
-  _postBuild() {
-    return;
-  }
-};
-
-// src/lib/entities/builder.ts
-var EntityCollisionBuilder = class extends CollisionBuilder {
-};
-var EntityMeshBuilder = class extends MeshBuilder {
-  build(options) {
-    return new BufferGeometry2();
-  }
-  postBuild() {
-    return;
-  }
-};
-var EntityBuilder = class {
-  meshBuilder;
-  collisionBuilder;
-  materialBuilder;
-  options;
-  entity;
-  constructor(options, entity, meshBuilder, collisionBuilder) {
-    this.options = options;
-    this.entity = entity;
-    this.meshBuilder = meshBuilder;
-    this.collisionBuilder = collisionBuilder;
-    this.materialBuilder = new MaterialBuilder();
-    const builders = {
-      meshBuilder: this.meshBuilder,
-      collisionBuilder: this.collisionBuilder,
-      materialBuilder: this.materialBuilder
-    };
-    this.options._builders = builders;
-  }
-  withPosition(setupPosition) {
-    this.options.position = setupPosition;
-    return this;
-  }
-  withMaterial(options, entityType) {
-    if (this.materialBuilder) {
-      this.materialBuilder.build(options, entityType);
-    }
-    return this;
-  }
-  applyMaterialToGroup(group, materials) {
-    group.traverse((child) => {
-      if (child instanceof Mesh5) {
-        if (child.type === "SkinnedMesh" && materials[0] && !child.material.map) {
-          child.material = materials[0];
-        }
-      }
-      child.castShadow = true;
-      child.receiveShadow = true;
-    });
-  }
-  build() {
-    const entity = this.entity;
-    if (this.materialBuilder) {
-      entity.materials = this.materialBuilder.materials;
-    }
-    if (this.meshBuilder && entity.materials) {
-      const geometry = this.meshBuilder.build(this.options);
-      entity.mesh = this.meshBuilder._build(this.options, geometry, entity.materials);
-      this.meshBuilder.postBuild();
-    }
-    if (entity.group && entity.materials) {
-      this.applyMaterialToGroup(entity.group, entity.materials);
-    }
-    if (this.collisionBuilder) {
-      this.collisionBuilder.withCollision(this.options?.collision || {});
-      const [bodyDesc, colliderDesc] = this.collisionBuilder.build(this.options);
-      entity.bodyDesc = bodyDesc;
-      entity.colliderDesc = colliderDesc;
-      entity.colliderDescs.push(colliderDesc);
-      const { x, y, z } = this.options.position || { x: 0, y: 0, z: 0 };
-      entity.bodyDesc.setTranslation(x, y, z);
-    }
-    if (this.options.collisionType) {
-      entity.collisionType = this.options.collisionType;
-    }
-    if (this.options.color instanceof Color5) {
-      const applyColor = (material) => {
-        const anyMat = material;
-        if (anyMat && anyMat.color && anyMat.color.set) {
-          anyMat.color.set(this.options.color);
-        }
-      };
-      if (entity.materials?.length) {
-        for (const mat of entity.materials) applyColor(mat);
-      }
-      if (entity.mesh && entity.mesh.material) {
-        const mat = entity.mesh.material;
-        if (Array.isArray(mat)) mat.forEach(applyColor);
-        else applyColor(mat);
-      }
-      if (entity.group) {
-        entity.group.traverse((child) => {
-          if (child instanceof Mesh5 && child.material) {
-            const mat = child.material;
-            if (Array.isArray(mat)) mat.forEach(applyColor);
-            else applyColor(mat);
-          }
-        });
-      }
-    }
-    return entity;
-  }
-};
-
-// src/lib/entities/delegates/loader.ts
-function isLoadable(obj) {
-  return typeof obj?.load === "function" && typeof obj?.data === "function";
-}
-var EntityLoader = class {
-  entityReference;
-  constructor(entity) {
-    this.entityReference = entity;
-  }
-  load() {
-    if (this.entityReference.load) {
-      this.entityReference.load();
-    }
-  }
-  data() {
-    if (this.entityReference.data) {
-      return this.entityReference.data();
-    }
-    return null;
-  }
-};
-
-// src/lib/entities/create.ts
-function createEntity(params) {
-  const {
-    args,
-    defaultConfig,
-    EntityClass,
-    BuilderClass,
-    entityType,
-    MeshBuilderClass,
-    CollisionBuilderClass,
-    cloneFactory
-  } = params;
-  let builder = null;
-  let configuration;
-  const configurationIndex = args.findIndex((node) => !(node instanceof BaseNode));
-  if (configurationIndex !== -1) {
-    const subArgs = args.splice(configurationIndex, 1);
-    configuration = subArgs.find((node) => !(node instanceof BaseNode));
-  }
-  const mergedConfiguration = configuration ? { ...defaultConfig, ...configuration } : defaultConfig;
-  args.push(mergedConfiguration);
-  for (const arg of args) {
-    if (arg instanceof BaseNode) {
-      continue;
-    }
-    let entityData = null;
-    const entity = new EntityClass(arg);
-    try {
-      if (isLoadable(entity)) {
-        const loader = new EntityLoader(entity);
-        loader.load();
-        entityData = loader.data();
-      }
-    } catch (error) {
-      console.error("Error creating entity with loader:", error);
-    }
-    builder = new BuilderClass(
-      arg,
-      entity,
-      MeshBuilderClass ? new MeshBuilderClass(entityData) : null,
-      CollisionBuilderClass ? new CollisionBuilderClass(entityData) : null
-    );
-    if (arg.material) {
-      builder.withMaterial(arg.material, entityType);
-    }
-  }
-  if (!builder) {
-    throw new Error(`missing options for ${String(entityType)}, builder is not initialized.`);
-  }
-  return finalizeEntityCloneSupport(
-    builder.build(),
-    (options) => cloneFactory(options)
-  );
-}
-
-// src/lib/entities/sprite.ts
-var spriteDefaults = {
-  ...commonDefaults,
-  size: new Vector310(1, 1, 1),
-  images: [],
-  animations: []
-};
-var SpriteCollisionBuilder = class extends EntityCollisionBuilder {
-  collider(options) {
-    const size = options.collisionSize || options.size || new Vector310(1, 1, 1);
-    const half = { x: size.x / 2, y: size.y / 2, z: size.z / 2 };
-    let colliderDesc = ColliderDesc3.cuboid(half.x, half.y, half.z);
-    return colliderDesc;
-  }
-};
-var SpriteBuilder = class extends EntityBuilder {
-  createEntity(options) {
-    return new ZylemSprite(options);
-  }
-};
-var SPRITE_TYPE = /* @__PURE__ */ Symbol("Sprite");
-var ZylemSprite = class _ZylemSprite extends GameEntity {
-  static type = SPRITE_TYPE;
-  sprites = [];
-  spriteMap = /* @__PURE__ */ new Map();
-  currentSpriteIndex = 0;
-  animations = /* @__PURE__ */ new Map();
-  currentAnimation = null;
-  currentAnimationFrame = "";
-  currentAnimationIndex = 0;
-  currentAnimationTime = 0;
-  constructor(options) {
-    super();
-    this.options = { ...spriteDefaults, ...options };
-    this.prependSetup(this.spriteSetup.bind(this));
-    this.prependUpdate(this.spriteUpdate.bind(this));
-    this.onCleanup(this.spriteDestroy.bind(this));
-  }
-  create() {
-    this.sprites = [];
-    this.spriteMap.clear();
-    this.animations.clear();
-    this.currentAnimation = null;
-    this.currentAnimationFrame = "";
-    this.currentAnimationIndex = 0;
-    this.currentAnimationTime = 0;
-    this.group = void 0;
-    this.createSpritesFromImages(this.options?.images || []);
-    this.createAnimations(this.options?.animations || []);
-    return super.create();
-  }
-  createSpritesFromImages(images) {
-    const textureLoader = new TextureLoader2();
-    const size = this.options.size ?? new Vector310(1, 1, 1);
-    images.forEach((image, index) => {
-      const spriteMap = textureLoader.load(image.file);
-      const material = new SpriteMaterial({
-        map: spriteMap,
-        transparent: true
-      });
-      const _sprite = new ThreeSprite(material);
-      _sprite.position.normalize();
-      _sprite.scale.set(size.x, size.y, size.z);
-      _sprite.visible = index === 0;
-      this.sprites.push(_sprite);
-      this.spriteMap.set(image.name, index);
-    });
-    this.group = new Group3();
-    this.group.add(...this.sprites);
-  }
-  createAnimations(animations) {
-    animations.forEach((animation) => {
-      const { name, frames, loop = false, speed = 1 } = animation;
-      const internalAnimation = {
-        frames: frames.map((frame, index) => ({
-          key: frame,
-          index,
-          time: (typeof speed === "number" ? speed : speed[index]) * (index + 1),
-          duration: typeof speed === "number" ? speed : speed[index]
-        })),
-        loop
-      };
-      this.animations.set(name, internalAnimation);
-    });
-  }
-  setSprite(key) {
-    const spriteIndex = this.spriteMap.get(key);
-    const useIndex = spriteIndex ?? 0;
-    this.currentSpriteIndex = useIndex;
-    this.sprites.forEach((_sprite, i) => {
-      _sprite.visible = this.currentSpriteIndex === i;
-    });
-  }
-  setAnimation(name, delta) {
-    const animation = this.animations.get(name);
-    if (!animation) return;
-    const { loop, frames } = animation;
-    const frame = frames[this.currentAnimationIndex];
-    if (name === this.currentAnimation) {
-      this.currentAnimationFrame = frame.key;
-      this.currentAnimationTime += delta;
-      this.setSprite(this.currentAnimationFrame);
-    } else {
-      this.currentAnimation = name;
-    }
-    if (this.currentAnimationTime > frame.time) {
-      this.currentAnimationIndex++;
-    }
-    if (this.currentAnimationIndex >= frames.length) {
-      if (loop) {
-        this.currentAnimationIndex = 0;
-        this.currentAnimationTime = 0;
-      } else {
-        this.currentAnimationTime = frames[this.currentAnimationIndex].time;
-      }
-    }
-  }
-  getCurrentRotationQuaternion() {
-    if (this.transformStore?.dirty.rotation) {
-      return this.transformStore.rotation;
-    }
-    return this.body?.rotation?.() ?? null;
-  }
-  syncSpriteMaterials() {
-    const q = this.getCurrentRotationQuaternion();
-    this.sprites.forEach((_sprite) => {
-      if (_sprite.material && q) {
-        const quat = new Quaternion3(q.x, q.y, q.z, q.w);
-        const euler = new Euler2().setFromQuaternion(quat, "XYZ");
-        _sprite.material.rotation = euler.z;
-      }
-      _sprite.scale.set(this.options.size?.x ?? 1, this.options.size?.y ?? 1, this.options.size?.z ?? 1);
-    });
-  }
-  spriteSetup(_params) {
-    this.syncSpriteMaterials();
-  }
-  spriteUpdate(params) {
-    this.syncSpriteMaterials();
-  }
-  spriteDestroy(params) {
-    this.sprites.forEach((_sprite) => {
-      _sprite.removeFromParent();
-    });
-    this.group?.remove(...this.sprites);
-    this.group?.removeFromParent();
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    return {
-      ...baseInfo,
-      type: String(_ZylemSprite.type)
-    };
-  }
-};
-function createSprite(...args) {
-  return createEntity({
-    args,
-    defaultConfig: spriteDefaults,
-    EntityClass: ZylemSprite,
-    BuilderClass: SpriteBuilder,
-    CollisionBuilderClass: SpriteCollisionBuilder,
-    entityType: ZylemSprite.type,
-    cloneFactory: (options) => createSprite(options ?? {})
-  });
-}
-
-// src/lib/entities/plane.ts
-import { ColliderDesc as ColliderDesc4 } from "@dimforge/rapier3d-compat";
-import { PlaneGeometry, Vector2 as Vector24, Vector3 as Vector311 } from "three";
-
-// src/lib/graphics/geometries/XZPlaneGeometry.ts
-import { BufferGeometry as BufferGeometry3, Float32BufferAttribute } from "three";
-var XZPlaneGeometry = class _XZPlaneGeometry extends BufferGeometry3 {
-  constructor(width = 1, height = 1, widthSegments = 1, heightSegments = 1) {
-    super();
-    this.type = "XZPlaneGeometry";
-    this.parameters = {
-      width,
-      height,
-      widthSegments,
-      heightSegments
-    };
-    const width_half = width / 2;
-    const height_half = height / 2;
-    const gridX = Math.floor(widthSegments);
-    const gridY = Math.floor(heightSegments);
-    const gridX1 = gridX + 1;
-    const gridY1 = gridY + 1;
-    const segment_width = width / gridX;
-    const segment_height = height / gridY;
-    const indices = [];
-    const vertices = [];
-    const normals = [];
-    const uvs = [];
-    for (let iy = 0; iy < gridY1; iy++) {
-      const z = iy * segment_height - height_half;
-      for (let ix = 0; ix < gridX1; ix++) {
-        const x = ix * segment_width - width_half;
-        vertices.push(x, 0, z);
-        normals.push(0, 1, 0);
-        uvs.push(ix / gridX);
-        uvs.push(1 - iy / gridY);
-      }
-    }
-    for (let iy = 0; iy < gridY; iy++) {
-      for (let ix = 0; ix < gridX; ix++) {
-        const a = ix + gridX1 * iy;
-        const b = ix + gridX1 * (iy + 1);
-        const c = ix + 1 + gridX1 * (iy + 1);
-        const d = ix + 1 + gridX1 * iy;
-        indices.push(a, b, d);
-        indices.push(b, c, d);
-      }
-    }
-    this.setIndex(indices);
-    this.setAttribute("position", new Float32BufferAttribute(vertices, 3));
-    this.setAttribute("normal", new Float32BufferAttribute(normals, 3));
-    this.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
-  }
-  copy(source) {
-    super.copy(source);
-    this.parameters = Object.assign({}, source.parameters);
-    return this;
-  }
-  static fromJSON(data) {
-    return new _XZPlaneGeometry(data.width, data.height, data.widthSegments, data.heightSegments);
-  }
-};
-
-// src/lib/entities/plane.ts
-var DEFAULT_SUBDIVISIONS = 4;
-var planeDefaults = {
-  ...commonDefaults,
-  tile: new Vector24(10, 10),
-  repeat: new Vector24(1, 1),
-  collision: {
-    static: true
-  },
-  subdivisions: DEFAULT_SUBDIVISIONS,
-  randomizeHeight: false,
-  heightScale: 1
-};
-var PlaneCollisionBuilder = class extends EntityCollisionBuilder {
-  collider(options) {
-    const tile = options.tile ?? new Vector24(1, 1);
-    const subdivisions = options.subdivisions ?? DEFAULT_SUBDIVISIONS;
-    const size = new Vector311(tile.x, 1, tile.y);
-    const heightData = options._builders?.meshBuilder?.heightData;
-    const scale2 = new Vector311(size.x, 1, size.z);
-    let colliderDesc = ColliderDesc4.heightfield(
-      subdivisions,
-      subdivisions,
-      heightData,
-      scale2
-    );
-    return colliderDesc;
-  }
-};
-var PlaneMeshBuilder = class extends EntityMeshBuilder {
-  heightData = new Float32Array();
-  columnsRows = /* @__PURE__ */ new Map();
-  subdivisions = DEFAULT_SUBDIVISIONS;
-  build(options) {
-    const tile = options.tile ?? new Vector24(1, 1);
-    const subdivisions = options.subdivisions ?? DEFAULT_SUBDIVISIONS;
-    this.subdivisions = subdivisions;
-    const size = new Vector311(tile.x, 1, tile.y);
-    const heightScale = options.heightScale ?? 1;
-    const geometry = new XZPlaneGeometry(size.x, size.z, subdivisions, subdivisions);
-    const vertexGeometry = new PlaneGeometry(size.x, size.z, subdivisions, subdivisions);
-    const dx = size.x / subdivisions;
-    const dy = size.z / subdivisions;
-    const originalVertices = geometry.attributes.position.array;
-    const vertices = vertexGeometry.attributes.position.array;
-    const columsRows = /* @__PURE__ */ new Map();
-    const heightMapData = options.heightMap;
-    const useRandomHeight = options.randomizeHeight ?? false;
-    for (let i = 0; i < vertices.length; i += 3) {
-      const vertexIndex = i / 3;
-      let row = Math.floor(Math.abs(vertices[i] + size.x / 2) / dx);
-      let column = Math.floor(Math.abs(vertices[i + 1] - size.z / 2) / dy);
-      let height = 0;
-      if (heightMapData && heightMapData.length > 0) {
-        const heightIndex = vertexIndex % heightMapData.length;
-        height = heightMapData[heightIndex] * heightScale;
-      } else if (useRandomHeight) {
-        height = Math.random() * 4 * heightScale;
-      }
-      vertices[i + 2] = height;
-      originalVertices[i + 1] = height;
-      if (!columsRows.get(column)) {
-        columsRows.set(column, /* @__PURE__ */ new Map());
-      }
-      columsRows.get(column).set(row, height);
-    }
-    this.columnsRows = columsRows;
-    return geometry;
-  }
-  postBuild() {
-    const heights = [];
-    for (let i = 0; i <= this.subdivisions; ++i) {
-      for (let j = 0; j <= this.subdivisions; ++j) {
-        const row = this.columnsRows.get(j);
-        if (!row) {
-          heights.push(0);
-          continue;
-        }
-        const data = row.get(i);
-        heights.push(data ?? 0);
-      }
-    }
-    this.heightData = new Float32Array(heights);
-  }
-};
-var PlaneBuilder = class extends EntityBuilder {
-  createEntity(options) {
-    return new ZylemPlane(options);
-  }
-};
-var PLANE_TYPE = /* @__PURE__ */ Symbol("Plane");
-var ZylemPlane = class extends GameEntity {
-  static type = PLANE_TYPE;
-  constructor(options) {
-    super();
-    this.options = { ...planeDefaults, ...options };
-  }
-};
-function createPlane(...args) {
-  return createEntity({
-    args,
-    defaultConfig: planeDefaults,
-    EntityClass: ZylemPlane,
-    BuilderClass: PlaneBuilder,
-    MeshBuilderClass: PlaneMeshBuilder,
-    CollisionBuilderClass: PlaneCollisionBuilder,
-    entityType: ZylemPlane.type,
-    cloneFactory: (options) => createPlane(options ?? {})
-  });
-}
-
-// src/lib/entities/zone.ts
-import { Vector3 as Vector312 } from "three";
-
-// src/lib/game/game-state.ts
-import { proxy as proxy2, subscribe } from "valtio/vanilla";
-var state = proxy2({
-  id: "",
-  globals: {},
-  time: 0
-});
-
-// src/lib/entities/zone.ts
-var zoneDefaults = {
-  ...commonDefaults,
-  size: new Vector312(1, 1, 1),
-  collision: {
-    static: true
-  }
-};
-var ZONE_TYPE = /* @__PURE__ */ Symbol("Zone");
-var ZylemZone = class extends GameEntity {
-  static type = ZONE_TYPE;
-  _enteredZone = /* @__PURE__ */ new Map();
-  _exitedZone = /* @__PURE__ */ new Map();
-  _zoneEntities = /* @__PURE__ */ new Map();
-  constructor(options) {
-    super();
-    this.options = { ...zoneDefaults, ...options };
-  }
-  handlePostCollision({ delta }) {
-    this._enteredZone.forEach((val, key) => {
-      this.exited(delta, key);
-    });
-    return this._enteredZone.size > 0;
-  }
-  handleIntersectionEvent({ other, delta }) {
-    const hasEntered = this._enteredZone.get(other.uuid);
-    if (!hasEntered) {
-      this.entered(other);
-      this._zoneEntities.set(other.uuid, other);
-    } else {
-      this.held(delta, other);
-    }
-  }
-  onEnter(callback) {
-    this.options.onEnter = callback;
-    return this;
-  }
-  onHeld(callback) {
-    this.options.onHeld = callback;
-    return this;
-  }
-  onExit(callback) {
-    this.options.onExit = callback;
-    return this;
-  }
-  entered(other) {
-    this._enteredZone.set(other.uuid, 1);
-    if (this.options.onEnter) {
-      this.options.onEnter({
-        self: this,
-        visitor: other,
-        globals: state.globals
-      });
-    }
-  }
-  exited(delta, key) {
-    const hasExited = this._exitedZone.get(key);
-    if (hasExited && hasExited > 1 + delta) {
-      this._exitedZone.delete(key);
-      this._enteredZone.delete(key);
-      const other = this._zoneEntities.get(key);
-      if (this.options.onExit) {
-        this.options.onExit({
-          self: this,
-          visitor: other,
-          globals: state.globals
-        });
-      }
-      return;
-    }
-    this._exitedZone.set(key, 1 + delta);
-  }
-  held(delta, other) {
-    const heldTime = this._enteredZone.get(other.uuid) ?? 0;
-    this._enteredZone.set(other.uuid, heldTime + delta);
-    this._exitedZone.set(other.uuid, 1);
-    if (this.options.onHeld) {
-      this.options.onHeld({
-        delta,
-        self: this,
-        visitor: other,
-        globals: state.globals,
-        heldTime
-      });
-    }
-  }
-};
-function createZone(...args) {
-  const options = mergeArgs(args, zoneDefaults);
-  const entity = new ZylemZone(options);
-  entity.add(
-    zoneCollision({
-      size: options.size,
-      static: options.collision?.static ?? true,
-      collisionType: options.collisionType,
-      collisionFilter: options.collisionFilter
-    })
-  );
-  return finalizeEntityCloneSupport(
-    entity,
-    (cloneOptions) => createZone(cloneOptions ?? {})
-  );
-}
-
-// src/lib/entities/actor.ts
-import { ActiveCollisionTypes as ActiveCollisionTypes3, ColliderDesc as ColliderDesc5 } from "@dimforge/rapier3d-compat";
-import {
-  Box3,
-  BufferAttribute,
-  SkinnedMesh,
-  MeshStandardMaterial as MeshStandardMaterial4,
-  Group as Group4,
-  Vector3 as Vector313,
-  Matrix4
-} from "three";
-
-// src/lib/core/entity-asset-loader.ts
-var EntityAssetLoader = class {
-  /**
-   * Load a model file (FBX, GLTF, GLB, OBJ) using the asset manager
-   */
-  async loadFile(file, options) {
-    const ext = file.split(".").pop()?.toLowerCase();
-    switch (ext) {
-      case "fbx": {
-        const result = await assetManager.loadFBX(file, options);
-        return {
-          object: result.object,
-          animation: result.animations?.[0]
-        };
-      }
-      case "gltf":
-      case "glb": {
-        const result = await assetManager.loadGLTF(file, options);
-        return {
-          object: result.object,
-          gltf: result.gltf
-        };
-      }
-      case "obj": {
-        const result = await assetManager.loadOBJ(file, options);
-        return {
-          object: result.object
-        };
-      }
-      default:
-        throw new Error(`Unsupported file type: ${file}`);
-    }
-  }
-};
-
-// src/lib/entities/delegates/animation.ts
-import {
-  AnimationMixer,
-  Bone,
-  LoopOnce,
-  LoopRepeat
-} from "three";
-function getTrackTargetName(trackName) {
-  const propertyIndex = trackName.lastIndexOf(".");
-  return propertyIndex >= 0 ? trackName.slice(0, propertyIndex) : trackName;
-}
-function shouldStripRootMotion(track, targetByName) {
-  if (!track?.name?.endsWith(".position")) {
-    return false;
-  }
-  const targetName = getTrackTargetName(track.name);
-  const target = targetByName.get(targetName);
-  if (target instanceof Bone) {
-    return !(target.parent instanceof Bone);
-  }
-  return /hips\.position$/i.test(track.name) || /root\.position$/i.test(track.name);
-}
-function stripClipRootMotion(clip, targetByName) {
-  for (const track of clip.tracks) {
-    if (!shouldStripRootMotion(track, targetByName)) {
-      continue;
-    }
-    if (!track.values || track.values.length < 3) {
-      continue;
-    }
-    const baseX = track.values[0];
-    const baseZ = track.values[2];
-    for (let i = 0; i < track.values.length; i += 3) {
-      track.values[i] = baseX;
-      track.values[i + 2] = baseZ;
-    }
-  }
-  return clip;
-}
-var AnimationDelegate = class {
-  constructor(target) {
-    this.target = target;
-  }
-  _mixer = null;
-  _actions = {};
-  _animations = [];
-  _currentAction = null;
-  _pauseAtPercentage = 0;
-  _isPaused = false;
-  _queuedKey = null;
-  _fadeDuration = 0.5;
-  _currentKey = "";
-  _assetLoader = new EntityAssetLoader();
-  async loadAnimations(animations) {
-    if (!animations.length) return;
-    const results = await Promise.all(animations.map((a) => this._assetLoader.loadFile(a.path)));
-    const targetByName = /* @__PURE__ */ new Map();
-    this.target.traverse((node) => {
-      if (node.name) {
-        targetByName.set(node.name, node);
-      }
-    });
-    const loadedAnimations = [];
-    results.forEach((result, i) => {
-      if (result.animation) {
-        loadedAnimations.push({
-          key: animations[i].key || i.toString(),
-          clip: stripClipRootMotion(result.animation, targetByName)
-        });
-      }
-    });
-    if (!loadedAnimations.length) return;
-    this._animations = loadedAnimations.map((a) => a.clip);
-    this._mixer = new AnimationMixer(this.target);
-    loadedAnimations.forEach(({ key, clip }) => {
-      this._actions[key] = this._mixer.clipAction(clip);
-    });
-    this.playAnimation({ key: loadedAnimations[0].key });
-  }
-  update(delta) {
-    if (!this._mixer || !this._currentAction) return;
-    this._mixer.update(delta);
-    const pauseAtTime = this._currentAction.getClip().duration * (this._pauseAtPercentage / 100);
-    if (!this._isPaused && this._pauseAtPercentage > 0 && this._currentAction.time >= pauseAtTime) {
-      this._currentAction.time = pauseAtTime;
-      this._currentAction.paused = true;
-      this._isPaused = true;
-      if (this._queuedKey !== null) {
-        const next = this._actions[this._queuedKey];
-        next.reset().play();
-        this._currentAction.crossFadeTo(next, this._fadeDuration, false);
-        this._currentAction = next;
-        this._currentKey = this._queuedKey;
-        this._queuedKey = null;
-      }
-    }
-  }
-  playAnimation(opts) {
-    if (!this._mixer) return;
-    const { key, pauseAtPercentage = 0, pauseAtEnd = false, fadeToKey, fadeDuration = 0.5 } = opts;
-    if (key === this._currentKey) return;
-    const action = this._actions[key];
-    if (!action) return;
-    this._queuedKey = fadeToKey || null;
-    this._fadeDuration = fadeDuration;
-    this._pauseAtPercentage = pauseAtEnd ? 100 : pauseAtPercentage;
-    this._isPaused = false;
-    const prev = this._currentAction;
-    if (this._pauseAtPercentage > 0) {
-      action.setLoop(LoopOnce, Infinity);
-      action.clampWhenFinished = true;
-    } else {
-      action.setLoop(LoopRepeat, Infinity);
-      action.clampWhenFinished = false;
-    }
-    action.reset().play();
-    if (prev) {
-      prev.crossFadeTo(action, fadeDuration, false);
-    }
-    this._currentAction = action;
-    this._currentKey = key;
-  }
-  /**
-   * Dispose of all animation resources
-   */
-  dispose() {
-    Object.values(this._actions).forEach((action) => {
-      action.stop();
-    });
-    if (this._mixer) {
-      this._mixer.stopAllAction();
-      this._mixer.uncacheRoot(this.target);
-      this._mixer = null;
-    }
-    this._actions = {};
-    this._animations = [];
-    this._currentAction = null;
-    this._currentKey = "";
-  }
-  get currentAnimationKey() {
-    return this._currentKey;
-  }
-  get animations() {
-    return this._animations;
-  }
-};
-
-// src/lib/entities/actor.ts
-var actorDefaults = {
-  ...commonDefaults,
-  material: {
-    shader: standardShader
-  },
-  animations: [],
-  models: [],
-  collisionShape: "capsule"
-};
-function getActorScale(options) {
-  return new Vector313(
-    options.scale?.x ?? 1,
-    options.scale?.y ?? 1,
-    options.scale?.z ?? 1
-  );
-}
-function getCollisionPosition(options) {
-  const position2 = options.collision?.position;
-  if (!position2) {
-    return null;
-  }
-  return {
-    x: position2.x ?? 0,
-    y: position2.y ?? 0,
-    z: position2.z ?? 0
-  };
-}
-function hasExplicitCollisionSize(options) {
-  return Boolean(options.collision?.size);
-}
-function warnDynamicTrimeshOnce(actor) {
-  if (actor.hasWarnedDynamicTrimesh) {
-    return;
-  }
-  actor.hasWarnedDynamicTrimesh = true;
-  console.warn(
-    `Actor "${actor.name || actor.uuid}" requested collisionShape="trimesh" on a dynamic body; falling back to bounds.`
-  );
-}
-function resolveCollisionShape(shape, isStatic, onDynamicTrimesh) {
-  const normalized = shape === "model" ? "bounds" : shape ?? "capsule";
-  if (normalized === "trimesh" && !isStatic) {
-    onDynamicTrimesh?.();
-    return "bounds";
-  }
-  return normalized;
-}
-function tagTrimeshCollider(colliderDesc, vertices, indices) {
-  colliderDesc.__zylemShapeData = {
-    shape: "trimesh",
-    vertices: Array.from(vertices),
-    indices: Array.from(indices)
-  };
-  return colliderDesc;
-}
-function createCapsuleColliderFromDimensions(size, translation) {
-  const fullWidth = size.x || 0.5;
-  const fullHeight = size.y || 1;
-  const fullDepth = size.z || 0.5;
-  const radius = Math.max(fullWidth, fullDepth) / 2;
-  const halfTotalHeight = fullHeight / 2;
-  const halfCylinder = Math.max(0, halfTotalHeight - radius);
-  const colliderDesc = ColliderDesc5.capsule(halfCylinder, radius);
-  colliderDesc.setSensor(false);
-  colliderDesc.setTranslation(translation.x, translation.y, translation.z);
-  colliderDesc.activeCollisionTypes = ActiveCollisionTypes3.DEFAULT;
-  return colliderDesc;
-}
-function createCapsuleCollider(options) {
-  const size = options.collision?.size ?? options.size ?? { x: 0.5, y: 1, z: 0.5 };
-  const fullHeight = size.y || 1;
-  const collisionPosition = getCollisionPosition(options);
-  return createCapsuleColliderFromDimensions(
-    {
-      x: size.x || 0.5,
-      y: fullHeight,
-      z: size.z || 0.5
-    },
-    collisionPosition ?? { x: 0, y: fullHeight / 2, z: 0 }
-  );
-}
-function createExplicitBoxCollider(options) {
-  const collisionSize = options.collision?.size;
-  if (!collisionSize) {
-    return null;
-  }
-  const halfWidth = collisionSize.x / 2;
-  const halfHeight = collisionSize.y / 2;
-  const halfDepth = collisionSize.z / 2;
-  const colliderDesc = ColliderDesc5.cuboid(halfWidth, halfHeight, halfDepth);
-  const collisionPosition = getCollisionPosition(options);
-  colliderDesc.setSensor(false);
-  colliderDesc.setTranslation(
-    collisionPosition?.x ?? 0,
-    collisionPosition?.y ?? halfHeight,
-    collisionPosition?.z ?? 0
-  );
-  colliderDesc.activeCollisionTypes = ActiveCollisionTypes3.DEFAULT;
-  return colliderDesc;
-}
-function computeActorSpaceMatrix(child, actorRoot, actorScale) {
-  const actorRootInverse = actorRoot.matrixWorld.clone().invert();
-  const actorSpaceMatrix = actorRootInverse.multiply(child.matrixWorld);
-  return new Matrix4().makeScale(actorScale.x, actorScale.y, actorScale.z).multiply(actorSpaceMatrix);
-}
-function computeModelBounds(modelRoot, actorRoot, actorScale) {
-  modelRoot.updateMatrixWorld(true);
-  let foundMesh = false;
-  const aggregated = new Box3();
-  modelRoot.traverse((child) => {
-    if (!child.isMesh) {
-      return;
-    }
-    const mesh = child;
-    const geometry = mesh.geometry;
-    if (!geometry) {
-      return;
-    }
-    let localBounds = null;
-    if (mesh instanceof SkinnedMesh) {
-      mesh.computeBoundingBox();
-      localBounds = mesh.boundingBox?.clone() ?? null;
-    } else {
-      geometry.computeBoundingBox();
-      localBounds = geometry.boundingBox?.clone() ?? null;
-    }
-    if (!localBounds) {
-      return;
-    }
-    const transformedBounds = localBounds.applyMatrix4(computeActorSpaceMatrix(mesh, actorRoot, actorScale));
-    if (!foundMesh) {
-      aggregated.copy(transformedBounds);
-      foundMesh = true;
-      return;
-    }
-    aggregated.union(transformedBounds);
-  });
-  if (!foundMesh || aggregated.isEmpty()) {
-    return null;
-  }
-  const size = new Vector313();
-  const center = new Vector313();
-  aggregated.getSize(size);
-  aggregated.getCenter(center);
-  return { size, center };
-}
-function computeModelTrimesh(modelRoot, actorRoot, actorScale) {
-  modelRoot.updateMatrixWorld(true);
-  const vertices = [];
-  const indices = [];
-  const bounds = new Box3();
-  const point = new Vector313();
-  let foundMesh = false;
-  modelRoot.traverse((child) => {
-    if (!child.isMesh) {
-      return;
-    }
-    const mesh = child;
-    const geometry = mesh.geometry;
-    if (!geometry) {
-      return;
-    }
-    const position2 = geometry.getAttribute("position");
-    if (!(position2 instanceof BufferAttribute)) {
-      return;
-    }
-    const transform = computeActorSpaceMatrix(mesh, actorRoot, actorScale);
-    const vertexOffset = vertices.length / 3;
-    for (let i = 0; i < position2.count; i++) {
-      point.set(position2.getX(i), position2.getY(i), position2.getZ(i));
-      point.applyMatrix4(transform);
-      vertices.push(point.x, point.y, point.z);
-      bounds.expandByPoint(point);
-    }
-    const index = geometry.getIndex();
-    if (index) {
-      for (let i = 0; i < index.count; i++) {
-        indices.push(vertexOffset + index.getX(i));
-      }
-    } else {
-      for (let i = 0; i < position2.count; i++) {
-        indices.push(vertexOffset + i);
-      }
-    }
-    foundMesh = true;
-  });
-  if (!foundMesh || vertices.length === 0 || indices.length === 0) {
-    return null;
-  }
-  const center = new Vector313();
-  bounds.getCenter(center);
-  return {
-    vertices: new Float32Array(vertices),
-    indices: new Uint32Array(indices),
-    center
-  };
-}
-function createBoundsColliderFromModel(modelRoot, actorRoot, options) {
-  const explicitCollider = createExplicitBoxCollider(options);
-  if (explicitCollider) {
-    return explicitCollider;
-  }
-  if (!modelRoot || !actorRoot) {
-    return createCapsuleCollider(options);
-  }
-  const bounds = computeModelBounds(modelRoot, actorRoot, getActorScale(options));
-  if (!bounds) {
-    return createCapsuleCollider(options);
-  }
-  const colliderDesc = ColliderDesc5.cuboid(
-    bounds.size.x / 2,
-    bounds.size.y / 2,
-    bounds.size.z / 2
-  );
-  const collisionPosition = getCollisionPosition(options);
-  colliderDesc.setSensor(false);
-  colliderDesc.setTranslation(
-    collisionPosition?.x ?? bounds.center.x,
-    collisionPosition?.y ?? bounds.center.y,
-    collisionPosition?.z ?? bounds.center.z
-  );
-  colliderDesc.activeCollisionTypes = ActiveCollisionTypes3.DEFAULT;
-  return colliderDesc;
-}
-function createCapsuleColliderFromModel(sizingRoot, sizingActorRoot, alignmentRoot, alignmentActorRoot, options) {
-  if (hasExplicitCollisionSize(options)) {
-    return createCapsuleCollider(options);
-  }
-  if (!sizingRoot || !sizingActorRoot) {
-    return createCapsuleCollider(options);
-  }
-  const sizingBounds = computeModelBounds(
-    sizingRoot,
-    sizingActorRoot,
-    getActorScale(options)
-  );
-  if (!sizingBounds) {
-    return createCapsuleCollider(options);
-  }
-  const collisionPosition = getCollisionPosition(options);
-  let translation = collisionPosition;
-  if (!translation) {
-    const alignmentBounds = alignmentRoot && alignmentActorRoot ? computeModelBounds(alignmentRoot, alignmentActorRoot, getActorScale(options)) : null;
-    translation = alignmentBounds ? {
-      x: alignmentBounds.center.x,
-      y: alignmentBounds.center.y,
-      z: alignmentBounds.center.z
-    } : {
-      x: sizingBounds.center.x,
-      y: sizingBounds.center.y,
-      z: sizingBounds.center.z
-    };
-  }
-  return createCapsuleColliderFromDimensions(
-    {
-      x: sizingBounds.size.x,
-      y: sizingBounds.size.y,
-      z: sizingBounds.size.z
-    },
-    translation
-  );
-}
-function createTrimeshColliderFromModel(modelRoot, actorRoot, options) {
-  const explicitCollider = createExplicitBoxCollider(options);
-  if (explicitCollider) {
-    return explicitCollider;
-  }
-  if (!modelRoot || !actorRoot) {
-    return createCapsuleCollider(options);
-  }
-  const trimesh = computeModelTrimesh(modelRoot, actorRoot, getActorScale(options));
-  if (!trimesh) {
-    return createCapsuleCollider(options);
-  }
-  const colliderDesc = tagTrimeshCollider(
-    ColliderDesc5.trimesh(trimesh.vertices, trimesh.indices),
-    trimesh.vertices,
-    trimesh.indices
-  );
-  const collisionPosition = getCollisionPosition(options);
-  if (collisionPosition) {
-    colliderDesc.setTranslation(
-      collisionPosition.x - trimesh.center.x,
-      collisionPosition.y - trimesh.center.y,
-      collisionPosition.z - trimesh.center.z
-    );
-  }
-  colliderDesc.setSensor(false);
-  colliderDesc.activeCollisionTypes = ActiveCollisionTypes3.DEFAULT;
-  return colliderDesc;
-}
-function disposeObjectResources(object) {
-  if (!object) {
-    return;
-  }
-  object.traverse((child) => {
-    if (!child.isMesh) {
-      return;
-    }
-    const mesh = child;
-    mesh.geometry?.dispose();
-    if (Array.isArray(mesh.material)) {
-      mesh.material.forEach((material) => material.dispose());
-    } else {
-      mesh.material?.dispose();
-    }
-  });
-}
-var ActorCollisionBuilder = class extends EntityCollisionBuilder {
-  objectModel = null;
-  collisionSource = null;
-  collisionShape = "capsule";
-  constructor(data) {
-    super();
-    this.objectModel = data.objectModel;
-    this.collisionSource = data.collisionSource ?? data.objectModel ?? null;
-    this.collisionShape = data.collisionShape ?? "capsule";
-  }
-  collider(options) {
-    const resolvedShape = resolveCollisionShape(
-      this.collisionShape,
-      Boolean(options.collision?.static)
-    );
-    if (resolvedShape === "bounds") {
-      return createBoundsColliderFromModel(this.objectModel, this.objectModel, options);
-    }
-    if (resolvedShape === "trimesh") {
-      return createTrimeshColliderFromModel(this.objectModel, this.objectModel, options);
-    }
-    return createCapsuleColliderFromModel(
-      this.collisionSource,
-      this.collisionSource,
-      this.objectModel,
-      this.objectModel,
-      options
-    );
-  }
-};
-var ActorBuilder = class extends EntityBuilder {
-  createEntity(options) {
-    return new ZylemActor(options);
-  }
-};
-var ACTOR_TYPE = /* @__PURE__ */ Symbol("Actor");
-var ZylemActor = class extends GameEntity {
-  static type = ACTOR_TYPE;
-  _object = null;
-  _collisionSource = null;
-  _animationDelegate = null;
-  _modelFileNames = [];
-  _assetLoader = new EntityAssetLoader();
-  _loadGeneration = 0;
-  _loadStatus = "idle";
-  controlledRotation = false;
-  hasWarnedDynamicTrimesh = false;
-  constructor(options) {
-    super();
-    this.options = { ...actorDefaults, ...options };
-    this.prependUpdate(this.actorUpdate.bind(this));
-    this.controlledRotation = true;
-  }
-  create() {
-    if (this._loadStatus === "idle" && (this.options.models?.length ?? 0) > 0) {
-      this.load();
-    }
-    return super.create();
-  }
-  load() {
-    if (this._loadStatus === "loading" || this._loadStatus === "loaded") {
-      return;
-    }
-    this._modelFileNames = [...this.options.models || []];
-    if (this._modelFileNames.length === 0) {
-      return;
-    }
-    this.disposeRuntimeState(true);
-    this._loadStatus = "loading";
-    this.loadModelsDeferred(++this._loadGeneration);
-  }
-  data() {
-    return {
-      animations: this._animationDelegate?.animations,
-      objectModel: this._object,
-      collisionSource: this._collisionSource ?? this._object,
-      collisionShape: this.options.collisionShape
-    };
-  }
-  needsDeferredModelCollision() {
-    if (!this.requiresLoadedCollisionSource()) {
-      return false;
-    }
-    return !this.getRuntimeCollisionSource();
-  }
-  synchronizeRuntimeCollider() {
-    const resolvedShape = this.getResolvedCollisionShape();
-    let colliderDesc;
-    if (resolvedShape === "bounds") {
-      colliderDesc = createBoundsColliderFromModel(
-        this._object,
-        this.group ?? this._object,
-        this.options
-      );
-    } else if (resolvedShape === "trimesh") {
-      colliderDesc = createTrimeshColliderFromModel(
-        this._object,
-        this.group ?? this._object,
-        this.options
-      );
-    } else {
-      const collisionSource = this.getRuntimeCollisionSource();
-      colliderDesc = createCapsuleColliderFromModel(
-        collisionSource,
-        collisionSource,
-        this._object,
-        this._object,
-        this.options
-      );
-    }
-    this.colliderDesc = colliderDesc;
-    if (this.colliderDescs.length > 0) {
-      this.colliderDescs[0] = colliderDesc;
-    } else {
-      this.colliderDescs.push(colliderDesc);
-    }
-  }
-  actorUpdate(params) {
-    this._animationDelegate?.update(params.delta);
-  }
-  actorDestroy() {
-    this._loadGeneration += 1;
-    this._loadStatus = "idle";
-    this.disposeRuntimeState(true);
-    this._modelFileNames = [];
-  }
-  _cleanup(params) {
-    super._cleanup(params);
-    this.actorDestroy();
-  }
-  playAnimation(animationOptions) {
-    this._animationDelegate?.playAnimation(animationOptions);
-  }
-  get object() {
-    return this._object;
-  }
-  get collisionSource() {
-    return this._collisionSource ?? this._object;
-  }
-  getDebugInfo() {
-    const debugInfo = {
-      type: "Actor",
-      models: this._modelFileNames.length > 0 ? this._modelFileNames : "none",
-      modelLoaded: !!this._object,
-      scale: this.options.scale ? `${this.options.scale.x}, ${this.options.scale.y}, ${this.options.scale.z}` : "1, 1, 1",
-      collisionShape: this.getResolvedCollisionShape()
-    };
-    if (this._animationDelegate) {
-      debugInfo.currentAnimation = this._animationDelegate.currentAnimationKey || "none";
-      debugInfo.animationsCount = this.options.animations?.length || 0;
-    }
-    if (this._object) {
-      let meshCount = 0;
-      let vertexCount = 0;
-      this._object.traverse((child) => {
-        if (!child.isMesh) {
-          return;
-        }
-        meshCount++;
-        const geometry = child.geometry;
-        if (geometry?.attributes.position) {
-          vertexCount += geometry.attributes.position.count;
-        }
-      });
-      debugInfo.meshCount = meshCount;
-      debugInfo.vertexCount = vertexCount;
-    }
-    return debugInfo;
-  }
-  getResolvedCollisionShape() {
-    return resolveCollisionShape(
-      this.options.collisionShape,
-      Boolean(this.options.collision?.static),
-      () => warnDynamicTrimeshOnce(this)
-    );
-  }
-  requiresLoadedCollisionSource() {
-    const resolvedShape = this.getResolvedCollisionShape();
-    if (resolvedShape === "bounds" || resolvedShape === "trimesh") {
-      return !hasExplicitCollisionSize(this.options);
-    }
-    if (resolvedShape === "capsule") {
-      return !hasExplicitCollisionSize(this.options) && this.getCollisionSourceSelection().file !== null;
-    }
-    return false;
-  }
-  getRuntimeCollisionSource() {
-    const resolvedShape = this.getResolvedCollisionShape();
-    if (resolvedShape === "bounds" || resolvedShape === "trimesh") {
-      return this._object;
-    }
-    return this._collisionSource ?? this._object;
-  }
-  getCollisionSourceSelection() {
-    const modelFile = this.options.models?.[0] ?? null;
-    const animationFile = this.options.animations?.[0]?.path ?? null;
-    if (animationFile) {
-      return {
-        file: animationFile,
-        reuseVisibleModel: animationFile === modelFile
-      };
-    }
-    return {
-      file: modelFile,
-      reuseVisibleModel: true
-    };
-  }
-  disposeRuntimeState(clearGroup) {
-    if (this._animationDelegate) {
-      this._animationDelegate.dispose();
-      this._animationDelegate = null;
-    }
-    const collisionSource = this._collisionSource;
-    disposeObjectResources(this._object);
-    if (collisionSource && collisionSource !== this._object) {
-      disposeObjectResources(collisionSource);
-    }
-    this._object = null;
-    this._collisionSource = null;
-    if (clearGroup && this.group) {
-      this.group.clear();
-      this.group = void 0;
-    }
-  }
-  loadModelsDeferred(loadGeneration) {
-    this.dispatch("entity:model:loading", {
-      entityId: this.uuid,
-      files: this._modelFileNames
-    });
-    const collisionSourceSelection = this.getCollisionSourceSelection();
-    const promises = this._modelFileNames.map(
-      (file) => this._assetLoader.loadFile(file, { clone: true })
-    );
-    const collisionSourcePromise = collisionSourceSelection.file && !collisionSourceSelection.reuseVisibleModel ? this._assetLoader.loadFile(collisionSourceSelection.file, { clone: true }) : Promise.resolve(null);
-    Promise.all([Promise.all(promises), collisionSourcePromise]).then(([results, collisionSourceResult]) => {
-      if (loadGeneration !== this._loadGeneration) {
-        results.forEach((result) => disposeObjectResources(result.object ?? null));
-        if (collisionSourceResult?.object) {
-          disposeObjectResources(collisionSourceResult.object);
-        }
-        return;
-      }
-      this._object = results[0]?.object ?? null;
-      this._collisionSource = collisionSourceSelection.reuseVisibleModel ? this._object : collisionSourceResult?.object ?? this._object;
-      this._loadStatus = this._object ? "loaded" : "idle";
-      let meshCount = 0;
-      if (this._object) {
-        this._object.traverse((child) => {
-          if (child.isMesh) {
-            meshCount++;
-          }
-        });
-        this.group = new Group4();
-        this.group.add(this._object);
-        this.group.scale.copy(getActorScale(this.options));
-        this.applyMaterialOverrides();
-        this._animationDelegate = new AnimationDelegate(this._object);
-        void this._animationDelegate.loadAnimations(this.options.animations || []).then(() => {
-          if (loadGeneration !== this._loadGeneration) {
-            return;
-          }
-          this.dispatch("entity:animation:loaded", {
-            entityId: this.uuid,
-            animationCount: this.options.animations?.length || 0
-          });
-        });
-      }
-      this.dispatch("entity:model:loaded", {
-        entityId: this.uuid,
-        success: !!this._object,
-        meshCount
-      });
-    }).catch((error) => {
-      if (loadGeneration !== this._loadGeneration) {
-        return;
-      }
-      this._loadStatus = "idle";
-      console.error("Failed to load actor model", error);
-      this.dispatch("entity:model:loaded", {
-        entityId: this.uuid,
-        success: false,
-        meshCount: 0
-      });
-    });
-  }
-  applyMaterialOverrides() {
-    const materialOptions = this.options.material;
-    if (!materialOptions || !materialOptions.color && !materialOptions.path && materialOptions.opacity === void 0) {
-      return;
-    }
-    if (!this._object) {
-      return;
-    }
-    this._object.traverse((child) => {
-      if (!child.isMesh) {
-        return;
-      }
-      const mesh = child;
-      if (materialOptions.color) {
-        const newMaterial = new MeshStandardMaterial4({
-          color: materialOptions.color,
-          emissiveIntensity: 0.5,
-          lightMapIntensity: 0.5,
-          fog: true,
-          opacity: materialOptions.opacity ?? 1,
-          transparent: materialOptions.opacity !== void 0 && materialOptions.opacity < 1
-        });
-        mesh.castShadow = true;
-        mesh.receiveShadow = true;
-        mesh.material = newMaterial;
-        return;
-      }
-      if (materialOptions.opacity === void 0) {
-        return;
-      }
-      const applyOpacity = (material) => {
-        const clonedMaterial = material.clone();
-        if ("opacity" in clonedMaterial && "transparent" in clonedMaterial) {
-          const transparentMaterial = clonedMaterial;
-          transparentMaterial.opacity = materialOptions.opacity;
-          transparentMaterial.transparent = materialOptions.opacity < 1;
-          transparentMaterial.needsUpdate = true;
-        }
-        return clonedMaterial;
-      };
-      mesh.material = Array.isArray(mesh.material) ? mesh.material.map(applyOpacity) : applyOpacity(mesh.material);
-    });
-  }
-};
-function createActor(...args) {
-  return createEntity({
-    args,
-    defaultConfig: actorDefaults,
-    EntityClass: ZylemActor,
-    BuilderClass: ActorBuilder,
-    CollisionBuilderClass: ActorCollisionBuilder,
-    entityType: ZylemActor.type,
-    cloneFactory: (options) => createActor(options ?? {})
-  });
-}
-
-// src/lib/entities/text.ts
-import { Color as Color7, Group as Group5, Sprite as ThreeSprite2, SpriteMaterial as SpriteMaterial2, CanvasTexture, LinearFilter, Vector2 as Vector25, ClampToEdgeWrapping } from "three";
-var textDefaults = {
-  position: void 0,
-  text: "",
-  fontFamily: 'Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
-  fontSize: 18,
-  fontColor: "#FFFFFF",
-  backgroundColor: null,
-  padding: 4,
-  stickToViewport: true,
-  screenPosition: new Vector25(24, 24),
-  zDistance: 1
-};
-var TextBuilder = class extends EntityBuilder {
-  createEntity(options) {
-    return new ZylemText(options);
-  }
-};
-var TEXT_TYPE = /* @__PURE__ */ Symbol("Text");
-var ZylemText = class _ZylemText extends GameEntity {
-  static type = TEXT_TYPE;
-  _sprite = null;
-  _texture = null;
-  _canvas = null;
-  _ctx = null;
-  _cameraRef = null;
-  _lastCanvasW = 0;
-  _lastCanvasH = 0;
-  constructor(options) {
-    super();
-    this.options = { ...textDefaults, ...options };
-    this.prependSetup(this.textSetup.bind(this));
-    this.prependUpdate(this.textUpdate.bind(this));
-    this.onCleanup(this.textDestroy.bind(this));
-  }
-  create() {
-    this._sprite = null;
-    this._texture = null;
-    this._canvas = null;
-    this._ctx = null;
-    this._lastCanvasW = 0;
-    this._lastCanvasH = 0;
-    this.group = new Group5();
-    this.createSprite();
-    return super.create();
-  }
-  createSprite() {
-    this._canvas = document.createElement("canvas");
-    this._ctx = this._canvas.getContext("2d");
-    this._texture = new CanvasTexture(this._canvas);
-    this._texture.minFilter = LinearFilter;
-    this._texture.magFilter = LinearFilter;
-    const material = new SpriteMaterial2({
-      map: this._texture,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-      alphaTest: 0.5
-    });
-    this._sprite = new ThreeSprite2(material);
-    this.group?.add(this._sprite);
-    this.redrawText(this.options.text ?? "");
-  }
-  measureAndResizeCanvas(text, fontSize, fontFamily, padding) {
-    if (!this._canvas || !this._ctx) return { sizeChanged: false };
-    this._ctx.font = `${fontSize}px ${fontFamily}`;
-    const metrics = this._ctx.measureText(text);
-    const textWidth = Math.ceil(metrics.width);
-    const textHeight = Math.ceil(fontSize * 1.4);
-    const nextW = Math.max(2, textWidth + padding * 2);
-    const nextH = Math.max(2, textHeight + padding * 2);
-    const sizeChanged = nextW !== this._lastCanvasW || nextH !== this._lastCanvasH;
-    this._canvas.width = nextW;
-    this._canvas.height = nextH;
-    this._lastCanvasW = nextW;
-    this._lastCanvasH = nextH;
-    return { sizeChanged };
-  }
-  drawCenteredText(text, fontSize, fontFamily) {
-    if (!this._canvas || !this._ctx) return;
-    this._ctx.font = `${fontSize}px ${fontFamily}`;
-    this._ctx.textAlign = "center";
-    this._ctx.textBaseline = "middle";
-    this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
-    if (this.options.backgroundColor) {
-      this._ctx.fillStyle = this.toCssColor(this.options.backgroundColor);
-      this._ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);
-    }
-    this._ctx.fillStyle = this.toCssColor(this.options.fontColor ?? "#FFFFFF");
-    this._ctx.fillText(text, this._canvas.width / 2, this._canvas.height / 2);
-  }
-  updateTexture(sizeChanged) {
-    if (!this._texture || !this._canvas) return;
-    if (sizeChanged) {
-      this._texture.dispose();
-      this._texture = new CanvasTexture(this._canvas);
-      this._texture.minFilter = LinearFilter;
-      this._texture.magFilter = LinearFilter;
-      this._texture.wrapS = ClampToEdgeWrapping;
-      this._texture.wrapT = ClampToEdgeWrapping;
-    }
-    this._texture.image = this._canvas;
-    this._texture.needsUpdate = true;
-    if (this._sprite && this._sprite.material) {
-      this._sprite.material.map = this._texture;
-      this._sprite.material.needsUpdate = true;
-    }
-  }
-  redrawText(_text) {
-    if (!this._canvas || !this._ctx) return;
-    const fontSize = this.options.fontSize ?? 18;
-    const fontFamily = this.options.fontFamily ?? textDefaults.fontFamily;
-    const padding = this.options.padding ?? 4;
-    const { sizeChanged } = this.measureAndResizeCanvas(_text, fontSize, fontFamily, padding);
-    this.drawCenteredText(_text, fontSize, fontFamily);
-    this.updateTexture(Boolean(sizeChanged));
-    if (this.options.stickToViewport && this._cameraRef) {
-      this.updateStickyTransform();
-    }
-  }
-  toCssColor(color) {
-    if (typeof color === "string") return color;
-    const c = color instanceof Color7 ? color : new Color7(color);
-    return `#${c.getHexString()}`;
-  }
-  textSetup(params) {
-    this._cameraRef = params.camera;
-    if (this.options.stickToViewport && this._cameraRef) {
-      this._cameraRef.camera.add(this.group);
-      this.updateStickyTransform();
-    }
-  }
-  textUpdate(params) {
-    if (!this._sprite) return;
-    if (this.options.stickToViewport && this._cameraRef) {
-      this.updateStickyTransform();
-    }
-  }
-  getResolution() {
-    return {
-      width: this._cameraRef?.screenResolution.x ?? 1,
-      height: this._cameraRef?.screenResolution.y ?? 1
-    };
-  }
-  getScreenPixels(sp, width, height) {
-    const isPercentX = sp.x >= 0 && sp.x <= 1;
-    const isPercentY = sp.y >= 0 && sp.y <= 1;
-    return {
-      px: isPercentX ? sp.x * width : sp.x,
-      py: isPercentY ? sp.y * height : sp.y
-    };
-  }
-  computeWorldExtents(camera, zDist) {
-    let worldHalfW = 1;
-    let worldHalfH = 1;
-    if (camera.isPerspectiveCamera) {
-      const pc = camera;
-      const halfH = Math.tan(pc.fov * Math.PI / 180 / 2) * zDist;
-      const halfW = halfH * pc.aspect;
-      worldHalfW = halfW;
-      worldHalfH = halfH;
-    } else if (camera.isOrthographicCamera) {
-      const oc = camera;
-      worldHalfW = (oc.right - oc.left) / 2;
-      worldHalfH = (oc.top - oc.bottom) / 2;
-    }
-    return { worldHalfW, worldHalfH };
-  }
-  updateSpriteScale(worldHalfH, viewportHeight) {
-    if (!this._canvas || !this._sprite) return;
-    const planeH = worldHalfH * 2;
-    const unitsPerPixel = planeH / viewportHeight;
-    const pixelH = this._canvas.height;
-    const scaleY = Math.max(1e-4, pixelH * unitsPerPixel);
-    const aspect = this._canvas.width / this._canvas.height;
-    const scaleX = scaleY * aspect;
-    this._sprite.scale.set(scaleX, scaleY, 1);
-  }
-  updateStickyTransform() {
-    if (!this._sprite || !this._cameraRef) return;
-    const camera = this._cameraRef.camera;
-    const { width, height } = this.getResolution();
-    const sp = this.options.screenPosition ?? new Vector25(24, 24);
-    const { px, py } = this.getScreenPixels(sp, width, height);
-    const zDist = Math.max(1e-3, this.options.zDistance ?? 1);
-    const { worldHalfW, worldHalfH } = this.computeWorldExtents(camera, zDist);
-    const ndcX = px / width * 2 - 1;
-    const ndcY = 1 - py / height * 2;
-    const localX = ndcX * worldHalfW;
-    const localY = ndcY * worldHalfH;
-    this.group?.position.set(localX, localY, -zDist);
-    this.updateSpriteScale(worldHalfH, height);
-  }
-  updateText(_text) {
-    this.options.text = _text;
-    this.redrawText(_text);
-    if (this.options.stickToViewport && this._cameraRef) {
-      this.updateStickyTransform();
-    }
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    return {
-      ...baseInfo,
-      type: String(_ZylemText.type),
-      text: this.options.text ?? "",
-      sticky: this.options.stickToViewport
-    };
-  }
-  /**
-   * Dispose of Three.js resources when the entity is destroyed.
-   */
-  textDestroy() {
-    this._texture?.dispose();
-    if (this._sprite?.material) {
-      this._sprite.material.dispose();
-    }
-    if (this._sprite) {
-      this._sprite.removeFromParent();
-    }
-    this.group?.removeFromParent();
-    this._sprite = null;
-    this._texture = null;
-    this._canvas = null;
-    this._ctx = null;
-    this._cameraRef = null;
-  }
-};
-function createText(...args) {
-  return createEntity({
-    args,
-    defaultConfig: { ...textDefaults },
-    EntityClass: ZylemText,
-    BuilderClass: TextBuilder,
-    entityType: ZylemText.type,
-    cloneFactory: (options) => createText(options ?? {})
-  });
-}
-
-// src/lib/entities/rect.ts
-import { Color as Color8, Group as Group6, Sprite as ThreeSprite3, SpriteMaterial as SpriteMaterial3, CanvasTexture as CanvasTexture2, LinearFilter as LinearFilter2, Vector2 as Vector26, ClampToEdgeWrapping as ClampToEdgeWrapping2, ShaderMaterial as ShaderMaterial3, Mesh as Mesh7, PlaneGeometry as PlaneGeometry2, Vector3 as Vector314 } from "three";
-var rectDefaults = {
-  position: void 0,
-  width: 120,
-  height: 48,
-  fillColor: "#FFFFFF",
-  strokeColor: null,
-  strokeWidth: 0,
-  radius: 0,
-  padding: 0,
-  stickToViewport: true,
-  screenPosition: new Vector26(24, 24),
-  zDistance: 1,
-  anchor: new Vector26(0, 0)
-};
-var RectBuilder = class extends EntityBuilder {
-  createEntity(options) {
-    return new ZylemRect(options);
-  }
-};
-var RECT_TYPE = /* @__PURE__ */ Symbol("Rect");
-var ZylemRect = class _ZylemRect extends GameEntity {
-  static type = RECT_TYPE;
-  _sprite = null;
-  _mesh = null;
-  _texture = null;
-  _canvas = null;
-  _ctx = null;
-  _cameraRef = null;
-  _lastCanvasW = 0;
-  _lastCanvasH = 0;
-  constructor(options) {
-    super();
-    this.options = { ...rectDefaults, ...options };
-    this.group = new Group6();
-    this.createSprite();
-    this.prependSetup(this.rectSetup.bind(this));
-    this.prependUpdate(this.rectUpdate.bind(this));
-  }
-  createSprite() {
-    this._canvas = document.createElement("canvas");
-    this._ctx = this._canvas.getContext("2d");
-    this._texture = new CanvasTexture2(this._canvas);
-    this._texture.minFilter = LinearFilter2;
-    this._texture.magFilter = LinearFilter2;
-    const material = new SpriteMaterial3({
-      map: this._texture,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-      alphaTest: 0.5
-    });
-    this._sprite = new ThreeSprite3(material);
-    this.group?.add(this._sprite);
-    this.redrawRect();
-  }
-  redrawRect() {
-    if (!this._canvas || !this._ctx) return;
-    const width = Math.max(2, Math.floor(this.options.width ?? 120));
-    const height = Math.max(2, Math.floor(this.options.height ?? 48));
-    const padding = this.options.padding ?? 0;
-    const strokeWidth = this.options.strokeWidth ?? 0;
-    const totalW = width + padding * 2 + strokeWidth;
-    const totalH = height + padding * 2 + strokeWidth;
-    const nextW = Math.max(2, totalW);
-    const nextH = Math.max(2, totalH);
-    const sizeChanged = nextW !== this._lastCanvasW || nextH !== this._lastCanvasH;
-    this._canvas.width = nextW;
-    this._canvas.height = nextH;
-    this._lastCanvasW = nextW;
-    this._lastCanvasH = nextH;
-    this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
-    const radius = Math.max(0, this.options.radius ?? 0);
-    const rectX = Math.floor(padding + strokeWidth / 2);
-    const rectY = Math.floor(padding + strokeWidth / 2);
-    const rectW = Math.floor(width);
-    const rectH = Math.floor(height);
-    this._ctx.beginPath();
-    if (radius > 0) {
-      this.roundedRectPath(this._ctx, rectX, rectY, rectW, rectH, radius);
-    } else {
-      this._ctx.rect(rectX, rectY, rectW, rectH);
-    }
-    if (this.options.fillColor) {
-      this._ctx.fillStyle = this.toCssColor(this.options.fillColor);
-      this._ctx.fill();
-    }
-    if (this.options.strokeColor && strokeWidth > 0) {
-      this._ctx.lineWidth = strokeWidth;
-      this._ctx.strokeStyle = this.toCssColor(this.options.strokeColor);
-      this._ctx.stroke();
-    }
-    if (this._texture) {
-      if (sizeChanged) {
-        this._texture.dispose();
-        this._texture = new CanvasTexture2(this._canvas);
-        this._texture.minFilter = LinearFilter2;
-        this._texture.magFilter = LinearFilter2;
-        this._texture.wrapS = ClampToEdgeWrapping2;
-        this._texture.wrapT = ClampToEdgeWrapping2;
-        if (this._sprite && this._sprite.material instanceof ShaderMaterial3) {
-          const shader = this._sprite.material;
-          if (shader.uniforms?.tDiffuse) shader.uniforms.tDiffuse.value = this._texture;
-          if (shader.uniforms?.iResolution) shader.uniforms.iResolution.value.set(this._canvas.width, this._canvas.height, 1);
-        }
-      }
-      this._texture.image = this._canvas;
-      this._texture.needsUpdate = true;
-      if (this._sprite && this._sprite.material) {
-        this._sprite.material.map = this._texture;
-        this._sprite.material.needsUpdate = true;
-      }
-    }
-  }
-  getWidth() {
-    return this.options.width ?? 0;
-  }
-  getHeight() {
-    return this.options.height ?? 0;
-  }
-  roundedRectPath(ctx, x, y, w, h, r) {
-    const radius = Math.min(r, Math.floor(Math.min(w, h) / 2));
-    ctx.moveTo(x + radius, y);
-    ctx.lineTo(x + w - radius, y);
-    ctx.quadraticCurveTo(x + w, y, x + w, y + radius);
-    ctx.lineTo(x + w, y + h - radius);
-    ctx.quadraticCurveTo(x + w, y + h, x + w - radius, y + h);
-    ctx.lineTo(x + radius, y + h);
-    ctx.quadraticCurveTo(x, y + h, x, y + h - radius);
-    ctx.lineTo(x, y + radius);
-    ctx.quadraticCurveTo(x, y, x + radius, y);
-  }
-  toCssColor(color) {
-    if (typeof color === "string") return color;
-    const c = color instanceof Color8 ? color : new Color8(color);
-    return `#${c.getHexString()}`;
-  }
-  /**
-   * Get the viewport resolution from the renderer DOM element,
-   * falling back to the camera's screenResolution if the renderer
-   * is not available (e.g. when using the new RendererManager path).
-   */
-  getResolution() {
-    try {
-      const dom = this._cameraRef?.renderer?.domElement;
-      if (dom) {
-        return { width: dom.clientWidth || 1, height: dom.clientHeight || 1 };
-      }
-    } catch {
-    }
-    return {
-      width: this._cameraRef?.screenResolution?.x ?? 1,
-      height: this._cameraRef?.screenResolution?.y ?? 1
-    };
-  }
-  rectSetup(params) {
-    this._cameraRef = params.camera;
-    if (this.options.stickToViewport && this._cameraRef) {
-      this._cameraRef.camera.add(this.group);
-    }
-    if (this.materials?.length && this._sprite) {
-      const mat = this.materials[0];
-      if (mat instanceof ShaderMaterial3) {
-        mat.transparent = true;
-        mat.depthTest = false;
-        mat.depthWrite = false;
-        if (this._texture) {
-          if (mat.uniforms?.tDiffuse) mat.uniforms.tDiffuse.value = this._texture;
-          if (mat.uniforms?.iResolution && this._canvas) mat.uniforms.iResolution.value.set(this._canvas.width, this._canvas.height, 1);
-        }
-        this._mesh = new Mesh7(new PlaneGeometry2(1, 1), mat);
-        this.group?.add(this._mesh);
-        this._sprite.visible = false;
-      }
-    }
-  }
-  rectUpdate(params) {
-    if (!this._sprite) return;
-    if (this._cameraRef && this.options.bounds) {
-      const screen = this.computeScreenBoundsFromOptions(this.options.bounds);
-      if (screen) {
-        const { x, y, width, height } = screen;
-        const desiredW = Math.max(2, Math.floor(width));
-        const desiredH = Math.max(2, Math.floor(height));
-        const changed = desiredW !== (this.options.width ?? 0) || desiredH !== (this.options.height ?? 0);
-        this.options.screenPosition = new Vector26(Math.floor(x), Math.floor(y));
-        this.options.width = desiredW;
-        this.options.height = desiredH;
-        this.options.anchor = new Vector26(0, 0);
-        if (changed) {
-          this.redrawRect();
-        }
-      }
-    }
-    if (this.options.stickToViewport && this._cameraRef) {
-      this.updateStickyTransform();
-    }
-  }
-  updateStickyTransform() {
-    if (!this._sprite || !this._cameraRef) return;
-    const camera = this._cameraRef.camera;
-    const { width, height } = this.getResolution();
-    const px = (this.options.screenPosition ?? new Vector26(24, 24)).x;
-    const py = (this.options.screenPosition ?? new Vector26(24, 24)).y;
-    const zDist = Math.max(1e-3, this.options.zDistance ?? 1);
-    let worldHalfW = 1;
-    let worldHalfH = 1;
-    if (camera.isPerspectiveCamera) {
-      const pc = camera;
-      const halfH = Math.tan(pc.fov * Math.PI / 180 / 2) * zDist;
-      const halfW = halfH * pc.aspect;
-      worldHalfW = halfW;
-      worldHalfH = halfH;
-    } else if (camera.isOrthographicCamera) {
-      const oc = camera;
-      worldHalfW = (oc.right - oc.left) / 2;
-      worldHalfH = (oc.top - oc.bottom) / 2;
-    }
-    const ndcX = px / width * 2 - 1;
-    const ndcY = 1 - py / height * 2;
-    const localX = ndcX * worldHalfW;
-    const localY = ndcY * worldHalfH;
-    let scaleX = 1;
-    let scaleY = 1;
-    if (this._canvas) {
-      const planeH = worldHalfH * 2;
-      const unitsPerPixel = planeH / height;
-      const pixelH = this._canvas.height;
-      scaleY = Math.max(1e-4, pixelH * unitsPerPixel);
-      const aspect = this._canvas.width / this._canvas.height;
-      scaleX = scaleY * aspect;
-      this._sprite.scale.set(scaleX, scaleY, 1);
-      if (this._mesh) this._mesh.scale.set(scaleX, scaleY, 1);
-    }
-    const anchor = this.options.anchor ?? new Vector26(0, 0);
-    const ax = Math.min(100, Math.max(0, anchor.x)) / 100;
-    const ay = Math.min(100, Math.max(0, anchor.y)) / 100;
-    const offsetX = (0.5 - ax) * scaleX;
-    const offsetY = (ay - 0.5) * scaleY;
-    this.group?.position.set(localX + offsetX, localY + offsetY, -zDist);
-  }
-  worldToScreen(point) {
-    if (!this._cameraRef) return { x: 0, y: 0 };
-    const camera = this._cameraRef.camera;
-    const { width, height } = this.getResolution();
-    const v = point.clone().project(camera);
-    const x = (v.x + 1) / 2 * width;
-    const y = (1 - v.y) / 2 * height;
-    return { x, y };
-  }
-  computeScreenBoundsFromOptions(bounds) {
-    if (!this._cameraRef) return null;
-    if (bounds.screen) {
-      return { ...bounds.screen };
-    }
-    if (bounds.world) {
-      const { left, right, top, bottom, z = 0 } = bounds.world;
-      const tl = this.worldToScreen(new Vector314(left, top, z));
-      const br = this.worldToScreen(new Vector314(right, bottom, z));
-      const x = Math.min(tl.x, br.x);
-      const y = Math.min(tl.y, br.y);
-      const width = Math.abs(br.x - tl.x);
-      const height = Math.abs(br.y - tl.y);
-      return { x, y, width, height };
-    }
-    return null;
-  }
-  updateRect(options) {
-    this.options = { ...this.options, ...options };
-    this.redrawRect();
-    if (this.options.stickToViewport && this._cameraRef) {
-      this.updateStickyTransform();
-    }
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    return {
-      ...baseInfo,
-      type: String(_ZylemRect.type),
-      width: this.options.width ?? 0,
-      height: this.options.height ?? 0,
-      sticky: this.options.stickToViewport
-    };
-  }
-};
-function createRect(...args) {
-  return createEntity({
-    args,
-    defaultConfig: { ...rectDefaults },
-    EntityClass: ZylemRect,
-    BuilderClass: RectBuilder,
-    entityType: ZylemRect.type,
-    cloneFactory: (options) => createRect(options ?? {})
-  });
-}
-
-// src/lib/entities/cone.ts
-var coneDefaults = {
-  ...commonDefaults,
-  radius: 1,
-  height: 2,
-  radialSegments: 32
-};
-var CONE_TYPE = /* @__PURE__ */ Symbol("Cone");
-var ZylemCone = class _ZylemCone extends GameEntity {
-  static type = CONE_TYPE;
-  constructor(options) {
-    super();
-    this.options = { ...coneDefaults, ...options };
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    const radius = this.options.radius ?? 1;
-    const height = this.options.height ?? 2;
-    return {
-      ...baseInfo,
-      type: String(_ZylemCone.type),
-      radius: radius.toFixed(2),
-      height: height.toFixed(2)
-    };
-  }
-};
-function createCone(...args) {
-  const options = mergeArgs(args, coneDefaults);
-  const entity = new ZylemCone(options);
-  entity.add(
-    coneMesh({
-      radius: options.radius,
-      height: options.height,
-      radialSegments: options.radialSegments,
-      material: options.material,
-      color: options.color
-    }),
-    coneCollision({
-      radius: options.radius,
-      height: options.height,
-      static: options.collision?.static,
-      sensor: options.collision?.sensor,
-      collisionType: options.collisionType,
-      collisionFilter: options.collisionFilter
-    })
-  );
-  return finalizeEntityCloneSupport(
-    entity,
-    (cloneOptions) => createCone(cloneOptions ?? {})
-  );
-}
-
-// src/lib/entities/pyramid.ts
-var pyramidDefaults = {
-  ...commonDefaults,
-  radius: 1,
-  height: 2
-};
-var PYRAMID_TYPE = /* @__PURE__ */ Symbol("Pyramid");
-var ZylemPyramid = class _ZylemPyramid extends GameEntity {
-  static type = PYRAMID_TYPE;
-  constructor(options) {
-    super();
-    this.options = { ...pyramidDefaults, ...options };
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    const radius = this.options.radius ?? 1;
-    const height = this.options.height ?? 2;
-    return {
-      ...baseInfo,
-      type: String(_ZylemPyramid.type),
-      radius: radius.toFixed(2),
-      height: height.toFixed(2)
-    };
-  }
-};
-function createPyramid(...args) {
-  const options = mergeArgs(args, pyramidDefaults);
-  const entity = new ZylemPyramid(options);
-  entity.add(
-    pyramidMesh({
-      radius: options.radius,
-      height: options.height,
-      material: options.material,
-      color: options.color
-    }),
-    pyramidCollision({
-      radius: options.radius,
-      height: options.height,
-      static: options.collision?.static,
-      sensor: options.collision?.sensor,
-      collisionType: options.collisionType,
-      collisionFilter: options.collisionFilter
-    })
-  );
-  return finalizeEntityCloneSupport(
-    entity,
-    (cloneOptions) => createPyramid(cloneOptions ?? {})
-  );
-}
-
-// src/lib/entities/cylinder.ts
-var cylinderDefaults = {
-  ...commonDefaults,
-  radiusTop: 1,
-  radiusBottom: 1,
-  height: 2,
-  radialSegments: 32
-};
-var CYLINDER_TYPE = /* @__PURE__ */ Symbol("Cylinder");
-var ZylemCylinder = class _ZylemCylinder extends GameEntity {
-  static type = CYLINDER_TYPE;
-  constructor(options) {
-    super();
-    this.options = { ...cylinderDefaults, ...options };
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    const radiusTop = this.options.radiusTop ?? 1;
-    const radiusBottom = this.options.radiusBottom ?? 1;
-    const height = this.options.height ?? 2;
-    return {
-      ...baseInfo,
-      type: String(_ZylemCylinder.type),
-      radiusTop: radiusTop.toFixed(2),
-      radiusBottom: radiusBottom.toFixed(2),
-      height: height.toFixed(2)
-    };
-  }
-};
-function createCylinder(...args) {
-  const options = mergeArgs(args, cylinderDefaults);
-  const entity = new ZylemCylinder(options);
-  entity.add(
-    cylinderMesh({
-      radiusTop: options.radiusTop,
-      radiusBottom: options.radiusBottom,
-      height: options.height,
-      radialSegments: options.radialSegments,
-      material: options.material,
-      color: options.color
-    }),
-    cylinderCollision({
-      radiusTop: options.radiusTop,
-      radiusBottom: options.radiusBottom,
-      height: options.height,
-      static: options.collision?.static,
-      sensor: options.collision?.sensor,
-      collisionType: options.collisionType,
-      collisionFilter: options.collisionFilter
-    })
-  );
-  return finalizeEntityCloneSupport(
-    entity,
-    (cloneOptions) => createCylinder(cloneOptions ?? {})
-  );
-}
-
-// src/lib/entities/pill.ts
-var pillDefaults = {
-  ...commonDefaults,
-  radius: 0.5,
-  length: 1,
-  capSegments: 10,
-  radialSegments: 20
-};
-var PILL_TYPE = /* @__PURE__ */ Symbol("Pill");
-var ZylemPill = class _ZylemPill extends GameEntity {
-  static type = PILL_TYPE;
-  constructor(options) {
-    super();
-    this.options = { ...pillDefaults, ...options };
-  }
-  buildInfo() {
-    const delegate = new DebugDelegate(this);
-    const baseInfo = delegate.buildDebugInfo();
-    const radius = this.options.radius ?? 0.5;
-    const length = this.options.length ?? 1;
-    return {
-      ...baseInfo,
-      type: String(_ZylemPill.type),
-      radius: radius.toFixed(2),
-      length: length.toFixed(2)
-    };
-  }
-};
-function createPill(...args) {
-  const options = mergeArgs(args, pillDefaults);
-  const entity = new ZylemPill(options);
-  entity.add(
-    pillMesh({
-      radius: options.radius,
-      length: options.length,
-      capSegments: options.capSegments,
-      radialSegments: options.radialSegments,
-      material: options.material,
-      color: options.color
-    }),
-    pillCollision({
-      radius: options.radius,
-      length: options.length,
-      static: options.collision?.static,
-      sensor: options.collision?.sensor,
-      collisionType: options.collisionType,
-      collisionFilter: options.collisionFilter
-    })
-  );
-  return finalizeEntityCloneSupport(
-    entity,
-    (cloneOptions) => createPill(cloneOptions ?? {})
-  );
-}
-export {
-  ZylemBox,
-  createActor,
-  createBox,
-  createCone,
-  createCylinder,
-  createPill,
-  createPlane,
-  createPyramid,
-  createRect,
-  createSphere,
-  createSprite,
-  createText,
-  createZone
-};
-//# sourceMappingURL=entities.js.map