@oasys/oecs 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,46 +1,34 @@
-class R extends Error {
+class H 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 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))(d || {});
-class u extends R {
+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 {
   constructor(t, e, s) {
     super(e ?? t, !0, s), this.category = t;
   }
 }
-var Y = /* @__PURE__ */ ((a) => (a.ASSERTION_FAIL_CONDITION = "ASSERTION_FAIL_CONDITION", a.VALIDATION_FAIL_CONDITION = "VALIDATION_FAIL_CONDITION", a))(Y || {});
-class X extends R {
-  constructor(t, e, s) {
-    super(e, !1, s), this.category = t;
-  }
-}
-const P = (a) => Number.isInteger(a) && a >= 0;
-function b(a, t, e) {
-  if (process.env.NODE_ENV !== "production" && !t(a))
-    throw new X(
-      Y.VALIDATION_FAIL_CONDITION,
-      `Expected value to meet validation: ${e}`
-    );
-  return a;
+function N(l, t, e) {
+  return l;
 }
-const C = 4;
-class N {
+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 {
   _words;
   constructor(t) {
-    this._words = t ?? new Array(C).fill(0);
+    this._words = t ?? new Array(ot).fill(0);
   }
   has(t) {
-    const e = t >>> 5;
-    return e >= this._words.length ? !1 : (this._words[e] & 1 << (t & 31)) !== 0;
+    const e = t >>> k;
+    return e >= this._words.length ? !1 : (this._words[e] & 1 << (t & I)) !== 0;
   }
   set(t) {
-    const e = t >>> 5;
-    e >= this._words.length && this.grow(e + 1), this._words[e] |= 1 << (t & 31);
+    const e = t >>> k;
+    e >= this._words.length && this.grow(e + 1), this._words[e] |= 1 << (t & I);
   }
   clear(t) {
-    const e = t >>> 5;
-    e >= this._words.length || (this._words[e] &= ~(1 << (t & 31)));
+    const e = t >>> k;
+    e >= this._words.length || (this._words[e] &= ~(1 << (t & I)));
   }
   /** True if any bit is set in both this and other (non-empty intersection). */
   overlaps(t) {
@@ -68,25 +56,25 @@ class N {
     return !0;
   }
   copy() {
-    return new N(this._words.slice());
+    return new x(this._words.slice());
   }
   copy_with_set(t) {
-    const e = t >>> 5, s = e + 1, n = this._words.length > s ? this._words.length : s, r = new Array(n).fill(0);
+    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 & 31), new N(r);
+    return r[e] |= 1 << (t & I), new x(r);
   }
   copy_with_clear(t) {
-    const e = this._words.slice(), s = t >>> 5;
-    return s < e.length && (e[s] &= ~(1 << (t & 31))), new N(e);
+    const e = this._words.slice(), s = t >>> k;
+    return s < e.length && (e[s] &= ~(1 << (t & I))), new x(e);
   }
   /** FNV-1a hash. Skips trailing zero words so differently-sized arrays with the same bits hash equally. */
   hash() {
-    let t = 2166136261;
+    let t = J;
     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, 16777619);
+      t ^= e[n], t = Math.imul(t, Z);
     return t;
   }
   /** Iterate all set bits via lowest-set-bit extraction. */
@@ -95,9 +83,9 @@ class N {
     for (let s = 0; s < e.length; s++) {
       let n = e[s];
       if (n === 0) continue;
-      const r = s << 5;
+      const r = s << k;
       for (; n !== 0; ) {
-        const i = n & -n >>> 0, _ = 31 - Math.clz32(i);
+        const i = n & -n >>> 0, _ = I - Math.clz32(i);
         t(r + _), n ^= i;
       }
     }
@@ -110,26 +98,144 @@ class N {
     this._words = s;
   }
 }
-const I = 20, k = (1 << I) - 1, j = k, G = 31 - I, D = (1 << G) - 1, $ = (a, t) => {
-  if (process.env.NODE_ENV !== "production") {
-    if (a < 0 || a > j)
-      throw new u(d.EID_MAX_INDEX_OVERFLOW);
-    if (t < 0 || t > D)
-      throw new u(d.EID_MAX_GEN_OVERFLOW);
-  }
-  return t << I | a;
-}, y = (a) => a & k, q = (a) => a >> I, z = (a) => b(
-  a,
-  P,
-  "ComponentID must be a non-negative integer"
-), W = (a) => b(
-  a,
-  P,
-  "EventID must be a non-negative integer"
+class A {
+  constructor(t, e = b) {
+    this._ctor = t, this._buf = new t(e);
+  }
+  _buf;
+  _len = 0;
+  get length() {
+    return this._len;
+  }
+  push(t) {
+    this._len >= this._buf.length && this._grow(), this._buf[this._len++] = t;
+  }
+  pop() {
+    return this._buf[--this._len];
+  }
+  get(t) {
+    return this._buf[t];
+  }
+  set_at(t, e) {
+    this._buf[t] = e;
+  }
+  /**
+   * Move the last element into slot i, decrement length.
+   * Returns the value that was removed from slot i.
+   */
+  swap_remove(t) {
+    const e = this._buf[t];
+    return this._buf[t] = this._buf[--this._len], e;
+  }
+  clear() {
+    this._len = 0;
+  }
+  /**
+   * Raw backing buffer. Valid data: indices 0..length-1.
+   * This reference is stable until the next push() that triggers a grow —
+   * do not cache across entity additions.
+   */
+  get buf() {
+    return this._buf;
+  }
+  /**
+   * Zero-copy subarray view of valid data (0..length-1).
+   * Shares the backing buffer — invalidated if a subsequent push() grows.
+   */
+  view() {
+    return this._buf.subarray(0, this._len);
+  }
+  [Symbol.iterator]() {
+    let t = 0;
+    const e = this._buf, s = this._len;
+    return {
+      next() {
+        return t < s ? { value: e[t++], done: !1 } : { value: 0, done: !0 };
+      }
+    };
+  }
+  /** Ensure the backing buffer can hold at least `capacity` elements without growing. */
+  ensure_capacity(t) {
+    if (t <= this._buf.length) return;
+    let e = this._buf.length || 1;
+    for (; e < t; ) e *= C;
+    const s = new this._ctor(e);
+    s.set(this._buf.subarray(0, this._len)), this._buf = s;
+  }
+  /**
+   * Append `count` elements from `src` starting at `src_offset`.
+   * Grows if needed. Equivalent to push() in a loop but uses TypedArray.set().
+   */
+  bulk_append(t, e, s) {
+    this.ensure_capacity(this._len + s), this._buf.set(t.subarray(e, e + s), this._len), this._len += s;
+  }
+  /** Append `count` zeroes. Grows if needed. */
+  bulk_append_zeroes(t) {
+    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);
+    t.set(this._buf), this._buf = t;
+  }
+}
+class _t extends A {
+  constructor(t = b) {
+    super(Float32Array, t);
+  }
+}
+class ct extends A {
+  constructor(t = b) {
+    super(Float64Array, t);
+  }
+}
+class ht extends A {
+  constructor(t = b) {
+    super(Int8Array, t);
+  }
+}
+class lt extends A {
+  constructor(t = b) {
+    super(Int16Array, t);
+  }
+}
+class at extends A {
+  constructor(t = b) {
+    super(Int32Array, t);
+  }
+}
+class dt extends A {
+  constructor(t = b) {
+    super(Uint8Array, t);
+  }
+}
+class ut extends A {
+  constructor(t = b) {
+    super(Uint16Array, t);
+  }
+}
+class B 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
 );
-class B {
+class wt {
   field_names;
   columns;
+  // any: type-erased storage — channel is stored in Map<number, EventChannel>, F is lost
   reader;
   constructor(t) {
     this.field_names = t, this.columns = [];
@@ -157,46 +263,92 @@ class B {
       t[e].length = 0;
   }
 }
-const Q = (a) => b(
-  a,
-  P,
-  "ArchetypeID must be a non-negative integer"
+const vt = (l) => N(
+  l
 );
-class K {
+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;
+  }
+}
+const bt = (l) => N(
+  l
+);
+class Tt {
   id;
   mask;
   has_columns;
-  entity_ids = [];
+  _entity_ids;
   length = 0;
   edges = [];
-  // Sparse array indexed by ComponentID — undefined for absent components.
-  // Allows O(1) column group lookup by component.
+  // --- Flat column storage ---
+  // Dense array of ALL columns across all components in this archetype.
+  _flat_columns = [];
+  // Sparse by ComponentID → starting index into _flat_columns.
+  _col_offset = [];
+  // Sparse by ComponentID → number of fields for that component.
+  _field_count = [];
+  // Sparse by ComponentID → field_index record (field name → offset within component).
+  _field_index = [];
+  // Sparse by ComponentID → field_names array.
+  _field_names = [];
+  // Sparse array indexed by ComponentID — kept for create_ref compatibility.
   column_groups = [];
-  // Dense list of ComponentIDs that have columns — used to iterate only
-  // data-bearing components in copy/add/remove operations.
+  // Dense list of ComponentIDs that have columns — used for copy_shared_from.
   _column_ids = [];
-  constructor(t, e, s) {
-    if (this.id = t, this.mask = e, s)
-      for (let n = 0; n < s.length; n++) {
-        const r = s[n], i = new Array(r.field_names.length);
-        for (let h = 0; h < r.field_names.length; h++)
-          i[h] = [];
-        const _ = /* @__PURE__ */ Object.create(null);
-        for (let h = 0; h < r.field_names.length; h++)
-          _[r.field_names[h]] = i[h];
-        this.column_groups[r.component_id] = {
-          layout: r,
-          columns: i,
-          record: _
-        }, this._column_ids.push(r.component_id);
+  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;
+        }
+        this.column_groups[c] = { layout: _, columns: o }, this._column_ids.push(c);
       }
+    }
     this.has_columns = this._column_ids.length > 0;
   }
   get entity_count() {
     return this.length;
   }
+  /** Raw entity ID buffer. Valid data at indices 0..entity_count-1. */
+  get entity_ids() {
+    return this._entity_ids.buf;
+  }
   get entity_list() {
-    return this.entity_ids;
+    return this._entity_ids.view();
   }
   has_component(t) {
     return this.mask.has(t);
@@ -206,47 +358,39 @@ class K {
   }
   /** Get a single field's column. Valid data: indices 0..entity_count-1. */
   get_column(t, e) {
-    const s = this.column_groups[t];
-    if (process.env.NODE_ENV !== "production" && !s)
-      throw new u(
-        d.COMPONENT_NOT_REGISTERED,
-        `Component ${t} not in archetype ${this.id}`
-      );
-    const n = s.layout.field_index[e];
-    if (process.env.NODE_ENV !== "production" && n === void 0)
-      throw new u(
-        d.COMPONENT_NOT_REGISTERED,
-        `Field "${e}" does not exist on component`
-      );
-    return s.columns[n];
-  }
-  /** Get all columns for a component as { fieldName: number[] }. */
-  get_column_group(t) {
-    const e = this.column_groups[t];
-    return e ? e.record : {};
+    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 = this.column_groups[e];
-    if (!n) return;
-    const { field_names: r } = n.layout;
-    for (let i = 0; i < r.length; i++)
-      n.columns[i][t] = s[r[i]];
+    const n = e, r = this._col_offset[n];
+    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]];
+  }
+  /** 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];
+    if (r === void 0) return;
+    const i = this._flat_columns;
+    for (let _ = 0; _ < s.length; _++)
+      i[r + _].buf[t] = s[_];
   }
   read_field(t, e, s) {
-    const n = this.column_groups[e];
-    if (!n) return NaN;
-    const r = n.layout.field_index[s];
-    return r === void 0 ? NaN : n.columns[r][t] ?? NaN;
+    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];
   }
   /** Copy all shared component columns from source archetype at src_row into dst_row. */
   copy_shared_from(t, e, s) {
-    const n = t.column_groups, r = this._column_ids;
-    for (let i = 0; i < r.length; i++) {
-      const _ = r[i], h = n[_];
-      if (!h) continue;
-      const o = this.column_groups[_];
-      for (let c = 0; c < o.columns.length; c++)
-        o.columns[c][s] = h.columns[c][e];
+    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];
     }
   }
   /**
@@ -255,49 +399,88 @@ class K {
    */
   add_entity(t) {
     const e = this.length;
-    this.entity_ids.push(t);
-    const s = this._column_ids;
-    for (let n = 0; n < s.length; n++) {
-      const r = this.column_groups[s[n]];
-      for (let i = 0; i < r.columns.length; i++)
-        r.columns[i].push(0);
-    }
+    this._entity_ids.push(t);
+    const s = this._flat_columns;
+    for (let n = 0; n < s.length; n++)
+      s[n].push(0);
     return this.length++, e;
   }
   /**
    * Remove entity at row via swap-and-pop. Swaps the last entity into the
    * vacated row to keep data dense. Returns the entity_index of the swapped
-   * entity (so Store can update its row), or -1 if no swap was needed.
+   * entity (so Store can update its row), or NO_SWAP if no swap was needed.
    */
   remove_entity(t) {
     const e = this.length - 1;
-    let s = -1;
-    const n = this._column_ids;
+    let s = y;
+    const n = this._flat_columns, r = this._entity_ids.buf;
     if (t !== e) {
-      this.entity_ids[t] = this.entity_ids[e], s = y(this.entity_ids[t]);
-      for (let r = 0; r < n.length; r++) {
-        const i = this.column_groups[n[r]];
-        for (let _ = 0; _ < i.columns.length; _++)
-          i.columns[_][t] = i.columns[_][e], i.columns[_].pop();
-      }
+      r[t] = r[e], s = m(r[t]);
+      for (let i = 0; i < n.length; i++)
+        n[i].swap_remove(t);
     } else
-      for (let r = 0; r < n.length; r++) {
-        const i = this.column_groups[n[r]];
-        for (let _ = 0; _ < i.columns.length; _++)
-          i.columns[_].pop();
-      }
-    return this.entity_ids.pop(), this.length--, s;
+      for (let i = 0; i < n.length; i++)
+        n[i].pop();
+    return this._entity_ids.pop(), this.length--, s;
   }
   /** Tag-optimized add: skip column push entirely (no data to store). */
   add_entity_tag(t) {
     const e = this.length;
-    return this.entity_ids.push(t), this.length++, e;
+    return this._entity_ids.push(t), this.length++, e;
   }
   /** Tag-optimized remove via swap-and-pop: skip column swap/pop entirely. */
   remove_entity_tag(t) {
     const e = this.length - 1;
-    let s = -1;
-    return t !== e && (this.entity_ids[t] = this.entity_ids[e], s = y(this.entity_ids[t])), this.entity_ids.pop(), this.length--, s;
+    let s = y;
+    const n = this._entity_ids.buf;
+    return t !== e && (n[t] = n[e], s = m(n[t])), this._entity_ids.pop(), this.length--, s;
+  }
+  /**
+   * Move an entity from src archetype into this archetype in a single pass.
+   * Combines add_entity + copy_shared_from + remove_entity(src).
+   * 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) {
+    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);
+    }
+    this.length++;
+    const c = t.has_columns ? t.remove_entity(e) : t.remove_entity_tag(e);
+    f[0] = r, f[1] = c;
+  }
+  /**
+   * Move an entity from src into this archetype (tag-only: no columns to copy).
+   * Writes dst_row to _move_result[0], swapped entity index to _move_result[1].
+   */
+  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;
+  }
+  /**
+   * 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);
+    for (let _ = 0; _ < r.length; _++) {
+      const c = e[_];
+      c >= 0 ? r[_].bulk_append(i[c].buf, 0, s) : r[_].bulk_append_zeroes(s);
+    }
+    this.length += s, t.length = 0, t._entity_ids.clear();
+    for (let _ = 0; _ < i.length; _++)
+      i[_].clear();
+    return n;
   }
   get_edge(t) {
     return this.edges[t];
@@ -306,12 +489,25 @@ class K {
     this.edges[t] = e;
   }
 }
-function F(a, t, e) {
-  const s = a.get(t);
-  s !== void 0 ? s.push(e) : a.set(t, [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;
+    else
+      for (let d = 0; d < a; d++)
+        s[h + d] = -1;
+  }
+  return s;
+}
+function K(l, t, e) {
+  const s = l.get(t);
+  s !== void 0 ? s.push(e) : l.set(t, [e]);
 }
-const m = -1, V = Object.freeze(/* @__PURE__ */ Object.create(null));
-class J {
+class At {
   // --- Entity ID management ---
   // Generational slot allocator: entity_generations[index] holds the current
   // generation for that slot. Free indices are recycled via a stack.
@@ -320,7 +516,7 @@ class J {
   entity_free_indices = [];
   entity_alive_count = 0;
   // --- Component metadata ---
-  // Parallel array indexed by ComponentID: field_names and field_index
+  // Parallel array indexed by ComponentID: field_names, field_index, and field_types
   // for building archetype column layouts.
   component_metas = [];
   component_count = 0;
@@ -328,6 +524,10 @@ class J {
   // 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
@@ -353,18 +553,14 @@ class J {
   pending_add_values = [];
   pending_remove_ids = [];
   pending_remove_defs = [];
-  constructor() {
-    this.empty_archetype_id = this.arch_get_or_create_from_mask(new N());
+  initial_capacity;
+  constructor(t) {
+    this.initial_capacity = t ?? V, this.empty_archetype_id = this.arch_get_or_create_from_mask(new x());
   }
   // =======================================================
   // Archetype graph
   // =======================================================
   arch_get(t) {
-    if (process.env.NODE_ENV !== "production" && (t < 0 || t >= this.archetypes.length))
-      throw new u(
-        d.ARCHETYPE_NOT_FOUND,
-        `Archetype with ID ${t} not found`
-      );
     return this.archetypes[t];
   }
   /**
@@ -374,28 +570,29 @@ class J {
   arch_get_or_create_from_mask(t) {
     const e = t.hash(), s = this.archetype_map.get(e);
     if (s !== void 0) {
-      for (let h = 0; h < s.length; h++)
-        if (this.archetypes[s[h]].mask.equals(t))
-          return s[h];
+      for (let c = 0; c < s.length; c++)
+        if (this.archetypes[s[c]].mask.equals(t))
+          return s[c];
     }
-    const n = Q(this.next_archetype_id++), r = [];
-    t.for_each((h) => {
-      const o = h, c = this.component_metas[o];
-      c && c.field_names.length > 0 && r.push({
+    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,
-        field_names: c.field_names,
-        field_index: c.field_index
+        field_names: h.field_names,
+        field_index: h.field_index,
+        field_types: h.field_types
       });
     });
-    const i = new K(n, t, r);
-    this.archetypes.push(i), F(this.archetype_map, e, n), t.for_each((h) => {
-      const o = h;
-      let c = this.component_index.get(o);
-      c || (c = /* @__PURE__ */ new Set(), this.component_index.set(o, c)), c.add(n);
+    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 _ = this.registered_queries;
-    for (let h = 0; h < _.length; h++) {
-      const o = _[h];
+    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);
     }
     return n;
@@ -426,41 +623,44 @@ class J {
   arch_cache_edge(t, e, s) {
     const n = t.get_edge(s) ?? {
       add: null,
-      remove: null
+      remove: null,
+      add_map: null,
+      remove_map: null
     };
-    n.add = e.id, t.set_edge(s, n);
-    const r = e.get_edge(s) ?? { add: null, remove: null };
-    r.remove = t.id, e.set_edge(s, r);
+    n.add = e.id, n.add_map = M(t, e), t.set_edge(s, n);
+    const r = 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);
   }
   // =======================================================
   // Entity lifecycle
   // =======================================================
   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] = 0, e = 0), this.entity_alive_count++;
-    const s = $(t, e);
-    return this.entity_archetype[t] = this.empty_archetype_id, this.entity_row[t] = m, s;
+    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;
   }
   /** Immediately destroy an entity, removing it from its archetype. */
   destroy_entity(t) {
-    if (!this.is_alive(t)) {
-      if (process.env.NODE_ENV !== "production") throw new u(d.ENTITY_NOT_ALIVE);
+    if (!this.is_alive(t))
       return;
-    }
-    const e = y(t), s = this.entity_row[e];
-    if (s !== m) {
+    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 !== -1 && (this.entity_row[i] = s);
+      i !== y && (this.entity_row[i] = s);
     }
-    this.entity_archetype[e] = m, this.entity_row[e] = m;
-    const n = q(t);
-    if (process.env.NODE_ENV !== "production" && n >= D)
-      throw new u(d.EID_MAX_GEN_OVERFLOW);
-    this.entity_generations[e] = n + 1 & D, this.entity_free_indices.push(e), this.entity_alive_count--;
+    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--;
   }
   is_alive(t) {
-    const e = y(t);
-    return e < this.entity_high_water && this.entity_generations[e] === q(t);
+    const e = m(t);
+    return e < this.entity_high_water && this.entity_generations[e] === Y(t);
   }
   get entity_count() {
     return this.entity_alive_count;
@@ -469,8 +669,6 @@ class J {
   // Deferred destruction
   // =======================================================
   destroy_entity_deferred(t) {
-    if (process.env.NODE_ENV !== "production" && !this.is_alive(t))
-      throw new u(d.ENTITY_NOT_ALIVE);
     this.pending_destroy.push(t);
   }
   /** Flush all buffered entity destructions in batch. */
@@ -479,16 +677,14 @@ class J {
     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 h = t[_], o = h & k, c = h >> I;
-      if (o >= i || n[o] !== c) continue;
-      const l = s[o];
-      if (l !== m) {
-        const p = r[e[o]], g = p.has_columns ? p.remove_entity(l) : p.remove_entity_tag(l);
-        g !== -1 && (s[g] = l);
+      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);
       }
-      if (e[o] = m, s[o] = m, process.env.NODE_ENV !== "production" && c >= D)
-        throw new u(d.EID_MAX_GEN_OVERFLOW);
-      n[o] = c + 1 & D, this.entity_free_indices.push(o), this.entity_alive_count--;
+      e[o] = v, s[o] = v, n[o] = h + 1 & X, this.entity_free_indices.push(o), this.entity_alive_count--;
     }
     t.length = 0;
   }
@@ -496,13 +692,9 @@ class J {
     return this.pending_destroy.length;
   }
   add_component_deferred(t, e, s) {
-    if (process.env.NODE_ENV !== "production" && !this.is_alive(t))
-      throw new u(d.ENTITY_NOT_ALIVE);
-    this.pending_add_ids.push(t), this.pending_add_defs.push(e), this.pending_add_values.push(s ?? V);
+    this.pending_add_ids.push(t), this.pending_add_defs.push(e), this.pending_add_values.push(s ?? D);
   }
   remove_component_deferred(t, e) {
-    if (process.env.NODE_ENV !== "production" && !this.is_alive(t))
-      throw new u(d.ENTITY_NOT_ALIVE);
     this.pending_remove_ids.push(t), this.pending_remove_defs.push(e);
   }
   flush_structural() {
@@ -510,37 +702,47 @@ class J {
   }
   /** 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, h = this.archetypes, o = this.component_metas, c = this.entity_high_water;
-    for (let l = 0; l < n; l++) {
-      const p = t[l], g = p & k, w = p >> I;
-      if (g >= c || _[g] !== w) continue;
-      const T = r[g], v = e[l], f = h[T];
-      if (f.mask.has(v)) {
-        o[v].field_names.length > 0 && f.write_fields(i[g], v, s[l]);
+    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]);
         continue;
       }
-      const O = this.arch_resolve_add(T, v), E = h[O], x = i[g], A = !E.has_columns && !f.has_columns, S = A ? E.add_entity_tag(p) : E.add_entity(p);
-      if (x !== m) {
-        A || E.copy_shared_from(f, x, S);
-        const U = A ? f.remove_entity_tag(x) : f.remove_entity(x);
-        U !== -1 && (i[U] = x);
-      }
-      o[v].field_names.length > 0 && E.write_fields(S, v, s[l]), r[g] = O, i[g] = S;
+      const S = this.arch_resolve_add(T, p), E = c[S], O = i[d], L = !E.has_columns && !w.has_columns;
+      let U;
+      if (O !== v) {
+        if (L)
+          E.move_entity_from_tag(w, O, u);
+        else {
+          const $ = w.get_edge(p);
+          E.move_entity_from(w, O, u, $.add_map);
+        }
+        U = f[0], f[1] !== y && (i[f[1]] = O);
+      } 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;
     }
     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, h = this.entity_high_water;
+    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 c = t[o], l = c & k, p = c >> I;
-      if (l >= h || i[l] !== p) continue;
-      const g = n[l], w = e[o], T = _[g];
-      if (!T.mask.has(w)) continue;
-      const v = this.arch_resolve_remove(g, w), f = _[v], O = r[l], E = !f.has_columns && !T.has_columns, x = E ? f.add_entity_tag(c) : f.add_entity(c);
-      E || f.copy_shared_from(T, O, x);
-      const A = E ? T.remove_entity_tag(O) : T.remove_entity(O);
-      A !== -1 && (r[A] = O), n[l] = v, r[l] = x;
+      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);
+      else {
+        const O = T.get_edge(g);
+        w.move_entity_from(T, S, h, O.remove_map);
+      }
+      f[1] !== y && (r[f[1]] = S), n[a] = p, r[a] = f[0];
     }
     t.length = 0, e.length = 0;
   }
@@ -551,17 +753,15 @@ class J {
   // Component registration
   // =======================================================
   register_component(t) {
-    const e = z(this.component_count++), s = t, n = /* @__PURE__ */ Object.create(null);
-    for (let r = 0; r < s.length; r++)
-      n[s[r]] = r;
-    return this.component_metas.push({ field_names: s, field_index: n }), e;
+    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;
   }
   add_component(t, e, s) {
-    if (!this.is_alive(t)) {
-      if (process.env.NODE_ENV !== "production") throw new u(d.ENTITY_NOT_ALIVE);
+    if (!this.is_alive(t))
       return;
-    }
-    const n = y(t), r = this.entity_archetype[n], i = this.arch_get(r);
+    const n = m(t), r = this.entity_archetype[n], i = this.arch_get(r);
     if (i.has_component(e)) {
       i.write_fields(
         this.entity_row[n],
@@ -573,25 +773,24 @@ class J {
     const _ = this.arch_resolve_add(
       r,
       e
-    ), h = this.arch_get(_), o = this.entity_row[n], c = h.add_entity(t);
-    if (o !== m) {
-      h.copy_shared_from(i, o, c);
-      const l = i.remove_entity(o);
-      l !== -1 && (this.entity_row[l] = o);
-    }
-    h.write_fields(
-      c,
+    ), c = this.arch_get(_), o = 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);
+    } else
+      h = c.has_columns ? c.add_entity(t) : c.add_entity_tag(t);
+    c.write_fields(
+      h,
       e,
       s
-    ), this.entity_archetype[n] = _, this.entity_row[n] = c;
+    ), this.entity_archetype[n] = _, this.entity_row[n] = h;
   }
   /** Add multiple components in one transition (resolves final archetype, then moves once). */
   add_components(t, e) {
-    if (!this.is_alive(t)) {
-      if (process.env.NODE_ENV !== "production") throw new u(d.ENTITY_NOT_ALIVE);
+    if (!this.is_alive(t))
       return;
-    }
-    const s = y(t), n = this.entity_archetype[s];
+    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(
@@ -599,83 +798,107 @@ class J {
         e[i].def
       );
     if (r !== n) {
-      const i = this.arch_get(n), _ = this.arch_get(r), h = this.entity_row[s], o = _.add_entity(t);
-      if (h !== m) {
-        _.copy_shared_from(i, h, o);
-        const c = i.remove_entity(h);
-        c !== -1 && (this.entity_row[c] = h);
-      }
-      for (let c = 0; c < e.length; c++)
+      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);
+      } else
+        o = _.add_entity(t);
+      for (let h = 0; h < e.length; h++)
         _.write_fields(
           o,
-          e[c].def,
-          e[c].values ?? V
+          e[h].def,
+          e[h].values ?? D
         );
       this.entity_archetype[s] = r, this.entity_row[s] = o;
     } else {
       const i = this.arch_get(n), _ = this.entity_row[s];
-      for (let h = 0; h < e.length; h++)
+      for (let c = 0; c < e.length; c++)
         i.write_fields(
           _,
-          e[h].def,
-          e[h].values ?? V
+          e[c].def,
+          e[c].values ?? D
         );
     }
   }
   remove_component(t, e) {
-    if (!this.is_alive(t)) {
-      if (process.env.NODE_ENV !== "production") throw new u(d.ENTITY_NOT_ALIVE);
+    if (!this.is_alive(t))
       return;
-    }
-    const s = y(t), n = this.entity_archetype[s], r = this.arch_get(n);
+    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), h = this.entity_row[s], o = _.add_entity(t);
-    _.copy_shared_from(r, h, o);
-    const c = r.remove_entity(h);
-    c !== -1 && (this.entity_row[c] = h), this.entity_archetype[s] = i, this.entity_row[s] = o;
+    ), _ = 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];
   }
   /** Remove multiple components in one transition (resolves final archetype, then moves once). */
   remove_components(t, e) {
-    if (!this.is_alive(t)) {
-      if (process.env.NODE_ENV !== "production") throw new u(d.ENTITY_NOT_ALIVE);
+    if (!this.is_alive(t))
       return;
-    }
-    const s = y(t), n = this.entity_archetype[s];
+    const s = m(t), n = this.entity_archetype[s];
     let r = n;
-    for (let l = 0; l < e.length; l++)
+    for (let h = 0; h < e.length; h++)
       r = this.arch_resolve_remove(
         r,
-        e[l]
+        e[h]
       );
     if (r === n) return;
-    const i = this.arch_get(n), _ = this.arch_get(r), h = this.entity_row[s], o = _.add_entity(t);
-    _.copy_shared_from(i, h, o);
-    const c = i.remove_entity(h);
-    c !== -1 && (this.entity_row[c] = h), this.entity_archetype[s] = r, this.entity_row[s] = o;
+    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];
   }
   has_component(t, e) {
-    if (!this.is_alive(t)) {
-      if (process.env.NODE_ENV !== "production") throw new u(d.ENTITY_NOT_ALIVE);
+    if (!this.is_alive(t))
       return !1;
-    }
-    const s = y(t);
+    const s = m(t);
     return this.arch_get(
       this.entity_archetype[s]
     ).has_component(e);
   }
