@zylem/game-lib 0.6.3 → 0.7.0

package/dist/entities.js

@@ -1,4069 +0,0 @@
-// src/lib/entities/box.ts
-import { Vector3 as Vector38 } 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: []
-  };
-  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);
-    return this;
-  }
-  /**
-   * Add loaded callbacks to be executed in order during nodeLoaded
-   */
-  onLoaded(...callbacks) {
-    this.lifecycleCallbacks.loaded.push(...callbacks);
-    return this;
-  }
-  /**
-   * Add update callbacks to be executed in order during nodeUpdate
-   */
-  onUpdate(...callbacks) {
-    this.lifecycleCallbacks.update.push(...callbacks);
-    return this;
-  }
-  /**
-   * Add destroy callbacks to be executed in order during nodeDestroy
-   */
-  onDestroy(...callbacks) {
-    this.lifecycleCallbacks.destroy.push(...callbacks);
-    return this;
-  }
-  /**
-   * Add cleanup callbacks to be executed in order during nodeCleanup
-   */
-  onCleanup(...callbacks) {
-    this.lifecycleCallbacks.cleanup.push(...callbacks);
-    return this;
-  }
-  /**
-   * Prepend setup callbacks (run before existing ones)
-   */
-  prependSetup(...callbacks) {
-    this.lifecycleCallbacks.setup.unshift(...callbacks);
-    return this;
-  }
-  /**
-   * Prepend update callbacks (run before existing ones)
-   */
-  prependUpdate(...callbacks) {
-    this.lifecycleCallbacks.update.unshift(...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;
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // 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 };
-  }
-};
-
-// ../../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 },
-    dirty: {
-      position: false,
-      rotation: false,
-      velocity: 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";
-function moveX(entity, delta) {
-  if (!entity.transformStore) return;
-  entity.transformStore.velocity.x = delta;
-  entity.transformStore.dirty.velocity = true;
-}
-function moveY(entity, delta) {
-  if (!entity.transformStore) return;
-  entity.transformStore.velocity.y = delta;
-  entity.transformStore.dirty.velocity = true;
-}
-function moveZ(entity, delta) {
-  if (!entity.transformStore) return;
-  entity.transformStore.velocity.z = delta;
-  entity.transformStore.dirty.velocity = true;
-}
-function moveXY(entity, deltaX, deltaY) {
-  if (!entity.transformStore) return;
-  entity.transformStore.velocity.x = deltaX;
-  entity.transformStore.velocity.y = deltaY;
-  entity.transformStore.dirty.velocity = true;
-}
-function moveXZ(entity, deltaX, deltaZ) {
-  if (!entity.transformStore) return;
-  entity.transformStore.velocity.x = deltaX;
-  entity.transformStore.velocity.z = deltaZ;
-  entity.transformStore.dirty.velocity = true;
-}
-function move(entity, vector) {
-  if (!entity.transformStore) return;
-  entity.transformStore.velocity.x += vector.x;
-  entity.transformStore.velocity.y += vector.y;
-  entity.transformStore.velocity.z += vector.z;
-  entity.transformStore.dirty.velocity = true;
-}
-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 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.group) return;
-  const euler = new Euler(rotation2.x, rotation2.y, rotation2.z);
-  entity.group.setRotationFromEuler(euler);
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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 Vector34 } 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/entities/parts/collision-factories.ts
-function isCollisionComponent(obj) {
-  return obj && obj.__kind === "collision";
-}
-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) {
-  applyCollisionOptions(colliderDesc, opts);
-  return {
-    __kind: "collision",
-    bodyDesc: buildBodyDesc(opts.static ?? false),
-    colliderDesc
-  };
-}
-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);
-  return makeComponent(desc, opts);
-}
-function sphereCollision(opts = {}) {
-  const desc = ColliderDesc2.ball(opts.radius ?? 1);
-  return makeComponent(desc, opts);
-}
-function coneCollision(opts = {}) {
-  const radius = opts.radius ?? 1;
-  const height = opts.height ?? 2;
-  const desc = ColliderDesc2.cone(height / 2, radius);
-  return makeComponent(desc, opts);
-}
-function pyramidCollision(opts = {}) {
-  const radius = opts.radius ?? 1;
-  const height = opts.height ?? 2;
-  const desc = ColliderDesc2.cone(height / 2, radius);
-  return makeComponent(desc, opts);
-}
-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);
-  return makeComponent(desc, opts);
-}
-function pillCollision(opts = {}) {
-  const radius = opts.radius ?? 0.5;
-  const length = opts.length ?? 1;
-  const desc = ColliderDesc2.capsule(length / 2, radius);
-  return makeComponent(desc, opts);
-}
-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;
-  return makeComponent(desc, { ...opts, static: opts.static ?? true, sensor: true });
-}
-
-// src/lib/entities/common.ts
-import { Color, Vector3 as Vector35 } 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 Vector35(0, 0, 0),
-  material: {
-    color: new Color("#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
-var GameEntity = class extends BaseNode {
-  behaviors = [];
-  group;
-  mesh;
-  materials;
-  bodyDesc = null;
-  body = null;
-  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: []
-  };
-  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 = [];
-  // 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);
-      } else if (isCollisionComponent(component)) {
-        this.addCollisionComponent(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);
-    }
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // 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;
-    store.dirty.velocity = false;
-    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;
-      store.dirty.velocity = false;
-      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;
-  }
-  /**
-   * Add collision callbacks
-   */
-  onCollision(...callbacks) {
-    const existing = this.collisionDelegate.collision ?? [];
-    this.collisionDelegate.collision = [...existing, ...callbacks];
-    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;
-  }
-  /**
-   * 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) {
-    if (this.collisionDelegate.collision?.length) {
-      const callbacks = this.collisionDelegate.collision;
-      callbacks.forEach((callback) => {
-        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();
-  }
-};
-
-// 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 Mesh2,
-  MeshStandardMaterial as MeshStandardMaterial3,
-  SphereGeometry
-} from "three";
-
-// src/lib/graphics/material.ts
-import { Color as Color3, Vector2 as Vector22, Vector3 as Vector37 } 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";
-var GLTFLoaderAdapter = class {
-  loader;
-  constructor() {
-    this.loader = new GLTFLoader();
-  }
-  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: result.object.clone(),
-      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: result.object.clone(),
-      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: result.object.clone(),
-      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();
-  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, useTSL } = options;
-    const shouldUseTSL = useTSL ?? this.useTSL;
-    if (shader) {
-      if (isTSLShader(shader)) {
-        this.setTSLShader(shader);
-      } else if (isGLSLShader(shader)) {
-        if (shouldUseTSL) {
-          console.warn("MaterialBuilder: GLSL shader provided but TSL mode requested. Using GLSL.");
-        }
-        this.setShader(shader);
-      }
-    } else if (path) {
-      this.setTexture(path, repeat, shouldUseTSL);
-    }
-    if (color) {
-      this.withColor(color, shouldUseTSL);
-    }
-    if (this.materials.length === 0) {
-      this.setColor(new Color3("#ffffff"), shouldUseTSL);
-    }
-    if (normalMap && this.materials.length > 0) {
-      this.setNormalMap(normalMap, repeat);
-    }
-    this.batchMaterial(options, entityType);
-  }
-  withColor(color, useTSL = false) {
-    this.setColor(color, useTSL);
-    return this;
-  }
-  withShader(shader) {
-    this.setShader(shader);
-    return this;
-  }
-  withTSLShader(shader) {
-    this.setTSLShader(shader);
-    return this;
-  }
-  /**
-   * Set texture - loads in background (deferred).
-   * Material is created immediately with null map, texture applies when loaded.
-   */
-  setTexture(texturePath = null, repeat = new Vector22(1, 1), useTSL = false) {
-    if (!texturePath) {
-      return;
-    }
-    if (useTSL) {
-      const material = new MeshStandardNodeMaterial();
-      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
-      });
-      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 Vector22(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) {
-    if (useTSL) {
-      const material = new MeshStandardNodeMaterial();
-      material.color = color;
-      this.materials.push(material);
-    } else {
-      const material = new MeshStandardMaterial2({
-        color,
-        emissiveIntensity: 0.5,
-        lightMapIntensity: 0.5,
-        fog: true
-      });
-      this.materials.push(material);
-    }
-  }
-  /**
-   * Set GLSL shader (WebGL only)
-   */
-  setShader(customShader) {
-    const { fragment: fragment2, vertex } = customShader ?? standardShader;
-    const shader = new ShaderMaterial2({
-      uniforms: {
-        iResolution: { value: new Vector37(1, 1, 1) },
-        iTime: { value: 0 },
-        tDiffuse: { value: null },
-        tDepth: { value: null },
-        tNormal: { value: null },
-        normalMap: { value: null },
-        lightDir: { value: new Vector37(1, 1, 1) },
-        normalStrength: { value: 1 }
-      },
-      vertexShader: vertex,
-      fragmentShader: fragment2,
-      transparent: true
-    });
-    this.materials.push(shader);
-  }
-  /**
-   * Set TSL shader (WebGPU compatible)
-   */
-  setTSLShader(tslShader) {
-    const material = new MeshBasicNodeMaterial();
-    material.colorNode = tslShader.colorNode;
-    if (tslShader.transparent) {
-      material.transparent = true;
-    }
-    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 Mesh2(geometry, materials.at(-1)), opts);
-}
-function sphereMesh(opts = {}) {
-  const geometry = new SphereGeometry(opts.radius ?? 1);
-  const materials = buildMaterial(opts);
-  return finalizeMesh(new Mesh2(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 Mesh2(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 Mesh2(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 Mesh2(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 Mesh2(geometry, materials.at(-1)), opts);
-}
-
-// src/lib/entities/box.ts
-var boxDefaults = {
-  ...commonDefaults,
-  size: new Vector38(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 entity;
-}
-
-// 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 entity;
-}
-
-// 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 Vector39 } from "three";
-import {
-  TextureLoader as TextureLoader2,
-  SpriteMaterial,
-  Sprite as ThreeSprite
-} from "three";
-
-// src/lib/entities/builder.ts
-import { BufferGeometry as BufferGeometry2, Mesh as Mesh4, Color as Color4 } from "three";
-
-// src/lib/graphics/mesh.ts
-import { Mesh as Mesh3 } 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 Mesh3(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 Mesh4) {
-        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 Color4) {
-      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 Mesh4 && 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
-  } = 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 builder.build();
-}
-
-// src/lib/entities/sprite.ts
-var spriteDefaults = {
-  ...commonDefaults,
-  size: new Vector39(1, 1, 1),
-  images: [],
-  animations: []
-};
-var SpriteCollisionBuilder = class extends EntityCollisionBuilder {
-  collider(options) {
-    const size = options.collisionSize || options.size || new Vector39(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.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();
-    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();
-      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;
-      }
-    }
-  }
-  spriteUpdate(params) {
-    this.sprites.forEach((_sprite) => {
-      if (_sprite.material) {
-        const q = this.body?.rotation();
-        if (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);
-      }
-    });
-  }
-  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
-  });
-}
-
-// src/lib/entities/plane.ts
-import { ColliderDesc as ColliderDesc4 } from "@dimforge/rapier3d-compat";
-import { PlaneGeometry, Vector2 as Vector23, Vector3 as Vector310 } 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 Vector23(10, 10),
-  repeat: new Vector23(1, 1),
-  collision: {
-    static: true
-  },
-  subdivisions: DEFAULT_SUBDIVISIONS,
-  randomizeHeight: false,
-  heightScale: 1
-};
-var PlaneCollisionBuilder = class extends EntityCollisionBuilder {
-  collider(options) {
-    const tile = options.tile ?? new Vector23(1, 1);
-    const subdivisions = options.subdivisions ?? DEFAULT_SUBDIVISIONS;
-    const size = new Vector310(tile.x, 1, tile.y);
-    const heightData = options._builders?.meshBuilder?.heightData;
-    const scale2 = new Vector310(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 Vector23(1, 1);
-    const subdivisions = options.subdivisions ?? DEFAULT_SUBDIVISIONS;
-    this.subdivisions = subdivisions;
-    const size = new Vector310(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
-  });
-}
-
-// src/lib/entities/zone.ts
-import { Vector3 as Vector311 } 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 Vector311(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 entity;
-}
-
-// src/lib/entities/actor.ts
-import { ActiveCollisionTypes as ActiveCollisionTypes3, ColliderDesc as ColliderDesc5 } from "@dimforge/rapier3d-compat";
-import { MeshStandardMaterial as MeshStandardMaterial4, Group as Group4, Vector3 as Vector312 } 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) {
-    const ext = file.split(".").pop()?.toLowerCase();
-    switch (ext) {
-      case "fbx": {
-        const result = await assetManager.loadFBX(file);
-        return {
-          object: result.object,
-          animation: result.animations?.[0]
-        };
-      }
-      case "gltf":
-      case "glb": {
-        const result = await assetManager.loadGLTF(file);
-        return {
-          object: result.object,
-          gltf: result.gltf
-        };
-      }
-      case "obj": {
-        const result = await assetManager.loadOBJ(file);
-        return {
-          object: result.object
-        };
-      }
-      default:
-        throw new Error(`Unsupported file type: ${file}`);
-    }
-  }
-};
-
-// src/lib/entities/delegates/animation.ts
-import {
-  AnimationMixer,
-  LoopOnce,
-  LoopRepeat
-} from "three";
-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 loadedAnimations = [];
-    results.forEach((result, i) => {
-      if (result.animation) {
-        loadedAnimations.push({
-          key: animations[i].key || i.toString(),
-          clip: result.animation
-        });
-      }
-    });
-    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,
-  collision: {
-    static: false,
-    size: new Vector312(0.5, 0.5, 0.5),
-    position: new Vector312(0, 0, 0)
-  },
-  material: {
-    shader: standardShader
-  },
-  animations: [],
-  models: [],
-  collisionShape: "capsule"
-};
-var ActorCollisionBuilder = class extends EntityCollisionBuilder {
-  objectModel = null;
-  collisionShape = "capsule";
-  constructor(data) {
-    super();
-    this.objectModel = data.objectModel;
-    this.collisionShape = data.collisionShape ?? "capsule";
-  }
-  collider(options) {
-    if (this.collisionShape === "model") {
-      return this.createColliderFromModel(this.objectModel, options);
-    }
-    return this.createCapsuleCollider(options);
-  }
-  /**
-   * Create a capsule collider based on size options (character controller style).
-   */
-  createCapsuleCollider(options) {
-    const size = options.collision?.size ?? options.size ?? { x: 0.5, y: 1, z: 0.5 };
-    const halfHeight = size.y || 1;
-    const radius = Math.max(size.x || 0.5, size.z || 0.5);
-    let colliderDesc = ColliderDesc5.capsule(halfHeight, radius);
-    colliderDesc.setSensor(false);
-    colliderDesc.setTranslation(0, halfHeight + radius, 0);
-    colliderDesc.activeCollisionTypes = ActiveCollisionTypes3.DEFAULT;
-    return colliderDesc;
-  }
-  /**
-   * Create a collider based on model geometry (works with Mesh and SkinnedMesh).
-   * If collision.size and collision.position are provided, use those instead of computing from geometry.
-   */
-  createColliderFromModel(objectModel, options) {
-    const collisionSize = options.collision?.size;
-    const collisionPosition = options.collision?.position;
-    if (collisionSize) {
-      const halfWidth = collisionSize.x / 2;
-      const halfHeight = collisionSize.y / 2;
-      const halfDepth = collisionSize.z / 2;
-      let colliderDesc2 = ColliderDesc5.cuboid(halfWidth, halfHeight, halfDepth);
-      colliderDesc2.setSensor(false);
-      const posX = collisionPosition ? collisionPosition.x : 0;
-      const posY = collisionPosition ? collisionPosition.y : halfHeight;
-      const posZ = collisionPosition ? collisionPosition.z : 0;
-      colliderDesc2.setTranslation(posX, posY, posZ);
-      colliderDesc2.activeCollisionTypes = ActiveCollisionTypes3.DEFAULT;
-      return colliderDesc2;
-    }
-    if (!objectModel) return this.createCapsuleCollider(options);
-    let foundGeometry = null;
-    objectModel.traverse((child) => {
-      if (!foundGeometry && child.isMesh) {
-        foundGeometry = child.geometry;
-      }
-    });
-    if (!foundGeometry) return this.createCapsuleCollider(options);
-    const geometry = foundGeometry;
-    geometry.computeBoundingBox();
-    const box = geometry.boundingBox;
-    if (!box) return this.createCapsuleCollider(options);
-    const height = box.max.y - box.min.y;
-    const width = box.max.x - box.min.x;
-    const depth = box.max.z - box.min.z;
-    let colliderDesc = ColliderDesc5.cuboid(width / 2, height / 2, depth / 2);
-    colliderDesc.setSensor(false);
-    const centerY = (box.max.y + box.min.y) / 2;
-    colliderDesc.setTranslation(0, centerY, 0);
-    colliderDesc.activeCollisionTypes = ActiveCollisionTypes3.DEFAULT;
-    return colliderDesc;
-  }
-};
-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;
-  _animationDelegate = null;
-  _modelFileNames = [];
-  _assetLoader = new EntityAssetLoader();
-  controlledRotation = false;
-  constructor(options) {
-    super();
-    this.options = { ...actorDefaults, ...options };
-    this.prependUpdate(this.actorUpdate.bind(this));
-    this.controlledRotation = true;
-  }
-  /**
-   * Initiates model and animation loading in background (deferred).
-   * Call returns immediately; assets will be ready on subsequent updates.
-   */
-  load() {
-    this._modelFileNames = this.options.models || [];
-    this.loadModelsDeferred();
-  }
-  /**
-   * Returns current data synchronously.
-   * May return null values if loading is still in progress.
-   */
-  data() {
-    return {
-      animations: this._animationDelegate?.animations,
-      objectModel: this._object,
-      collisionShape: this.options.collisionShape
-    };
-  }
-  actorUpdate(params) {
-    this._animationDelegate?.update(params.delta);
-  }
-  /**
-   * Clean up actor resources including animations, models, and groups
-   */
-  actorDestroy() {
-    if (this._animationDelegate) {
-      this._animationDelegate.dispose();
-      this._animationDelegate = null;
-    }
-    if (this._object) {
-      this._object.traverse((child) => {
-        if (child.isMesh) {
-          const mesh = child;
-          mesh.geometry?.dispose();
-          if (Array.isArray(mesh.material)) {
-            mesh.material.forEach((m) => m.dispose());
-          } else if (mesh.material) {
-            mesh.material.dispose();
-          }
-        }
-      });
-      this._object = null;
-    }
-    if (this.group) {
-      this.group.clear();
-      this.group = null;
-    }
-    this._modelFileNames = [];
-  }
-  /**
-   * Deferred loading - starts async load and updates entity when complete.
-   * Called by synchronous load() method.
-   */
-  loadModelsDeferred() {
-    if (this._modelFileNames.length === 0) return;
-    this.dispatch("entity:model:loading", {
-      entityId: this.uuid,
-      files: this._modelFileNames
-    });
-    const promises = this._modelFileNames.map((file) => this._assetLoader.loadFile(file));
-    Promise.all(promises).then((results) => {
-      if (results[0]?.object) {
-        this._object = results[0].object;
-      }
-      let meshCount = 0;
-      if (this._object) {
-        this._object.traverse((child) => {
-          if (child.isMesh) meshCount++;
-        });
-        this.group = new Group4();
-        this.group.attach(this._object);
-        this.group.scale.set(
-          this.options.scale?.x || 1,
-          this.options.scale?.y || 1,
-          this.options.scale?.z || 1
-        );
-        this.applyMaterialOverrides();
-        this._animationDelegate = new AnimationDelegate(this._object);
-        this._animationDelegate.loadAnimations(this.options.animations || []).then(() => {
-          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
-      });
-    });
-  }
-  playAnimation(animationOptions) {
-    this._animationDelegate?.playAnimation(animationOptions);
-  }
-  /**
-   * Apply material overrides from options to all meshes in the loaded model.
-   * Only applies if material options are explicitly specified (not just defaults).
-   */
-  applyMaterialOverrides() {
-    const materialOptions = this.options.material;
-    if (!materialOptions || !materialOptions.color && !materialOptions.path) {
-      return;
-    }
-    if (!this._object) return;
-    this._object.traverse((child) => {
-      if (child.isMesh) {
-        const mesh = child;
-        if (materialOptions.color) {
-          const newMaterial = new MeshStandardMaterial4({
-            color: materialOptions.color,
-            emissiveIntensity: 0.5,
-            lightMapIntensity: 0.5,
-            fog: true
-          });
-          mesh.castShadow = true;
-          mesh.receiveShadow = true;
-          mesh.material = newMaterial;
-        }
-      }
-    });
-  }
-  get object() {
-    return this._object;
-  }
-  /**
-   * Provide custom debug information for the actor
-   * This will be merged with the default debug information
-   */
-  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"
-    };
-    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) {
-          meshCount++;
-          const geometry = child.geometry;
-          if (geometry && geometry.attributes.position) {
-            vertexCount += geometry.attributes.position.count;
-          }
-        }
-      });
-      debugInfo.meshCount = meshCount;
-      debugInfo.vertexCount = vertexCount;
-    }
-    return debugInfo;
-  }
-};
-function createActor(...args) {
-  return createEntity({
-    args,
-    defaultConfig: actorDefaults,
-    EntityClass: ZylemActor,
-    BuilderClass: ActorBuilder,
-    CollisionBuilderClass: ActorCollisionBuilder,
-    entityType: ZylemActor.type
-  });
-}
-
-// src/lib/entities/text.ts
-import { Color as Color6, Group as Group5, Sprite as ThreeSprite2, SpriteMaterial as SpriteMaterial2, CanvasTexture, LinearFilter, Vector2 as Vector24, 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 Vector24(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 Color6 ? color : new Color6(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 Vector24(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
-  });
-}
-
-// src/lib/entities/rect.ts
-import { Color as Color7, Group as Group6, Sprite as ThreeSprite3, SpriteMaterial as SpriteMaterial3, CanvasTexture as CanvasTexture2, LinearFilter as LinearFilter2, Vector2 as Vector25, ClampToEdgeWrapping as ClampToEdgeWrapping2, ShaderMaterial as ShaderMaterial3, Mesh as Mesh6, PlaneGeometry as PlaneGeometry2, Vector3 as Vector313 } 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 Vector25(24, 24),
-  zDistance: 1,
-  anchor: new Vector25(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 Color7 ? color : new Color7(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 Mesh6(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 Vector25(Math.floor(x), Math.floor(y));
-        this.options.width = desiredW;
-        this.options.height = desiredH;
-        this.options.anchor = new Vector25(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 Vector25(24, 24)).x;
-    const py = (this.options.screenPosition ?? new Vector25(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 Vector25(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 Vector313(left, top, z));
-      const br = this.worldToScreen(new Vector313(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
-  });
-}
-
-// 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 entity;
-}
-
-// 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 entity;
-}
-
-// 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 entity;
-}
-
-// 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 entity;
-}
-export {
-  ZylemBox,
-  createActor,
-  createBox,
-  createCone,
-  createCylinder,
-  createPill,
-  createPlane,
-  createPyramid,
-  createRect,
-  createSphere,
-  createSprite,
-  createText,
-  createZone
-};
-//# sourceMappingURL=entities.js.map