@yagejs/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2943 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/types.ts
+var Phase = /* @__PURE__ */ ((Phase2) => {
+  Phase2["EarlyUpdate"] = "earlyUpdate";
+  Phase2["FixedUpdate"] = "fixedUpdate";
+  Phase2["Update"] = "update";
+  Phase2["LateUpdate"] = "lateUpdate";
+  Phase2["Render"] = "render";
+  Phase2["EndOfFrame"] = "endOfFrame";
+  return Phase2;
+})(Phase || {});
+
+// src/Vec2.ts
+var EPSILON = 1e-6;
+var Vec2 = class _Vec2 {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  x;
+  y;
+  static {
+    __name(this, "Vec2");
+  }
+  /** The zero vector (0, 0). */
+  static ZERO = new _Vec2(0, 0);
+  /** The one vector (1, 1). */
+  static ONE = new _Vec2(1, 1);
+  /** Up direction (0, -1) — screen coordinates. */
+  static UP = new _Vec2(0, -1);
+  /** Down direction (0, 1) — screen coordinates. */
+  static DOWN = new _Vec2(0, 1);
+  /** Left direction (-1, 0). */
+  static LEFT = new _Vec2(-1, 0);
+  /** Right direction (1, 0). */
+  static RIGHT = new _Vec2(1, 0);
+  /** Add another vector. */
+  add(other) {
+    return new _Vec2(this.x + other.x, this.y + other.y);
+  }
+  /** Subtract another vector. */
+  sub(other) {
+    return new _Vec2(this.x - other.x, this.y - other.y);
+  }
+  /** Scale by a scalar. */
+  scale(scalar) {
+    return new _Vec2(this.x * scalar, this.y * scalar);
+  }
+  /** Component-wise multiply with another vector. */
+  multiply(other) {
+    return new _Vec2(this.x * other.x, this.y * other.y);
+  }
+  /** Dot product with another vector. */
+  dot(other) {
+    return this.x * other.x + this.y * other.y;
+  }
+  /** Cross product (z-component of the 3D cross product). */
+  cross(other) {
+    return this.x * other.y - this.y * other.x;
+  }
+  /** Magnitude of this vector. */
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  /** Squared magnitude (avoids sqrt). */
+  lengthSq() {
+    return this.x * this.x + this.y * this.y;
+  }
+  /** Return a unit vector in the same direction. Returns ZERO for zero-length vectors. */
+  normalize() {
+    const len = this.length();
+    if (len < EPSILON) return _Vec2.ZERO;
+    return new _Vec2(this.x / len, this.y / len);
+  }
+  /** Euclidean distance to another vector. */
+  distance(other) {
+    const dx = this.x - other.x;
+    const dy = this.y - other.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /** Squared distance to another vector (avoids sqrt). */
+  distanceSq(other) {
+    const dx = this.x - other.x;
+    const dy = this.y - other.y;
+    return dx * dx + dy * dy;
+  }
+  /** Linear interpolation toward another vector. */
+  lerp(other, t) {
+    return new _Vec2(
+      this.x + (other.x - this.x) * t,
+      this.y + (other.y - this.y) * t
+    );
+  }
+  /** Angle of this vector in radians (atan2). */
+  angle() {
+    return Math.atan2(this.y, this.x);
+  }
+  /** Rotate this vector by radians. */
+  rotate(radians) {
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    return new _Vec2(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
+  }
+  /** Check equality with optional epsilon tolerance. */
+  equals(other, epsilon = EPSILON) {
+    return Math.abs(this.x - other.x) < epsilon && Math.abs(this.y - other.y) < epsilon;
+  }
+  /** String representation. */
+  toString() {
+    return `Vec2(${this.x}, ${this.y})`;
+  }
+  /** Create a unit vector from an angle in radians, optionally scaled. */
+  static fromAngle(radians, length = 1) {
+    return new _Vec2(Math.cos(radians) * length, Math.sin(radians) * length);
+  }
+  /** Euclidean distance between two vectors. */
+  static distance(a, b) {
+    const dx = a.x - b.x;
+    const dy = a.y - b.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /** Linear interpolation between two vectors. */
+  static lerp(a, b, t) {
+    return new _Vec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+  }
+};
+
+// src/MathUtils.ts
+var MathUtils = {
+  /** Linear interpolation between a and b. */
+  lerp(a, b, t) {
+    return a + (b - a) * t;
+  },
+  /** Clamp a value between min and max. */
+  clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+  },
+  /** Remap a value from one range to another. */
+  remap(value, inMin, inMax, outMin, outMax) {
+    const t = (value - inMin) / (inMax - inMin);
+    return outMin + (outMax - outMin) * t;
+  },
+  /** Random float in [min, max). */
+  randomRange(min, max) {
+    return min + Math.random() * (max - min);
+  },
+  /** Random integer in [min, max] (inclusive). */
+  randomInt(min, max) {
+    return Math.floor(min + Math.random() * (max - min + 1));
+  },
+  /** Convert degrees to radians. */
+  degToRad(degrees) {
+    return degrees * Math.PI / 180;
+  },
+  /** Convert radians to degrees. */
+  radToDeg(radians) {
+    return radians * 180 / Math.PI;
+  },
+  /** Move current toward target by at most step. */
+  approach(current, target, step) {
+    if (current < target) {
+      return Math.min(current + step, target);
+    }
+    return Math.max(current - step, target);
+  },
+  /** Wrap value into the range [min, max). */
+  wrap(value, min, max) {
+    const range = max - min;
+    return ((value - min) % range + range) % range + min;
+  }
+};
+
+// src/EventBus.ts
+var EventBus = class {
+  static {
+    __name(this, "EventBus");
+  }
+  handlers = /* @__PURE__ */ new Map();
+  /** Subscribe to an event. Returns an unsubscribe function. */
+  on(event, handler) {
+    let list = this.handlers.get(event);
+    if (!list) {
+      list = [];
+      this.handlers.set(event, list);
+    }
+    list.push(handler);
+    return () => {
+      const arr = this.handlers.get(event);
+      if (arr) {
+        const idx = arr.indexOf(handler);
+        if (idx !== -1) arr.splice(idx, 1);
+      }
+    };
+  }
+  /** Subscribe to an event, auto-unsubscribe after first emission. */
+  once(event, handler) {
+    const unsub = this.on(event, (data) => {
+      unsub();
+      handler(data);
+    });
+    return unsub;
+  }
+  /** Emit an event. Handlers are called synchronously in registration order. */
+  emit(event, data) {
+    const list = this.handlers.get(event);
+    if (!list) return;
+    const snapshot = [...list];
+    for (const handler of snapshot) {
+      handler(data);
+    }
+  }
+  /** Remove all handlers for an event, or all handlers if no event specified. */
+  clear(event) {
+    if (event !== void 0) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+};
+
+// src/Logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 0] = "Debug";
+  LogLevel2[LogLevel2["Info"] = 1] = "Info";
+  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  LogLevel2[LogLevel2["None"] = 4] = "None";
+  return LogLevel2;
+})(LogLevel || {});
+var LEVEL_LABELS = {
+  [0 /* Debug */]: "DEBUG",
+  [1 /* Info */]: "INFO",
+  [2 /* Warn */]: "WARN",
+  [3 /* Error */]: "ERROR",
+  [4 /* None */]: "NONE"
+};
+var Logger = class {
+  static {
+    __name(this, "Logger");
+  }
+  level;
+  categories;
+  bufferSize;
+  output;
+  buffer;
+  writeIndex = 0;
+  count = 0;
+  currentFrame = 0;
+  constructor(config) {
+    this.level = config?.level ?? 1 /* Info */;
+    this.categories = new Set(config?.categories ?? []);
+    this.bufferSize = config?.bufferSize ?? 500;
+    this.output = config?.output;
+    this.buffer = new Array(this.bufferSize);
+  }
+  /** Set the current frame number (incremented externally by the game loop). */
+  setFrame(frame) {
+    this.currentFrame = frame;
+  }
+  /** Log a debug message. */
+  debug(category, message, data) {
+    this.log(0 /* Debug */, category, message, data);
+  }
+  /** Log an info message. */
+  info(category, message, data) {
+    this.log(1 /* Info */, category, message, data);
+  }
+  /** Log a warning message. */
+  warn(category, message, data) {
+    this.log(2 /* Warn */, category, message, data);
+  }
+  /** Log an error message. */
+  error(category, message, data) {
+    this.log(3 /* Error */, category, message, data);
+  }
+  /** Get recent log entries from the ring buffer. */
+  getRecent(count) {
+    const available = Math.min(this.count, this.bufferSize);
+    const n = count !== void 0 ? Math.min(count, available) : available;
+    const result = [];
+    for (let i = 0; i < n; i++) {
+      const idx = (this.writeIndex - n + i + this.bufferSize) % this.bufferSize;
+      const entry = this.buffer[idx];
+      if (entry) result.push(entry);
+    }
+    return result;
+  }
+  /** Format recent logs as structured text for agent consumption. */
+  formatRecentLogs(count) {
+    return this.getRecent(count).map((e) => {
+      const levelStr = LEVEL_LABELS[e.level] ?? "UNKNOWN";
+      const dataStr = e.data !== void 0 ? ` ${JSON.stringify(e.data)}` : "";
+      return `[${levelStr}][${e.category}] f${e.frame} ${e.message}${dataStr}`;
+    }).join("\n");
+  }
+  /** Clear the ring buffer. */
+  clear() {
+    this.writeIndex = 0;
+    this.count = 0;
+    this.buffer.fill(void 0);
+  }
+  log(level, category, message, data) {
+    if (level < this.level) return;
+    if (this.categories.size > 0 && !this.categories.has(category)) return;
+    const entry = {
+      level,
+      category,
+      message,
+      data,
+      timestamp: Date.now(),
+      frame: this.currentFrame
+    };
+    this.buffer[this.writeIndex] = entry;
+    this.writeIndex = (this.writeIndex + 1) % this.bufferSize;
+    this.count++;
+    this.output?.(entry);
+  }
+};
+
+// src/EngineContext.ts
+var ServiceKey = class {
+  constructor(id) {
+    this.id = id;
+  }
+  id;
+  static {
+    __name(this, "ServiceKey");
+  }
+};
+var EngineContext = class {
+  static {
+    __name(this, "EngineContext");
+  }
+  services = /* @__PURE__ */ new Map();
+  /** Register a service. Throws if the key is already registered. */
+  register(key, service) {
+    if (this.services.has(key.id)) {
+      throw new Error(`Service "${key.id}" is already registered.`);
+    }
+    this.services.set(key.id, service);
+  }
+  /** Resolve a service. Throws if not registered. */
+  resolve(key) {
+    if (!this.services.has(key.id)) {
+      throw new Error(`Service "${key.id}" is not registered.`);
+    }
+    return this.services.get(key.id);
+  }
+  /** Resolve a service, returning undefined if not registered. */
+  tryResolve(key) {
+    return this.services.get(key.id);
+  }
+  /** Remove a registered service. No-op if not registered. */
+  unregister(key) {
+    this.services.delete(key.id);
+  }
+  /** Check if a service is registered. */
+  has(key) {
+    return this.services.has(key.id);
+  }
+};
+var EngineKey = new ServiceKey("engine");
+var EventBusKey = new ServiceKey("eventBus");
+var SceneManagerKey = new ServiceKey("sceneManager");
+var LoggerKey = new ServiceKey("logger");
+var InspectorKey = new ServiceKey("inspector");
+var QueryCacheKey = new ServiceKey("queryCache");
+var ErrorBoundaryKey = new ServiceKey("errorBoundary");
+var GameLoopKey = new ServiceKey("gameLoop");
+var SystemSchedulerKey = new ServiceKey("systemScheduler");
+var ProcessSystemKey = new ServiceKey("processSystem");
+var AssetManagerKey = new ServiceKey("assetManager");
+
+// src/EventToken.ts
+var EventToken = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+  static {
+    __name(this, "EventToken");
+  }
+};
+function defineEvent(name) {
+  return new EventToken(name);
+}
+__name(defineEvent, "defineEvent");
+
+// src/AssetHandle.ts
+var AssetHandle = class {
+  constructor(type, path) {
+    this.type = type;
+    this.path = path;
+  }
+  type;
+  path;
+  static {
+    __name(this, "AssetHandle");
+  }
+};
+
+// src/AssetManager.ts
+var AssetManager = class {
+  static {
+    __name(this, "AssetManager");
+  }
+  loaders = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  /** Register a loader for a given asset type. Called by plugins during install(). */
+  registerLoader(type, loader) {
+    this.loaders.set(type, loader);
+  }
+  /** Retrieve a loaded asset. Throws if not loaded. */
+  get(handle) {
+    const key = this.key(handle);
+    const asset = this.cache.get(key);
+    if (asset === void 0) {
+      throw new Error(`Asset not loaded: "${handle.path}" (type: ${handle.type})`);
+    }
+    return asset;
+  }
+  /** Check if an asset is loaded. */
+  has(handle) {
+    return this.cache.has(this.key(handle));
+  }
+  /**
+   * Load all assets, skipping already-cached ones.
+   * Reports progress via optional callback (0→1).
+   */
+  async loadAll(handles, onProgress) {
+    const toLoad = handles.filter((h) => !this.cache.has(this.key(h)));
+    if (toLoad.length === 0) {
+      onProgress?.(1);
+      return;
+    }
+    let done = 0;
+    onProgress?.(0);
+    await Promise.all(
+      toLoad.map(async (handle) => {
+        const loader = this.loaders.get(handle.type);
+        if (!loader) {
+          throw new Error(
+            `No loader registered for asset type "${handle.type}". Missing plugin?`
+          );
+        }
+        const asset = await loader.load(handle.path);
+        this.cache.set(this.key(handle), asset);
+        onProgress?.(++done / toLoad.length);
+      })
+    );
+  }
+  /** Unload a single asset and remove from cache. */
+  unload(handle) {
+    const key = this.key(handle);
+    const asset = this.cache.get(key);
+    if (asset === void 0) return;
+    const loader = this.loaders.get(handle.type);
+    loader?.unload?.(handle.path, asset);
+    this.cache.delete(key);
+  }
+  /** Unload all cached assets. */
+  clear() {
+    for (const [key, asset] of this.cache) {
+      const [type, ...pathParts] = key.split(":");
+      const path = pathParts.join(":");
+      this.loaders.get(type)?.unload?.(path, asset);
+    }
+    this.cache.clear();
+  }
+  key(handle) {
+    return `${handle.type}:${handle.path}`;
+  }
+};
+
+// src/Blueprint.ts
+function defineBlueprint(name, build) {
+  return { name, build };
+}
+__name(defineBlueprint, "defineBlueprint");
+
+// src/Trait.ts
+var TRAITS_KEY = /* @__PURE__ */ Symbol("TRAITS_KEY");
+var TraitToken = class {
+  constructor(name) {
+    this.name = name;
+    this.symbol = /* @__PURE__ */ Symbol(`Trait:${name}`);
+  }
+  name;
+  static {
+    __name(this, "TraitToken");
+  }
+  symbol;
+};
+function defineTrait(name) {
+  return new TraitToken(name);
+}
+__name(defineTrait, "defineTrait");
+function trait(token) {
+  return (target) => {
+    const traitSymbols = new Set(target[TRAITS_KEY] ?? []);
+    traitSymbols.add(token.symbol);
+    target[TRAITS_KEY] = traitSymbols;
+    return target;
+  };
+}
+__name(trait, "trait");
+
+// src/Serializable.ts
+var SERIALIZABLE_KEY = /* @__PURE__ */ Symbol("SERIALIZABLE");
+var registry = /* @__PURE__ */ new Map();
+var SerializableRegistry = {
+  /** Look up a class by its type string. */
+  get(type) {
+    return registry.get(type);
+  },
+  /** Check if a type string is registered. */
+  has(type) {
+    return registry.has(type);
+  },
+  /** Iterate all registered [type, class] entries. */
+  entries() {
+    return registry.entries();
+  },
+  /** Remove a type from the registry. */
+  delete(type) {
+    return registry.delete(type);
+  }
+};
+function isSerializable(instance) {
+  return SERIALIZABLE_KEY in instance.constructor;
+}
+__name(isSerializable, "isSerializable");
+function getSerializableType(target) {
+  const ctor = typeof target === "function" ? target : target.constructor;
+  return ctor[SERIALIZABLE_KEY];
+}
+__name(getSerializableType, "getSerializableType");
+function serializable(targetOrConfig) {
+  if (typeof targetOrConfig === "function") {
+    const target = targetOrConfig;
+    const type = target.name;
+    target[SERIALIZABLE_KEY] = type;
+    registry.set(type, target);
+    return target;
+  }
+  const config = targetOrConfig;
+  return (target) => {
+    target[SERIALIZABLE_KEY] = config.type;
+    registry.set(config.type, target);
+    return target;
+  };
+}
+__name(serializable, "serializable");
+
+// src/EntityFilter.ts
+function filterEntities(entities, filter) {
+  const result = [];
+  for (const entity of entities) {
+    if (entity.isDestroyed) continue;
+    if (filter.name !== void 0 && entity.name !== filter.name) continue;
+    if (filter.tags) {
+      let allMatch = true;
+      for (const tag of filter.tags) {
+        if (!entity.tags.has(tag)) {
+          allMatch = false;
+          break;
+        }
+      }
+      if (!allMatch) continue;
+    }
+    if (filter.trait && !entity.hasTrait(filter.trait)) continue;
+    if (filter.filter && !filter.filter(entity)) continue;
+    result.push(entity);
+  }
+  return result;
+}
+__name(filterEntities, "filterEntities");
+
+// src/Component.ts
+var Component = class {
+  static {
+    __name(this, "Component");
+  }
+  /**
+   * Back-reference to the owning entity. Set by the engine when the component
+   * is added to an entity. Do not set manually.
+   */
+  entity;
+  /** Whether this component is active. Disabled components are skipped by ComponentUpdateSystem. */
+  enabled = true;
+  _serviceCache;
+  _cleanups;
+  /**
+   * Access the entity's scene. Throws if the entity is not in a scene.
+   * Prefer this over `this.entity.scene!` in component methods.
+   */
+  get scene() {
+    const scene = this.entity.scene;
+    if (!scene) {
+      throw new Error(
+        "Cannot access scene: entity is not attached to a scene."
+      );
+    }
+    return scene;
+  }
+  /**
+   * Access the EngineContext from the entity's scene.
+   * Throws if the entity is not in a scene.
+   */
+  get context() {
+    return this.scene.context;
+  }
+  /** Resolve a service by key, cached after first lookup. */
+  use(key) {
+    this._serviceCache ??= /* @__PURE__ */ new Map();
+    let value = this._serviceCache.get(key.id);
+    if (value === void 0) {
+      value = this.context.resolve(key);
+      this._serviceCache.set(key.id, value);
+    }
+    return value;
+  }
+  /**
+   * Lazy proxy-based service resolution. Can be used at field-declaration time:
+   * ```ts
+   * readonly camera = this.service(CameraKey);
+   * ```
+   * The actual resolution is deferred until first property access.
+   */
+  service(key) {
+    let resolved;
+    return new Proxy({}, {
+      get: /* @__PURE__ */ __name((_target, prop) => {
+        resolved ??= this.use(key);
+        const value = resolved[prop];
+        return typeof value === "function" ? value.bind(resolved) : value;
+      }, "get"),
+      set: /* @__PURE__ */ __name((_target, prop, value) => {
+        resolved ??= this.use(key);
+        resolved[prop] = value;
+        return true;
+      }, "set")
+    });
+  }
+  /**
+   * Lazy proxy-based sibling component resolution. Can be used at field-declaration time:
+   * ```ts
+   * readonly anim = this.sibling(AnimatedSpriteComponent);
+   * ```
+   * The actual resolution is deferred until first property access.
+   */
+  sibling(cls) {
+    let resolved;
+    return new Proxy({}, {
+      get: /* @__PURE__ */ __name((_target, prop) => {
+        resolved ??= this.entity.get(cls);
+        const value = resolved[prop];
+        return typeof value === "function" ? value.bind(resolved) : value;
+      }, "get"),
+      set: /* @__PURE__ */ __name((_target, prop, value) => {
+        resolved ??= this.entity.get(cls);
+        resolved[prop] = value;
+        return true;
+      }, "set")
+    });
+  }
+  /** Subscribe to events on any entity, auto-unsubscribe on removal. */
+  listen(entity, token, handler) {
+    const unsub = entity.on(token, handler);
+    this.addCleanup(unsub);
+  }
+  /** Subscribe to scene-level bubbled events, auto-unsubscribe on removal. */
+  listenScene(token, handler) {
+    const unsub = this.scene.on(token, handler);
+    this.addCleanup(unsub);
+  }
+  /** Register a cleanup function to run when this component is removed or destroyed. */
+  addCleanup(fn) {
+    this._cleanups ??= [];
+    this._cleanups.push(fn);
+  }
+  /**
+   * Run and clear all registered cleanups.
+   * Called by Entity.remove() and Entity._performDestroy() before onRemove/onDestroy.
+   * @internal
+   */
+  _runCleanups() {
+    if (this._cleanups) {
+      for (const fn of this._cleanups) {
+        fn();
+      }
+      this._cleanups.length = 0;
+    }
+  }
+};
+
+// src/Transform.ts
+var _Transform_decorators, _init, _a;
+_Transform_decorators = [serializable];
+var _Transform = class _Transform extends (_a = Component) {
+  static {
+    __name(this, "Transform");
+  }
+  // Private backing fields
+  _position;
+  _rotation;
+  _scale;
+  _worldPosition;
+  _worldRotation;
+  _worldScale;
+  _dirty = false;
+  constructor(options) {
+    super();
+    this._position = options?.position ? new Vec2(options.position.x, options.position.y) : Vec2.ZERO;
+    this._rotation = options?.rotation ?? 0;
+    this._scale = options?.scale ? new Vec2(options.scale.x, options.scale.y) : Vec2.ONE;
+    this._worldPosition = this._position;
+    this._worldRotation = this._rotation;
+    this._worldScale = this._scale;
+  }
+  /** Local position (relative to parent, or world if no parent). */
+  get position() {
+    return this._position;
+  }
+  set position(v) {
+    this._position = v;
+    this._markDirty();
+  }
+  /** Local rotation in radians. */
+  get rotation() {
+    return this._rotation;
+  }
+  set rotation(v) {
+    this._rotation = v;
+    this._markDirty();
+  }
+  /** Local scale factor. */
+  get scale() {
+    return this._scale;
+  }
+  set scale(v) {
+    this._scale = v;
+    this._markDirty();
+  }
+  /** Computed world position. Recomputed lazily when dirty. */
+  get worldPosition() {
+    if (this._dirty) this._recompute();
+    return this._worldPosition;
+  }
+  /** Set position in world space. Back-computes the local position from the parent chain. */
+  set worldPosition(v) {
+    const pt = this.entity?.parent?.tryGet(_Transform);
+    if (!pt) {
+      this._position = v;
+    } else {
+      const delta = v.sub(pt.worldPosition).rotate(-pt.worldRotation);
+      const ps = pt.worldScale;
+      this._position = new Vec2(delta.x / ps.x, delta.y / ps.y);
+    }
+    this._markDirty();
+  }
+  /** Computed world rotation. Recomputed lazily when dirty. */
+  get worldRotation() {
+    if (this._dirty) this._recompute();
+    return this._worldRotation;
+  }
+  /** Set rotation in world space. Back-computes the local rotation from the parent chain. */
+  set worldRotation(v) {
+    const pt = this.entity?.parent?.tryGet(_Transform);
+    if (!pt) {
+      this._rotation = v;
+    } else {
+      this._rotation = v - pt.worldRotation;
+    }
+    this._markDirty();
+  }
+  /** Computed world scale. Recomputed lazily when dirty. */
+  get worldScale() {
+    if (this._dirty) this._recompute();
+    return this._worldScale;
+  }
+  /** Set position directly. */
+  setPosition(x, y) {
+    this._position = new Vec2(x, y);
+    this._markDirty();
+  }
+  /** Translate by an offset. */
+  translate(dx, dy) {
+    this._position = new Vec2(this._position.x + dx, this._position.y + dy);
+    this._markDirty();
+  }
+  /** Set rotation in radians. */
+  setRotation(radians) {
+    this._rotation = radians;
+    this._markDirty();
+  }
+  /** Rotate by a delta in radians. */
+  rotate(deltaRadians) {
+    this._rotation += deltaRadians;
+    this._markDirty();
+  }
+  /** Set scale. */
+  setScale(x, y) {
+    this._scale = new Vec2(x, y);
+    this._markDirty();
+  }
+  /**
+   * Mark this transform and all descendant transforms as dirty.
+   * @internal
+   */
+  _markDirty() {
+    if (this._dirty) return;
+    this._dirty = true;
+    for (const child of this.entity?.children.values() ?? []) {
+      child.tryGet(_Transform)?._markDirty();
+    }
+  }
+  _recompute() {
+    this._dirty = false;
+    const pt = this.entity?.parent?.tryGet(_Transform);
+    if (!pt) {
+      this._worldPosition = this._position;
+      this._worldRotation = this._rotation;
+      this._worldScale = this._scale;
+      return;
+    }
+    const rotatedLocal = this._position.multiply(pt.worldScale).rotate(pt.worldRotation);
+    this._worldPosition = pt.worldPosition.add(rotatedLocal);
+    this._worldRotation = pt.worldRotation + this._rotation;
+    this._worldScale = pt.worldScale.multiply(this._scale);
+  }
+  // ---- Save/load support ----
+  serialize() {
+    return {
+      position: { x: this._position.x, y: this._position.y },
+      rotation: this._rotation,
+      scale: { x: this._scale.x, y: this._scale.y }
+    };
+  }
+  static fromSnapshot(data) {
+    return new _Transform({
+      position: { x: data.position.x, y: data.position.y },
+      rotation: data.rotation,
+      scale: { x: data.scale.x, y: data.scale.y }
+    });
+  }
+};
+_init = __decoratorStart(_a);
+_Transform = __decorateElement(_init, 0, "Transform", _Transform_decorators, _Transform);
+__runInitializers(_init, 1, _Transform);
+var Transform = _Transform;
+
+// src/Entity.ts
+var nextEntityId = 1;
+var EMPTY_CHILDREN = /* @__PURE__ */ new Map();
+function _resetEntityIdCounter() {
+  nextEntityId = 1;
+}
+__name(_resetEntityIdCounter, "_resetEntityIdCounter");
+var Entity = class {
+  static {
+    __name(this, "Entity");
+  }
+  static [TRAITS_KEY] = /* @__PURE__ */ new Set();
+  /** Unique auto-incrementing ID. */
+  id;
+  /** Display name for debugging. */
+  name;
+  /** Tags for group queries. */
+  tags;
+  components = /* @__PURE__ */ new Map();
+  _destroyed = false;
+  _scene = null;
+  callbacks = null;
+  _eventHandlers;
+  _parent = null;
+  _children = null;
+  constructor(name, tags) {
+    this.id = nextEntityId++;
+    this.name = name ?? new.target.name ?? "Entity";
+    this.tags = new Set(tags);
+  }
+  /** The scene this entity belongs to, or null. */
+  get scene() {
+    return this._scene;
+  }
+  /** True if destroy() has been called. */
+  get isDestroyed() {
+    return this._destroyed;
+  }
+  /** The parent entity, or null if this is a root entity. */
+  get parent() {
+    return this._parent;
+  }
+  /** Named children as a read-only map. Empty map if no children. */
+  get children() {
+    return this._children ?? EMPTY_CHILDREN;
+  }
+  /** Add a named child entity. Auto-adds to parent's scene if not already in one. */
+  addChild(name, child) {
+    if (child === this) {
+      throw new Error(`Entity "${this.name}" cannot be a child of itself.`);
+    }
+    if (child._parent) {
+      throw new Error(
+        `Entity "${child.name}" already has a parent ("${child._parent.name}"). Remove it first.`
+      );
+    }
+    this._children ??= /* @__PURE__ */ new Map();
+    if (this._children.has(name)) {
+      throw new Error(
+        `Entity "${this.name}" already has a child named "${name}".`
+      );
+    }
+    child._parent = this;
+    this._children.set(name, child);
+    child.tryGet(Transform)?._markDirty();
+    if (this._scene && !child._scene) {
+      this._scene._addExistingEntity(child);
+    }
+  }
+  /** Remove a named child. Returns the detached entity. */
+  removeChild(name) {
+    const child = this._children?.get(name);
+    if (!child) {
+      throw new Error(`Entity "${this.name}" has no child named "${name}".`);
+    }
+    child._parent = null;
+    this._children.delete(name);
+    child.tryGet(Transform)?._markDirty();
+    return child;
+  }
+  /** Get a child by name. Throws if not found. */
+  getChild(name) {
+    const child = this._children?.get(name);
+    if (!child) {
+      throw new Error(`Entity "${this.name}" has no child named "${name}".`);
+    }
+    return child;
+  }
+  /** Get a child by name, or undefined if not found. */
+  tryGetChild(name) {
+    return this._children?.get(name);
+  }
+  /** Add a component instance. Returns the component for chaining. */
+  add(component) {
+    const cls = component.constructor;
+    if (this.components.has(cls)) {
+      throw new Error(
+        `Entity "${this.name}" already has component ${cls.name}.`
+      );
+    }
+    component.entity = this;
+    this.components.set(cls, component);
+    component.onAdd?.();
+    this.callbacks?.onComponentAdded(this, cls);
+    return component;
+  }
+  /** Get a component by class. Throws if not found. */
+  get(cls) {
+    const comp = this.components.get(cls);
+    if (!comp) {
+      throw new Error(
+        `Entity "${this.name}" does not have component ${cls.name}.`
+      );
+    }
+    return comp;
+  }
+  /** Get a component by class, or undefined if not found. */
+  tryGet(cls) {
+    return this.components.get(cls);
+  }
+  /** Check if entity has a component of the given class. */
+  has(cls) {
+    return this.components.has(cls);
+  }
+  /** Remove a component by class. */
+  remove(cls) {
+    const comp = this.components.get(cls);
+    if (!comp) return;
+    comp._runCleanups();
+    comp.onRemove?.();
+    comp.onDestroy?.();
+    this.components.delete(cls);
+    this.callbacks?.onComponentRemoved(this, cls);
+  }
+  /** Subscribe to a typed event on this entity. Returns an unsubscribe function. */
+  on(token, handler) {
+    this._eventHandlers ??= /* @__PURE__ */ new Map();
+    let handlers = this._eventHandlers.get(token.name);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this._eventHandlers.set(token.name, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  emit(token, data) {
+    if (this._destroyed) return;
+    const handlers = this._eventHandlers?.get(token.name);
+    if (handlers) {
+      for (const handler of [...handlers]) {
+        handler(data);
+      }
+    }
+    this._scene?._onEntityEvent(token.name, data, this);
+  }
+  /** Get all components as an iterable. */
+  getAll() {
+    return this.components.values();
+  }
+  /** Mark for deferred destruction. Actual cleanup happens at end of frame. */
+  destroy() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    if (this._children) {
+      for (const child of this._children.values()) {
+        child.destroy();
+      }
+    }
+    this._scene?._queueDestroy(this);
+  }
+  /**
+   * Internal: perform actual destruction — remove all components and clear state.
+   * Called by Scene during endOfFrame flush.
+   * @internal
+   */
+  _performDestroy() {
+    if (this._parent?._children) {
+      for (const [name, child] of this._parent._children) {
+        if (child === this) {
+          this._parent._children.delete(name);
+          break;
+        }
+      }
+    }
+    this._parent = null;
+    this._children?.clear();
+    for (const [cls, comp] of this.components) {
+      comp._runCleanups();
+      comp.onRemove?.();
+      comp.onDestroy?.();
+      this.callbacks?.onComponentRemoved(this, cls);
+    }
+    this.components.clear();
+    this._eventHandlers?.clear();
+  }
+  /** Check if this entity's class implements a given trait. Acts as a type guard. */
+  hasTrait(token) {
+    let ctor = this.constructor;
+    while (ctor) {
+      const traits = ctor[TRAITS_KEY];
+      if (traits?.has(token.symbol)) return true;
+      ctor = Object.getPrototypeOf(ctor);
+    }
+    return false;
+  }
+  /**
+   * Internal: set the scene and callbacks. Called by Scene.spawn().
+   * @internal
+   */
+  _setScene(scene, callbacks) {
+    this._scene = scene;
+    this.callbacks = callbacks;
+  }
+};
+
+// src/QueryCache.ts
+var QueryResult = class {
+  static {
+    __name(this, "QueryResult");
+  }
+  /** @internal */
+  _entities = /* @__PURE__ */ new Set();
+  /** @internal */
+  _filter;
+  /** @internal */
+  constructor(filter) {
+    this._filter = filter;
+  }
+  /** Iterate matching entities. */
+  [Symbol.iterator]() {
+    return this._entities[Symbol.iterator]();
+  }
+  /** Number of matching entities. */
+  get size() {
+    return this._entities.size;
+  }
+  /** Get the first match (useful for singleton queries). */
+  get first() {
+    for (const e of this._entities) return e;
+    return void 0;
+  }
+  /** Convert to array (allocates). */
+  toArray() {
+    return [...this._entities];
+  }
+};
+var QueryCache = class {
+  static {
+    __name(this, "QueryCache");
+  }
+  queries = [];
+  /** Register a query. Returns a stable reference to a live result set. */
+  register(filter) {
+    const result = new QueryResult(filter);
+    this.queries.push(result);
+    return result;
+  }
+  /** Called by Entity when a component is added. */
+  onComponentAdded(entity) {
+    for (const q of this.queries) {
+      if (this.matches(entity, q._filter)) {
+        q._entities.add(entity);
+      }
+    }
+  }
+  /** Called by Entity when a component is removed. */
+  onComponentRemoved(entity) {
+    for (const q of this.queries) {
+      if (!this.matches(entity, q._filter)) {
+        q._entities.delete(entity);
+      }
+    }
+  }
+  /** Called when an entity is destroyed. */
+  onEntityDestroyed(entity) {
+    for (const q of this.queries) {
+      q._entities.delete(entity);
+    }
+  }
+  matches(entity, filter) {
+    for (const cls of filter) {
+      if (!entity.has(cls)) return false;
+    }
+    return true;
+  }
+};
+
+// src/System.ts
+var System = class {
+  static {
+    __name(this, "System");
+  }
+  /** Execution priority within the phase. Lower = earlier. Default: 0. */
+  priority = 0;
+  /** Whether this system is active. */
+  enabled = true;
+  /** Reference to the engine context, set on registration. */
+  context;
+  _serviceCache;
+  /**
+   * Set the engine context. Called by Engine during startup.
+   * @internal
+   */
+  _setContext(context) {
+    this.context = context;
+  }
+  /** Resolve a service by key, cached after first lookup. */
+  use(key) {
+    this._serviceCache ??= /* @__PURE__ */ new Map();
+    let value = this._serviceCache.get(key.id);
+    if (value === void 0) {
+      value = this.context.resolve(key);
+      this._serviceCache.set(key.id, value);
+    }
+    return value;
+  }
+};
+
+// src/SystemScheduler.ts
+var SystemScheduler = class {
+  static {
+    __name(this, "SystemScheduler");
+  }
+  phases = /* @__PURE__ */ new Map();
+  errorBoundary = null;
+  /** Set the error boundary for wrapping system execution. */
+  setErrorBoundary(boundary) {
+    this.errorBoundary = boundary;
+  }
+  /** Register a system. Sorted by priority within its phase. */
+  add(system) {
+    let list = this.phases.get(system.phase);
+    if (!list) {
+      list = [];
+      this.phases.set(system.phase, list);
+    }
+    list.push(system);
+    list.sort((a, b) => a.priority - b.priority);
+  }
+  /** Remove a system. */
+  remove(system) {
+    const list = this.phases.get(system.phase);
+    if (!list) return;
+    const idx = list.indexOf(system);
+    if (idx !== -1) list.splice(idx, 1);
+  }
+  /** Run all enabled systems in a given phase. Wraps each in ErrorBoundary if available. */
+  run(phase, dt) {
+    const list = this.phases.get(phase);
+    if (!list) return;
+    for (const system of list) {
+      if (!system.enabled) continue;
+      if (this.errorBoundary) {
+        this.errorBoundary.wrapSystem(system, () => system.update(dt));
+      } else {
+        system.update(dt);
+      }
+    }
+  }
+  /** Get all systems registered for a phase. */
+  getSystems(phase) {
+    return this.phases.get(phase) ?? [];
+  }
+  /** Get all systems across all phases. */
+  getAllSystems() {
+    const all = [];
+    for (const list of this.phases.values()) {
+      all.push(...list);
+    }
+    return all;
+  }
+};
+
+// src/ComponentUpdateSystem.ts
+var BaseComponentUpdateSystem = class extends System {
+  static {
+    __name(this, "BaseComponentUpdateSystem");
+  }
+  /** High priority so game logic runs after engine systems like physics. */
+  priority = 1e3;
+  sceneManager;
+  errorBoundary;
+  onRegister(context) {
+    this.sceneManager = context.resolve(SceneManagerKey);
+    this.errorBoundary = context.resolve(ErrorBoundaryKey);
+  }
+};
+var ComponentFixedUpdateSystem = class extends BaseComponentUpdateSystem {
+  static {
+    __name(this, "ComponentFixedUpdateSystem");
+  }
+  phase = "fixedUpdate" /* FixedUpdate */;
+  update(dt) {
+    for (const scene of this.sceneManager.activeScenes) {
+      const sceneDt = dt * scene.timeScale;
+      for (const entity of scene.getEntities()) {
+        if (entity.isDestroyed) continue;
+        for (const component of entity.getAll()) {
+          if (!component.enabled || !component.fixedUpdate) continue;
+          const fixedUpdate = component.fixedUpdate;
+          this.errorBoundary.wrapComponent(
+            component,
+            () => fixedUpdate.call(component, sceneDt)
+          );
+        }
+      }
+    }
+  }
+};
+var ComponentUpdateSystem = class extends BaseComponentUpdateSystem {
+  static {
+    __name(this, "ComponentUpdateSystem");
+  }
+  phase = "update" /* Update */;
+  update(dt) {
+    for (const scene of this.sceneManager.activeScenes) {
+      const sceneDt = dt * scene.timeScale;
+      for (const entity of scene.getEntities()) {
+        if (entity.isDestroyed) continue;
+        for (const component of entity.getAll()) {
+          if (!component.enabled || !component.update) continue;
+          const update = component.update;
+          this.errorBoundary.wrapComponent(
+            component,
+            () => update.call(component, sceneDt)
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/ErrorBoundary.ts
+var ErrorBoundary = class {
+  static {
+    __name(this, "ErrorBoundary");
+  }
+  logger;
+  disabledSystems = [];
+  disabledComponents = [];
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /** Wrap a system update call. On throw, disables the system. */
+  wrapSystem(system, fn) {
+    try {
+      fn();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      system.enabled = false;
+      this.disabledSystems.push({ system, error: message });
+      this.logger.error(
+        "core",
+        `System ${system.constructor.name} threw and was disabled`,
+        { error: message }
+      );
+    }
+  }
+  /** Wrap a component lifecycle or update call. On throw, disables the component. */
+  wrapComponent(component, fn) {
+    try {
+      fn();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      component.enabled = false;
+      this.disabledComponents.push({ component, error: message });
+      const entityName = component.entity?.name ?? "unknown";
+      this.logger.error(
+        "core",
+        `Component ${component.constructor.name} on entity "${entityName}" threw and was disabled`,
+        { error: message }
+      );
+    }
+  }
+  /** Get all disabled systems and components for inspection. */
+  getDisabled() {
+    return {
+      systems: this.disabledSystems,
+      components: this.disabledComponents
+    };
+  }
+};
+
+// src/GameLoop.ts
+var GameLoop = class {
+  static {
+    __name(this, "GameLoop");
+  }
+  /** Fixed timestep in ms. */
+  fixedTimestep;
+  /** Max fixed steps per frame. */
+  maxFixedStepsPerFrame;
+  accumulator = 0;
+  running = false;
+  callbacks = null;
+  tickerUnsubscribe = null;
+  rafId = null;
+  lastTime = 0;
+  _frameCount = 0;
+  constructor(config) {
+    this.fixedTimestep = config?.fixedTimestep ?? 1e3 / 60;
+    this.maxFixedStepsPerFrame = config?.maxFixedStepsPerFrame ?? 5;
+  }
+  /** Current frame count. */
+  get frameCount() {
+    return this._frameCount;
+  }
+  /** Whether the loop is running. */
+  get isRunning() {
+    return this.running;
+  }
+  /** Ratio of accumulated time to fixed timestep, for physics interpolation. */
+  get interpolationAlpha() {
+    return this.accumulator / this.fixedTimestep;
+  }
+  /** Provide the callbacks that the loop invokes each frame. */
+  setCallbacks(callbacks) {
+    this.callbacks = callbacks;
+  }
+  /**
+   * Attach an external ticker (e.g., PixiJS Ticker).
+   * The ticker calls `tick(dt)` every frame.
+   * If no ticker is attached, the loop uses requestAnimationFrame.
+   */
+  attachTicker(subscribe) {
+    this.tickerUnsubscribe = subscribe((dt) => this.tick(dt));
+  }
+  /** Start the loop. */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this._frameCount = 0;
+    this.accumulator = 0;
+    if (!this.tickerUnsubscribe && typeof requestAnimationFrame !== "undefined") {
+      this.lastTime = performance.now();
+      const loop = /* @__PURE__ */ __name((now) => {
+        if (!this.running) return;
+        const dt = now - this.lastTime;
+        this.lastTime = now;
+        this.tick(dt);
+        this.rafId = requestAnimationFrame(loop);
+      }, "loop");
+      this.rafId = requestAnimationFrame(loop);
+    }
+  }
+  /** Stop the loop. */
+  stop() {
+    this.running = false;
+    if (this.rafId !== null && typeof cancelAnimationFrame !== "undefined") {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+    if (this.tickerUnsubscribe) {
+      this.tickerUnsubscribe();
+      this.tickerUnsubscribe = null;
+    }
+  }
+  /** Process one frame with the given dt in milliseconds. */
+  tick(dtMs) {
+    if (!this.callbacks) return;
+    this._frameCount++;
+    this.callbacks.earlyUpdate(dtMs);
+    this.accumulator += dtMs;
+    let steps = 0;
+    while (this.accumulator >= this.fixedTimestep && steps < this.maxFixedStepsPerFrame) {
+      this.callbacks.fixedUpdate(this.fixedTimestep);
+      this.accumulator -= this.fixedTimestep;
+      steps++;
+    }
+    this.callbacks.update(dtMs);
+    this.callbacks.lateUpdate(dtMs);
+    this.callbacks.render(dtMs);
+    this.callbacks.endOfFrame(dtMs);
+  }
+};
+
+// src/Scene.ts
+var Scene = class {
+  static {
+    __name(this, "Scene");
+  }
+  /** Whether scenes below this one in the stack should be paused. Default: true. */
+  pauseBelow = true;
+  /** Whether scenes below this one should still render. Default: false. */
+  transparentBelow = false;
+  /** Asset handles to load before onEnter(). Override in subclasses. */
+  preload;
+  /** Manual pause flag. Set by game code to pause this scene regardless of stack position. */
+  paused = false;
+  /** Time scale multiplier for this scene. 1.0 = normal, 0.5 = half speed. Default: 1. */
+  timeScale = 1;
+  entities = /* @__PURE__ */ new Set();
+  destroyQueue = [];
+  _context;
+  entityCallbacks;
+  queryCache;
+  bus;
+  _entityEventHandlers;
+  /** Access the EngineContext. */
+  get context() {
+    return this._context;
+  }
+  /** Whether this scene is effectively paused (manual pause or paused by stack). */
+  get isPaused() {
+    if (this.paused) return true;
+    const sm = this._context?.tryResolve(SceneManagerKey);
+    if (!sm) return false;
+    const stack = sm.all;
+    const idx = stack.indexOf(this);
+    if (idx === -1) return false;
+    for (let i = idx + 1; i < stack.length; i++) {
+      if (stack[i].pauseBelow) return true;
+    }
+    return false;
+  }
+  /** Convenience accessor for the AssetManager. */
+  get assets() {
+    return this._context.resolve(AssetManagerKey);
+  }
+  /**
+   * Lazy proxy-based service resolution. Can be used at field-declaration time:
+   * ```ts
+   * readonly layers = this.service(RenderLayerManagerKey);
+   * ```
+   * The actual resolution is deferred until first property access.
+   */
+  service(key) {
+    let resolved;
+    return new Proxy({}, {
+      get: /* @__PURE__ */ __name((_target, prop) => {
+        resolved ??= this._context.resolve(key);
+        const value = resolved[prop];
+        return typeof value === "function" ? value.bind(resolved) : value;
+      }, "get"),
+      set: /* @__PURE__ */ __name((_target, prop, value) => {
+        resolved ??= this._context.resolve(key);
+        resolved[prop] = value;
+        return true;
+      }, "set")
+    });
+  }
+  spawn(nameOrBlueprintOrClass, params) {
+    if (typeof nameOrBlueprintOrClass === "function") {
+      const entity2 = new nameOrBlueprintOrClass();
+      entity2._setScene(this, this.entityCallbacks);
+      this.entities.add(entity2);
+      this.bus?.emit("entity:created", { entity: entity2 });
+      entity2.setup?.(params);
+      return entity2;
+    }
+    const isBlueprint = typeof nameOrBlueprintOrClass === "object" && nameOrBlueprintOrClass !== null && "build" in nameOrBlueprintOrClass;
+    const name = isBlueprint ? nameOrBlueprintOrClass.name : nameOrBlueprintOrClass;
+    const entity = new Entity(name);
+    entity._setScene(this, this.entityCallbacks);
+    this.entities.add(entity);
+    this.bus?.emit("entity:created", { entity });
+    if (isBlueprint) {
+      nameOrBlueprintOrClass.build(entity, params);
+    }
+    return entity;
+  }
+  /**
+   * Add an existing entity to this scene (used by Entity.addChild for auto-scene-membership).
+   * @internal
+   */
+  _addExistingEntity(entity) {
+    entity._setScene(this, this.entityCallbacks);
+    this.entities.add(entity);
+    this.bus?.emit("entity:created", { entity });
+    if (!entity.getAll()[Symbol.iterator]().next().done) {
+      this.queryCache?.onComponentAdded(entity);
+    }
+  }
+  /** Mark an entity for destruction. Deferred to endOfFrame flush. */
+  destroyEntity(entity) {
+    entity.destroy();
+  }
+  /**
+   * Add an entity to the destroy queue. Called by Entity.destroy().
+   * @internal
+   */
+  _queueDestroy(entity) {
+    this.destroyQueue.push(entity);
+  }
+  /** Get all active entities. */
+  getEntities() {
+    return this.entities;
+  }
+  /** Find entity by name (first match). */
+  findEntity(name) {
+    for (const e of this.entities) {
+      if (e.name === name && !e.isDestroyed) return e;
+    }
+    return void 0;
+  }
+  /** Find entities by tag. */
+  findEntitiesByTag(tag) {
+    const result = [];
+    for (const e of this.entities) {
+      if (e.tags.has(tag) && !e.isDestroyed) result.push(e);
+    }
+    return result;
+  }
+  findEntities(filter) {
+    if (!filter) {
+      const result = [];
+      for (const e of this.entities) {
+        if (!e.isDestroyed) result.push(e);
+      }
+      return result;
+    }
+    return filterEntities(this.entities, filter);
+  }
+  /** Subscribe to bubbled entity events at the scene level. Handler receives (data, emittingEntity). */
+  on(token, handler) {
+    this._entityEventHandlers ??= /* @__PURE__ */ new Map();
+    let handlers = this._entityEventHandlers.get(token.name);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this._entityEventHandlers.set(token.name, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  /**
+   * Called by Entity.emit() for bubbling entity events to the scene.
+   * @internal
+   */
+  _onEntityEvent(eventName, data, entity) {
+    const handlers = this._entityEventHandlers?.get(eventName);
+    if (handlers) {
+      for (const handler of [...handlers]) {
+        handler(data, entity);
+      }
+    }
+  }
+  // ---- Internal methods ----
+  /**
+   * Set the engine context. Called by SceneManager when the scene is pushed.
+   * @internal
+   */
+  _setContext(context) {
+    this._context = context;
+    this.queryCache = context.tryResolve(QueryCacheKey);
+    this.bus = context.tryResolve(EventBusKey);
+    this.entityCallbacks = {
+      onComponentAdded: /* @__PURE__ */ __name((entity, cls) => {
+        this.queryCache?.onComponentAdded(entity);
+        this.bus?.emit("component:added", {
+          entity,
+          component: entity.get(cls)
+        });
+      }, "onComponentAdded"),
+      onComponentRemoved: /* @__PURE__ */ __name((entity, cls) => {
+        this.queryCache?.onComponentRemoved(entity);
+        this.bus?.emit("component:removed", { entity, componentClass: cls });
+      }, "onComponentRemoved")
+    };
+  }
+  /**
+   * Flush the destroy queue — destroy pending entities.
+   * Called by the engine during the endOfFrame phase.
+   * @internal
+   */
+  _flushDestroyQueue() {
+    for (const entity of this.destroyQueue) {
+      entity._performDestroy();
+      this.queryCache?.onEntityDestroyed(entity);
+      this.entities.delete(entity);
+      this.bus?.emit("entity:destroyed", { entity });
+    }
+    this.destroyQueue.length = 0;
+  }
+  /**
+   * Destroy all entities — used during scene exit.
+   * @internal
+   */
+  _destroyAllEntities() {
+    for (const entity of this.entities) {
+      entity._performDestroy();
+      this.queryCache?.onEntityDestroyed(entity);
+    }
+    this.entities.clear();
+    this.destroyQueue.length = 0;
+    this._entityEventHandlers?.clear();
+  }
+};
+
+// src/SceneManager.ts
+var SceneManager = class {
+  static {
+    __name(this, "SceneManager");
+  }
+  stack = [];
+  _context;
+  bus;
+  assetManager;
+  /**
+   * Set the engine context.
+   * @internal
+   */
+  _setContext(context) {
+    this._context = context;
+    this.bus = context.tryResolve(EventBusKey);
+    this.assetManager = context.tryResolve(AssetManagerKey);
+  }
+  /** The topmost (active) scene. */
+  get active() {
+    return this.stack[this.stack.length - 1];
+  }
+  /** All scenes in the stack, bottom to top. */
+  get all() {
+    return this.stack;
+  }
+  /** All non-paused scenes in the stack, bottom to top. */
+  get activeScenes() {
+    return this.stack.filter((s) => !s.isPaused);
+  }
+  /**
+   * Push a scene onto the stack. Scenes below may receive onPause().
+   * If the scene declares a `preload` array, assets are loaded before onEnter().
+   * Await the returned promise when using preloaded scenes.
+   */
+  push(scene) {
+    const wasPaused = new Map(this.stack.map((s) => [s, s.isPaused]));
+    scene._setContext(this._context);
+    this.stack.push(scene);
+    this._firePauseTransitions(wasPaused);
+    if (scene.preload?.length && this.assetManager) {
+      return this.assetManager.loadAll(scene.preload, scene.onProgress?.bind(scene)).then(() => {
+        scene.onEnter?.();
+        this.bus?.emit("scene:pushed", { scene });
+      });
+    }
+    scene.onEnter?.();
+    this.bus?.emit("scene:pushed", { scene });
+    return Promise.resolve();
+  }
+  /** Pop the top scene. Scenes below may receive onResume(). */
+  pop() {
+    const wasPaused = new Map(this.stack.map((s) => [s, s.isPaused]));
+    const removed = this.stack.pop();
+    if (!removed) return void 0;
+    removed.onExit?.();
+    removed._destroyAllEntities();
+    this._fireResumeTransitions(wasPaused);
+    this.bus?.emit("scene:popped", { scene: removed });
+    return removed;
+  }
+  /**
+   * Replace the top scene. Old scene receives onExit().
+   * New scene receives onEnter() (after preload, if declared).
+   */
+  replace(scene) {
+    const wasPaused = new Map(this.stack.map((s) => [s, s.isPaused]));
+    const old = this.stack.pop();
+    if (old) {
+      old.onExit?.();
+      old._destroyAllEntities();
+    }
+    scene._setContext(this._context);
+    this.stack.push(scene);
+    this._firePauseTransitions(wasPaused);
+    this._fireResumeTransitions(wasPaused);
+    if (scene.preload?.length && this.assetManager) {
+      return this.assetManager.loadAll(scene.preload, scene.onProgress?.bind(scene)).then(() => {
+        scene.onEnter?.();
+        if (old) {
+          this.bus?.emit("scene:replaced", {
+            oldScene: old,
+            newScene: scene
+          });
+        } else {
+          this.bus?.emit("scene:pushed", { scene });
+        }
+      });
+    }
+    scene.onEnter?.();
+    if (old) {
+      this.bus?.emit("scene:replaced", { oldScene: old, newScene: scene });
+    } else {
+      this.bus?.emit("scene:pushed", { scene });
+    }
+    return Promise.resolve();
+  }
+  /** Clear all scenes. Each receives onExit() from top to bottom. */
+  clear() {
+    while (this.stack.length > 0) {
+      const scene = this.stack.pop();
+      if (!scene) break;
+      scene.onExit?.();
+      scene._destroyAllEntities();
+      this.bus?.emit("scene:popped", { scene });
+    }
+  }
+  /**
+   * Flush destroy queues for all active scenes.
+   * Called by the engine during endOfFrame.
+   * @internal
+   */
+  _flushDestroyQueues() {
+    for (const scene of this.stack) {
+      scene._flushDestroyQueue();
+    }
+  }
+  /** Fire onPause() for scenes that transitioned from not-paused to paused. */
+  _firePauseTransitions(wasPaused) {
+    for (const s of this.stack) {
+      const was = wasPaused.get(s) ?? false;
+      if (s.isPaused && !was) {
+        s.onPause?.();
+      }
+    }
+  }
+  /** Fire onResume() for scenes that transitioned from paused to not-paused. */
+  _fireResumeTransitions(wasPaused) {
+    for (const s of this.stack) {
+      const was = wasPaused.get(s) ?? false;
+      if (!s.isPaused && was) {
+        s.onResume?.();
+      }
+    }
+  }
+};
+
+// src/Process.ts
+var Process = class _Process {
+  static {
+    __name(this, "Process");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  updateFn;
+  onCompleteFn;
+  duration;
+  loop;
+  /** Tags for filtering/grouping. */
+  tags;
+  elapsed = 0;
+  _completed = false;
+  _paused = false;
+  _cancelled = false;
+  resolvePromise;
+  /** Create a timer that fires `onComplete` after `duration` ms. */
+  static delay(duration, onComplete, tags) {
+    const opts = { duration };
+    if (onComplete !== void 0) opts.onComplete = onComplete;
+    if (tags !== void 0) opts.tags = tags;
+    return new _Process(opts);
+  }
+  constructor(options) {
+    this.updateFn = options.update ?? (() => {
+    });
+    this.onCompleteFn = options.onComplete;
+    this.duration = options.duration;
+    this.loop = options.loop ?? false;
+    this.tags = options.tags ?? [];
+  }
+  /** Whether the process has completed. */
+  get completed() {
+    return this._completed;
+  }
+  /** Whether the process is paused. */
+  get paused() {
+    return this._paused;
+  }
+  /** Pause the process. */
+  pause() {
+    this._paused = true;
+  }
+  /** Resume the process. */
+  resume() {
+    this._paused = false;
+  }
+  /** Cancel the process. */
+  cancel() {
+    this._cancelled = true;
+    this._completed = true;
+    this.resolvePromise?.();
+  }
+  /** Returns a promise that resolves when the process completes or is cancelled. */
+  toPromise() {
+    if (this._completed) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.resolvePromise = resolve;
+    });
+  }
+  /**
+   * Advance the process by dt milliseconds.
+   * @internal
+   */
+  _update(dt) {
+    if (this._completed || this._paused || this._cancelled) return;
+    this.elapsed += dt;
+    if (this.duration !== void 0 && this.elapsed >= this.duration) {
+      const result2 = this.updateFn(dt, this.elapsed);
+      if (this.loop && result2 !== true) {
+        this.elapsed = this.elapsed % this.duration;
+        return;
+      }
+      this.complete();
+      return;
+    }
+    const result = this.updateFn(dt, this.elapsed);
+    if (result === true) {
+      if (this.loop) {
+        this.elapsed = 0;
+        return;
+      }
+      this.complete();
+    }
+  }
+  /**
+   * Reset the process to its initial state so it can be re-run.
+   * @internal Used by Sequence for loop/repeat with direct instances.
+   */
+  _reset() {
+    this.elapsed = 0;
+    this._completed = false;
+    this._paused = false;
+    this._cancelled = false;
+    delete this.resolvePromise;
+  }
+  complete() {
+    this._completed = true;
+    this.onCompleteFn?.();
+    this.resolvePromise?.();
+  }
+};
+var easeLinear = /* @__PURE__ */ __name((t) => t, "easeLinear");
+var easeInQuad = /* @__PURE__ */ __name((t) => t * t, "easeInQuad");
+var easeOutQuad = /* @__PURE__ */ __name((t) => t * (2 - t), "easeOutQuad");
+var easeInOutQuad = /* @__PURE__ */ __name((t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t, "easeInOutQuad");
+var easeOutBounce = /* @__PURE__ */ __name((t) => {
+  if (t < 1 / 2.75) {
+    return 7.5625 * t * t;
+  } else if (t < 2 / 2.75) {
+    const t2 = t - 1.5 / 2.75;
+    return 7.5625 * t2 * t2 + 0.75;
+  } else if (t < 2.5 / 2.75) {
+    const t2 = t - 2.25 / 2.75;
+    return 7.5625 * t2 * t2 + 0.9375;
+  } else {
+    const t2 = t - 2.625 / 2.75;
+    return 7.5625 * t2 * t2 + 0.984375;
+  }
+}, "easeOutBounce");
+
+// src/Tween.ts
+var Tween = {
+  /** Tween a numeric property on a target object. */
+  to(target, property, to, duration, easing = easeLinear) {
+    const from = target[property] ?? 0;
+    return new Process({
+      duration,
+      update: /* @__PURE__ */ __name((_dt, elapsed) => {
+        const t = Math.min(elapsed / duration, 1);
+        target[property] = from + (to - from) * easing(t);
+      }, "update")
+    });
+  },
+  /** Tween using a custom setter. */
+  custom(setter, from, to, duration, easing = easeLinear) {
+    return new Process({
+      duration,
+      update: /* @__PURE__ */ __name((_dt, elapsed) => {
+        const t = Math.min(elapsed / duration, 1);
+        setter(from + (to - from) * easing(t));
+      }, "update")
+    });
+  },
+  /** Tween a Vec2 value. */
+  vec2(setter, from, to, duration, easing = easeLinear) {
+    return new Process({
+      duration,
+      update: /* @__PURE__ */ __name((_dt, elapsed) => {
+        const t = Math.min(elapsed / duration, 1);
+        const e = easing(t);
+        setter(
+          new Vec2(from.x + (to.x - from.x) * e, from.y + (to.y - from.y) * e)
+        );
+      }, "update")
+    });
+  }
+};
+
+// src/interpolate.ts
+function interpolate(from, to, t, easing) {
+  const e = easing ? easing(t) : t;
+  if (typeof from === "number") {
+    return from + (to - from) * e;
+  }
+  const a = from;
+  const b = to;
+  return new Vec2(a.x + (b.x - a.x) * e, a.y + (b.y - a.y) * e);
+}
+__name(interpolate, "interpolate");
+
+// src/KeyframeTrack.ts
+function createKeyframeTrack(options) {
+  const {
+    keyframes,
+    setter,
+    speed = 1,
+    easing: defaultEasing = easeLinear,
+    onComplete
+  } = options;
+  const duration = options.duration ?? keyframes[keyframes.length - 1].time;
+  if (duration <= 0) {
+    throw new Error("createKeyframeTrack: duration must be > 0");
+  }
+  const loop = options.loop ?? false;
+  let internalElapsed = 0;
+  const firedEvents = /* @__PURE__ */ new Set();
+  const processOpts = {
+    update(dt) {
+      internalElapsed += dt * speed;
+      if (internalElapsed >= duration) {
+        if (loop) {
+          for (let i = 0; i < keyframes.length; i++) {
+            if (keyframes[i].event && !firedEvents.has(i)) {
+              keyframes[i].event();
+            }
+          }
+          internalElapsed = internalElapsed % duration;
+          firedEvents.clear();
+          return;
+        } else {
+          setter(keyframes[keyframes.length - 1].data);
+          for (let i = 0; i < keyframes.length; i++) {
+            if (!firedEvents.has(i) && keyframes[i].event) {
+              keyframes[i].event();
+            }
+          }
+          return true;
+        }
+      }
+      for (let i = 0; i < keyframes.length; i++) {
+        if (!firedEvents.has(i) && keyframes[i].event && internalElapsed >= keyframes[i].time) {
+          firedEvents.add(i);
+          keyframes[i].event();
+        }
+      }
+      let segIdx = 0;
+      for (let i = 0; i < keyframes.length - 1; i++) {
+        if (internalElapsed >= keyframes[i].time) {
+          segIdx = i;
+        }
+      }
+      const kfA = keyframes[segIdx];
+      const kfB = keyframes[segIdx + 1];
+      const segDuration = kfB.time - kfA.time;
+      const segT = segDuration > 0 ? Math.min((internalElapsed - kfA.time) / segDuration, 1) : 1;
+      const segEasing = kfA.easing ?? defaultEasing;
+      setter(interpolate(kfA.data, kfB.data, segT, segEasing));
+    }
+  };
+  if (onComplete) processOpts.onComplete = onComplete;
+  return new Process(processOpts);
+}
+__name(createKeyframeTrack, "createKeyframeTrack");
+
+// src/ProcessSlot.ts
+var ProcessSlot = class {
+  static {
+    __name(this, "ProcessSlot");
+  }
+  config;
+  _elapsed = 0;
+  _completed = true;
+  _paused = false;
+  /** Tags for filtering/grouping. */
+  tags;
+  constructor(config = {}) {
+    this.config = config;
+    this.tags = config.tags ?? [];
+  }
+  /** Whether the slot has completed (starts true). */
+  get completed() {
+    return this._completed;
+  }
+  /** Whether the slot is actively running (not completed and not paused). */
+  get running() {
+    return !this._completed && !this._paused;
+  }
+  /** Milliseconds elapsed since start. */
+  get elapsed() {
+    return this._elapsed;
+  }
+  /** Progress ratio 0..1 (elapsed / duration). 0 if no duration set. */
+  get ratio() {
+    const d = this.config.duration;
+    if (d === void 0 || d <= 0) return 0;
+    return Math.min(this._elapsed / d, 1);
+  }
+  /** Start the slot. No-op if already running (use restart() to force). */
+  start(overrides) {
+    if (!this._completed) return this;
+    this._elapsed = 0;
+    this._completed = false;
+    this._paused = false;
+    if (overrides) {
+      this.config = { ...this.config, ...overrides };
+      if (overrides.tags) {
+        this.tags = overrides.tags;
+      }
+    }
+    return this;
+  }
+  /** Cancel if running, then start fresh. Always restarts. */
+  restart(overrides) {
+    if (!this._completed) {
+      this.config.cleanup?.();
+      this._completed = true;
+    }
+    this._completed = true;
+    return this.start(overrides);
+  }
+  /** Cancel the slot. Calls cleanup if running. */
+  cancel() {
+    if (this._completed) return;
+    this.config.cleanup?.();
+    this._completed = true;
+  }
+  /** Pause the slot. */
+  pause() {
+    if (!this._completed) this._paused = true;
+  }
+  /** Resume the slot. */
+  resume() {
+    this._paused = false;
+  }
+  /** Set/override the onComplete callback. Chainable. */
+  onComplete(fn) {
+    this.config = { ...this.config, onComplete: fn };
+    return this;
+  }
+  /**
+   * Advance the slot by dt milliseconds.
+   * @internal — called by ProcessComponent
+   */
+  _tick(dt) {
+    if (this._completed || this._paused) return;
+    this._elapsed += dt;
+    const result = this.config.update?.(dt, this._elapsed);
+    const duration = this.config.duration;
+    if (duration !== void 0 && this._elapsed >= duration) {
+      if (this.config.loop && result !== true) {
+        this._elapsed = this._elapsed % duration;
+        return;
+      }
+      this._complete();
+      return;
+    }
+    if (result === true) {
+      if (this.config.loop) {
+        this._elapsed = 0;
+        return;
+      }
+      this._complete();
+    }
+  }
+  _complete() {
+    this._completed = true;
+    try {
+      this.config.onComplete?.();
+    } finally {
+      this.config.cleanup?.();
+    }
+  }
+};
+
+// src/ProcessComponent.ts
+var ProcessComponent = class extends Component {
+  static {
+    __name(this, "ProcessComponent");
+  }
+  processes = /* @__PURE__ */ new Set();
+  slots = /* @__PURE__ */ new Set();
+  /**
+   * Run a one-off process (tween, sequence, delay).
+   * Optionally apply tags for cancel-by-tag.
+   */
+  run(process, options) {
+    if (options?.tags?.length) {
+      process.tags = [
+        ...process.tags,
+        ...options.tags
+      ];
+    }
+    this.processes.add(process);
+    return process;
+  }
+  /** Create a reusable, restartable process slot. */
+  slot(config) {
+    const s = new ProcessSlot(config);
+    this.slots.add(s);
+    return s;
+  }
+  /** Cancel all processes and slots, or only those matching a tag. */
+  cancel(tag) {
+    for (const p of this.processes) {
+      if (tag === void 0 || p.tags.includes(tag)) {
+        p.cancel();
+        this.processes.delete(p);
+      }
+    }
+    for (const s of this.slots) {
+      if (tag === void 0 || s.tags.includes(tag)) {
+        s.cancel();
+      }
+    }
+  }
+  /** Number of active (non-completed) processes and slots. */
+  get count() {
+    let n = 0;
+    for (const p of this.processes) {
+      if (!p.completed) n++;
+    }
+    for (const s of this.slots) {
+      if (!s.completed) n++;
+    }
+    return n;
+  }
+  /**
+   * Advance all processes and slots by dt milliseconds and remove completed one-offs.
+   * @internal — called by ProcessSystem
+   */
+  _tick(dt) {
+    for (const p of this.processes) {
+      p._update(dt);
+      if (p.completed) {
+        this.processes.delete(p);
+      }
+    }
+    for (const s of this.slots) {
+      s._tick(dt);
+    }
+  }
+  /** Cancel all processes and slots on entity destroy. */
+  onDestroy() {
+    this.cancel();
+  }
+};
+
+// src/KeyframeAnimator.ts
+var KeyframeAnimator = class extends Component {
+  static {
+    __name(this, "KeyframeAnimator");
+  }
+  defs;
+  active = /* @__PURE__ */ new Map();
+  pc = this.sibling(ProcessComponent);
+  constructor(animations) {
+    super();
+    this.defs = animations;
+  }
+  /** Start (or restart) a named animation. */
+  play(name) {
+    const def = this.defs[name];
+    if (!def) return;
+    if (this.active.has(name)) {
+      this.stopInternal(name, false);
+    }
+    def.onEnter?.();
+    const opts = {
+      keyframes: def.keyframes,
+      setter: def.setter,
+      onComplete: /* @__PURE__ */ __name(() => {
+        this.active.delete(name);
+        def.onExit?.(true);
+      }, "onComplete")
+    };
+    if (def.loop !== void 0) opts.loop = def.loop;
+    if (def.speed !== void 0) opts.speed = def.speed;
+    if (def.duration !== void 0) opts.duration = def.duration;
+    if (def.easing !== void 0) opts.easing = def.easing;
+    const process = createKeyframeTrack(opts);
+    this.active.set(name, process);
+    this.pc.run(process);
+  }
+  /** Stop a named animation. */
+  stop(name) {
+    this.stopInternal(name, false);
+  }
+  /** Stop all playing animations. */
+  stopAll() {
+    for (const name of [...this.active.keys()]) {
+      this.stopInternal(name, false);
+    }
+  }
+  /** Whether a named animation is currently playing. */
+  isPlaying(name) {
+    return this.active.has(name);
+  }
+  onDestroy() {
+    this.stopAll();
+  }
+  stopInternal(name, complete) {
+    const process = this.active.get(name);
+    if (!process) return;
+    process.cancel();
+    this.active.delete(name);
+    this.defs[name]?.onExit?.(complete);
+  }
+};
+
+// src/Sequence.ts
+var Sequence = class {
+  static {
+    __name(this, "Sequence");
+  }
+  steps = [];
+  _loop = false;
+  _repeatCount;
+  /** Add a step (Process or factory function). */
+  then(step) {
+    this.steps.push({
+      type: "single",
+      factories: [typeof step === "function" ? step : wrapInstance(step)]
+    });
+    return this;
+  }
+  /** Add a delay in ms. */
+  wait(ms) {
+    this.steps.push({
+      type: "single",
+      factories: [
+        () => new Process({
+          duration: ms,
+          update: /* @__PURE__ */ __name(() => {
+          }, "update")
+        })
+      ]
+    });
+    return this;
+  }
+  /** Add an instant callback. */
+  call(fn) {
+    this.steps.push({
+      type: "single",
+      factories: [
+        () => new Process({
+          update: /* @__PURE__ */ __name(() => {
+            fn();
+            return true;
+          }, "update")
+        })
+      ]
+    });
+    return this;
+  }
+  /** Run steps in parallel (all must complete before sequence continues). */
+  parallel(...steps) {
+    this.steps.push({
+      type: "parallel",
+      factories: steps.map(
+        (s) => typeof s === "function" ? s : wrapInstance(s)
+      )
+    });
+    return this;
+  }
+  /** Loop the sequence indefinitely. */
+  loop() {
+    this._loop = true;
+    return this;
+  }
+  /** Repeat the sequence a fixed number of times (1 = play once, 2 = play twice, etc.). */
+  repeat(times) {
+    this._repeatCount = times;
+    return this;
+  }
+  /**
+   * Build the sequence into a Process without registering with a scene.
+   * Exposed for unit testing.
+   * @internal
+   */
+  _build() {
+    const steps = this.steps;
+    const looping = this._loop;
+    const repeatCount = this._repeatCount;
+    let stepIndex = 0;
+    let active = [];
+    let iteration = 1;
+    return new Process({
+      update: /* @__PURE__ */ __name((dt) => {
+        if (active.length === 0 && stepIndex < steps.length) {
+          const step = steps[stepIndex];
+          if (!step) return true;
+          active = step.factories.map((f) => f());
+        }
+        for (const proc of active) {
+          proc._update(dt);
+        }
+        if (active.every((p) => p.completed)) {
+          active = [];
+          stepIndex++;
+          if (stepIndex >= steps.length) {
+            if (looping) {
+              stepIndex = 0;
+              return false;
+            }
+            if (repeatCount !== void 0 && iteration < repeatCount) {
+              iteration++;
+              stepIndex = 0;
+              return false;
+            }
+            return true;
+          }
+        }
+        return false;
+      }, "update")
+    });
+  }
+  /** Build and start the sequence. Returns the wrapping Process. */
+  start() {
+    return this._build();
+  }
+};
+function wrapInstance(proc) {
+  return () => {
+    proc._reset();
+    return proc;
+  };
+}
+__name(wrapInstance, "wrapInstance");
+
+// src/TimerEntity.ts
+var TimerEntity = class extends Entity {
+  static {
+    __name(this, "TimerEntity");
+  }
+  pc;
+  setup() {
+    this.pc = this.add(new ProcessComponent());
+  }
+  run(process, options) {
+    return this.pc.run(process, options);
+  }
+  slot(config) {
+    return this.pc.slot(config);
+  }
+  cancel(tag) {
+    this.pc.cancel(tag);
+  }
+};
+
+// src/ProcessSystem.ts
+var ProcessSystem = class extends System {
+  static {
+    __name(this, "ProcessSystem");
+  }
+  phase = "update" /* Update */;
+  priority = 500;
+  /** Global time scale multiplier. Stacks multiplicatively with per-scene timeScale. */
+  timeScale = 1;
+  sceneManager;
+  sceneProcesses = /* @__PURE__ */ new Set();
+  onRegister(context) {
+    this.sceneManager = context.resolve(SceneManagerKey);
+  }
+  /** Add a scene-level process (not tied to any entity). */
+  add(process) {
+    this.sceneProcesses.add(process);
+    return process;
+  }
+  /** Cancel scene-level processes, optionally by tag. */
+  cancel(tag) {
+    for (const p of this.sceneProcesses) {
+      if (tag === void 0 || p.tags.includes(tag)) {
+        p.cancel();
+      }
+    }
+    if (tag === void 0) {
+      this.sceneProcesses.clear();
+    }
+  }
+  update(dt) {
+    const globalScaledDt = dt * this.timeScale;
+    for (const p of this.sceneProcesses) {
+      p._update(globalScaledDt);
+      if (p.completed) {
+        this.sceneProcesses.delete(p);
+      }
+    }
+    for (const scene of this.sceneManager.activeScenes) {
+      const effectiveDt = globalScaledDt * scene.timeScale;
+      for (const entity of scene.getEntities()) {
+        if (entity.isDestroyed) continue;
+        const pc = entity.tryGet(ProcessComponent);
+        if (!pc) continue;
+        pc._tick(effectiveDt);
+      }
+    }
+  }
+};
+
+// src/Inspector.ts
+var Inspector = class {
+  static {
+    __name(this, "Inspector");
+  }
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  /** Full state snapshot (serializable). */
+  snapshot() {
+    return {
+      frameCount: this.engine.loop.frameCount,
+      sceneStack: this.getSceneStack(),
+      entityCount: this.countEntities(),
+      systemCount: this.getSystems().length,
+      errors: this.getErrors()
+    };
+  }
+  /** Find entity by name in the active scene. */
+  getEntityByName(name) {
+    const entity = this.findActiveEntity(name);
+    if (!entity) return void 0;
+    return this.entityToSnapshot(entity);
+  }
+  /** Get entity position (from Transform component). */
+  getEntityPosition(name) {
+    const entity = this.findActiveEntity(name);
+    if (!entity) return void 0;
+    const transform = this.getTransform(entity);
+    if (!transform) return void 0;
+    return { x: transform.position.x, y: transform.position.y };
+  }
+  /** Check if an entity has a component by class name string. */
+  hasComponent(entityName, componentClass) {
+    return this.findComponentByName(entityName, componentClass) !== void 0;
+  }
+  /** Get component data (serializable subset) by class name string. */
+  getComponentData(entityName, componentClass) {
+    const comp = this.findComponentByName(entityName, componentClass);
+    if (!comp) return void 0;
+    return this.serializeComponent(comp);
+  }
+  /** Get all entities in the active scene as snapshots. */
+  getEntities() {
+    const scene = this.engine.scenes.active;
+    if (!scene) return [];
+    const result = [];
+    for (const entity of scene.getEntities()) {
+      if (!entity.isDestroyed) {
+        result.push(this.entityToSnapshot(entity));
+      }
+    }
+    return result;
+  }
+  /** Get scene stack info. */
+  getSceneStack() {
+    return this.engine.scenes.all.map((scene) => ({
+      name: scene.name,
+      entityCount: scene.getEntities().size,
+      paused: scene.isPaused
+    }));
+  }
+  /** Get active system info. */
+  getSystems() {
+    const scheduler = this.engine.context.tryResolve(SystemSchedulerKey);
+    if (!scheduler) return [];
+    return scheduler.getAllSystems().map((sys) => ({
+      name: sys.constructor.name,
+      phase: sys.phase,
+      priority: sys.priority,
+      enabled: sys.enabled
+    }));
+  }
+  /** Get disabled components/systems from error boundary. */
+  getErrors() {
+    const boundary = this.engine.context.tryResolve(ErrorBoundaryKey);
+    if (!boundary) return { disabledSystems: [], disabledComponents: [] };
+    const disabled = boundary.getDisabled();
+    return {
+      disabledSystems: disabled.systems.map(
+        (s) => s.system.constructor.name
+      ),
+      disabledComponents: disabled.components.map((c) => ({
+        entity: c.component.entity?.name ?? "unknown",
+        component: c.component.constructor.name,
+        error: c.error
+      }))
+    };
+  }
+  findActiveEntity(name) {
+    return this.engine.scenes.active?.findEntity(name);
+  }
+  findComponentByName(entityName, componentClass) {
+    const entity = this.findActiveEntity(entityName);
+    if (!entity) return void 0;
+    for (const comp of entity.getAll()) {
+      if (comp.constructor.name === componentClass) return comp;
+    }
+    return void 0;
+  }
+  entityToSnapshot(entity) {
+    const transform = this.getTransform(entity);
+    const snapshot = {
+      id: entity.id,
+      name: entity.name,
+      tags: [...entity.tags],
+      components: [...entity.getAll()].map((c) => c.constructor.name)
+    };
+    if (transform) {
+      snapshot.position = {
+        x: transform.position.x,
+        y: transform.position.y
+      };
+    }
+    return snapshot;
+  }
+  getTransform(entity) {
+    return entity.has(Transform) ? entity.get(Transform) : void 0;
+  }
+  serializeComponent(comp) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(comp)) {
+      if (key === "entity") continue;
+      const value = comp[key];
+      if (typeof value !== "function") {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  countEntities() {
+    let count = 0;
+    for (const scene of this.engine.scenes.all) {
+      count += scene.getEntities().size;
+    }
+    return count;
+  }
+};
+
+// src/Engine.ts
+var Engine = class {
+  static {
+    __name(this, "Engine");
+  }
+  /** The dependency injection container. */
+  context;
+  /** The scene manager. */
+  scenes;
+  /** The event bus. */
+  events;
+  /** The game loop. */
+  loop;
+  /** The logger. */
+  logger;
+  /** The inspector (debug queries). */
+  inspector;
+  scheduler;
+  errorBoundary;
+  queryCache;
+  /** The asset manager. */
+  assets;
+  plugins = /* @__PURE__ */ new Map();
+  sortedPlugins = [];
+  started = false;
+  debug;
+  constructor(config) {
+    this.debug = config?.debug ?? false;
+    this.context = new EngineContext();
+    this.events = new EventBus();
+    this.logger = new Logger(config?.logger);
+    this.queryCache = new QueryCache();
+    this.errorBoundary = new ErrorBoundary(this.logger);
+    this.loop = new GameLoop(config);
+    this.scenes = new SceneManager();
+    this.scheduler = new SystemScheduler();
+    this.inspector = new Inspector(this);
+    this.assets = new AssetManager();
+    this.scheduler.setErrorBoundary(this.errorBoundary);
+    this.context.register(EngineKey, this);
+    this.context.register(EventBusKey, this.events);
+    this.context.register(SceneManagerKey, this.scenes);
+    this.context.register(LoggerKey, this.logger);
+    this.context.register(QueryCacheKey, this.queryCache);
+    this.context.register(ErrorBoundaryKey, this.errorBoundary);
+    this.context.register(GameLoopKey, this.loop);
+    this.context.register(InspectorKey, this.inspector);
+    this.context.register(SystemSchedulerKey, this.scheduler);
+    this.context.register(AssetManagerKey, this.assets);
+    this.scenes._setContext(this.context);
+    this.registerBuiltInSystems();
+    this.loop.setCallbacks({
+      earlyUpdate: /* @__PURE__ */ __name((dt) => {
+        this.logger.setFrame(this.loop.frameCount);
+        this.scheduler.run("earlyUpdate" /* EarlyUpdate */, dt);
+      }, "earlyUpdate"),
+      fixedUpdate: /* @__PURE__ */ __name((dt) => this.scheduler.run("fixedUpdate" /* FixedUpdate */, dt), "fixedUpdate"),
+      update: /* @__PURE__ */ __name((dt) => this.scheduler.run("update" /* Update */, dt), "update"),
+      lateUpdate: /* @__PURE__ */ __name((dt) => this.scheduler.run("lateUpdate" /* LateUpdate */, dt), "lateUpdate"),
+      render: /* @__PURE__ */ __name((dt) => this.scheduler.run("render" /* Render */, dt), "render"),
+      endOfFrame: /* @__PURE__ */ __name((dt) => {
+        this.scheduler.run("endOfFrame" /* EndOfFrame */, dt);
+        this.scenes._flushDestroyQueues();
+      }, "endOfFrame")
+    });
+  }
+  /** Register a plugin. Must be called before start(). */
+  use(plugin) {
+    if (this.started) {
+      throw new Error("Cannot register plugins after engine has started.");
+    }
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered.`);
+    }
+    this.plugins.set(plugin.name, plugin);
+    return this;
+  }
+  /** Start the engine. Installs plugins in topological order, starts the game loop. */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    this.sortedPlugins = this.topologicalSort();
+    const sorted = this.sortedPlugins;
+    for (const plugin of sorted) {
+      await plugin.install?.(this.context);
+    }
+    for (const plugin of sorted) {
+      plugin.registerSystems?.(this.scheduler);
+    }
+    for (const sys of this.scheduler.getAllSystems()) {
+      sys._setContext(this.context);
+      sys.onRegister?.(this.context);
+    }
+    this.loop.start();
+    if (this.debug && typeof globalThis !== "undefined") {
+      globalThis["__yage__"] = {
+        inspector: this.inspector,
+        logger: this.logger
+      };
+    }
+    for (const plugin of sorted) {
+      plugin.onStart?.();
+    }
+    this.events.emit("engine:started", void 0);
+  }
+  /** Stop the engine. Destroys all scenes, plugins, and the game loop. */
+  destroy() {
+    this.events.emit("engine:stopped", void 0);
+    this.loop.stop();
+    this.scenes.clear();
+    const allSystems = this.scheduler.getAllSystems();
+    for (let i = allSystems.length - 1; i >= 0; i--) {
+      allSystems[i].onUnregister?.();
+    }
+    for (let i = this.sortedPlugins.length - 1; i >= 0; i--) {
+      const plugin = this.sortedPlugins[i];
+      if (plugin) plugin.onDestroy?.();
+    }
+    if (this.debug && typeof globalThis !== "undefined" && "__yage__" in globalThis) {
+      delete globalThis["__yage__"];
+    }
+    this.events.clear();
+    this.started = false;
+  }
+  registerBuiltInSystems() {
+    const fixedUpdate = new ComponentFixedUpdateSystem();
+    const update = new ComponentUpdateSystem();
+    const processSystem = new ProcessSystem();
+    this.scheduler.add(fixedUpdate);
+    this.scheduler.add(update);
+    this.scheduler.add(processSystem);
+    this.context.register(ProcessSystemKey, processSystem);
+  }
+  /**
+   * Topological sort of plugins using Kahn's algorithm.
+   * Errors on missing dependencies, circular dependencies, and duplicates.
+   */
+  topologicalSort() {
+    const plugins = [...this.plugins.values()];
+    const nameMap = /* @__PURE__ */ new Map();
+    const inDegree = /* @__PURE__ */ new Map();
+    const edges = /* @__PURE__ */ new Map();
+    for (const p of plugins) {
+      nameMap.set(p.name, p);
+      inDegree.set(p.name, 0);
+      edges.set(p.name, []);
+    }
+    for (const p of plugins) {
+      for (const dep of p.dependencies ?? []) {
+        if (!nameMap.has(dep)) {
+          throw new Error(
+            `Plugin "${p.name}" depends on "${dep}", which is not registered.`
+          );
+        }
+        const depEdges = edges.get(dep);
+        if (depEdges) depEdges.push(p.name);
+        inDegree.set(p.name, (inDegree.get(p.name) ?? 0) + 1);
+      }
+    }
+    const queue = [];
+    for (const [name, degree] of inDegree) {
+      if (degree === 0) queue.push(name);
+    }
+    const result = [];
+    while (queue.length > 0) {
+      const name = queue.shift();
+      if (name === void 0) break;
+      const plugin = nameMap.get(name);
+      if (!plugin) continue;
+      result.push(plugin);
+      for (const dependent of edges.get(name) ?? []) {
+        const newDegree = (inDegree.get(dependent) ?? 0) - 1;
+        inDegree.set(dependent, newDegree);
+        if (newDegree === 0) queue.push(dependent);
+      }
+    }
+    if (result.length !== plugins.length) {
+      throw new Error("Circular dependency detected among plugins.");
+    }
+    return result;
+  }
+};
+
+// src/test-utils.ts
+var _TestScene = class extends Scene {
+  static {
+    __name(this, "_TestScene");
+  }
+  name;
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+};
+async function createTestEngine(config) {
+  _resetEntityIdCounter();
+  const engine = new Engine(config);
+  await engine.start();
+  return engine;
+}
+__name(createTestEngine, "createTestEngine");
+function createMockScene(name = "mock-scene") {
+  _resetEntityIdCounter();
+  const ctx = new EngineContext();
+  const queryCache = new QueryCache();
+  const bus = new EventBus();
+  const logger = new Logger({ level: 0 /* Debug */ });
+  const boundary = new ErrorBoundary(logger);
+  ctx.register(QueryCacheKey, queryCache);
+  ctx.register(EventBusKey, bus);
+  ctx.register(ErrorBoundaryKey, boundary);
+  const scene = new _TestScene(name);
+  scene._setContext(ctx);
+  return { scene, context: ctx };
+}
+__name(createMockScene, "createMockScene");
+function createMockEntity(name = "mock-entity") {
+  const { scene, context } = createMockScene();
+  const entity = scene.spawn(name);
+  return { entity, scene, context };
+}
+__name(createMockEntity, "createMockEntity");
+function advanceFrames(engine, n, dtMs = 1e3 / 60) {
+  for (let i = 0; i < n; i++) {
+    engine.loop.tick(dtMs);
+  }
+}
+__name(advanceFrames, "advanceFrames");
+
+// src/index.ts
+var VERSION = "0.0.0";
+export {
+  AssetHandle,
+  AssetManager,
+  AssetManagerKey,
+  Component,
+  ComponentFixedUpdateSystem,
+  ComponentUpdateSystem,
+  Engine,
+  EngineContext,
+  EngineKey,
+  Entity,
+  ErrorBoundary,
+  ErrorBoundaryKey,
+  EventBus,
+  EventBusKey,
+  EventToken,
+  GameLoop,
+  GameLoopKey,
+  Inspector,
+  InspectorKey,
+  KeyframeAnimator,
+  LogLevel,
+  Logger,
+  LoggerKey,
+  MathUtils,
+  Phase,
+  Process,
+  ProcessComponent,
+  ProcessSlot,
+  ProcessSystem,
+  ProcessSystemKey,
+  QueryCache,
+  QueryCacheKey,
+  QueryResult,
+  SERIALIZABLE_KEY,
+  Scene,
+  SceneManager,
+  SceneManagerKey,
+  Sequence,
+  SerializableRegistry,
+  ServiceKey,
+  System,
+  SystemScheduler,
+  SystemSchedulerKey,
+  TimerEntity,
+  TraitToken,
+  Transform,
+  Tween,
+  VERSION,
+  Vec2,
+  _resetEntityIdCounter,
+  advanceFrames,
+  createKeyframeTrack,
+  createMockEntity,
+  createMockScene,
+  createTestEngine,
+  defineBlueprint,
+  defineEvent,
+  defineTrait,
+  easeInOutQuad,
+  easeInQuad,
+  easeLinear,
+  easeOutBounce,
+  easeOutQuad,
+  filterEntities,
+  getSerializableType,
+  interpolate,
+  isSerializable,
+  serializable,
+  trait
+};
+//# sourceMappingURL=index.js.map