+  /**
+   * Bulk add a component to ALL entities in the given archetype.
+   * Uses TypedArray.set() for O(columns) instead of O(N×columns).
+   * The archetype must not already contain this component.
+   */
+  batch_add_component(t, e, s) {
+    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;
+    }
+    if (this.component_metas[n].field_names.length > 0 && s)
+      for (let d = 0; d < c; d++)
+        i.write_fields(a + d, n, s);
+  }
+  /**
+   * Bulk remove a component from ALL entities in the given archetype.
+   * Uses TypedArray.set() for O(columns) instead of O(N×columns).
+   * The archetype must contain this component.
+   */
+  batch_remove_component(t, e) {
+    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;
+    }
+  }
   // =======================================================
   // Direct data access (used by SystemContext)
   // =======================================================
   get_entity_archetype(t) {
     return this.arch_get(
-      this.entity_archetype[y(t)]
+      this.entity_archetype[m(t)]
     );
   }
   get_entity_row(t) {
-    return this.entity_row[y(t)];
+    return this.entity_row[m(t)];
   }
   // =======================================================
   // Query support
@@ -699,28 +922,28 @@ class J {
       );
     let i, _ = !1;
     for (let o = 0; o < n.length; o++) {
-      let c = n[o];
-      if (c === 0) continue;
-      const l = o << 5;
-      for (; c !== 0; ) {
-        const p = c & -c >>> 0, g = l + (31 - Math.clz32(p));
-        c ^= p;
-        const w = this.component_index.get(g);
-        if (!w || w.size === 0) {
+      let h = n[o];
+      if (h === 0) continue;
+      const a = o << k;
+      for (; h !== 0; ) {
+        const u = h & -h >>> 0, d = a + (I - Math.clz32(u));
+        h ^= u;
+        const g = this.component_index.get(d);
+        if (!g || g.size === 0) {
           _ = !0;
           break;
         }
-        (!i || w.size < i.size) && (i = w);
+        (!i || g.size < i.size) && (i = g);
       }
       if (_) break;
     }
     if (_ || !i) return [];
-    const h = [];
+    const c = [];
     for (const o of i) {
-      const c = this.arch_get(o);
-      c.matches(t) && (!e || !c.mask.overlaps(e)) && (!s || c.mask.overlaps(s)) && h.push(c);
+      const h = this.arch_get(o);
+      h.matches(t) && (!e || !h.mask.overlaps(e)) && (!s || h.mask.overlaps(s)) && c.push(h);
     }
-    return h;
+    return c;
   }
   /**
    * Register a live query. Returns a mutable Archetype[] that this Store will
@@ -746,7 +969,7 @@ class J {
   // Event channels
   // =======================================================
   register_event(t) {
-    const e = W(this.event_count++), s = new B(t);
+    const e = pt(this.event_count++), s = new wt(t);
     return this.event_channels.push(s), e;
   }
   emit_event(t, e) {
@@ -763,40 +986,47 @@ class J {
     for (let e = 0; e < t.length; e++)
       t[e].clear();
   }
+  // =======================================================
+  // Resource channels
+  // =======================================================
+  register_resource(t, e) {
+    const s = vt(this.resource_count++), n = new xt(t, e);
+    return this.resource_channels.push(n), s;
+  }
+  get_resource_reader(t) {
+    return this.resource_channels[t].reader;
+  }
+  get_resource_channel(t) {
+    return this.resource_channels[t];
+  }
 }
-var Z = /* @__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))(Z || {});
-const M = [
+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 = [
   "PRE_STARTUP",
   "STARTUP",
   "POST_STARTUP"
   /* POST_STARTUP */
-], L = [
+], G = [
   "PRE_UPDATE",
   "UPDATE",
   "POST_UPDATE"
   /* POST_UPDATE */
 ];
