@oasys/oecs 0.2.1 → 0.3.1

package/dist/index.js

@@ -1,80 +1,80 @@
-class H extends Error {
+class Z extends Error {
   constructor(t, e, s) {
     super(t), this.is_operational = e, this.context = s, this.name = this.constructor.name, Error.captureStackTrace(this, this.constructor);
   }
 }
-var z = /* @__PURE__ */ ((l) => (l.EID_MAX_INDEX_OVERFLOW = "EID_MAX_INDEX_OVERFLOW", l.EID_MAX_GEN_OVERFLOW = "EID_MAX_GEN_OVERFLOW", l.COMPONENT_NOT_REGISTERED = "COMPONENT_NOT_REGISTERED", l.ENTITY_NOT_ALIVE = "ENTITY_NOT_ALIVE", l.CIRCULAR_SYSTEM_DEPENDENCY = "CIRCULAR_SYSTEM_DEPENDENCY", l.DUPLICATE_SYSTEM = "DUPLICATE_SYSTEM", l.ARCHETYPE_NOT_FOUND = "ARCHETYPE_NOT_FOUND", l.RESOURCE_NOT_REGISTERED = "RESOURCE_NOT_REGISTERED", l))(z || {});
-class Q extends H {
+var D = /* @__PURE__ */ ((a) => (a.EID_MAX_INDEX_OVERFLOW = "EID_MAX_INDEX_OVERFLOW", a.EID_MAX_GEN_OVERFLOW = "EID_MAX_GEN_OVERFLOW", a.COMPONENT_NOT_REGISTERED = "COMPONENT_NOT_REGISTERED", a.ENTITY_NOT_ALIVE = "ENTITY_NOT_ALIVE", a.CIRCULAR_SYSTEM_DEPENDENCY = "CIRCULAR_SYSTEM_DEPENDENCY", a.DUPLICATE_SYSTEM = "DUPLICATE_SYSTEM", a.ARCHETYPE_NOT_FOUND = "ARCHETYPE_NOT_FOUND", a.RESOURCE_NOT_REGISTERED = "RESOURCE_NOT_REGISTERED", a.RESOURCE_ALREADY_REGISTERED = "RESOURCE_ALREADY_REGISTERED", a.EVENT_ALREADY_REGISTERED = "EVENT_ALREADY_REGISTERED", a.EVENT_NOT_REGISTERED = "EVENT_NOT_REGISTERED", a))(D || {});
+class O extends Z {
   constructor(t, e, s) {
     super(e ?? t, !0, s), this.category = t;
   }
 }
-function N(l, t, e) {
-  return l;
+function F(a, t, e) {
+  return a;
 }
-const v = -1, y = -1, D = Object.freeze(/* @__PURE__ */ Object.create(null)), k = 5, I = 31, J = 2166136261, Z = 16777619, tt = 2654435769, et = 1367130551, b = 16, C = 2, V = 1024, R = 0, j = 0, st = 31, nt = 1 / 60, rt = 4, it = 0, ot = 4;
-class x {
+const I = 5, S = 31, tt = 2166136261, et = 16777619, st = 4;
+class p {
   _words;
   constructor(t) {
-    this._words = t ?? new Array(ot).fill(0);
+    this._words = t ?? new Array(st).fill(0);
   }
   has(t) {
-    const e = t >>> k;
-    return e >= this._words.length ? !1 : (this._words[e] & 1 << (t & I)) !== 0;
+    const e = t >>> I;
+    return e >= this._words.length ? !1 : (this._words[e] & 1 << (t & S)) !== 0;
   }
   set(t) {
-    const e = t >>> k;
-    e >= this._words.length && this.grow(e + 1), this._words[e] |= 1 << (t & I);
+    const e = t >>> I;
+    e >= this._words.length && this.grow(e + 1), this._words[e] |= 1 << (t & S);
   }
   clear(t) {
-    const e = t >>> k;
-    e >= this._words.length || (this._words[e] &= ~(1 << (t & I)));
+    const e = t >>> I;
+    e >= this._words.length || (this._words[e] &= ~(1 << (t & S)));
   }
   /** True if any bit is set in both this and other (non-empty intersection). */
   overlaps(t) {
     const e = this._words, s = t._words, n = e.length < s.length ? e.length : s.length;
-    for (let r = 0; r < n; r++)
-      if ((e[r] & s[r]) !== 0) return !0;
+    for (let i = 0; i < n; i++)
+      if ((e[i] & s[i]) !== 0) return !0;
     return !1;
   }
   /** True if this is a superset of other (all bits in other are set in this). */
   contains(t) {
     const e = t._words, s = this._words, n = s.length;
-    for (let r = 0; r < e.length; r++) {
-      const i = e[r];
-      if (i !== 0 && (r >= n || (s[r] & i) !== i))
+    for (let i = 0; i < e.length; i++) {
+      const r = e[i];
+      if (r !== 0 && (i >= n || (s[i] & r) !== r))
         return !1;
     }
     return !0;
   }
   equals(t) {
     const e = this._words, s = t._words, n = e.length > s.length ? e.length : s.length;
-    for (let r = 0; r < n; r++) {
-      const i = r < e.length ? e[r] : 0, _ = r < s.length ? s[r] : 0;
-      if (i !== _) return !1;
+    for (let i = 0; i < n; i++) {
+      const r = i < e.length ? e[i] : 0, c = i < s.length ? s[i] : 0;
+      if (r !== c) return !1;
     }
     return !0;
   }
   copy() {
-    return new x(this._words.slice());
+    return new p(this._words.slice());
   }
   copy_with_set(t) {
-    const e = t >>> k, s = e + 1, n = this._words.length > s ? this._words.length : s, r = new Array(n).fill(0);
-    for (let i = 0; i < this._words.length; i++) r[i] = this._words[i];
-    return r[e] |= 1 << (t & I), new x(r);
+    const e = t >>> I, s = e + 1, n = this._words.length > s ? this._words.length : s, i = new Array(n).fill(0);
+    for (let r = 0; r < this._words.length; r++) i[r] = this._words[r];
+    return i[e] |= 1 << (t & S), new p(i);
   }
   copy_with_clear(t) {
-    const e = this._words.slice(), s = t >>> k;
-    return s < e.length && (e[s] &= ~(1 << (t & I))), new x(e);
+    const e = this._words.slice(), s = t >>> I;
+    return s < e.length && (e[s] &= ~(1 << (t & S))), new p(e);
   }
   /** FNV-1a hash. Skips trailing zero words so differently-sized arrays with the same bits hash equally. */
   hash() {
-    let t = J;
+    let t = tt;
     const e = this._words;
     let s = e.length - 1;
     for (; s >= 0 && e[s] === 0; ) s--;
     for (let n = 0; n <= s; n++)
-      t ^= e[n], t = Math.imul(t, Z);
+      t ^= e[n], t = Math.imul(t, et);
     return t;
   }
   /** Iterate all set bits via lowest-set-bit extraction. */
@@ -83,10 +83,10 @@ class x {
     for (let s = 0; s < e.length; s++) {
       let n = e[s];
       if (n === 0) continue;
-      const r = s << k;
+      const i = s << I;
       for (; n !== 0; ) {
-        const i = n & -n >>> 0, _ = I - Math.clz32(i);
-        t(r + _), n ^= i;
+        const r = n & -n >>> 0, c = S - Math.clz32(r);
+        t(i + c), n ^= r;
       }
     }
   }
@@ -98,8 +98,9 @@ class x {
     this._words = s;
   }
 }
+const b = 16, X = 2;
 class A {
-  constructor(t, e = b) {
+  constructor(t, e = 16) {
     this._ctor = t, this._buf = new t(e);
   }
   _buf;
@@ -158,7 +159,7 @@ class A {
   ensure_capacity(t) {
     if (t <= this._buf.length) return;
     let e = this._buf.length || 1;
-    for (; e < t; ) e *= C;
+    for (; e < t; ) e *= X;
     const s = new this._ctor(e);
     s.set(this._buf.subarray(0, this._len)), this._buf = s;
   }
@@ -174,65 +175,151 @@ class A {
     this.ensure_capacity(this._len + t), this._buf.fill(0, this._len, this._len + t), this._len += t;
   }
   _grow() {
-    const t = new this._ctor(this._buf.length * C);
+    const t = new this._ctor(this._buf.length * X);
     t.set(this._buf), this._buf = t;
   }
 }
-class _t extends A {
+class nt extends A {
   constructor(t = b) {
     super(Float32Array, t);
   }
 }
-class ct extends A {
+class it extends A {
   constructor(t = b) {
     super(Float64Array, t);
   }
 }
-class ht extends A {
+class rt extends A {
   constructor(t = b) {
     super(Int8Array, t);
   }
 }
-class lt extends A {
+class _t extends A {
   constructor(t = b) {
     super(Int16Array, t);
   }
 }
-class at extends A {
+class ot extends A {
   constructor(t = b) {
     super(Int32Array, t);
   }
 }
-class dt extends A {
+class ct extends A {
   constructor(t = b) {
     super(Uint8Array, t);
   }
 }
-class ut extends A {
+class ht extends A {
   constructor(t = b) {
     super(Uint16Array, t);
   }
 }
-class B extends A {
+class H extends A {
   constructor(t = b) {
     super(Uint32Array, t);
   }
 }
-const ft = {
-  f32: _t,
-  f64: ct,
-  i8: ht,
-  i16: lt,
-  i32: at,
-  u8: dt,
-  u16: ut,
-  u32: B
-}, P = 20, F = (1 << P) - 1, gt = st - P, X = (1 << gt) - 1, mt = (l, t) => t << P | l, m = (l) => l & F, Y = (l) => l >> P, yt = (l) => N(
-  l
-), pt = (l) => N(
-  l
+const at = {
+  f32: nt,
+  f64: it,
+  i8: rt,
+  i16: _t,
+  i32: ot,
+  u8: ct,
+  u16: ht,
+  u32: H
+};
+class lt {
+  _compare;
+  _data = [];
+  constructor(t) {
+    this._compare = t;
+  }
+  get size() {
+    return this._data.length;
+  }
+  /** Returns the highest-priority element without removing it, or undefined if empty. */
+  peek() {
+    return this._data[0];
+  }
+  /** Inserts a value and restores heap order by sifting up. O(log n). */
+  push(t) {
+    this._data.push(t), this._sift_up(this._data.length - 1);
+  }
+  /** Removes and returns the highest-priority element, or undefined if empty. O(log n). */
+  pop() {
+    const t = this._data;
+    if (t.length === 0) return;
+    const s = t[0], n = t.pop();
+    return t.length > 0 && (t[0] = n, this._sift_down(0)), s;
+  }
+  /** Removes all elements. O(1). */
+  clear() {
+    this._data.length = 0;
+  }
+  /** Moves a node up toward the root until heap order is restored. */
+  _sift_up(t) {
+    const e = this._data, s = this._compare, n = e[t];
+    for (; t > 0; ) {
+      const i = t - 1 >> 1;
+      if (s(n, e[i]) >= 0) break;
+      e[t] = e[i], t = i;
+    }
+    e[t] = n;
+  }
+  /** Moves a node down away from the root until heap order is restored. */
+  _sift_down(t) {
+    const e = this._data, s = this._compare, n = e.length, i = n >> 1, r = e[t];
+    for (; t < i; ) {
+      let c = (t << 1) + 1;
+      const o = c + 1;
+      if (o < n && s(e[o], e[c]) < 0 && (c = o), s(e[c], r) >= 0) break;
+      e[t] = e[c], t = c;
+    }
+    e[t] = r;
+  }
+}
+function dt(a, t, e, s) {
+  const n = s ?? ((o) => String(o)), i = /* @__PURE__ */ new Map();
+  for (let o = 0; o < a.length; o++)
+    i.set(a[o], 0);
+  for (const [, o] of t)
+    for (let _ = 0; _ < o.length; _++) {
+      const h = o[_];
+      i.has(h) && i.set(h, i.get(h) + 1);
+    }
+  const r = new lt(e);
+  for (let o = 0; o < a.length; o++)
+    i.get(a[o]) === 0 && r.push(a[o]);
+  const c = [];
+  for (; r.size > 0; ) {
+    const o = r.pop();
+    c.push(o);
+    const _ = t.get(o);
+    if (_ !== void 0)
+      for (let h = 0; h < _.length; h++) {
+        const l = _[h];
+        if (!i.has(l)) continue;
+        const d = i.get(l) - 1;
+        i.set(l, d), d === 0 && r.push(l);
+      }
+  }
+  if (c.length !== a.length) {
+    const o = [];
+    for (const [_, h] of i)
+      h > 0 && o.push(n(_));
+    throw new globalThis.TypeError(
+      `Cycle detected in topological sort. Nodes still pending: ${o.join(", ")}`
+    );
+  }
+  return c;
+}
+const k = -1, m = -1, q = Object.freeze(/* @__PURE__ */ Object.create(null)), ut = 2654435769, ft = 1367130551, K = 1024, j = 0, gt = 31, yt = 1 / 60, mt = 4, pt = 0, R = 20, M = (1 << R) - 1, wt = gt - R, V = (1 << wt) - 1, vt = (a, t) => t << R | a, y = (a) => a & M, z = (a) => a >> R, Et = (a) => F(
+  a
+), kt = (a) => F(
+  a
 );
-class wt {
+class Tt {
   field_names;
   columns;
   // any: type-erased storage — channel is stored in Map<number, EventChannel>, F is lost
@@ -263,53 +350,26 @@ class wt {
       t[e].length = 0;
   }
 }
-const vt = (l) => N(
-  l
-);
-class xt {
-  field_names;
-  field_index;
-  columns;
-  // any: type-erased storage — channel is stored in Map<number, ResourceChannel>, F is lost
-  reader;
-  constructor(t, e) {
-    this.field_names = t, this.field_index = /* @__PURE__ */ Object.create(null), this.columns = [];
-    for (let r = 0; r < t.length; r++)
-      this.field_index[t[r]] = r, this.columns.push([e[t[r]] ?? 0]);
-    const s = /* @__PURE__ */ Object.create(null), n = this.columns;
-    for (let r = 0; r < t.length; r++) {
-      const i = n[r];
-      Object.defineProperty(s, t[r], {
-        get() {
-          return i[R];
-        },
-        enumerable: !0
-      });
-    }
-    this.reader = s;
-  }
-  write(t) {
-    const e = this.field_names, s = this.columns;
-    for (let n = 0; n < e.length; n++)
-      e[n] in t && (s[n][R] = t[e[n]]);
-  }
-  read_field(t) {
-    return this.columns[t][R];
-  }
-  write_field(t, e) {
-    this.columns[t][R] = e;
-  }
+function Ot(a) {
+  return Symbol(a);
 }
-const bt = (l) => N(
-  l
+function qt(a) {
+  return Symbol(a);
+}
+const bt = (a) => F(
+  a
 );
-class Tt {
+class At {
   id;
   mask;
   has_columns;
   _entity_ids;
   length = 0;
   edges = [];
+  // Cache for multi-component transition maps (from this archetype to another).
+  // Covers add_components / remove_components where the (src, dst) pair is not
+  // a single-component edge and therefore not covered by `edges[].add_map/remove_map`.
+  batch_transition_maps = /* @__PURE__ */ new Map();
   // --- Flat column storage ---
   // Dense array of ALL columns across all components in this archetype.
   _flat_columns = [];
@@ -325,17 +385,19 @@ class Tt {
   column_groups = [];
   // Dense list of ComponentIDs that have columns — used for copy_shared_from.
   _column_ids = [];
-  constructor(t, e, s, n = V) {
-    if (this.id = t, this.mask = e, this._entity_ids = new B(n), s) {
-      let r = 0;
-      for (let i = 0; i < s.length; i++) {
-        const _ = s[i], c = _.component_id, o = new Array(_.field_names.length);
-        this._col_offset[c] = r, this._field_count[c] = _.field_names.length, this._field_index[c] = _.field_index, this._field_names[c] = _.field_names;
-        for (let h = 0; h < _.field_names.length; h++) {
-          const a = new ft[_.field_types[h]](n);
-          o[h] = a, this._flat_columns[r++] = a;
+  // Sparse by ComponentID → last tick that modified this component's columns.
+  _changed_tick = [];
+  constructor(t, e, s, n = K) {
+    if (this.id = t, this.mask = e, this._entity_ids = new H(n), s) {
+      let i = 0;
+      for (let r = 0; r < s.length; r++) {
+        const c = s[r], o = c.component_id, _ = new Array(c.field_names.length);
+        this._col_offset[o] = i, this._field_count[o] = c.field_names.length, this._field_index[o] = c.field_index, this._field_names[o] = c.field_names;
+        for (let h = 0; h < c.field_names.length; h++) {
+          const l = new at[c.field_types[h]](n);
+          _[h] = l, this._flat_columns[i++] = l;
         }
-        this.column_groups[c] = { layout: _, columns: o }, this._column_ids.push(c);
+        this.column_groups[o] = { layout: c, columns: _ }, this._column_ids.push(o), this._changed_tick[o] = 0;
       }
     }
     this.has_columns = this._column_ids.length > 0;
@@ -356,41 +418,51 @@ class Tt {
   matches(t) {
     return this.mask.contains(t);
   }
-  /** Get a single field's column. Valid data: indices 0..entity_count-1. */
+  /** Get a single field's column (read-only). Valid data: indices 0..entity_count-1. */
   get_column(t, e) {
     const s = t, n = this._field_index[s][e];
     return this._flat_columns[this._col_offset[s] + n].buf;
   }
-  write_fields(t, e, s) {
-    const n = e, r = this._col_offset[n];
+  /** Get a single field's column (mutable). Marks the component as changed at the given tick. */
+  get_column_mut(t, e, s) {
+    const n = t;
+    this._changed_tick[n] = s;
+    const i = this._field_index[n][e];
+    return this._flat_columns[this._col_offset[n] + i].buf;
+  }
+  write_fields(t, e, s, n) {
+    const i = e, r = this._col_offset[i];
     if (r === void 0) return;
-    const i = this._field_names[n], _ = this._flat_columns;
-    for (let c = 0; c < i.length; c++)
-      _[r + c].buf[t] = s[i[c]];
+    this._changed_tick[i] = n;
+    const c = this._field_names[i], o = this._flat_columns;
+    for (let _ = 0; _ < c.length; _++)
+      o[r + _].buf[t] = s[c[_]];
   }
   /** Fast positional write: values[i] → field[i] in declaration order. No string lookup. */
-  write_fields_positional(t, e, s) {
-    const n = e, r = this._col_offset[n];
+  write_fields_positional(t, e, s, n) {
+    const i = e, r = this._col_offset[i];
     if (r === void 0) return;
-    const i = this._flat_columns;
-    for (let _ = 0; _ < s.length; _++)
-      i[r + _].buf[t] = s[_];
+    this._changed_tick[i] = n;
+    const c = this._flat_columns;
+    for (let o = 0; o < s.length; o++)
+      c[r + o].buf[t] = s[o];
   }
   read_field(t, e, s) {
-    const n = e, r = this._col_offset[n];
-    if (r === void 0) return NaN;
-    const i = this._field_index[n][s];
-    return i === void 0 ? NaN : this._flat_columns[r + i].buf[t];
+    const n = e, i = this._col_offset[n];
+    if (i === void 0) return NaN;
+    const r = this._field_index[n][s];
+    return r === void 0 ? NaN : this._flat_columns[i + r].buf[t];
   }
   /** Copy all shared component columns from source archetype at src_row into dst_row. */
-  copy_shared_from(t, e, s) {
-    const n = t._col_offset, r = t._field_count, i = t._flat_columns, _ = this._flat_columns, c = this._column_ids;
-    for (let o = 0; o < c.length; o++) {
-      const h = c[o], a = n[h];
-      if (a === void 0) continue;
-      const u = this._col_offset[h], d = r[h];
-      for (let g = 0; g < d; g++)
-        _[u + g].buf[s] = i[a + g].buf[e];
+  copy_shared_from(t, e, s, n) {
+    const i = t._col_offset, r = t._field_count, c = t._flat_columns, o = this._flat_columns, _ = this._column_ids;
+    for (let h = 0; h < _.length; h++) {
+      const l = _[h], d = i[l];
+      if (d === void 0) continue;
+      this._changed_tick[l] = n;
+      const u = this._col_offset[l], g = r[l];
+      for (let w = 0; w < g; w++)
+        o[u + w].buf[s] = c[d + w].buf[e];
     }
   }
   /**
@@ -412,15 +484,15 @@ class Tt {
    */
   remove_entity(t) {
     const e = this.length - 1;
-    let s = y;
-    const n = this._flat_columns, r = this._entity_ids.buf;
+    let s = m;
+    const n = this._flat_columns, i = this._entity_ids.buf;
     if (t !== e) {
-      r[t] = r[e], s = m(r[t]);
-      for (let i = 0; i < n.length; i++)
-        n[i].swap_remove(t);
+      i[t] = i[e], s = y(i[t]);
+      for (let r = 0; r < n.length; r++)
+        n[r].swap_remove(t);
     } else
-      for (let i = 0; i < n.length; i++)
-        n[i].pop();
+      for (let r = 0; r < n.length; r++)
+        n[r].pop();
     return this._entity_ids.pop(), this.length--, s;
   }
   /** Tag-optimized add: skip column push entirely (no data to store). */
@@ -431,9 +503,9 @@ class Tt {
   /** Tag-optimized remove via swap-and-pop: skip column swap/pop entirely. */
   remove_entity_tag(t) {
     const e = this.length - 1;
-    let s = y;
+    let s = m;
     const n = this._entity_ids.buf;
-    return t !== e && (n[t] = n[e], s = m(n[t])), this._entity_ids.pop(), this.length--, s;
+    return t !== e && (n[t] = n[e], s = y(n[t])), this._entity_ids.pop(), this.length--, s;
   }
   /**
    * Move an entity from src archetype into this archetype in a single pass.
@@ -441,17 +513,20 @@ class Tt {
    * Uses a pre-computed transition map for branchless column copy.
    * Writes dst_row to _move_result[0], swapped entity index to _move_result[1].
    */
-  move_entity_from(t, e, s, n) {
+  move_entity_from(t, e, s, n, i) {
     const r = this.length;
     this._entity_ids.push(s);
-    const i = this._flat_columns, _ = t._flat_columns;
-    for (let o = 0; o < i.length; o++) {
-      const h = n[o];
-      i[o].push(h >= 0 ? _[h].buf[e] : 0);
+    const c = this._flat_columns, o = t._flat_columns;
+    for (let l = 0; l < c.length; l++) {
+      const d = n[l];
+      c[l].push(d >= 0 ? o[d].buf[e] : 0);
     }
+    const _ = this._column_ids;
+    for (let l = 0; l < _.length; l++)
+      this._changed_tick[_[l]] = i;
     this.length++;
-    const c = t.has_columns ? t.remove_entity(e) : t.remove_entity_tag(e);
-    f[0] = r, f[1] = c;
+    const h = t.has_columns ? t.remove_entity(e) : t.remove_entity_tag(e);
+    f[0] = r, f[1] = h;
   }
   /**
    * Move an entity from src into this archetype (tag-only: no columns to copy).
@@ -460,27 +535,30 @@ class Tt {
   move_entity_from_tag(t, e, s) {
     const n = this.length;
     this._entity_ids.push(s), this.length++;
-    const r = t.remove_entity_tag(e);
-    f[0] = n, f[1] = r;
+    const i = t.remove_entity_tag(e);
+    f[0] = n, f[1] = i;
   }
   /**
    * Bulk-move ALL entities from src into this archetype using TypedArray.set().
    * Much faster than per-entity move_entity_from when the entire source is moving.
    * After this call, src is empty. Returns the starting dst_row for the batch.
    */
-  bulk_move_all_from(t, e) {
-    const s = t.length;
-    if (s === 0) return this.length;
-    const n = this.length, r = this._flat_columns, i = t._flat_columns;
-    this._entity_ids.bulk_append(t._entity_ids.buf, 0, s);
+  bulk_move_all_from(t, e, s) {
+    const n = t.length;
+    if (n === 0) return this.length;
+    const i = this.length, r = this._flat_columns, c = t._flat_columns;
+    this._entity_ids.bulk_append(t._entity_ids.buf, 0, n);
     for (let _ = 0; _ < r.length; _++) {
-      const c = e[_];
-      c >= 0 ? r[_].bulk_append(i[c].buf, 0, s) : r[_].bulk_append_zeroes(s);
+      const h = e[_];
+      h >= 0 ? r[_].bulk_append(c[h].buf, 0, n) : r[_].bulk_append_zeroes(n);
     }
-    this.length += s, t.length = 0, t._entity_ids.clear();
-    for (let _ = 0; _ < i.length; _++)
-      i[_].clear();
-    return n;
+    const o = this._column_ids;
+    for (let _ = 0; _ < o.length; _++)
+      this._changed_tick[o[_]] = s;
+    this.length += n, t.length = 0, t._entity_ids.clear();
+    for (let _ = 0; _ < c.length; _++)
+      c[_].clear();
+    return i;
   }
   get_edge(t) {
     return this.edges[t];
@@ -488,26 +566,35 @@ class Tt {
   set_edge(t, e) {
     this.edges[t] = e;
   }
+  /**
+   * Get the cached transition map from this archetype to `target`, building
+   * and caching it on miss. Archetypes live for the lifetime of the Store,
+   * so entries never need invalidation.
+   */
+  get_batch_transition_map(t) {
+    let e = this.batch_transition_maps.get(t.id);
+    return e === void 0 && (e = G(this, t), this.batch_transition_maps.set(t.id, e)), e;
+  }
 }
-const f = [0, y];
-function M(l, t) {
-  const e = t._flat_columns, s = new Int16Array(e.length), n = t._column_ids, r = l._col_offset, i = t._col_offset, _ = t._field_count;
-  for (let c = 0; c < n.length; c++) {
-    const o = n[c], h = i[o], a = _[o], u = r[o];
-    if (u !== void 0)
-      for (let d = 0; d < a; d++)
-        s[h + d] = u + d;
+const f = [0, m];
+function G(a, t) {
+  const e = t._flat_columns, s = new Int16Array(e.length), n = t._column_ids, i = a._col_offset, r = t._col_offset, c = t._field_count;
+  for (let o = 0; o < n.length; o++) {
+    const _ = n[o], h = r[_], l = c[_], d = i[_];
+    if (d !== void 0)
+      for (let u = 0; u < l; u++)
+        s[h + u] = d + u;
     else
-      for (let d = 0; d < a; d++)
-        s[h + d] = -1;
+      for (let u = 0; u < l; u++)
+        s[h + u] = -1;
   }
   return s;
 }
-function K(l, t, e) {
-  const s = l.get(t);
-  s !== void 0 ? s.push(e) : l.set(t, [e]);
+function Q(a, t, e) {
+  const s = a.get(t);
+  s !== void 0 ? s.push(e) : a.set(t, [e]);
 }
-class At {
+class xt {
   // --- Entity ID management ---
   // Generational slot allocator: entity_generations[index] holds the current
   // generation for that slot. Free indices are recycled via a stack.
@@ -524,10 +611,6 @@ class At {
   // Parallel array indexed by EventID: each channel holds SoA columns + reader.
   event_channels = [];
   event_count = 0;
-  // --- Resource channels ---
-  // Parallel array indexed by ResourceID: each channel holds a single row of SoA columns.
-  resource_channels = [];
-  resource_count = 0;
   // --- Archetype management ---
   archetypes = [];
   // Hash-bucketed lookup: BitSet.hash() → ArchetypeID[] for deduplication
@@ -553,9 +636,10 @@ class At {
   pending_add_values = [];
   pending_remove_ids = [];
   pending_remove_defs = [];
+  _tick = 0;
   initial_capacity;
   constructor(t) {
-    this.initial_capacity = t ?? V, this.empty_archetype_id = this.arch_get_or_create_from_mask(new x());
+    this.initial_capacity = t ?? K, this.empty_archetype_id = this.arch_get_or_create_from_mask(new p());
   }
   // =======================================================
   // Archetype graph
@@ -570,30 +654,30 @@ class At {
   arch_get_or_create_from_mask(t) {
     const e = t.hash(), s = this.archetype_map.get(e);
     if (s !== void 0) {
-      for (let c = 0; c < s.length; c++)
-        if (this.archetypes[s[c]].mask.equals(t))
-          return s[c];
+      for (let o = 0; o < s.length; o++)
+        if (this.archetypes[s[o]].mask.equals(t))
+          return s[o];
     }
-    const n = bt(this.next_archetype_id++), r = [];
-    t.for_each((c) => {
-      const o = c, h = this.component_metas[o];
-      h && h.field_names.length > 0 && r.push({
-        component_id: o,
+    const n = bt(this.next_archetype_id++), i = [];
+    t.for_each((o) => {
+      const _ = o, h = this.component_metas[_];
+      h && h.field_names.length > 0 && i.push({
+        component_id: _,
         field_names: h.field_names,
         field_index: h.field_index,
         field_types: h.field_types
       });
     });
-    const i = new Tt(n, t, r, this.initial_capacity);
-    this.archetypes.push(i), K(this.archetype_map, e, n), t.for_each((c) => {
-      const o = c;
-      let h = this.component_index.get(o);
-      h || (h = /* @__PURE__ */ new Set(), this.component_index.set(o, h)), h.add(n);
+    const r = new At(n, t, i, this.initial_capacity);
+    this.archetypes.push(r), Q(this.archetype_map, e, n), t.for_each((o) => {
+      const _ = o;
+      let h = this.component_index.get(_);
+      h || (h = /* @__PURE__ */ new Set(), this.component_index.set(_, h)), h.add(n);
     });
-    const _ = this.registered_queries;
-    for (let c = 0; c < _.length; c++) {
-      const o = _[c];
-      i.matches(o.include_mask) && (!o.exclude_mask || !i.mask.overlaps(o.exclude_mask)) && (!o.any_of_mask || i.mask.overlaps(o.any_of_mask)) && o.result.push(i);
+    const c = this.registered_queries;
+    for (let o = 0; o < c.length; o++) {
+      const _ = c[o];
+      r.matches(_.include_mask) && (!_.exclude_mask || !r.mask.overlaps(_.exclude_mask)) && (!_.any_of_mask || r.mask.overlaps(_.any_of_mask)) && (_.result.push(r), _.query?.mark_non_empty_dirty());
     }
     return n;
   }
@@ -603,10 +687,10 @@ class At {
     if (s.mask.has(e)) return t;
     const n = s.get_edge(e);
     if (n?.add != null) return n.add;
-    const r = this.arch_get_or_create_from_mask(
+    const i = this.arch_get_or_create_from_mask(
       s.mask.copy_with_set(e)
     );
-    return this.arch_cache_edge(s, this.arch_get(r), e), r;
+    return this.arch_cache_edge(s, this.arch_get(i), e), i;
   }
   /** Resolve "remove component_id from archetype_id" → target ArchetypeID. Caches the edge. */
   arch_resolve_remove(t, e) {
@@ -614,10 +698,10 @@ class At {
     if (!s.mask.has(e)) return t;
     const n = s.get_edge(e);
     if (n?.remove != null) return n.remove;
-    const r = this.arch_get_or_create_from_mask(
+    const i = this.arch_get_or_create_from_mask(
       s.mask.copy_with_clear(e)
     );
-    return this.arch_cache_edge(this.arch_get(r), s, e), r;
+    return this.arch_cache_edge(this.arch_get(i), s, e), i;
   }
   /** Cache a bidirectional add/remove edge between two archetypes. */
   arch_cache_edge(t, e, s) {
@@ -627,14 +711,14 @@ class At {
       add_map: null,
       remove_map: null
     };
-    n.add = e.id, n.add_map = M(t, e), t.set_edge(s, n);
-    const r = e.get_edge(s) ?? {
+    n.add = e.id, n.add_map = G(t, e), t.set_edge(s, n);
+    const i = e.get_edge(s) ?? {
       add: null,
       remove: null,
       add_map: null,
       remove_map: null
     };
-    r.remove = t.id, r.remove_map = M(e, t), e.set_edge(s, r);
+    i.remove = t.id, i.remove_map = G(e, t), e.set_edge(s, i);
   }
   // =======================================================
   // Entity lifecycle
@@ -642,29 +726,34 @@ class At {
   create_entity() {
     let t, e;
     this.entity_free_indices.length > 0 ? (t = this.entity_free_indices.pop(), e = this.entity_generations[t]) : (t = this.entity_high_water++, this.entity_generations[t] = j, e = j), this.entity_alive_count++;
-    const s = mt(t, e);
-    return this.entity_archetype[t] = this.empty_archetype_id, this.entity_row[t] = v, s;
+    const s = vt(t, e);
+    return this.entity_archetype[t] = this.empty_archetype_id, this.entity_row[t] = k, s;
   }
   /** Immediately destroy an entity, removing it from its archetype. */
   destroy_entity(t) {
     if (!this.is_alive(t))
       return;
-    const e = m(t), s = this.entity_row[e];
-    if (s !== v) {
-      const i = this.arch_get(this.entity_archetype[e]).remove_entity(s);
-      i !== y && (this.entity_row[i] = s);
+    const e = y(t), s = this.entity_row[e];
+    if (s !== k) {
+      const r = this.arch_get(this.entity_archetype[e]).remove_entity(s);
+      r !== m && (this.entity_row[r] = s);
     }
-    this.entity_archetype[e] = v, this.entity_row[e] = v;
-    const n = Y(t);
-    this.entity_generations[e] = n + 1 & X, this.entity_free_indices.push(e), this.entity_alive_count--;
+    this.entity_archetype[e] = k, this.entity_row[e] = k;
+    const n = z(t);
+    this.entity_generations[e] = n + 1 & V, this.entity_free_indices.push(e), this.entity_alive_count--;
   }
   is_alive(t) {
-    const e = m(t);
-    return e < this.entity_high_water && this.entity_generations[e] === Y(t);
+    const e = y(t);
+    return e < this.entity_high_water && this.entity_generations[e] === z(t);
   }
   get entity_count() {
     return this.entity_alive_count;
   }
+  _mark_queries_dirty() {
+    const t = this.registered_queries;
+    for (let e = 0; e < t.length; e++)
+      t[e].query?.mark_non_empty_dirty();
+  }
   // =======================================================
   // Deferred destruction
   // =======================================================
@@ -675,74 +764,75 @@ class At {
   flush_destroyed() {
     const t = this.pending_destroy;
     if (t.length === 0) return;
-    const e = this.entity_archetype, s = this.entity_row, n = this.entity_generations, r = this.archetypes, i = this.entity_high_water;
-    for (let _ = 0; _ < t.length; _++) {
-      const c = t[_], o = c & F, h = c >> P;
-      if (o >= i || n[o] !== h) continue;
-      const a = s[o];
-      if (a !== v) {
-        const u = r[e[o]], d = u.has_columns ? u.remove_entity(a) : u.remove_entity_tag(a);
-        d !== y && (s[d] = a);
+    const e = this.entity_archetype, s = this.entity_row, n = this.entity_generations, i = this.archetypes, r = this.entity_high_water;
+    for (let c = 0; c < t.length; c++) {
+      const o = t[c], _ = o & M, h = o >> R;
+      if (_ >= r || n[_] !== h) continue;
+      const l = s[_];
+      if (l !== k) {
+        const d = i[e[_]], u = d.has_columns ? d.remove_entity(l) : d.remove_entity_tag(l);
+        u !== m && (s[u] = l);
       }
-      e[o] = v, s[o] = v, n[o] = h + 1 & X, this.entity_free_indices.push(o), this.entity_alive_count--;
+      e[_] = k, s[_] = k, n[_] = h + 1 & V, this.entity_free_indices.push(_), this.entity_alive_count--;
     }
-    t.length = 0;
+    t.length = 0, this._mark_queries_dirty();
   }
   get pending_destroy_count() {
     return this.pending_destroy.length;
   }
   add_component_deferred(t, e, s) {
-    this.pending_add_ids.push(t), this.pending_add_defs.push(e), this.pending_add_values.push(s ?? D);
+    this.pending_add_ids.push(t), this.pending_add_defs.push(e), this.pending_add_values.push(s ?? q);
   }
   remove_component_deferred(t, e) {
     this.pending_remove_ids.push(t), this.pending_remove_defs.push(e);
   }
   flush_structural() {
-    this.pending_add_ids.length > 0 && this._flush_adds(), this.pending_remove_ids.length > 0 && this._flush_removes();
+    const t = this.pending_add_ids.length > 0, e = this.pending_remove_ids.length > 0;
+    t && this._flush_adds(), e && this._flush_removes(), (t || e) && this._mark_queries_dirty();
   }
   /** Batch-apply all deferred component additions. */
   _flush_adds() {
-    const t = this.pending_add_ids, e = this.pending_add_defs, s = this.pending_add_values, n = t.length, r = this.entity_archetype, i = this.entity_row, _ = this.entity_generations, c = this.archetypes, o = this.component_metas, h = this.entity_high_water;
-    for (let a = 0; a < n; a++) {
-      const u = t[a], d = u & F, g = u >> P;
-      if (d >= h || _[d] !== g) continue;
-      const T = r[d], p = e[a], w = c[T];
-      if (w.mask.has(p)) {
-        o[p].field_names.length > 0 && w.write_fields(i[d], p, s[a]);
+    const t = this.pending_add_ids, e = this.pending_add_defs, s = this.pending_add_values, n = t.length, i = this.entity_archetype, r = this.entity_row, c = this.entity_generations, o = this.archetypes, _ = this.component_metas, h = this.entity_high_water, l = this._tick;
+    for (let d = 0; d < n; d++) {
+      const u = t[d], g = u & M, w = u >> R;
+      if (g >= h || c[g] !== w) continue;
+      const T = i[g], v = e[d], E = o[T];
+      if (E.mask.has(v)) {
+        _[v].field_names.length > 0 && E.write_fields(r[g], v, s[d], l);
         continue;
       }
-      const S = this.arch_resolve_add(T, p), E = c[S], O = i[d], L = !E.has_columns && !w.has_columns;
+      const N = this.arch_resolve_add(T, v), x = o[N], P = r[g], Y = !x.has_columns && !E.has_columns;
       let U;
-      if (O !== v) {
-        if (L)
-          E.move_entity_from_tag(w, O, u);
+      if (P !== k) {
+        if (Y)
+          x.move_entity_from_tag(E, P, u);
         else {
-          const $ = w.get_edge(p);
-          E.move_entity_from(w, O, u, $.add_map);
+          const J = E.get_edge(v);
+          x.move_entity_from(E, P, u, J.add_map, l);
         }
-        U = f[0], f[1] !== y && (i[f[1]] = O);
+        U = f[0], f[1] !== m && (r[f[1]] = P);
       } else
-        U = L ? E.add_entity_tag(u) : E.add_entity(u);
-      o[p].field_names.length > 0 && E.write_fields(U, p, s[a]), r[d] = S, i[d] = U;
+        U = Y ? x.add_entity_tag(u) : x.add_entity(u);
+      _[v].field_names.length > 0 && x.write_fields(U, v, s[d], l), i[g] = N, r[g] = U;
     }
     t.length = 0, e.length = 0, s.length = 0;
   }
   /** Batch-apply all deferred component removals. */
   _flush_removes() {
-    const t = this.pending_remove_ids, e = this.pending_remove_defs, s = t.length, n = this.entity_archetype, r = this.entity_row, i = this.entity_generations, _ = this.archetypes, c = this.entity_high_water;
-    for (let o = 0; o < s; o++) {
-      const h = t[o], a = h & F, u = h >> P;
-      if (a >= c || i[a] !== u) continue;
-      const d = n[a], g = e[o], T = _[d];
-      if (!T.mask.has(g)) continue;
-      const p = this.arch_resolve_remove(d, g), w = _[p], S = r[a];
-      if (!w.has_columns && !T.has_columns)
-        w.move_entity_from_tag(T, S, h);
+    const t = this.pending_remove_ids, e = this.pending_remove_defs, s = t.length, n = this.entity_archetype, i = this.entity_row, r = this.entity_generations, c = this.archetypes, o = this.entity_high_water, _ = this._tick;
+    for (let h = 0; h < s; h++) {
+      const l = t[h], d = l & M, u = l >> R;
+      if (d >= o || r[d] !== u) continue;
+      const g = n[d], w = e[h], T = c[g];
+      if (!T.mask.has(w)) continue;
+      const v = this.arch_resolve_remove(g, w), E = c[v], N = i[d];
+      if (!E.has_columns && !T.has_columns)
+        E.move_entity_from_tag(T, N, l);
       else {
-        const O = T.get_edge(g);
-        w.move_entity_from(T, S, h, O.remove_map);
+        const P = T.get_edge(w);
+        E.move_entity_from(T, N, l, P.remove_map, _);
       }
-      f[1] !== y && (r[f[1]] = S), n[a] = p, r[a] = f[0];
+      f[1] !== m && (i[f[1]] = N), n[d] = v, i[d] = f[0];
     }
     t.length = 0, e.length = 0;
   }
@@ -753,108 +843,101 @@ class At {
   // Component registration
   // =======================================================
   register_component(t) {
-    const e = yt(this.component_count++), s = Object.keys(t), n = new Array(s.length), r = /* @__PURE__ */ Object.create(null);
-    for (let i = 0; i < s.length; i++)
-      r[s[i]] = i, n[i] = t[s[i]];
-    return this.component_metas.push({ field_names: s, field_index: r, field_types: n }), e;
+    const e = Et(this.component_count++), s = Object.keys(t), n = new Array(s.length), i = /* @__PURE__ */ Object.create(null);
+    for (let r = 0; r < s.length; r++)
+      i[s[r]] = r, n[r] = t[s[r]];
+    return this.component_metas.push({ field_names: s, field_index: i, field_types: n }), e;
   }
   add_component(t, e, s) {
     if (!this.is_alive(t))
       return;
-    const n = m(t), r = this.entity_archetype[n], i = this.arch_get(r);
-    if (i.has_component(e)) {
-      i.write_fields(
+    const n = y(t), i = this.entity_archetype[n], r = this.arch_get(i);
+    if (r.has_component(e)) {
+      r.write_fields(
         this.entity_row[n],
         e,
-        s
+        s,
+        this._tick
       );
       return;
     }
-    const _ = this.arch_resolve_add(
-      r,
-      e
-    ), c = this.arch_get(_), o = this.entity_row[n];
+    const c = this.arch_resolve_add(i, e), o = this.arch_get(c), _ = this.entity_row[n];
     let h;
-    if (o !== v) {
-      const a = i.get_edge(e);
-      !c.has_columns && !i.has_columns ? c.move_entity_from_tag(i, o, t) : c.move_entity_from(i, o, t, a.add_map), h = f[0], f[1] !== y && (this.entity_row[f[1]] = o);
+    if (_ !== k) {
+      const l = r.get_edge(e);
+      !o.has_columns && !r.has_columns ? o.move_entity_from_tag(r, _, t) : o.move_entity_from(r, _, t, l.add_map, this._tick), h = f[0], f[1] !== m && (this.entity_row[f[1]] = _);
     } else
-      h = c.has_columns ? c.add_entity(t) : c.add_entity_tag(t);
-    c.write_fields(
+      h = o.has_columns ? o.add_entity(t) : o.add_entity_tag(t);
+    o.write_fields(
       h,
       e,
-      s
-    ), this.entity_archetype[n] = _, this.entity_row[n] = h;
+      s,
+      this._tick
+    ), this.entity_archetype[n] = c, this.entity_row[n] = h, this._mark_queries_dirty();
   }
   /** Add multiple components in one transition (resolves final archetype, then moves once). */
   add_components(t, e) {
     if (!this.is_alive(t))
       return;
-    const s = m(t), n = this.entity_archetype[s];
-    let r = n;
-    for (let i = 0; i < e.length; i++)
-      r = this.arch_resolve_add(
-        r,
-        e[i].def
-      );
-    if (r !== n) {
-      const i = this.arch_get(n), _ = this.arch_get(r), c = this.entity_row[s];
-      let o;
-      if (c !== v) {
-        const h = M(i, _);
-        _.move_entity_from(i, c, t, h), o = f[0], f[1] !== y && (this.entity_row[f[1]] = c);
+    const s = y(t), n = this.entity_archetype[s];
+    let i = n;
+    for (let r = 0; r < e.length; r++)
+      i = this.arch_resolve_add(i, e[r].def);
+    if (i !== n) {
+      const r = this.arch_get(n), c = this.arch_get(i), o = this.entity_row[s];
+      let _;
+      if (o !== k) {
+        const h = r.get_batch_transition_map(c);
+        c.move_entity_from(r, o, t, h, this._tick), _ = f[0], f[1] !== m && (this.entity_row[f[1]] = o);
       } else
-        o = _.add_entity(t);
+        _ = c.add_entity(t);
       for (let h = 0; h < e.length; h++)
-        _.write_fields(
-          o,
+        c.write_fields(
+          _,
           e[h].def,
-          e[h].values ?? D
+          e[h].values ?? q,
+          this._tick
         );
-      this.entity_archetype[s] = r, this.entity_row[s] = o;
+      this.entity_archetype[s] = i, this.entity_row[s] = _, this._mark_queries_dirty();
     } else {
-      const i = this.arch_get(n), _ = this.entity_row[s];
-      for (let c = 0; c < e.length; c++)
-        i.write_fields(
-          _,
-          e[c].def,
-          e[c].values ?? D
+      const r = this.arch_get(n), c = this.entity_row[s];
+      for (let o = 0; o < e.length; o++)
+        r.write_fields(
+          c,
+          e[o].def,
+          e[o].values ?? q,
+          this._tick
         );
     }
   }
   remove_component(t, e) {
     if (!this.is_alive(t))
       return;
-    const s = m(t), n = this.entity_archetype[s], r = this.arch_get(n);
-    if (!r.has_component(e)) return;
-    const i = this.arch_resolve_remove(
-      n,
-      e
-    ), _ = this.arch_get(i), c = this.entity_row[s], o = r.get_edge(e);
-    !_.has_columns && !r.has_columns ? _.move_entity_from_tag(r, c, t) : _.move_entity_from(r, c, t, o.remove_map), f[1] !== y && (this.entity_row[f[1]] = c), this.entity_archetype[s] = i, this.entity_row[s] = f[0];
+    const s = y(t), n = this.entity_archetype[s], i = this.arch_get(n);
+    if (!i.has_component(e)) return;
+    const r = this.arch_resolve_remove(n, e), c = this.arch_get(r), o = this.entity_row[s], _ = i.get_edge(e);
+    !c.has_columns && !i.has_columns ? c.move_entity_from_tag(i, o, t) : c.move_entity_from(i, o, t, _.remove_map, this._tick), f[1] !== m && (this.entity_row[f[1]] = o), this.entity_archetype[s] = r, this.entity_row[s] = f[0], this._mark_queries_dirty();
   }
   /** Remove multiple components in one transition (resolves final archetype, then moves once). */
   remove_components(t, e) {
     if (!this.is_alive(t))
       return;
-    const s = m(t), n = this.entity_archetype[s];
-    let r = n;
+    const s = y(t), n = this.entity_archetype[s];
+    let i = n;
     for (let h = 0; h < e.length; h++)
-      r = this.arch_resolve_remove(
-        r,
+      i = this.arch_resolve_remove(
+        i,
         e[h]
       );
-    if (r === n) return;
-    const i = this.arch_get(n), _ = this.arch_get(r), c = this.entity_row[s], o = M(i, _);
-    _.move_entity_from(i, c, t, o), f[1] !== y && (this.entity_row[f[1]] = c), this.entity_archetype[s] = r, this.entity_row[s] = f[0];
+    if (i === n) return;
+    const r = this.arch_get(n), c = this.arch_get(i), o = this.entity_row[s], _ = G(r, c);
+    c.move_entity_from(r, o, t, _, this._tick), f[1] !== m && (this.entity_row[f[1]] = o), this.entity_archetype[s] = i, this.entity_row[s] = f[0], this._mark_queries_dirty();
   }
   has_component(t, e) {
     if (!this.is_alive(t))
       return !1;
-    const s = m(t);
-    return this.arch_get(
-      this.entity_archetype[s]
-    ).has_component(e);
+    const s = y(t);
+    return this.arch_get(this.entity_archetype[s]).has_component(e);
   }
   /**
    * Bulk add a component to ALL entities in the given archetype.
@@ -865,14 +948,15 @@ class At {
     if (t.length === 0) return;
     const n = e;
     if (t.mask.has(n)) return;
-    const r = this.arch_resolve_add(t.id, n), i = this.arch_get(r), _ = t.get_edge(n), c = t.length, o = this.entity_archetype, h = this.entity_row, a = i.bulk_move_all_from(t, _.add_map);
-    for (let d = 0; d < c; d++) {
-      const g = m(i.entity_ids[a + d]);
-      o[g] = r, h[g] = a + d;
+    const i = this.arch_resolve_add(t.id, n), r = this.arch_get(i), c = t.get_edge(n), o = t.length, _ = this.entity_archetype, h = this.entity_row, l = r.bulk_move_all_from(t, c.add_map, this._tick);
+    for (let u = 0; u < o; u++) {
+      const g = y(r.entity_ids[l + u]);
+      _[g] = i, h[g] = l + u;
     }
     if (this.component_metas[n].field_names.length > 0 && s)
-      for (let d = 0; d < c; d++)
-        i.write_fields(a + d, n, s);
+      for (let u = 0; u < o; u++)
+        r.write_fields(l + u, n, s, this._tick);
+    this._mark_queries_dirty();
   }
   /**
    * Bulk remove a component from ALL entities in the given archetype.
@@ -883,22 +967,21 @@ class At {
     if (t.length === 0) return;
     const s = e;
     if (!t.mask.has(s)) return;
-    const n = this.arch_resolve_remove(t.id, s), r = this.arch_get(n), i = t.get_edge(s), _ = t.length, c = r.bulk_move_all_from(t, i.remove_map), o = this.entity_archetype, h = this.entity_row;
-    for (let a = 0; a < _; a++) {
-      const u = m(r.entity_ids[c + a]);
-      o[u] = n, h[u] = c + a;
+    const n = this.arch_resolve_remove(t.id, s), i = this.arch_get(n), r = t.get_edge(s), c = t.length, o = i.bulk_move_all_from(t, r.remove_map, this._tick), _ = this.entity_archetype, h = this.entity_row;
+    for (let l = 0; l < c; l++) {
+      const d = y(i.entity_ids[o + l]);
+      _[d] = n, h[d] = o + l;
     }
+    this._mark_queries_dirty();
   }
   // =======================================================
   // Direct data access (used by SystemContext)
   // =======================================================
   get_entity_archetype(t) {
-    return this.arch_get(
-      this.entity_archetype[m(t)]
-    );
+    return this.arch_get(this.entity_archetype[y(t)]);
   }
   get_entity_row(t) {
-    return this.entity_row[m(t)];
+    return this.entity_row[y(t)];
   }
   // =======================================================
   // Query support
@@ -910,58 +993,63 @@ class At {
    */
   get_matching_archetypes(t, e, s) {
     const n = t._words;
-    let r = !1;
-    for (let o = 0; o < n.length; o++)
-      if (n[o] !== 0) {
-        r = !0;
+    let i = !1;
+    for (let _ = 0; _ < n.length; _++)
+      if (n[_] !== 0) {
+        i = !0;
         break;
       }
-    if (!r)
+    if (!i)
       return this.archetypes.filter(
-        (o) => (!e || !o.mask.overlaps(e)) && (!s || o.mask.overlaps(s))
+        (_) => (!e || !_.mask.overlaps(e)) && (!s || _.mask.overlaps(s))
       );
-    let i, _ = !1;
-    for (let o = 0; o < n.length; o++) {
-      let h = n[o];
+    let r, c = !1;
+    for (let _ = 0; _ < n.length; _++) {
+      let h = n[_];
       if (h === 0) continue;
-      const a = o << k;
+      const l = _ << I;
       for (; h !== 0; ) {
-        const u = h & -h >>> 0, d = a + (I - Math.clz32(u));
-        h ^= u;
-        const g = this.component_index.get(d);
+        const d = h & -h >>> 0, u = l + (S - Math.clz32(d));
+        h ^= d;
+        const g = this.component_index.get(u);
         if (!g || g.size === 0) {
-          _ = !0;
+          c = !0;
           break;
         }
-        (!i || g.size < i.size) && (i = g);
+        (!r || g.size < r.size) && (r = g);
       }
-      if (_) break;
+      if (c) break;
     }
-    if (_ || !i) return [];
-    const c = [];
-    for (const o of i) {
-      const h = this.arch_get(o);
-      h.matches(t) && (!e || !h.mask.overlaps(e)) && (!s || h.mask.overlaps(s)) && c.push(h);
+    if (c || !r) return [];
+    const o = [];
+    for (const _ of r) {
+      const h = this.arch_get(_);
+      h.matches(t) && (!e || !h.mask.overlaps(e)) && (!s || h.mask.overlaps(s)) && o.push(h);
     }
-    return c;
+    return o;
   }
   /**
    * Register a live query. Returns a mutable Archetype[] that this Store will
    * push newly-created matching archetypes into, keeping the query always up-to-date.
    */
   register_query(t, e, s) {
-    const n = this.get_matching_archetypes(
-      t,
-      e,
-      s
-    );
+    const n = this.get_matching_archetypes(t, e, s);
     return this.registered_queries.push({
       include_mask: t.copy(),
       exclude_mask: e ? e.copy() : null,
       any_of_mask: s ? s.copy() : null,
-      result: n
+      result: n,
+      query: null
     }), n;
   }
+  update_query_ref(t, e) {
+    const s = this.registered_queries;
+    for (let n = 0; n < s.length; n++)
+      if (s[n].result === t) {
+        s[n].query = e;
+        return;
+      }
+  }
   get archetype_count() {
     return this.archetypes.length;
   }
@@ -969,7 +1057,7 @@ class At {
   // Event channels
   // =======================================================
   register_event(t) {
-    const e = pt(this.event_count++), s = new wt(t);
+    const e = kt(this.event_count++), s = new Tt(t);
     return this.event_channels.push(s), e;
   }
   emit_event(t, e) {
@@ -987,76 +1075,107 @@ class At {
       t[e].clear();
   }
   // =======================================================
-  // Resource channels
+  // Event key storage
+  // =======================================================
+  // any: type-erased — EventDef<F> phantom is lost in the map, recovered by callers via EventKey<F>
+  event_key_map = /* @__PURE__ */ new Map();
+  register_event_by_key(t, e) {
+    if (this.event_key_map.has(t))
+      throw new O(D.EVENT_ALREADY_REGISTERED, "Event key already registered");
+    const s = this.register_event(e);
+    return this.event_key_map.set(t, s), s;
+  }
+  // any: type-erased — caller recovers F from EventKey<F>
+  get_event_def_by_key(t) {
+    const e = this.event_key_map.get(t);
+    if (e === void 0)
+      throw new O(D.EVENT_NOT_REGISTERED, "Event key not registered");
+    return e;
+  }
+  has_event_key(t) {
+    return this.event_key_map.has(t);
+  }
+  // =======================================================
+  // Resource storage
   // =======================================================
+  resource_key_map = /* @__PURE__ */ new Map();
   register_resource(t, e) {
-    const s = vt(this.resource_count++), n = new xt(t, e);
-    return this.resource_channels.push(n), s;
+    if (this.resource_key_map.has(t))
+      throw new O(D.RESOURCE_ALREADY_REGISTERED, "Resource key already registered");
+    this.resource_key_map.set(t, e);
   }
-  get_resource_reader(t) {
-    return this.resource_channels[t].reader;
+  get_resource(t) {
+    if (!this.resource_key_map.has(t))
+      throw new O(D.RESOURCE_NOT_REGISTERED, "Resource key not registered");
+    return this.resource_key_map.get(t);
+  }
+  set_resource(t, e) {
+    if (!this.resource_key_map.has(t))
+      throw new O(D.RESOURCE_NOT_REGISTERED, "Resource key not registered");
+    this.resource_key_map.set(t, e);
   }
-  get_resource_channel(t) {
-    return this.resource_channels[t];
+  has_resource(t) {
+    return this.resource_key_map.has(t);
   }
 }
-var Et = /* @__PURE__ */ ((l) => (l.PRE_STARTUP = "PRE_STARTUP", l.STARTUP = "STARTUP", l.POST_STARTUP = "POST_STARTUP", l.FIXED_UPDATE = "FIXED_UPDATE", l.PRE_UPDATE = "PRE_UPDATE", l.UPDATE = "UPDATE", l.POST_UPDATE = "POST_UPDATE", l))(Et || {});
-const q = [
+var It = /* @__PURE__ */ ((a) => (a.PRE_STARTUP = "PRE_STARTUP", a.STARTUP = "STARTUP", a.POST_STARTUP = "POST_STARTUP", a.FIXED_UPDATE = "FIXED_UPDATE", a.PRE_UPDATE = "PRE_UPDATE", a.UPDATE = "UPDATE", a.POST_UPDATE = "POST_UPDATE", a))(It || {});
+const L = [
   "PRE_STARTUP",
   "STARTUP",
   "POST_STARTUP"
   /* POST_STARTUP */
-], G = [
+], C = [
   "PRE_UPDATE",
   "UPDATE",
   "POST_UPDATE"
   /* POST_UPDATE */
 ];
-class kt {
+class St {
   label_systems = /* @__PURE__ */ new Map();
   sorted_cache = /* @__PURE__ */ new Map();
   system_index = /* @__PURE__ */ new Map();
+  system_last_run = /* @__PURE__ */ new Map();
   next_insertion_order = 0;
   constructor() {
-    for (let t = 0; t < q.length; t++)
-      this.label_systems.set(q[t], []);
+    for (let t = 0; t < L.length; t++)
+      this.label_systems.set(L[t], []);
     this.label_systems.set("FIXED_UPDATE", []);
-    for (let t = 0; t < G.length; t++)
-      this.label_systems.set(G[t], []);
+    for (let t = 0; t < C.length; t++)
+      this.label_systems.set(C[t], []);
   }
   add_systems(t, ...e) {
     for (const s of e) {
-      const n = "system" in s ? s.system : s, r = "system" in s ? s.ordering : void 0, i = {
+      const n = "system" in s ? s.system : s, i = "system" in s ? s.ordering : void 0, r = {
         descriptor: n,
         insertion_order: this.next_insertion_order++,
-        before: new Set(r?.before ?? []),
-        after: new Set(r?.after ?? [])
+        before: new Set(i?.before ?? []),
+        after: new Set(i?.after ?? [])
       };
-      this.label_systems.get(t).push(i), this.system_index.set(n, t), this.sorted_cache.delete(t);
+      this.label_systems.get(t).push(r), this.system_index.set(n, t), this.system_last_run.set(n, 0), this.sorted_cache.delete(t);
     }
   }
   remove_system(t) {
     const e = this.system_index.get(t);
     if (e === void 0) return;
-    const s = this.label_systems.get(e), n = s.findIndex((r) => r.descriptor === t);
+    const s = this.label_systems.get(e), n = s.findIndex((i) => i.descriptor === t);
     if (n !== -1) {
-      const r = s.length - 1;
-      n !== r && (s[n] = s[r]), s.pop();
-      for (const i of s)
-        i.before.delete(t), i.after.delete(t);
+      const i = s.length - 1;
+      n !== i && (s[n] = s[i]), s.pop();
+      for (const r of s)
+        r.before.delete(t), r.after.delete(t);
     }
-    this.system_index.delete(t), this.sorted_cache.delete(e);
+    this.system_index.delete(t), this.system_last_run.delete(t), this.sorted_cache.delete(e);
   }
-  run_startup(t) {
-    for (const e of q)
-      this.run_label(e, t, it);
+  run_startup(t, e) {
+    for (const s of L)
+      this.run_label(s, t, pt, e);
   }
-  run_update(t, e) {
-    for (const s of G)
-      this.run_label(s, t, e);
+  run_update(t, e, s) {
+    for (const n of C)
+      this.run_label(n, t, e, s);
   }
-  run_fixed_update(t, e) {
-    this.run_label("FIXED_UPDATE", t, e);
+  run_fixed_update(t, e, s) {
+    this.run_label("FIXED_UPDATE", t, e, s);
   }
   has_fixed_systems() {
     return this.label_systems.get(
@@ -1077,93 +1196,96 @@ class kt {
   clear() {
     for (const t of this.label_systems.values())
       t.length = 0;
-    this.sorted_cache.clear(), this.system_index.clear();
+    this.sorted_cache.clear(), this.system_index.clear(), this.system_last_run.clear();
   }
-  run_label(t, e, s) {
-    const n = this.get_sorted(t);
-    for (let r = 0; r < n.length; r++)
-      n[r].fn(e, s);
+  run_label(t, e, s, n) {
+    const i = this.get_sorted(t);
+    for (let r = 0; r < i.length; r++)
+      this.system_last_run.set(i[r], n), e.last_run_tick = n, i[r].fn(e, s);
     e.flush();
   }
   get_sorted(t) {
     const e = this.sorted_cache.get(t);
     if (e !== void 0) return e;
-    const s = this.label_systems.get(t), n = this.topological_sort(s, t);
+    const s = this.label_systems.get(t), n = this.sort_systems(s, t);
     return this.sorted_cache.set(t, n), n;
   }
   /**
-   * Kahn's algorithm: BFS-based topological sort.
-   * Uses insertion_order as a stable tiebreaker (lower insertion order runs first).
+   * Delegates to the shared topological_sort utility.
+   * Builds the dependency edge map from before/after constraints, then
+   * catches any cycle TypeError and re-throws as ECSError.
    */
-  topological_sort(t, e) {
+  sort_systems(t, e) {
     if (t.length === 0) return [];
-    const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
-    for (const o of t)
-      s.set(o.descriptor, /* @__PURE__ */ new Set()), n.set(o.descriptor, 0), r.set(o.descriptor, o.insertion_order), i.add(o.descriptor);
-    for (const o of t) {
-      for (const h of o.before)
-        i.has(h) && (s.get(o.descriptor).add(h), n.set(h, n.get(h) + 1));
-      for (const h of o.after)
-        i.has(h) && (s.get(h).add(o.descriptor), n.set(o.descriptor, n.get(o.descriptor) + 1));
-    }
-    let _ = [];
-    for (const o of t)
-      n.get(o.descriptor) === 0 && _.push(o.descriptor);
-    _.sort((o, h) => r.get(h) - r.get(o));
-    const c = [];
-    for (; _.length > 0; ) {
-      const o = _.pop();
-      c.push(o);
-      for (const h of s.get(o)) {
-        const a = n.get(h) - 1;
-        n.set(h, a), a === 0 && _.push(h);
-      }
-      _.sort((h, a) => r.get(a) - r.get(h));
+    const s = [], n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
+    for (const _ of t)
+      s.push(_.descriptor), n.set(_.descriptor, _.insertion_order), i.add(_.descriptor);
+    const r = /* @__PURE__ */ new Map();
+    for (const _ of t)
+      r.set(_.descriptor, []);
+    for (const _ of t) {
+      for (const h of _.before)
+        i.has(h) && r.get(_.descriptor).push(h);
+      for (const h of _.after)
+        i.has(h) && r.get(h).push(_.descriptor);
     }
-    if (c.length !== t.length) {
-      const o = new Set(c), h = t.filter((a) => !o.has(a.descriptor)).map((a) => a.descriptor.name ?? `system_${a.descriptor.id}`);
-      throw new Q(
-        z.CIRCULAR_SYSTEM_DEPENDENCY,
-        `Circular system dependency detected in ${e}: [${h.join(", ")}]`
-      );
+    const c = (_, h) => n.get(_) - n.get(h), o = (_) => _.name ?? `system_${_.id}`;
+    try {
+      return dt(s, r, c, o);
+    } catch (_) {
+      throw _ instanceof TypeError ? new O(
+        D.CIRCULAR_SYSTEM_DEPENDENCY,
+        `Circular system dependency detected in ${e}: ${_.message}`
+      ) : _;
     }
-    return c;
   }
 }
 const W = /* @__PURE__ */ new WeakMap();
-function It(l, t) {
-  let e = W.get(l);
+function B(a, t) {
+  let e = W.get(a);
   if (!e) {
     e = /* @__PURE__ */ Object.create(null);
-    const { field_names: r } = l.layout;
-    for (let i = 0; i < r.length; i++) {
-      const _ = i;
-      Object.defineProperty(e, r[i], {
+    const { field_names: i } = a.layout;
+    for (let r = 0; r < i.length; r++) {
+      const c = r;
+      Object.defineProperty(e, i[r], {
         get() {
-          return this._columns[_][this._row];
+          return this._columns[c][this._row];
         },
-        set(c) {
-          this._columns[_][this._row] = c;
+        set(o) {
+          this._columns[c][this._row] = o;
         },
         enumerable: !0,
         configurable: !1
       });
     }
-    W.set(l, e);
+    W.set(a, e);
   }
-  const s = Object.create(e), n = new Array(l.columns.length);
-  for (let r = 0; r < l.columns.length; r++) n[r] = l.columns[r].buf;
+  const s = Object.create(e), n = new Array(a.columns.length);
+  for (let i = 0; i < a.columns.length; i++) n[i] = a.columns[i].buf;
   return s._columns = n, s._row = t, s;
 }
-class Pt {
+class Dt {
   _archetypes;
   _defs;
   _resolver;
   _include;
   _exclude;
   _any_of;
-  constructor(t, e, s, n, r, i) {
-    this._archetypes = t, this._defs = e, this._resolver = s, this._include = n, this._exclude = r, this._any_of = i;
+  _non_empty_archetypes = [];
+  _non_empty_dirty = !0;
+  // Per-Query composition caches — single-component fast path.
+  // The final Query produced by _resolve_query is already cached by the
+  // resolver, but the caller pays a BitSet copy + defs slice per call
+  // before the resolver can hash and hit that cache. These caches
+  // short-circuit that allocation path for the common single-component
+  // composition shape (q.and(X), q.changed(X), etc).
+  _and_cache_single = null;
+  _not_cache_single = null;
+  _any_of_cache_single = null;
+  _changed_cache_single = null;
+  constructor(t, e, s, n, i, r) {
+    this._archetypes = t, this._defs = e, this._resolver = s, this._include = n, this._exclude = i, this._any_of = r;
   }
   /** Number of matching archetypes (including empty ones). */
   get archetype_count() {
@@ -1179,27 +1301,43 @@ class Pt {
   get archetypes() {
     return this._archetypes;
   }
-  /** Iterate non-empty archetypes. Skips archetypes with zero entities. */
-  *[Symbol.iterator]() {
-    const t = this._archetypes;
-    for (let e = 0; e < t.length; e++)
-      t[e].entity_count > 0 && (yield t[e]);
-  }
   /** Extend required component set. Returns a new (cached) Query. */
   and(...t) {
+    if (t.length === 1) {
+      const n = t[0], i = this._and_cache_single;
+      if (i !== null) {
+        const _ = i.get(n);
+        if (_ !== void 0) return _;
+      }
+      const r = this._include.copy(), c = this._defs.slice();
+      r.has(n) || (r.set(n), c.push(t[0]));
+      const o = this._resolver._resolve_query(r, this._exclude, this._any_of, c);
+      return (this._and_cache_single ??= /* @__PURE__ */ new Map()).set(n, o), o;
+    }
     const e = this._include.copy(), s = this._defs.slice();
     for (let n = 0; n < t.length; n++)
       e.has(t[n]) || (e.set(t[n]), s.push(t[n]));
-    return this._resolver._resolve_query(
-      e,
-      this._exclude,
-      this._any_of,
-      s
-    );
+    return this._resolver._resolve_query(e, this._exclude, this._any_of, s);
   }
   /** Exclude archetypes that have any of these components. */
   not(...t) {
-    const e = this._exclude ? this._exclude.copy() : new x();
+    if (t.length === 1) {
+      const s = t[0], n = this._not_cache_single;
+      if (n !== null) {
+        const c = n.get(s);
+        if (c !== void 0) return c;
+      }
+      const i = this._exclude ? this._exclude.copy() : new p();
+      i.set(s);
+      const r = this._resolver._resolve_query(
+        this._include,
+        i,
+        this._any_of,
+        this._defs
+      );
+      return (this._not_cache_single ??= /* @__PURE__ */ new Map()).set(s, r), r;
+    }
+    const e = this._exclude ? this._exclude.copy() : new p();
     for (let s = 0; s < t.length; s++) e.set(t[s]);
     return this._resolver._resolve_query(
       this._include,
@@ -1208,9 +1346,45 @@ class Pt {
       this._defs
     );
   }
+  for_each(t) {
+    const e = this._non_empty();
+    for (let s = 0; s < e.length; s++)
+      t(e[s]);
+  }
+  /** @internal — called by Store after flush and archetype push. */
+  mark_non_empty_dirty() {
+    this._non_empty_dirty = !0;
+  }
+  /** @internal — used by ChangedQuery. Rebuild non-empty archetype list if dirty, return cached result. */
+  _non_empty() {
+    if (this._non_empty_dirty) {
+      const t = this._archetypes, e = this._non_empty_archetypes;
+      e.length = 0;
+      for (let s = 0; s < t.length; s++)
+        t[s].entity_count > 0 && e.push(t[s]);
+      this._non_empty_dirty = !1;
+    }
+    return this._non_empty_archetypes;
+  }
   /** Require at least one of these components. */
   any_of(...t) {
-    const e = this._any_of ? this._any_of.copy() : new x();
+    if (t.length === 1) {
+      const s = t[0], n = this._any_of_cache_single;
+      if (n !== null) {
+        const c = n.get(s);
+        if (c !== void 0) return c;
+      }
+      const i = this._any_of ? this._any_of.copy() : new p();
+      i.set(s);
+      const r = this._resolver._resolve_query(
+        this._include,
+        this._exclude,
+        i,
+        this._defs
+      );
+      return (this._any_of_cache_single ??= /* @__PURE__ */ new Map()).set(s, r), r;
+    }
+    const e = this._any_of ? this._any_of.copy() : new p();
     for (let s = 0; s < t.length; s++) e.set(t[s]);
     return this._resolver._resolve_query(
       this._include,
@@ -1219,19 +1393,43 @@ class Pt {
       this._defs
     );
   }
+  /** Create a ChangedQuery that filters archetypes by change tick. */
+  changed(...t) {
+    if (t.length === 1) {
+      const s = t[0], n = this._changed_cache_single;
+      if (n !== null) {
+        const r = n.get(s);
+        if (r !== void 0) return r;
+      }
+      const i = new $(this, [s]);
+      return (this._changed_cache_single ??= /* @__PURE__ */ new Map()).set(s, i), i;
+    }
+    const e = new Array(t.length);
+    for (let s = 0; s < t.length; s++) e[s] = t[s];
+    return new $(this, e);
+  }
+  /** @internal — reads last_run_tick from the resolver (ECS). */
+  _ctx_last_run_tick() {
+    return this._resolver._get_last_run_tick();
+  }
 }
-class St {
+class Rt {
   constructor(t) {
     this._resolver = t;
   }
   every(...t) {
-    const e = new x();
+    const e = new p();
     for (let s = 0; s < t.length; s++) e.set(t[s]);
     return this._resolver._resolve_query(e, null, null, t);
   }
 }
-class Ot {
+class Nt {
   store;
+  last_run_tick = 0;
+  /** Current world tick. Use this for write ticks in get_column_mut. */
+  get world_tick() {
+    return this.store._tick;
+  }
   constructor(t) {
     this.store = t;
   }
@@ -1239,24 +1437,29 @@ class Ot {
     return this.store.create_entity();
   }
   get_field(t, e, s) {
-    const n = this.store.get_entity_archetype(t), r = this.store.get_entity_row(t);
-    return n.read_field(r, e, s);
+    const n = this.store.get_entity_archetype(t), i = this.store.get_entity_row(t);
+    return n.read_field(i, e, s);
   }
   set_field(t, e, s, n) {
-    const r = this.store.get_entity_archetype(t), i = this.store.get_entity_row(t), _ = r.get_column(e, s);
-    _[i] = n;
+    const i = this.store.get_entity_archetype(t), r = this.store.get_entity_row(t), c = i.get_column_mut(e, s, this.store._tick);
+    c[r] = n;
   }
-  /** Create a cached component reference for a single entity. See ref.ts. */
+  /** Create a cached read-only component reference for a single entity. See ref.ts. */
   ref(t, e) {
     const s = this.store.get_entity_archetype(e), n = this.store.get_entity_row(e);
-    return It(s.column_groups[t], n);
+    return B(s.column_groups[t], n);
+  }
+  /** Create a cached mutable component reference. Marks the component as changed. */
+  ref_mut(t, e) {
+    const s = this.store.get_entity_archetype(e), n = this.store.get_entity_row(e);
+    return s._changed_tick[t] = this.store._tick, B(s.column_groups[t], n);
   }
   /** Buffer an entity for deferred destruction (applied at phase flush). */
   destroy_entity(t) {
     return this.store.destroy_entity_deferred(t), this;
   }
   add_component(t, e, s) {
-    return this.store.add_component_deferred(t, e, s ?? D), this;
+    return this.store.add_component_deferred(t, e, s ?? q), this;
   }
   remove_component(t, e) {
     return this.store.remove_component_deferred(t, e), this;
@@ -1266,30 +1469,55 @@ class Ot {
     this.store.flush_structural(), this.store.flush_destroyed();
   }
   emit(t, e) {
-    e === void 0 ? this.store.emit_signal(t) : this.store.emit_event(t, e);
+    const s = this.store.get_event_def_by_key(t);
+    e === void 0 ? this.store.emit_signal(s) : this.store.emit_event(s, e);
   }
   read(t) {
-    return this.store.get_event_reader(t);
+    const e = this.store.get_event_def_by_key(t);
+    return this.store.get_event_reader(e);
   }
   // =======================================================
   // Resources
   // =======================================================
   resource(t) {
-    return this.store.get_resource_reader(t);
+    return this.store.get_resource(t);
   }
   set_resource(t, e) {
-    this.store.get_resource_channel(t).write(e);
+    this.store.set_resource(t, e);
+  }
+  has_resource(t) {
+    return this.store.has_resource(t);
   }
 }
-const Dt = (l) => N(
-  l
+class $ {
+  _query;
+  _changed_ids;
+  constructor(t, e) {
+    this._query = t, this._changed_ids = e;
+  }
+  for_each(t) {
+    const e = this._query._ctx_last_run_tick(), s = this._query._non_empty(), n = this._changed_ids;
+    for (let i = 0; i < s.length; i++) {
+      const r = s[i];
+      for (let c = 0; c < n.length; c++)
+        if (r._changed_tick[n[c]] >= e) {
+          t(r);
+          break;
+        }
+    }
+  }
+}
+const Pt = (a) => F(
+  a
 );
-class Nt {
+class Ut {
   store;
   schedule;
   ctx;
   systems = /* @__PURE__ */ new Set();
   next_system_id = 0;
+  // Tick counter for change detection
+  _tick = 0;
   // Fixed timestep accumulator
   _fixed_timestep;
   _accumulator = 0;
@@ -1298,9 +1526,9 @@ class Nt {
   // Multiple queries can share the same hash (collision), so each bucket is an array.
   query_cache = /* @__PURE__ */ new Map();
   // Reusable BitSet for building query masks — avoids allocation per query() call
-  scratch_mask = new x();
+  scratch_mask = new p();
   constructor(t) {
-    this.store = new At(t?.initial_capacity), this.schedule = new kt(), this.ctx = new Ot(this.store), this._fixed_timestep = t?.fixed_timestep ?? nt, this._max_fixed_steps = t?.max_fixed_steps ?? rt;
+    this.store = new xt(t?.initial_capacity), this.schedule = new St(), this.ctx = new Nt(this.store), this._fixed_timestep = t?.fixed_timestep ?? yt, this._max_fixed_steps = t?.max_fixed_steps ?? mt;
   }
   get fixed_timestep() {
     return this._fixed_timestep;
@@ -1315,7 +1543,7 @@ class Nt {
   register_component(t, e) {
     if (Array.isArray(t)) {
       const s = e ?? "f64", n = /* @__PURE__ */ Object.create(null);
-      for (const r of t) n[r] = s;
+      for (const i of t) n[i] = s;
       return this.store.register_component(n);
     }
     return this.store.register_component(t);
@@ -1323,23 +1551,23 @@ class Nt {
   register_tag() {
     return this.store.register_component({});
   }
-  register_event(t) {
-    return this.store.register_event(t);
+  register_event(t, e) {
+    this.store.register_event_by_key(t, e);
   }
-  register_signal() {
-    return this.store.register_event([]);
+  register_signal(t) {
+    this.store.register_event_by_key(t, []);
   }
   register_resource(t, e) {
-    return this.store.register_resource(
-      t,
-      e
-    );
+    this.store.register_resource(t, e);
   }
   resource(t) {
-    return this.store.get_resource_reader(t);
+    return this.store.get_resource(t);
   }
   set_resource(t, e) {
-    this.store.get_resource_channel(t).write(e);
+    this.store.set_resource(t, e);
+  }
+  has_resource(t) {
+    return this.store.has_resource(t);
   }
   create_entity() {
     return this.store.create_entity();
@@ -1354,7 +1582,7 @@ class Nt {
     return this.store.entity_count;
   }
   add_component(t, e, s) {
-    return this.store.add_component(t, e, s ?? D), this;
+    return this.store.add_component(t, e, s ?? q), this;
   }
   add_components(t, e) {
     this.store.add_components(t, e);
@@ -1379,15 +1607,20 @@ class Nt {
     this.store.batch_remove_component(t, e);
   }
   get_field(t, e, s) {
-    const n = this.store.get_entity_archetype(t), r = this.store.get_entity_row(t);
-    return n.read_field(r, e, s);
+    const n = this.store.get_entity_archetype(t), i = this.store.get_entity_row(t);
+    return n.read_field(i, e, s);
   }
   set_field(t, e, s, n) {
-    const r = this.store.get_entity_archetype(t), i = this.store.get_entity_row(t), _ = r.get_column(e, s);
-    _[i] = n;
+    const i = this.store.get_entity_archetype(t), r = this.store.get_entity_row(t), c = i.get_column_mut(e, s, this.store._tick);
+    c[r] = n;
   }
   emit(t, e) {
-    e === void 0 ? this.store.emit_signal(t) : this.store.emit_event(t, e);
+    const s = this.store.get_event_def_by_key(t);
+    e === void 0 ? this.store.emit_signal(s) : this.store.emit_event(s, e);
+  }
+  read(t) {
+    const e = this.store.get_event_def_by_key(t);
+    return this.store.get_event_reader(e);
   }
   query(...t) {
     const e = this.scratch_mask;
@@ -1396,15 +1629,14 @@ class Nt {
       e.set(t[s]);
     return this._resolve_query(e.copy(), null, null, t);
   }
+  _get_last_run_tick() {
+    return this.ctx.last_run_tick;
+  }
   /** QueryResolver implementation — creates or retrieves a cached Query. */
   _resolve_query(t, e, s, n) {
-    const r = t.hash(), i = e ? e.hash() : 0, _ = s ? s.hash() : 0, c = r ^ Math.imul(i, tt) ^ Math.imul(_, et) | 0, o = this._find_cached(c, t, e, s);
-    if (o !== void 0) return o.query;
-    const h = this.store.register_query(
-      t,
-      e ?? void 0,
-      s ?? void 0
-    ), a = new Pt(
+    const i = t.hash(), r = e ? e.hash() : 0, c = s ? s.hash() : 0, o = i ^ Math.imul(r, ut) ^ Math.imul(c, ft) | 0, _ = this._find_cached(o, t, e, s);
+    if (_ !== void 0) return _.query;
+    const h = this.store.register_query(t, e ?? void 0, s ?? void 0), l = new Dt(
       h,
       n,
       this,
@@ -1412,20 +1644,20 @@ class Nt {
       e?.copy() ?? null,
       s?.copy() ?? null
     );
-    return K(this.query_cache, c, {
+    return this.store.update_query_ref(h, l), Q(this.query_cache, o, {
       include_mask: t.copy(),
       exclude_mask: e?.copy() ?? null,
       any_of_mask: s?.copy() ?? null,
-      query: a
-    }), a;
+      query: l
+    }), l;
   }
   _find_cached(t, e, s, n) {
-    const r = this.query_cache.get(t);
-    if (r)
-      for (let i = 0; i < r.length; i++) {
-        const _ = r[i];
-        if (!(!_.include_mask.equals(e) || !(s === null ? _.exclude_mask === null : _.exclude_mask !== null && _.exclude_mask.equals(s)) || !(n === null ? _.any_of_mask === null : _.any_of_mask !== null && _.any_of_mask.equals(n))))
-          return _;
+    const i = this.query_cache.get(t);
+    if (i)
+      for (let r = 0; r < i.length; r++) {
+        const c = i[r];
+        if (!(!c.include_mask.equals(e) || !(s === null ? c.exclude_mask === null : c.exclude_mask !== null && c.exclude_mask.equals(s)) || !(n === null ? c.any_of_mask === null : c.any_of_mask !== null && c.any_of_mask.equals(n))))
+          return c;
       }
   }
   // any: overload implementation must unify bare fn, (fn, query_fn), and SystemConfig
@@ -1433,16 +1665,14 @@ class Nt {
     let s;
     if (typeof t == "function")
       if (e !== void 0) {
-        const i = e(new St(this)), _ = this.ctx, c = t;
-        s = { fn: (o, h) => c(i, _, h) };
+        const r = e(new Rt(this)), c = this.ctx, o = t;
+        s = { fn: (_, h) => o(r, c, h) };
       } else
         s = { fn: t };
     else
       s = t;
-    const n = Dt(this.next_system_id++), r = Object.freeze(
-      Object.assign({ id: n }, s)
-    );
-    return this.systems.add(r), r;
+    const n = Pt(this.next_system_id++), i = Object.freeze(Object.assign({ id: n }, s));
+    return this.systems.add(i), i;
   }
   add_systems(t, ...e) {
     return this.schedule.add_systems(t, ...e), this;
@@ -1456,16 +1686,16 @@ class Nt {
   startup() {
     for (const t of this.systems.values())
       t.on_added?.(this.ctx);
-    this.schedule.run_startup(this.ctx);
+    this.schedule.run_startup(this.ctx, this._tick);
   }
   update(t) {
-    if (this.schedule.has_fixed_systems()) {
+    if (this.store._tick = this._tick, this.schedule.has_fixed_systems()) {
       this._accumulator += t;
       const e = this._max_fixed_steps * this._fixed_timestep;
       for (this._accumulator > e && (this._accumulator = e); this._accumulator >= this._fixed_timestep; )
-        this.schedule.run_fixed_update(this.ctx, this._fixed_timestep), this._accumulator -= this._fixed_timestep;
+        this.schedule.run_fixed_update(this.ctx, this._fixed_timestep, this._tick), this._accumulator -= this._fixed_timestep;
     }
-    this.schedule.run_update(this.ctx, t), this.store.clear_events();
+    this.schedule.run_update(this.ctx, t, this._tick), this.store.clear_events(), this._tick++;
   }
   flush() {
     this.ctx.flush();
@@ -1476,10 +1706,17 @@ class Nt {
     this.systems.clear(), this.schedule.clear();
   }
 }
+function Mt(a) {
+  return Symbol(a);
+}
 export {
-  Nt as ECS,
-  Pt as Query,
-  St as QueryBuilder,
-  Et as SCHEDULE,
-  Ot as SystemContext
+  $ as ChangedQuery,
+  Ut as ECS,
+  Dt as Query,
+  Rt as QueryBuilder,
+  It as SCHEDULE,
+  Nt as SystemContext,
+  Ot as event_key,
+  Mt as resource_key,
+  qt as signal_key
 };