-class H {
+class kt {
   label_systems = /* @__PURE__ */ new Map();
   sorted_cache = /* @__PURE__ */ new Map();
   system_index = /* @__PURE__ */ new Map();
   next_insertion_order = 0;
   constructor() {
-    for (let t = 0; t < M.length; t++)
-      this.label_systems.set(M[t], []);
+    for (let t = 0; t < q.length; t++)
+      this.label_systems.set(q[t], []);
     this.label_systems.set("FIXED_UPDATE", []);
-    for (let t = 0; t < L.length; t++)
-      this.label_systems.set(L[t], []);
+    for (let t = 0; t < G.length; t++)
+      this.label_systems.set(G[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;
-      if (process.env.NODE_ENV !== "production" && this.system_index.has(n))
-        throw new u(
-          d.DUPLICATE_SYSTEM,
-          `System ${n.id} is already scheduled`
-        );
-      const i = {
+      const n = "system" in s ? s.system : s, r = "system" in s ? s.ordering : void 0, i = {
         descriptor: n,
         insertion_order: this.next_insertion_order++,
         before: new Set(r?.before ?? []),
@@ -818,11 +1048,11 @@ class H {
     this.system_index.delete(t), this.sorted_cache.delete(e);
   }
   run_startup(t) {
-    for (const e of M)
-      this.run_label(e, t, 0);
+    for (const e of q)
+      this.run_label(e, t, it);
   }
   run_update(t, e) {
-    for (const s of L)
+    for (const s of G)
       this.run_label(s, t, e);
   }
   run_fixed_update(t, e) {
@@ -871,51 +1101,72 @@ class H {
     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 c of o.before)
-        i.has(c) && (s.get(o.descriptor).add(c), n.set(c, n.get(c) + 1));
-      for (const c of o.after)
-        i.has(c) && (s.get(c).add(o.descriptor), n.set(o.descriptor, n.get(o.descriptor) + 1));
+      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, c) => r.get(c) - r.get(o));
-    const h = [];
+    _.sort((o, h) => r.get(h) - r.get(o));
+    const c = [];
     for (; _.length > 0; ) {
       const o = _.pop();
-      h.push(o);
-      for (const c of s.get(o)) {
-        const l = n.get(c) - 1;
-        n.set(c, l), l === 0 && _.push(c);
+      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((c, l) => r.get(l) - r.get(c));
+      _.sort((h, a) => r.get(a) - r.get(h));
     }
-    if (h.length !== t.length) {
-      const o = new Set(h), c = t.filter((l) => !o.has(l.descriptor)).map((l) => `system_${l.descriptor.id}`);
-      throw new u(
-        d.CIRCULAR_SYSTEM_DEPENDENCY,
-        `Circular system dependency detected in ${e}: [${c.join(", ")}]`
+    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(", ")}]`
       );
     }
-    return h;
+    return c;
   }
 }
-const tt = Object.freeze(/* @__PURE__ */ Object.create(null));
-class et {
+const W = /* @__PURE__ */ new WeakMap();
+function It(l, t) {
+  let e = W.get(l);
+  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], {
+        get() {
+          return this._columns[_][this._row];
+        },
+        set(c) {
+          this._columns[_][this._row] = c;
+        },
+        enumerable: !0,
+        configurable: !1
+      });
+    }
+    W.set(l, 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;
+  return s._columns = n, s._row = t, s;
+}
+class Pt {
   _archetypes;
   _defs;
   _resolver;
   _include;
   _exclude;
   _any_of;
-  // Pre-allocated args buffer for each() — avoids allocating a new array per
-  // archetype. Holds [columnGroup0, columnGroup1, ..., entityCount].
-  _args_buf;
   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, this._args_buf = new Array(e.length + 1);
+    this._archetypes = t, this._defs = e, this._resolver = s, this._include = n, this._exclude = r, this._any_of = i;
   }
   /** Number of matching archetypes (including empty ones). */
-  get length() {
+  get archetype_count() {
     return this._archetypes.length;
   }
   /** Total entity count across all matching archetypes. */
@@ -934,22 +1185,6 @@ class et {
     for (let e = 0; e < t.length; e++)
       t[e].entity_count > 0 && (yield t[e]);
   }
-  /**
-   * Typed per-archetype iteration. Calls fn once per non-empty archetype
-   * with column groups for each queried component, plus the entity count.
-   * The system is responsible for the inner loop over entities.
-   */
-  each(t) {
-    const e = this._archetypes, s = this._defs, n = this._args_buf;
-    for (let r = 0; r < e.length; r++) {
-      const i = e[r], _ = i.entity_count;
-      if (_ !== 0) {
-        for (let h = 0; h < s.length; h++)
-          n[h] = i.get_column_group(s[h]);
-        n[s.length] = _, t.apply(null, n);
-      }
-    }
-  }
   /** Extend required component set. Returns a new (cached) Query. */
   and(...t) {
     const e = this._include.copy(), s = this._defs.slice();
@@ -964,7 +1199,7 @@ class et {
   }
   /** Exclude archetypes that have any of these components. */
   not(...t) {
-    const e = this._exclude ? this._exclude.copy() : new N();
+    const e = this._exclude ? this._exclude.copy() : new x();
     for (let s = 0; s < t.length; s++) e.set(t[s]);
     return this._resolver._resolve_query(
       this._include,
@@ -974,8 +1209,8 @@ class et {
     );
   }
   /** Require at least one of these components. */
-  or(...t) {
-    const e = this._any_of ? this._any_of.copy() : new N();
+  any_of(...t) {
+    const e = this._any_of ? this._any_of.copy() : new x();
     for (let s = 0; s < t.length; s++) e.set(t[s]);
     return this._resolver._resolve_query(
       this._include,
@@ -985,17 +1220,17 @@ class et {
     );
   }
 }
-class st {
+class St {
   constructor(t) {
     this._resolver = t;
   }
   every(...t) {
-    const e = new N();
+    const e = new x();
     for (let s = 0; s < t.length; s++) e.set(t[s]);
     return this._resolver._resolve_query(e, null, null, t);
   }
 }
-class nt {
+class Ot {
   store;
   constructor(t) {
     this.store = t;
@@ -1004,22 +1239,24 @@ class nt {
     return this.store.create_entity();
   }
   get_field(t, e, s) {
-    const n = this.store.get_entity_archetype(e), r = this.store.get_entity_row(e);
-    return n.read_field(r, t, s);
+    const n = this.store.get_entity_archetype(t), r = this.store.get_entity_row(t);
+    return n.read_field(r, e, s);
   }
   set_field(t, e, s, n) {
-    const r = this.store.get_entity_archetype(e), i = this.store.get_entity_row(e), _ = r.get_column(t, s);
+    const r = this.store.get_entity_archetype(t), i = this.store.get_entity_row(t), _ = r.get_column(e, s);
     _[i] = n;
   }
+  /** Create a cached 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);
+  }
   /** Buffer an entity for deferred destruction (applied at phase flush). */
   destroy_entity(t) {
     return this.store.destroy_entity_deferred(t), this;
   }
-  flush_destroyed() {
-    this.store.flush_destroyed();
-  }
   add_component(t, e, s) {
-    return this.store.add_component_deferred(t, e, s ?? tt), this;
+    return this.store.add_component_deferred(t, e, s ?? D), this;
   }
   remove_component(t, e) {
     return this.store.remove_component_deferred(t, e), this;
@@ -1034,13 +1271,20 @@ class nt {
   read(t) {
     return this.store.get_event_reader(t);
   }
+  // =======================================================
+  // Resources
+  // =======================================================
+  resource(t) {
+    return this.store.get_resource_reader(t);
+  }
+  set_resource(t, e) {
+    this.store.get_resource_channel(t).write(e);
+  }
 }
-const rt = (a) => b(
-  a,
-  P,
-  "SystemID must be a non-negative integer"
-), it = Object.freeze(/* @__PURE__ */ Object.create(null));
-class ot {
+const Dt = (l) => N(
+  l
+);
+class Nt {
   store;
   schedule;
   ctx;
@@ -1054,9 +1298,9 @@ class ot {
   // 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 N();
+  scratch_mask = new x();
   constructor(t) {
-    this.store = new J(), this.schedule = new H(), this.ctx = new nt(this.store), this._fixed_timestep = t?.fixed_timestep ?? 1 / 60, this._max_fixed_steps = t?.max_fixed_steps ?? 4;
+    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;
   }
   get fixed_timestep() {
     return this._fixed_timestep;
@@ -1067,11 +1311,17 @@ class ot {
   get fixed_alpha() {
     return this._accumulator / this._fixed_timestep;
   }
-  register_component(t) {
+  // Implementation
+  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;
+      return this.store.register_component(n);
+    }
     return this.store.register_component(t);
   }
   register_tag() {
-    return this.store.register_component([]);
+    return this.store.register_component({});
   }
   register_event(t) {
     return this.store.register_event(t);
@@ -1079,10 +1329,22 @@ class ot {
   register_signal() {
     return this.store.register_event([]);
   }
+  register_resource(t, e) {
+    return this.store.register_resource(
+      t,
+      e
+    );
+  }
+  resource(t) {
+    return this.store.get_resource_reader(t);
+  }
+  set_resource(t, e) {
+    this.store.get_resource_channel(t).write(e);
+  }
   create_entity() {
     return this.store.create_entity();
   }
-  destroy_entity(t) {
+  destroy_entity_deferred(t) {
     this.store.destroy_entity_deferred(t);
   }
   is_alive(t) {
@@ -1092,7 +1354,7 @@ class ot {
     return this.store.entity_count;
   }
   add_component(t, e, s) {
-    this.store.add_component(t, e, s ?? it);
+    return this.store.add_component(t, e, s ?? D), this;
   }
   add_components(t, e) {
     this.store.add_components(t, e);
@@ -1106,9 +1368,23 @@ class ot {
   has_component(t, e) {
     return this.store.has_component(t, e);
   }
+  batch_add_component(t, e, s) {
+    this.store.batch_add_component(t, e, s);
+  }
+  /**
+   * Bulk remove a component from ALL entities in the given archetype.
+   * O(columns) via TypedArray.set() instead of O(N×columns).
+   */
+  batch_remove_component(t, e) {
+    this.store.batch_remove_component(t, e);
+  }
   get_field(t, e, s) {
-    const n = this.store.get_entity_archetype(e), r = this.store.get_entity_row(e);
-    return n.read_field(r, t, s);
+    const n = this.store.get_entity_archetype(t), r = this.store.get_entity_row(t);
+    return n.read_field(r, 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;
   }
   emit(t, e) {
     e === void 0 ? this.store.emit_signal(t) : this.store.emit_event(t, e);
@@ -1122,26 +1398,26 @@ class ot {
   }
   /** 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, h = r ^ Math.imul(i, 2654435769) ^ Math.imul(_, 1367130551) | 0, o = this._find_cached(h, t, e, s);
+    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 c = this.store.register_query(
+    const h = this.store.register_query(
       t,
       e ?? void 0,
       s ?? void 0
-    ), l = new et(
-      c,
+    ), a = new Pt(
+      h,
       n,
       this,
       t.copy(),
       e?.copy() ?? null,
       s?.copy() ?? null
     );
-    return F(this.query_cache, h, {
+    return K(this.query_cache, c, {
       include_mask: t.copy(),
       exclude_mask: e?.copy() ?? null,
       any_of_mask: s?.copy() ?? null,
-      query: l
-    }), l;
+      query: a
+    }), a;
   }
   _find_cached(t, e, s, n) {
     const r = this.query_cache.get(t);
@@ -1152,14 +1428,18 @@ class ot {
           return _;
       }
   }
+  // any: overload implementation must unify bare fn, (fn, query_fn), and SystemConfig
   register_system(t, e) {
     let s;
-    if (typeof t == "function") {
-      const i = e(new st(this)), _ = this.ctx;
-      s = { fn: (h, o) => t(i, _, o) };
-    } else
+    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) };
+      } else
+        s = { fn: t };
+    else
       s = t;
-    const n = rt(this.next_system_id++), r = Object.freeze(
+    const n = Dt(this.next_system_id++), r = Object.freeze(
       Object.assign({ id: n }, s)
     );
     return this.systems.add(r), r;
@@ -1175,17 +1455,17 @@ class ot {
   }
   startup() {
     for (const t of this.systems.values())
-      t.on_added?.(this.store);
+      t.on_added?.(this.ctx);
     this.schedule.run_startup(this.ctx);
   }
   update(t) {
-    if (this.store.clear_events(), this.schedule.has_fixed_systems()) {
+    if (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_update(this.ctx, t);
+    this.schedule.run_update(this.ctx, t), this.store.clear_events();
   }
   flush() {
     this.ctx.flush();
@@ -1197,9 +1477,9 @@ class ot {
   }
 }
 export {
-  et as Query,
-  st as QueryBuilder,
-  Z as SCHEDULE,
-  nt as SystemContext,
-  ot as World
+  Nt as ECS,
+  Pt as Query,
+  St as QueryBuilder,
+  Et as SCHEDULE,
+  Ot as SystemContext
 };