@oasys/oecs 0.3.1 → 0.5.0

package/dist/host_commands-i4cAeyL5.js

@@ -0,0 +1,2318 @@
+import { S as et, t as tt } from "./topological_sort-DK6EjpWa.js";
+import { D as nt, h as K, w as we, g as st } from "./shared-BU1Cd40h.js";
+class Be extends Error {
+  constructor(t, n, r) {
+    super(t), this.isOperational = n, this.context = r, this.name = this.constructor.name, Error.captureStackTrace(this, this.constructor);
+  }
+}
+var Fe = /* @__PURE__ */ ((e) => (e.ASSERTION_FAIL_CONDITION = "ASSERTION_FAIL_CONDITION", e.VALIDATION_FAIL_CONDITION = "VALIDATION_FAIL_CONDITION", e.ASSERTION_FAIL_NON_NULLABLE = "ASSERTION_FAIL_NON_NULLABLE", e.ASSERTION_FAIL_UNREACHABLE = "ASSERTION_FAIL_UNREACHABLE", e))(Fe || {});
+class rt extends Be {
+  constructor(t, n, r) {
+    super(n, !1, r), this.category = t;
+  }
+}
+function yn(e, t, n) {
+  return e;
+}
+function Tn(e) {
+  return e;
+}
+function ot(e, t) {
+  throw new rt(
+    Fe.ASSERTION_FAIL_UNREACHABLE,
+    `Unhandled ${t}: ${String(e)}`
+  );
+}
+var w = /* @__PURE__ */ ((e) => (e.EID_MAX_INDEX_OVERFLOW = "EID_MAX_INDEX_OVERFLOW", e.EID_MAX_GEN_OVERFLOW = "EID_MAX_GEN_OVERFLOW", e.COMPONENT_NOT_REGISTERED = "COMPONENT_NOT_REGISTERED", e.COMPONENT_LIMIT_EXCEEDED = "COMPONENT_LIMIT_EXCEEDED", e.ENTITY_NOT_ALIVE = "ENTITY_NOT_ALIVE", e.CIRCULAR_SYSTEM_DEPENDENCY = "CIRCULAR_SYSTEM_DEPENDENCY", e.DUPLICATE_SYSTEM = "DUPLICATE_SYSTEM", e.ARCHETYPE_NOT_FOUND = "ARCHETYPE_NOT_FOUND", e.RESOURCE_NOT_REGISTERED = "RESOURCE_NOT_REGISTERED", e.RESOURCE_ALREADY_REGISTERED = "RESOURCE_ALREADY_REGISTERED", e.EVENT_ALREADY_REGISTERED = "EVENT_ALREADY_REGISTERED", e.EVENT_NOT_REGISTERED = "EVENT_NOT_REGISTERED", e.FIELD_NOT_REGISTERED = "FIELD_NOT_REGISTERED", e.RELATION_NOT_REGISTERED = "RELATION_NOT_REGISTERED", e.RELATION_MODE_INVALID = "RELATION_MODE_INVALID", e.RELATION_MODE_MISMATCH = "RELATION_MODE_MISMATCH", e.RELATION_CYCLE = "RELATION_CYCLE", e.SPARSE_CACHE_KEY_OVERFLOW = "SPARSE_CACHE_KEY_OVERFLOW", e.SPARSE_QUERY_DENSE_PATH = "SPARSE_QUERY_DENSE_PATH", e.HIERARCHY_ALREADY_SET = "HIERARCHY_ALREADY_SET", e.HIERARCHY_INVALID_MAX_DEPTH = "HIERARCHY_INVALID_MAX_DEPTH", e.OBSERVER_NON_CONVERGENT = "OBSERVER_NON_CONVERGENT", e.OBSERVER_INVALID_CONFIG = "OBSERVER_INVALID_CONFIG", e.OBSERVER_ONSET_EMIT = "OBSERVER_ONSET_EMIT", e.INVALID_FIXED_TIMESTEP = "INVALID_FIXED_TIMESTEP", e.INVALID_MAX_FIXED_STEPS = "INVALID_MAX_FIXED_STEPS", e.INVALID_RECORDER_SCHEDULE = "INVALID_RECORDER_SCHEDULE", e.EMPTY_ARCHETYPE_MATERIALIZE = "EMPTY_ARCHETYPE_MATERIALIZE", e.COMPONENT_INDEX_INVARIANT = "COMPONENT_INDEX_INVARIANT", e.OPTIONAL_TERM_NOT_DECLARED = "OPTIONAL_TERM_NOT_DECLARED", e.QUERY_ACCESS_UNDECLARED = "QUERY_ACCESS_UNDECLARED", e.ACCESS_UNDECLARED = "ACCESS_UNDECLARED", e.QUERY_NOT_SINGLETON = "QUERY_NOT_SINGLETON", e.INVALID_RUN_CONDITION = "INVALID_RUN_CONDITION", e.SYSTEM_FN_ARITY = "SYSTEM_FN_ARITY", e.PARTITION_APPEND_NEEDS_ENTITY_ROW = "PARTITION_APPEND_NEEDS_ENTITY_ROW", e.PARTITION_BULK_INTO_DISABLED = "PARTITION_BULK_INTO_DISABLED", e.ENTITY_NOT_DISABLED = "ENTITY_NOT_DISABLED", e.STRUCTURAL_DURING_ITERATION = "STRUCTURAL_DURING_ITERATION", e.BACKEND_ALREADY_ATTACHED = "BACKEND_ALREADY_ATTACHED", e.DETERMINISM_DISABLED = "DETERMINISM_DISABLED", e.NON_DETERMINISTIC_COLUMN_TYPE = "NON_DETERMINISTIC_COLUMN_TYPE", e.INVALID_MEMORY_OPTIONS = "INVALID_MEMORY_OPTIONS", e.STORE_CAP_EXCEEDED = "STORE_CAP_EXCEEDED", e.REGION_NOT_DECLARED = "REGION_NOT_DECLARED", e.COMMAND_LOG_TAG_COLLISION = "COMMAND_LOG_TAG_COLLISION", e.INVALID_FRAME_STEP = "INVALID_FRAME_STEP", e))(w || {});
+class S extends Be {
+  constructor(t, n, r) {
+    super(n ?? t, !0, r), this.category = t;
+  }
+}
+function An(e) {
+  return e instanceof S;
+}
+const In = -1, wn = -1, Sn = Object.freeze(/* @__PURE__ */ Object.create(null)), Nn = 2654435769, Dn = 1367130551, B = 1024, Rn = 0, it = 31, On = 1 / 60, bn = 4, at = 0, z = 20, Ye = (1 << z) - 1, P = Ye, ct = it - z, _e = (1 << ct) - 1, Cn = _e, Un = _e - 1, Se = _e << z | P, vn = (e, t) => t << z | e, k = (e) => e & Ye, Ln = (e) => e >> z, he = /* @__PURE__ */ new WeakMap();
+function Mn(e, t) {
+  he.set(e, t);
+}
+function $n(e) {
+  return he.get(e);
+}
+function dt(e) {
+  const t = he.get(e);
+  return t !== void 0 ? `'${t}' (component ${e.id})` : `component ${e.id}`;
+}
+const lt = 827148627, ut = 0, J = 4, ft = 52, m = {
+  magic: 0,
+  sim_abi_version: 4,
+  view_stamp: 8,
+  capacity: 12,
+  archetype_count: 16,
+  layout_descriptor_off: 20,
+  command_ring_off: 24,
+  action_ring_off: 28,
+  entity_index_off: 32,
+  event_ring_off: 36,
+  region_table_off: 40,
+  region_table_count: 44,
+  bindings_off: 48
+}, q = 12, L = {
+  region_id: 0,
+  byte_offset: 4,
+  byte_length: 8
+}, me = 16, O = {
+  component_id: 0,
+  field_id: 2,
+  type_tag: 4,
+  byte_off: 8,
+  stride: 12
+}, ge = 36, N = {
+  archetype_id: 0,
+  component_mask: 4,
+  row_count: 20,
+  row_capacity: 24,
+  column_count: 28,
+  enabled_count: 32
+};
+function _t(e, t) {
+  e.setUint32(m.magic, t.magic, !0), e.setUint32(m.sim_abi_version, t.simAbiVersion, !0), e.setUint32(m.view_stamp, t.viewStamp, !0), e.setUint32(m.capacity, t.capacity, !0), e.setUint32(m.archetype_count, t.archetypeCount, !0), e.setUint32(m.layout_descriptor_off, t.layoutDescriptorOff, !0), e.setUint32(m.command_ring_off, t.commandRingOff, !0), e.setUint32(m.action_ring_off, t.actionRingOff, !0), e.setUint32(m.entity_index_off, t.entityIndexOff, !0), e.setUint32(m.event_ring_off, t.eventRingOff, !0), e.setUint32(m.region_table_off, t.regionTableOff, !0), e.setUint32(m.region_table_count, t.regionTableCount, !0), e.setUint32(m.bindings_off, t.bindingsOff, !0);
+}
+function Pn(e) {
+  return {
+    magic: e.getUint32(m.magic, !0),
+    simAbiVersion: e.getUint32(m.sim_abi_version, !0),
+    viewStamp: e.getUint32(m.view_stamp, !0),
+    capacity: e.getUint32(m.capacity, !0),
+    archetypeCount: e.getUint32(m.archetype_count, !0),
+    layoutDescriptorOff: e.getUint32(m.layout_descriptor_off, !0),
+    commandRingOff: e.getUint32(m.command_ring_off, !0),
+    actionRingOff: e.getUint32(m.action_ring_off, !0),
+    entityIndexOff: e.getUint32(m.entity_index_off, !0),
+    eventRingOff: e.getUint32(m.event_ring_off, !0),
+    regionTableOff: e.getUint32(m.region_table_off, !0),
+    regionTableCount: e.getUint32(m.region_table_count, !0),
+    bindingsOff: e.getUint32(m.bindings_off, !0)
+  };
+}
+const E = {
+  u8: 0,
+  i8: 1,
+  u16: 2,
+  i16: 3,
+  u32: 4,
+  i32: 5,
+  f32: 6,
+  f64: 7
+}, Ne = Object.freeze({
+  [E.u8]: 1,
+  [E.i8]: 1,
+  [E.u16]: 2,
+  [E.i16]: 2,
+  [E.u32]: 4,
+  [E.i32]: 4,
+  [E.f32]: 4,
+  [E.f64]: 8
+}), xn = {
+  u8: E.u8,
+  i8: E.i8,
+  u16: E.u16,
+  i16: E.i16,
+  u32: E.u32,
+  i32: E.i32,
+  f32: E.f32,
+  f64: E.f64
+};
+function ht(e, t, n) {
+  e.setUint16(t + O.component_id, n.componentId, !0), e.setUint16(t + O.field_id, n.fieldId, !0), e.setUint8(t + O.type_tag, n.typeTag), e.setUint32(t + O.byte_off, n.byteOff, !0), e.setUint16(t + O.stride, n.stride, !0);
+}
+function mt(e, t) {
+  return {
+    componentId: e.getUint16(t + O.component_id, !0),
+    fieldId: e.getUint16(t + O.field_id, !0),
+    typeTag: e.getUint8(t + O.type_tag),
+    byteOff: e.getUint32(t + O.byte_off, !0),
+    stride: e.getUint16(t + O.stride, !0)
+  };
+}
+const Bn = J * 32;
+function ke(e) {
+  return ge + e * me;
+}
+function gt(e, t, n) {
+  e.setUint32(t + N.archetype_id, n.archetypeId, !0);
+  for (let s = 0; s < J; s++)
+    e.setUint32(
+      t + N.component_mask + s * 4,
+      n.componentMask[s] ?? 0,
+      !0
+    );
+  e.setUint32(t + N.row_count, n.rowCount, !0), e.setUint32(t + N.row_capacity, n.rowCapacity, !0), e.setUint32(t + N.column_count, n.columns.length, !0), e.setUint32(t + N.enabled_count, n.enabledCount, !0);
+  let r = t + ge;
+  for (let s = 0; s < n.columns.length; s++)
+    ht(e, r, n.columns[s]), r += me;
+  return r;
+}
+function Et(e, t) {
+  const n = e.getUint32(t + N.column_count, !0), r = new Array(n);
+  let s = t + ge;
+  for (let i = 0; i < n; i++)
+    r[i] = mt(e, s), s += me;
+  const o = new Array(J);
+  for (let i = 0; i < J; i++)
+    o[i] = e.getUint32(
+      t + N.component_mask + i * 4,
+      !0
+    );
+  return {
+    archetypeId: e.getUint32(t + N.archetype_id, !0),
+    componentMask: o,
+    rowCount: e.getUint32(t + N.row_count, !0),
+    rowCapacity: e.getUint32(t + N.row_capacity, !0),
+    enabledCount: e.getUint32(t + N.enabled_count, !0),
+    columns: r
+  };
+}
+function pt(e, t, n) {
+  let r = t;
+  for (let s = 0; s < n.length; s++)
+    r = gt(e, r, n[s]);
+  return r;
+}
+function Fn(e, t, n) {
+  const r = new Array(n);
+  let s = t;
+  for (let o = 0; o < n; o++) {
+    const i = Et(e, s);
+    r[o] = i, s += ke(i.columns.length);
+  }
+  return r;
+}
+function yt(e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++)
+    t += ke(e[n].columns.length);
+  return t;
+}
+const Ve = 16, M = 16, Yn = 256, b = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+}, Ee = 0;
+function De(e) {
+  return Ve + e * M;
+}
+function Tt(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class U extends Error {
+  constructor(t) {
+    super(t), this.name = "CommandRingError";
+  }
+}
+function At(e, t, n) {
+  if (!Tt(n))
+    throw new U(
+      `command ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  e.setUint32(t + b.write_head, 0, !0), e.setUint32(t + b.read_head, 0, !0), e.setUint32(t + b.capacity_slots, n, !0), e.setUint32(t + b.overflow_flag, 0, !0);
+}
+function It(e, t) {
+  return e.getUint32(t + b.write_head, !0);
+}
+function wt(e, t) {
+  return e.getUint32(t + b.read_head, !0);
+}
+function St(e, t) {
+  return e.getUint32(t + b.capacity_slots, !0);
+}
+function Nt(e, t, n) {
+  if (n.byteLength !== M - 1)
+    throw new U(
+      `out_payload must be ${M - 1} bytes (got ${n.byteLength})`
+    );
+  const r = It(e, t), s = wt(e, t);
+  if (r === s) return Ee;
+  const o = St(e, t), i = s & o - 1, c = t + Ve + i * M, a = e.getUint8(c), l = new Uint8Array(e.buffer, c + 1, M - 1);
+  return n.set(l), e.setUint32(t + b.read_head, s + 1 >>> 0, !0), a;
+}
+function Dt(e, t, n) {
+  let r = 0;
+  const s = new Uint8Array(M - 1);
+  for (; ; ) {
+    const o = Nt(e, t, s);
+    if (o === Ee) return r;
+    n(o, s.slice()), r++;
+  }
+}
+const re = 16, D = 12, ee = {
+  length: 0,
+  capacity: 4
+  // 8..16: pad to 16-byte alignment so the i32 arrays start aligned.
+}, v = 1 << 20;
+function Re(e) {
+  if (e < 0 || !Number.isInteger(e))
+    throw new Ge(
+      `entity_index capacity must be a non-negative integer (got ${e})`
+    );
+  return re + e * D;
+}
+function Rt(e) {
+  return e + re;
+}
+function Ot(e, t) {
+  return e + re + t * 4;
+}
+function bt(e, t) {
+  return e + re + t * 8;
+}
+class Ge extends Error {
+  constructor(t) {
+    super(t), this.name = "EntityIndexError";
+  }
+}
+function Ct(e, t, n) {
+  if (n < 0 || !Number.isInteger(n))
+    throw new Ge(
+      `entity_index capacity must be a non-negative integer (got ${n})`
+    );
+  e.setUint32(t + ee.length, 0, !0), e.setUint32(t + ee.capacity, n, !0);
+}
+function kn(e, t, n) {
+  return {
+    generations: new Int32Array(e, Rt(t), n),
+    archetypes: new Int32Array(e, Ot(t, n), n),
+    rows: new Int32Array(e, bt(t, n), n)
+  };
+}
+const Ut = 16, vt = 16, Vn = 256, Y = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+};
+function Oe(e) {
+  return Ut + e * vt;
+}
+function Lt(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class Mt extends Error {
+  constructor(t) {
+    super(t), this.name = "EventRingError";
+  }
+}
+function $t(e, t, n) {
+  if (!Lt(n))
+    throw new Mt(
+      `event ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  e.setUint32(t + Y.write_head, 0, !0), e.setUint32(t + Y.read_head, 0, !0), e.setUint32(t + Y.capacity_slots, n, !0), e.setUint32(t + Y.overflow_flag, 0, !0);
+}
+const Pt = 16, xt = 16, Gn = 256, V = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+}, Bt = V.write_head / 4, Ft = V.read_head / 4, Yt = V.capacity_slots / 4, kt = V.overflow_flag / 4;
+function Vt(e, t) {
+  return new Int32Array(e.buffer, e.byteOffset + t, 4);
+}
+function be(e) {
+  return Pt + e * xt;
+}
+function Gt(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class Ce extends Error {
+  constructor(t) {
+    super(t), this.name = "ActionRingError";
+  }
+}
+function Ht(e, t, n) {
+  if (!Gt(n))
+    throw new Ce(
+      `action ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  if ((e.byteOffset + t) % 4 !== 0)
+    throw new Ce(
+      `action ring header must be 4-byte aligned for Atomics (view.byteOffset ${e.byteOffset} + ring_off ${t} is not a multiple of 4)`
+    );
+  const r = Vt(e, t);
+  Atomics.store(r, Bt, 0), Atomics.store(r, Ft, 0), Atomics.store(r, Yt, n), Atomics.store(r, kt, 0);
+}
+const j = [
+  {
+    name: "command_ring",
+    headerOff: "command_ring_off",
+    sizeFromOptions: (e) => e.commandRingCapacitySlots !== void 0 ? De(e.commandRingCapacitySlots) : 0,
+    init: (e, t, n) => At(e, t, n.commandRingCapacitySlots),
+    regionBytes: (e, t) => De(e.getUint32(t + b.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.commandRingCapacitySlots = e.getUint32(
+        t + b.capacity_slots,
+        !0
+      );
+    }
+  },
+  {
+    name: "entity_index",
+    headerOff: "entity_index_off",
+    sizeFromOptions: (e) => e.entityIndexCapacity !== void 0 ? Re(e.entityIndexCapacity) : 0,
+    init: (e, t, n) => Ct(e, t, n.entityIndexCapacity),
+    regionBytes: (e, t) => Re(e.getUint32(t + ee.capacity, !0)),
+    readOptions: (e, t, n) => {
+      n.entityIndexCapacity = e.getUint32(t + ee.capacity, !0);
+    }
+  },
+  {
+    name: "event_ring",
+    headerOff: "event_ring_off",
+    sizeFromOptions: (e) => e.eventRingCapacitySlots !== void 0 ? Oe(e.eventRingCapacitySlots) : 0,
+    init: (e, t, n) => $t(e, t, n.eventRingCapacitySlots),
+    regionBytes: (e, t) => Oe(e.getUint32(t + Y.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.eventRingCapacitySlots = e.getUint32(
+        t + Y.capacity_slots,
+        !0
+      );
+    }
+  },
+  {
+    name: "action_ring",
+    headerOff: "action_ring_off",
+    sizeFromOptions: (e) => e.actionRingCapacitySlots !== void 0 ? be(e.actionRingCapacitySlots) : 0,
+    init: (e, t, n) => Ht(e, t, n.actionRingCapacitySlots),
+    regionBytes: (e, t) => be(e.getUint32(t + V.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.actionRingCapacitySlots = e.getUint32(
+        t + V.capacity_slots,
+        !0
+      );
+    }
+  }
+];
+class Z extends Error {
+  constructor(t) {
+    super(t), this.name = "RegionRegistryError";
+  }
+}
+function He(e) {
+  return e * q;
+}
+function pe(e, t) {
+  const n = e.getUint32(m.region_table_count, !0);
+  if (t + He(n) > e.byteLength)
+    throw new Z(
+      `region table of ${n} entries at byte ${t} overruns the buffer (${e.byteLength} bytes)`
+    );
+  return n;
+}
+function Xt(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (let n = 0; n < e.length; n++) {
+    const r = e[n];
+    if (!Number.isInteger(r.id) || r.id <= 0)
+      throw new Z(
+        `region "${r.name}" has invalid id ${r.id} — region ids must be positive integers (0 is the absent sentinel)`
+      );
+    if (t.has(r.id))
+      throw new Z(
+        `duplicate region id ${r.id} (region "${r.name}") — ids must be distinct within a consumer's region set`
+      );
+    if (t.add(r.id), !Number.isInteger(r.bytes) || r.bytes <= 0)
+      throw new Z(
+        `region "${r.name}" (id ${r.id}) has invalid byte size ${r.bytes} — must be a positive integer`
+      );
+  }
+}
+function Wt(e, t, n) {
+  e.setUint32(t + L.region_id, n.regionId, !0), e.setUint32(t + L.byte_offset, n.byteOffset, !0), e.setUint32(t + L.byte_length, n.byteLength, !0);
+}
+function Xe(e, t) {
+  return {
+    regionId: e.getUint32(t + L.region_id, !0),
+    byteOffset: e.getUint32(t + L.byte_offset, !0),
+    byteLength: e.getUint32(t + L.byte_length, !0)
+  };
+}
+function zt(e, t, n) {
+  for (let r = 0; r < n.length; r++)
+    Wt(e, t + r * q, n[r]);
+}
+function qt(e, t, n) {
+  const r = new Array(n);
+  for (let s = 0; s < n; s++)
+    r[s] = Xe(e, t + s * q);
+  return r;
+}
+function Hn(e) {
+  const t = e.getUint32(m.region_table_off, !0);
+  if (t === 0) return [];
+  const n = pe(e, t);
+  return qt(e, t, n);
+}
+function Xn(e, t) {
+  const n = e.getUint32(m.region_table_off, !0);
+  if (n === 0) return 0;
+  const r = pe(e, n);
+  for (let s = 0; s < r; s++) {
+    const o = n + s * q;
+    if (e.getUint32(o + L.region_id, !0) === t)
+      return e.getUint32(o + L.byte_offset, !0);
+  }
+  return 0;
+}
+function Wn(e, t) {
+  const n = e.getUint32(m.region_table_off, !0);
+  if (n === 0) return null;
+  const r = pe(e, n);
+  for (let s = 0; s < r; s++) {
+    const o = Xe(e, n + s * q);
+    if (o.regionId === t) return o;
+  }
+  return null;
+}
+function Kt(e, t) {
+  return e << 16 | t;
+}
+const ye = 2 ** 31;
+class We extends Error {
+  constructor(t) {
+    super(
+      `SAB column layout offset ${t} reaches or exceeds the 2³¹ (${ye}-byte) ceiling. Past 2 GiB the signed-32-bit bitwise alignment math wraps to negative/misaligned offsets. This is a structural limit independent of the (default 256 MiB) allocator cap — a single SAB cannot back more than ~2 GiB of column data (#382).`
+    ), this.name = "StoreLayoutOverflowError";
+  }
+}
+function ze(e, t) {
+  if (e + t > ye)
+    throw new We(e);
+  return e + (t - 1) & ~(t - 1);
+}
+function jt(e, t, n, r) {
+  switch (t) {
+    case E.u8:
+      return new Uint8Array(e, n, r);
+    case E.i8:
+      return new Int8Array(e, n, r);
+    case E.u16:
+      return new Uint16Array(e, n, r);
+    case E.i16:
+      return new Int16Array(e, n, r);
+    case E.u32:
+      return new Uint32Array(e, n, r);
+    case E.i32:
+      return new Int32Array(e, n, r);
+    case E.f32:
+      return new Float32Array(e, n, r);
+    case E.f64:
+      return new Float64Array(e, n, r);
+  }
+}
+function Qt(e, t, n = 0) {
+  const s = yt(
+    e.map((c) => ({
+      archetypeId: c.archetypeId,
+      componentMask: c.componentMask,
+      rowCount: 0,
+      enabledCount: 0,
+      rowCapacity: c.rowCapacity,
+      columns: c.columns.map((a) => ({
+        componentId: a.componentId,
+        fieldId: a.fieldId,
+        typeTag: a.typeTag,
+        byteOff: 0,
+        stride: Ne[a.typeTag]
+      }))
+    }))
+  ) + n;
+  let o = t + s;
+  const i = new Array(e.length);
+  for (let c = 0; c < e.length; c++) {
+    const a = e[c], l = new Array(a.columns.length);
+    for (let d = 0; d < a.columns.length; d++) {
+      const f = a.columns[d], _ = Ne[f.typeTag];
+      o = ze(o, _), l[d] = {
+        componentId: f.componentId,
+        fieldId: f.fieldId,
+        typeTag: f.typeTag,
+        byteOff: o,
+        stride: _
+      }, o += _ * a.rowCapacity;
+    }
+    i[c] = {
+      archetypeId: a.archetypeId,
+      componentMask: a.componentMask,
+      rowCount: 0,
+      enabledCount: 0,
+      rowCapacity: a.rowCapacity,
+      columns: l
+    };
+  }
+  if (o > ye)
+    throw new We(o);
+  return { descriptors: i, totalBytes: o, regionBytes: s };
+}
+function zn(e) {
+  const t = e;
+  return typeof t._regionBytes == "number" && typeof t._allocator == "function" && typeof t._reservedDescriptorBytes == "number";
+}
+function qn(e, t = nt, n = {}) {
+  const r = {};
+  let s = ft;
+  for (let A = 0; A < j.length; A++) {
+    const C = j[A], H = C.sizeFromOptions(n);
+    r[C.headerOff] = H === 0 ? 0 : s, s += H;
+  }
+  const o = n.regions ?? [];
+  Xt(o);
+  const i = o.length, c = i > 0 ? s : 0;
+  s += He(i);
+  const a = new Array(i);
+  for (let A = 0; A < o.length; A++) {
+    const C = o[A];
+    a[A] = { regionId: C.id, byteOffset: s, byteLength: C.bytes }, s += C.bytes;
+  }
+  const l = n.bindingsRegionBytes ?? 0, d = l === 0 ? 0 : s;
+  s += l;
+  const f = s, { descriptors: _, totalBytes: g, regionBytes: y } = Qt(
+    e,
+    f,
+    n.reservedDescriptorBytes ?? 0
+  ), u = t(g), h = new DataView(u), T = {
+    magic: lt,
+    simAbiVersion: ut,
+    viewStamp: 0,
+    capacity: g,
+    archetypeCount: e.length,
+    layoutDescriptorOff: f,
+    bindingsOff: d,
+    regionTableOff: c,
+    regionTableCount: i,
+    // `regionOffsets` stays keyed by the snake ABI field names (it also indexes
+    // `STORE_HEADER_OFFSETS`); map its 4 entries onto the camelCase header fields.
+    commandRingOff: r.command_ring_off,
+    entityIndexOff: r.entity_index_off,
+    eventRingOff: r.event_ring_off,
+    actionRingOff: r.action_ring_off
+  };
+  _t(h, T), l > 0 && new Uint8Array(u, d, l).fill(0);
+  for (let A = 0; A < j.length; A++) {
+    const C = j[A], H = r[C.headerOff];
+    H !== 0 && C.init(h, H, n);
+  }
+  c !== 0 && zt(h, c, a);
+  for (let A = 0; A < o.length; A++)
+    o[A].init(h, a[A].byteOffset);
+  pt(h, f, _);
+  const x = Zt(u, _);
+  return {
+    buffer: u,
+    view: h,
+    header: T,
+    archetypes: x,
+    _regionBytes: y,
+    _allocator: t,
+    // Carry the headroom policy with the store so the realloc slow path
+    // (`optionsFromOld`) can re-reserve the same margin (#541).
+    _reservedDescriptorBytes: n.reservedDescriptorBytes ?? 0
+  };
+}
+function Zt(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r], o = new Array(s.columns.length), i = /* @__PURE__ */ new Map();
+    for (let c = 0; c < s.columns.length; c++) {
+      const a = s.columns[c], l = {
+        componentId: a.componentId,
+        fieldId: a.fieldId,
+        typeTag: a.typeTag,
+        byteOff: a.byteOff,
+        stride: a.stride,
+        view: jt(e, a.typeTag, a.byteOff, s.rowCapacity)
+      };
+      o[c] = l, i.set(Kt(a.componentId, a.fieldId), l);
+    }
+    n.set(s.archetypeId, {
+      archetypeId: s.archetypeId,
+      componentMask: s.componentMask,
+      rowCapacity: s.rowCapacity,
+      columns: i,
+      columnsInOrder: o
+    });
+  }
+  return n;
+}
+const Jt = 2166136261, qe = 16777619;
+function ae(e, t) {
+  return e = (e ^ t & 255) >>> 0, Math.imul(e, qe) >>> 0;
+}
+function Kn(e, t) {
+  return e = (e ^ t >>> 0) >>> 0, Math.imul(e, qe) >>> 0;
+}
+class jn {
+  /** entity index → field-value row (length = field count; `[]` for a tag). */
+  _data = new et();
+  fieldNames;
+  fieldTypes;
+  fieldIndex;
+  constructor(t, n) {
+    this.fieldNames = t, this.fieldTypes = n;
+    const r = /* @__PURE__ */ Object.create(null);
+    for (let s = 0; s < t.length; s++) r[t[s]] = s;
+    this.fieldIndex = r;
+  }
+  /** Number of entities holding this sparse component. */
+  get size() {
+    return this._data.size;
+  }
+  /** Live entity indices that hold this component (dense, iteration order is
+   * SparseMap insertion/swap order — NOT canonical). Used by the hot query
+   * integration path (#469); for the determinism surface use
+   * `canonicalIndices` instead. */
+  get indices() {
+    return this._data.keys;
+  }
+  /** Live entity indices in **canonical** (ascending) order — the determinism
+   * ordering for `stateHash` + snapshot/restore (ADR-0011, #470). The native
+   * `indices` getter is insertion/swap order and would make two worlds with
+   * identical contents reached by different add/remove histories diverge, so
+   * the cold determinism paths sort here. Allocates a sorted copy each call;
+   * never call it on the hot query path. Indices are 20-bit entity indices,
+   * so the subtraction comparator can't overflow. */
+  canonicalIndices() {
+    return this._data.keys.slice().sort((t, n) => t - n);
+  }
+  /** The field-value row for `index` (length = field count; `[]` for a tag),
+   * or `undefined` if `index` isn't a member. Read-only view for the
+   * determinism paths (`stateHash`, snapshot); mutate via `setField`. */
+  getRow(t) {
+    return this._data.get(t);
+  }
+  /** Drop all membership + data. Restore path only — `restoreSparseStores`
+   * repopulates a cleared store from snapshot bytes. */
+  clear() {
+    this._data.clear();
+  }
+  /** Insert the positional field-value `row` for `index`, taking ownership of
+   * the array. Restore path only; bypasses the name→index mapping `setRow`
+   * does, because snapshot bytes are already positional. */
+  setRawRow(t, n) {
+    this._data.set(t, n);
+  }
+  has(t) {
+    return this._data.has(t);
+  }
+  /** Insert or overwrite the row for `index`, building it from `values`.
+   * Fields absent from `values` default to 0; a tag stores `[]`. */
+  setRow(t, n) {
+    const r = this.fieldNames, s = new Array(r.length);
+    for (let o = 0; o < r.length; o++) {
+      const i = n[r[o]];
+      s[o] = i === void 0 ? 0 : i;
+    }
+    this._data.set(t, s);
+  }
+  /** Drop `index`'s membership + data. Returns whether it was present. */
+  remove(t) {
+    return this._data.delete(t);
+  }
+  /** Read one field, or `undefined` if `index` doesn't hold this component. */
+  getField(t, n) {
+    const r = this._data.get(t);
+    return r === void 0 ? void 0 : r[n];
+  }
+  /** Write one field. Returns `false` (no-op) if `index` isn't a member. */
+  setField(t, n, r) {
+    const s = this._data.get(t);
+    return s === void 0 ? !1 : (s[n] = r, !0);
+  }
+}
+class p extends Error {
+  constructor(t) {
+    super(t), this.name = "SparseRestoreError";
+  }
+}
+const Te = 12, Ae = 4, G = 8;
+function Ie(e, t) {
+  let n = Jt;
+  const r = (s) => {
+    for (let o = 0; o < s.length; o++) n = ae(n, s.charCodeAt(o));
+  };
+  for (let s = 0; s < e.length; s++)
+    r(e[s]), n = ae(n, 31), r(t[s]), n = ae(n, 30);
+  return n >>> 0;
+}
+function Qn(e) {
+  let t = 4;
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o], c = i.fieldNames.length;
+    t += Te + i.size * (Ae + c * G);
+  }
+  const n = new Uint8Array(t), r = new DataView(n.buffer);
+  let s = 0;
+  r.setUint32(s, e.length, !0), s += 4;
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o], c = i.fieldNames.length, a = i.canonicalIndices();
+    r.setUint32(s, c, !0), s += 4, r.setUint32(s, Ie(i.fieldNames, i.fieldTypes), !0), s += 4, r.setUint32(s, a.length, !0), s += 4;
+    for (let l = 0; l < a.length; l++) {
+      const d = a[l];
+      r.setUint32(s, d, !0), s += 4;
+      const f = i.getRow(d);
+      for (let _ = 0; _ < c; _++)
+        r.setFloat64(s, f[_], !0), s += G;
+    }
+  }
+  return n;
+}
+function Zn(e, t) {
+  const n = new DataView(t.buffer, t.byteOffset, t.byteLength), r = t.byteLength;
+  let s = 0;
+  const o = (c) => {
+    if (s + c > r)
+      throw new p(
+        `sparse snapshot truncated: need ${c} more bytes at offset ${s}, have ${r - s}`
+      );
+  };
+  o(4);
+  const i = n.getUint32(s, !0);
+  if (s += 4, i !== e.length)
+    throw new p(
+      `sparse store count mismatch: snapshot=${i}, registered=${e.length}`
+    );
+  for (let c = 0; c < e.length; c++) {
+    const a = e[c];
+    o(Te);
+    const l = n.getUint32(s, !0);
+    s += 4;
+    const d = n.getUint32(s, !0);
+    s += 4;
+    const f = n.getUint32(s, !0);
+    if (s += 4, l !== a.fieldNames.length)
+      throw new p(
+        `sparse store ${c} field-count mismatch: snapshot=${l}, registered=${a.fieldNames.length}`
+      );
+    const _ = Ie(a.fieldNames, a.fieldTypes);
+    if (d !== _)
+      throw new p(
+        `sparse store ${c} schema identity mismatch: snapshot hash=${d}, registered=${_} (same field count, different field names/types — likely a registration-order divergence between the snapshot and restore worlds)`
+      );
+    a.clear();
+    for (let g = 0; g < f; g++) {
+      o(Ae + l * G);
+      const y = n.getUint32(s, !0);
+      if (s += 4, y > P)
+        throw new p(
+          `sparse store ${c} member ${g} entity index ${y} exceeds MAX_INDEX (${P})`
+        );
+      const u = new Array(l);
+      for (let h = 0; h < l; h++)
+        u[h] = n.getFloat64(s, !0), s += G;
+      a.setRawRow(y, u);
+    }
+  }
+  if (s !== r)
+    throw new p(
+      `sparse snapshot has ${r - s} trailing bytes after the last store (not a canonical encoding)`
+    );
+}
+function Jn(e, t) {
+  const n = new DataView(t.buffer, t.byteOffset, t.byteLength), r = t.byteLength;
+  let s = 0;
+  const o = (c) => {
+    if (s + c > r)
+      throw new p(
+        `sparse snapshot truncated: need ${c} more bytes at offset ${s}, have ${r - s}`
+      );
+  };
+  o(4);
+  const i = n.getUint32(s, !0);
+  if (s += 4, i !== e.length)
+    throw new p(
+      `sparse store count mismatch: snapshot=${i}, registered=${e.length}`
+    );
+  for (let c = 0; c < e.length; c++) {
+    const a = e[c];
+    o(Te);
+    const l = n.getUint32(s, !0);
+    s += 4;
+    const d = n.getUint32(s, !0);
+    s += 4;
+    const f = n.getUint32(s, !0);
+    if (s += 4, l !== a.fieldNames.length)
+      throw new p(
+        `sparse store ${c} field-count mismatch: snapshot=${l}, registered=${a.fieldNames.length}`
+      );
+    const _ = Ie(a.fieldNames, a.fieldTypes);
+    if (d !== _)
+      throw new p(
+        `sparse store ${c} schema identity mismatch: snapshot hash=${d}, registered=${_} (same field count, different field names/types — likely a registration-order divergence between the snapshot and restore worlds)`
+      );
+    for (let g = 0; g < f; g++) {
+      o(Ae + l * G);
+      const y = n.getUint32(s, !0);
+      if (s += 4, y > P)
+        throw new p(
+          `sparse store ${c} member ${g} entity index ${y} exceeds MAX_INDEX (${P})`
+        );
+      s += l * G;
+    }
+  }
+  if (s !== r)
+    throw new p(
+      `sparse snapshot has ${r - s} trailing bytes after the last store (not a canonical encoding)`
+    );
+}
+const Ue = 2147483647, es = "orphan", en = "target", tn = Object.freeze({});
+class Ke {
+  /** `true` → one target per source (target in the sparse field); `false` →
+   * a set of targets per source. The cardinality discriminant survives as a
+   * field because it is part of the snapshot header and the traversal/`targetOf`
+   * mode guards — but the forward *mechanics* are virtual, not branched on it. */
+  exclusive;
+  /** Backing sparse component def: `{ target: f64 }` when exclusive, a tag when
+   * multi. Carries membership (and the target, when exclusive). */
+  sparse;
+  /** Cleanup policy applied to this relation's sources when a target is
+   * destroyed (#473). `orphan` (the default) is a no-op — the link dangles
+   * safely. `Store` reads this at destroy-flush off `sourcesOf`. */
+  onDeleteTarget;
+  /** The backing sparse store instance. Owned for registration/liveness by
+   * `Store`, but the relation drives the forward/membership rows on it directly
+   * — that is the cardinality interaction this class now encapsulates (#498). */
+  _store;
+  /** target `EntityID` → set of source `EntityID`s. Keyed by the full id, not
+   * the index, so a recycled target slot can't alias a dead target's sources.
+   * An entry is dropped the moment its set empties (`unlinkReverse`). */
+  _reverse = /* @__PURE__ */ new Map();
+  constructor(t, n, r, s) {
+    this.exclusive = t, this.sparse = n, this._store = r, this.onDeleteTarget = s;
+  }
+  // --- shared reverse index (cardinality-agnostic) ---
+  /** Record that `src` points at `tgt` in the reverse index. */
+  linkReverse(t, n) {
+    let r = this._reverse.get(t);
+    r === void 0 && (r = /* @__PURE__ */ new Set(), this._reverse.set(t, r)), r.add(n);
+  }
+  /** Drop the `src → tgt` edge from the reverse index, removing the target's
+   * entry entirely once its last source is gone (so a dead-target key doesn't
+   * linger with an empty set). */
+  unlinkReverse(t, n) {
+    const r = this._reverse.get(t);
+    r !== void 0 && (r.delete(n), r.size === 0 && this._reverse.delete(t));
+  }
+  /** Drop every reverse-index entry whose **target** is no longer alive,
+   * returning the count dropped (#491). The `orphan` policy intentionally
+   * leaves a destroyed target's reverse entry intact (the link dangles
+   * safely), so a long-lived source that orphan-points at a stream of
+   * short-lived targets and never re-targets/dies accumulates dead-target keys
+   * without bound. This is the reclaim primitive behind `Store.compactRelations`
+   * — a cold path the host calls at scene/snapshot boundaries. It is
+   * cardinality-free (reverse-index only), so it lives on the base unchanged.
+   *
+   * Pure index reclaim: the **forward** links (the exclusive sparse target
+   * field, the multi forward set) are left untouched, so `targetOf` /
+   * `targetsOf` still return the dangling dead handle exactly as `orphan`
+   * promises. The reverse index is derived, so dropping a dead-target entry
+   * changes nothing observable except `sourcesOf` on that dead handle (which
+   * goes from the dangling sources to `[]` — meaningless either way, the target
+   * is gone) and is faithfully rebuilt by snapshot/restore from the surviving
+   * forward links. Only the **target** role can leak here: a destroyed *source*
+   * is already unlinked from every reverse set by `purgeSource`, so a live
+   * target's set never holds a dead source. `isAlive` is supplied by `Store`,
+   * which owns entity liveness. Deleting during `Map` key iteration is
+   * well-defined — already-visited and not-yet-reached keys are unaffected. */
+  pruneDeadReverse(t) {
+    let n = 0;
+    for (const r of this._reverse.keys())
+      t(r) || (this._reverse.delete(r), n++);
+    return n;
+  }
+  /** Sources that point at `tgt`, ascending by id (deterministic, cold-path
+   * sort) — empty when none. */
+  sourcesOf(t) {
+    const n = this._reverse.get(t);
+    if (n === void 0 || n.size === 0) return [];
+    const r = new Array(n.size);
+    let s = 0;
+    return n.forEach((o) => {
+      r[s++] = o;
+    }), r.sort((o, i) => o - i), r;
+  }
+  /** Drop every derived side index — the reverse index and (for multi) the
+   * forward target sets. Restore path only (`restoreRelations`): the side
+   * indices are rebuilt from scratch, so they're cleared first to stay
+   * idempotent when restoring into a dirty world. The backing sparse store is
+   * cleared separately by `restoreSparseStores`. */
+  resetIndices() {
+    this._reverse.clear(), this._resetForward();
+  }
+}
+class nn extends Ke {
+  constructor(t, n, r) {
+    super(!0, t, n, r);
+  }
+  _resetForward() {
+  }
+  link(t, n) {
+    const r = k(t), s = this._store.getField(r, 0);
+    if (s !== void 0) {
+      if (s === n) return;
+      this.unlinkReverse(s, t);
+    }
+    this._store.setRow(r, { [en]: n }), this.linkReverse(n, t);
+  }
+  unlink(t, n) {
+    const r = k(t), s = this._store.getField(r, 0);
+    s !== void 0 && (n !== void 0 && s !== n || (this.unlinkReverse(s, t), this._store.remove(r)));
+  }
+  purgeSource(t) {
+    const n = k(t), r = this._store.getField(n, 0);
+    r !== void 0 && this.unlinkReverse(r, t);
+  }
+  singleTarget(t) {
+    const n = this._store.getField(t, 0);
+    return n === void 0 ? void 0 : n;
+  }
+  targetsOf(t) {
+    const n = this._store.getField(t, 0);
+    return n === void 0 ? [] : [n];
+  }
+  has(t) {
+    return this._store.has(t);
+  }
+  forEachCanonicalTargetSet(t) {
+  }
+  forEachCanonicalPair(t, n) {
+    const r = this._store.canonicalIndices();
+    for (let s = 0; s < r.length; s++) {
+      const o = r[s];
+      n(t(o), this._store.getField(o, 0));
+    }
+  }
+  rebuildReverseFromForward(t) {
+    const n = this._store.indices;
+    for (let r = 0; r < n.length; r++) {
+      const s = n[r];
+      this.linkReverse(this._store.getField(s, 0), t(s));
+    }
+  }
+  restoreAddTarget() {
+    throw new p(
+      "exclusive relation has no multi forward sources to restore (snapshot header should have guarded this)"
+    );
+  }
+}
+class sn extends Ke {
+  /** source entity **index** → set of target `EntityID`s. Keyed by source index
+   * so destroy-purge — which has the freed index — can drop it in O(1). An
+   * entry is removed the moment its set empties. */
+  _forward = /* @__PURE__ */ new Map();
+  constructor(t, n, r) {
+    super(!1, t, n, r);
+  }
+  _resetForward() {
+    this._forward.clear();
+  }
+  link(t, n) {
+    const r = k(t);
+    let s = this._forward.get(r);
+    s === void 0 && (s = /* @__PURE__ */ new Set(), this._forward.set(r, s), this._store.setRow(r, tn)), s.add(n), this.linkReverse(n, t);
+  }
+  unlink(t, n) {
+    const r = k(t), s = this._forward.get(r);
+    if (s !== void 0) {
+      if (n === void 0) {
+        this._forward.delete(r), s.forEach((o) => this.unlinkReverse(o, t)), this._store.remove(r);
+        return;
+      }
+      s.has(n) && (s.delete(n), this.unlinkReverse(n, t), s.size === 0 && (this._forward.delete(r), this._store.remove(r)));
+    }
+  }
+  purgeSource(t) {
+    const n = k(t), r = this._forward.get(n);
+    r !== void 0 && (this._forward.delete(n), r.forEach((s) => this.unlinkReverse(s, t)));
+  }
+  singleTarget() {
+  }
+  targetsOf(t) {
+    const n = this._forward.get(t);
+    if (n === void 0 || n.size === 0) return [];
+    const r = new Array(n.size);
+    let s = 0;
+    return n.forEach((o) => {
+      r[s++] = o;
+    }), r.sort((o, i) => o - i), r;
+  }
+  has(t) {
+    return this._store.has(t);
+  }
+  forEachCanonicalTargetSet(t) {
+    const n = Array.from(this._forward.keys()).sort((r, s) => r - s);
+    for (let r = 0; r < n.length; r++) {
+      const s = this.targetsOf(n[r]);
+      s.length !== 0 && t(n[r], s);
+    }
+  }
+  forEachCanonicalPair(t, n) {
+    this.forEachCanonicalTargetSet((r, s) => {
+      const o = t(r);
+      for (let i = 0; i < s.length; i++) n(o, s[i]);
+    });
+  }
+  rebuildReverseFromForward() {
+  }
+  restoreAddTarget(t, n, r) {
+    let s = this._forward.get(t);
+    s === void 0 && (s = /* @__PURE__ */ new Set(), this._forward.set(t, s)), s.add(n), this.linkReverse(n, r);
+  }
+}
+function ts(e, t, n, r) {
+  return e ? new nn(t, n, r) : new sn(t, n, r);
+}
+const je = 4, Qe = 4, Ze = 8, te = 8;
+function ns(e) {
+  const t = new Array(e.length);
+  let n = 4;
+  for (let i = 0; i < e.length; i++) {
+    n += je;
+    const c = e[i];
+    if (c.exclusive) {
+      t[i] = null;
+      continue;
+    }
+    const a = [];
+    c.forEachCanonicalTargetSet((l, d) => a.push([l, d])), t[i] = a, n += Qe;
+    for (let l = 0; l < a.length; l++)
+      n += Ze + a[l][1].length * te;
+  }
+  const r = new Uint8Array(n), s = new DataView(r.buffer);
+  let o = 0;
+  s.setUint32(o, e.length, !0), o += 4;
+  for (let i = 0; i < e.length; i++) {
+    s.setUint32(o, e[i].exclusive ? 0 : 1, !0), o += 4;
+    const c = t[i];
+    if (c !== null) {
+      s.setUint32(o, c.length, !0), o += 4;
+      for (let a = 0; a < c.length; a++) {
+        const l = c[a][0], d = c[a][1];
+        s.setUint32(o, l, !0), o += 4, s.setUint32(o, d.length, !0), o += 4;
+        for (let f = 0; f < d.length; f++)
+          s.setFloat64(o, d[f], !0), o += te;
+      }
+    }
+  }
+  return r;
+}
+function ss(e, t, n) {
+  const r = new DataView(t.buffer, t.byteOffset, t.byteLength), s = t.byteLength;
+  let o = 0;
+  const i = (a) => {
+    if (o + a > s)
+      throw new p(
+        `relation snapshot truncated: need ${a} more bytes at offset ${o}, have ${s - o}`
+      );
+  };
+  for (let a = 0; a < e.length; a++) e[a].resetIndices();
+  i(4);
+  const c = r.getUint32(o, !0);
+  if (o += 4, c !== e.length)
+    throw new p(
+      `relation count mismatch: snapshot=${c}, registered=${e.length}`
+    );
+  for (let a = 0; a < e.length; a++) {
+    const l = e[a];
+    i(je);
+    const d = r.getUint32(o, !0);
+    if (o += 4, d === 1 === l.exclusive)
+      throw new p(
+        `relation ${a} cardinality mismatch: snapshot ${d ? "multi" : "exclusive"}, registered ${l.exclusive ? "exclusive" : "multi"}`
+      );
+    if (l.exclusive) continue;
+    i(Qe);
+    const f = r.getUint32(o, !0);
+    o += 4;
+    for (let _ = 0; _ < f; _++) {
+      i(Ze);
+      const g = r.getUint32(o, !0);
+      o += 4;
+      const y = r.getUint32(o, !0);
+      if (o += 4, g > P)
+        throw new p(
+          `relation ${a} source index ${g} exceeds MAX_INDEX (${P})`
+        );
+      i(y * te);
+      const u = n(g);
+      for (let h = 0; h < y; h++) {
+        const T = r.getFloat64(o, !0);
+        o += te;
+        const x = T;
+        if (!Number.isInteger(x) || x < 0 || x > Se)
+          throw new p(
+            `relation ${a} target ${x} is not a well-formed packed EntityID (expected an integer in [0, ${Se}])`
+          );
+        l.restoreAddTarget(g, T, u);
+      }
+    }
+  }
+  if (o !== s)
+    throw new p(
+      `relation snapshot has ${s - o} trailing bytes after the last relation (not a canonical encoding)`
+    );
+}
+const ve = /* @__PURE__ */ new WeakMap();
+function rn(e) {
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+  for (let u = 0; u < e.writes.length; u++) {
+    const h = e.writes[u].id;
+    n.add(h), t.add(h), r.add(h);
+  }
+  for (let u = 0; u < e.reads.length; u++)
+    t.add(e.reads[u].id);
+  for (let u = 0; u < e.spawns.length; u++) {
+    const h = e.spawns[u];
+    for (let T = 0; T < h.length; T++)
+      r.add(h[T].id);
+  }
+  for (let u = 0; u < e.transitions.length; u++) {
+    const h = e.transitions[u];
+    if (h.add)
+      for (let T = 0; T < h.add.length; T++)
+        r.add(h.add[T].id);
+    if (h.remove)
+      for (let T = 0; T < h.remove.length; T++)
+        s.add(h.remove[T].id);
+  }
+  for (let u = 0; u < e.despawns.length; u++)
+    s.add(e.despawns[u].id);
+  for (let u = 0; u < e.resourceReads.length; u++)
+    o.add(e.resourceReads[u]);
+  for (let u = 0; u < e.resourceWrites.length; u++) {
+    const h = e.resourceWrites[u];
+    i.add(h), o.add(h);
+  }
+  const f = e.sparseWrites;
+  if (f !== void 0)
+    for (let u = 0; u < f.length; u++) {
+      const h = f[u];
+      a.add(h), c.add(h);
+    }
+  const _ = e.sparseReads;
+  if (_ !== void 0)
+    for (let u = 0; u < _.length; u++) c.add(_[u]);
+  const g = e.relationWrites;
+  if (g !== void 0)
+    for (let u = 0; u < g.length; u++) {
+      const h = g[u];
+      d.add(h), l.add(h);
+    }
+  const y = e.relationReads;
+  if (y !== void 0)
+    for (let u = 0; u < y.length; u++)
+      l.add(y[u]);
+  return {
+    reads: t,
+    writes: n,
+    addAllowed: r,
+    removeAllowed: s,
+    hasDespawns: e.despawns.length > 0,
+    resourceReads: o,
+    resourceWrites: i,
+    sparseReads: c,
+    sparseWrites: a,
+    relationReads: l,
+    relationWrites: d
+  };
+}
+function on(e) {
+  const t = ve.get(e);
+  if (t !== void 0) return t;
+  const n = rn(e);
+  return ve.set(e, n), n;
+}
+const Le = /* @__PURE__ */ new WeakMap();
+function an(e) {
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+  if (e.reads !== void 0)
+    for (let r = 0; r < e.reads.length; r++) t.add(e.reads[r].id);
+  if (e.resourceReads !== void 0)
+    for (let r = 0; r < e.resourceReads.length; r++)
+      n.add(e.resourceReads[r]);
+  return {
+    reads: t,
+    writes: /* @__PURE__ */ new Set(),
+    addAllowed: /* @__PURE__ */ new Set(),
+    removeAllowed: /* @__PURE__ */ new Set(),
+    hasDespawns: !1,
+    resourceReads: n,
+    resourceWrites: /* @__PURE__ */ new Set(),
+    sparseReads: /* @__PURE__ */ new Set(),
+    sparseWrites: /* @__PURE__ */ new Set(),
+    relationReads: /* @__PURE__ */ new Set(),
+    relationWrites: /* @__PURE__ */ new Set()
+  };
+}
+function cn(e) {
+  const t = Le.get(e);
+  if (t !== void 0) return t;
+  const n = an(e);
+  return Le.set(e, n), n;
+}
+class dn {
+  active = null;
+  sets = null;
+  // The label used in violation messages. Tracks `active` for a system span,
+  // but a run-condition span (#576) has no descriptor — only this name — so the
+  // failure helpers read the label here rather than off `active`.
+  activeName = null;
+  // An `exclusive` system (#681) has full world access: every check_* below
+  // passes for the whole span. Kept as an explicit flag (rather than leaving
+  // `sets` null) so `isActive()` stays truthful inside the span.
+  exclusive = !1;
+  enter(t) {
+    this.active = t, this.activeName = t.name ?? `system_${t.id}`, this.exclusive = t.exclusive === !0, this.sets = this.exclusive ? null : on(t);
+  }
+  /** Open a reads-only span for a run condition (#576). No descriptor — a
+   * condition can gate a whole SystemSet, so it isn't attributable to one
+   * system — just its declared reads/resource_reads and a name for diagnostics.
+   * Paired with `leave()`. */
+  enterCondition(t) {
+    this.active = null, this.activeName = t.name, this.sets = cn(t);
+  }
+  leave() {
+    this.active = null, this.activeName = null, this.sets = null, this.exclusive = !1;
+  }
+  isActive() {
+    return this.sets !== null || this.exclusive;
+  }
+  /** Current system descriptor, if any. Null during a run-condition span. */
+  current() {
+    return this.active;
+  }
+  checkRead(t) {
+    this.sets !== null && (this.sets.reads.has(t.id) || this.failComponent("read", t, "reads"));
+  }
+  checkWrite(t) {
+    this.sets !== null && (this.sets.writes.has(t.id) || this.failComponent("write", t, "writes"));
+  }
+  checkAdd(t) {
+    this.sets !== null && (this.sets.addAllowed.has(t.id) || this.failComponent("addComponent", t, "spawns / transitions.add / writes"));
+  }
+  checkRemove(t) {
+    this.sets !== null && (this.sets.removeAllowed.has(t.id) || this.failComponent("removeComponent", t, "despawns / transitions.remove"));
+  }
+  checkDestroy() {
+    if (this.sets === null || this.sets.hasDespawns) return;
+    const t = this.activeName;
+    throw new S(
+      w.ACCESS_UNDECLARED,
+      `system '${t}' called despawn but didn't declare any despawns — declare the components this system removes via despawn in its 'despawns'`,
+      { system: t, op: "despawn" }
+    );
+  }
+  checkResourceRead(t) {
+    if (this.sets === null) return;
+    const n = t;
+    this.sets.resourceReads.has(n) || this.failResource("read", t, "resourceReads");
+  }
+  checkResourceWrite(t) {
+    if (this.sets === null) return;
+    const n = t;
+    this.sets.resourceWrites.has(n) || this.failResource("write", t, "resourceWrites");
+  }
+  // --- Sparse component / relation checks (#496) ---
+  // Keyed against the dedicated sparse/relation sets, NOT the dense
+  // `reads`/`writes` sets — the id spaces are disjoint by construction (see
+  // file header). `def as unknown as number` recovers the SparseComponentID /
+  // RelationID the branded handle erases to at runtime.
+  checkSparseRead(t) {
+    if (this.sets === null) return;
+    const n = t;
+    this.sets.sparseReads.has(n) || this.failSparse("read", n, "sparseReads");
+  }
+  checkSparseWrite(t) {
+    if (this.sets === null) return;
+    const n = t;
+    this.sets.sparseWrites.has(n) || this.failSparse("write", n, "sparseWrites");
+  }
+  checkRelationRead(t) {
+    if (this.sets === null) return;
+    const n = t;
+    this.sets.relationReads.has(n) || this.failRelation("read", n, "relationReads");
+  }
+  checkRelationWrite(t) {
+    if (this.sets === null) return;
+    const n = t;
+    this.sets.relationWrites.has(n) || this.failRelation("write", n, "relationWrites");
+  }
+  /** A `(*, T)` wildcard (`Query.forEachRelatedTo`, #579) reads every
+   * relation's reverse index, so it can't name a specific relation — it is
+   * authorised by the `ANY_RELATION` sentinel in `relationReads`. Honoured here
+   * exactly like a per-relation read, just keyed on the reserved sentinel id
+   * (which computeSets folds into `relationReads` like any other entry). */
+  checkRelationReadAny() {
+    this.sets !== null && (this.sets.relationReads.has(Ue) || this.failRelation(
+      "(*, T) wildcard read",
+      Ue,
+      "relationReads (as ANY_RELATION)"
+    ));
+  }
+  // --- Optional query-term scope (#592) ---
+  // `Query.forEach` and `ChangedQuery.forEach` push the iterating query's
+  // `_optional` term list for the span of the callback;
+  // `Archetype.getOptionalColumnRead` then verifies the fetched component was
+  // declared via `.optional(T)` — the term that authorizes the optional fetch.
+  // This is what makes the optional term *consumed* rather than decorative: like
+  // `reads:[T]` for required access, `.optional(T)` is the fetch's declaration,
+  // checked here in `DEV`. A stack (not a single slot) handles re-entrant /
+  // nested `forEach`. The optional scope is independent of the per-system
+  // `enter`/`leave` above — a host-side `ecs.query(...).forEach` outside any
+  // system still establishes one. No active scope ⇒ lenient: a manual
+  // `query.archetypes` walk can't be attributed to an optional declaration, so it
+  // isn't checked — mirroring the unchecked outside-of-system calls in the header.
+  //
+  // CAVEAT (#594 Task 3): the gate always attributes to the INNERMOST active
+  // `forEach`. If you nest `forEach` and call `getOptionalColumnRead` on an
+  // OUTER query's archetype inside the inner loop, it is checked against the inner
+  // query's terms (a false throw or false pass). Per-query attribution isn't worth
+  // the complexity for a dev-only assertion; iterate one query at a time, or read
+  // the outer span before entering the inner loop.
+  optionalScopes = [];
+  enterOptionalScope(t) {
+    this.optionalScopes.push(t);
+  }
+  leaveOptionalScope() {
+    this.optionalScopes.pop();
+  }
+  checkOptionalFetch(t) {
+    const n = this.optionalScopes.length;
+    if (n === 0) return;
+    const r = this.optionalScopes[n - 1], s = t.id;
+    for (let o = 0; o < r.length; o++)
+      if (r[o] === s) return;
+    throw new S(
+      w.OPTIONAL_TERM_NOT_DECLARED,
+      `getOptionalColumnRead fetched optional component ${s} but the iterating query didn't declare it — add .optional(component) to the query before fetching it`
+    );
+  }
+  failComponent(t, n, r) {
+    const s = this.activeName, o = dt(n);
+    throw new S(
+      w.ACCESS_UNDECLARED,
+      `system '${s}' performed ${t} on ${o} but didn't declare it — add it to '${r}' (see docs/api/systems.md)`,
+      { system: s, op: t, component: n.id }
+    );
+  }
+  failSparse(t, n, r) {
+    const s = this.activeName;
+    throw new S(
+      w.ACCESS_UNDECLARED,
+      `system '${s}' performed ${t} on sparse component ${n} but didn't declare it — add it to '${r}' (see docs/api/systems.md)`,
+      { system: s, op: t, sparse: n }
+    );
+  }
+  failRelation(t, n, r) {
+    const s = this.activeName;
+    throw new S(
+      w.ACCESS_UNDECLARED,
+      `system '${s}' performed ${t} on relation ${n} but didn't declare it — add it to '${r}' (see docs/api/systems.md)`,
+      { system: s, op: t, relation: n }
+    );
+  }
+  failResource(t, n, r) {
+    const s = this.activeName, o = n.description ?? "<unnamed>";
+    throw new S(
+      w.ACCESS_UNDECLARED,
+      `system '${s}' performed resource ${t} on '${o}' but didn't declare it — add the resource key to '${r}' (see docs/api/systems.md)`,
+      { system: s, op: t, resource: o }
+    );
+  }
+}
+const rs = new dn();
+var $ = /* @__PURE__ */ ((e) => (e.PRE_STARTUP = "PRE_STARTUP", e.STARTUP = "STARTUP", e.POST_STARTUP = "POST_STARTUP", e.FIXED_UPDATE = "FIXED_UPDATE", e.PRE_UPDATE = "PRE_UPDATE", e.UPDATE = "UPDATE", e.POST_UPDATE = "POST_UPDATE", e))($ || {});
+const ce = [
+  "PRE_STARTUP",
+  "STARTUP",
+  "POST_STARTUP"
+  /* POST_STARTUP */
+], de = [
+  "PRE_UPDATE",
+  "UPDATE",
+  "POST_UPDATE"
+  /* POST_UPDATE */
+];
+function os(e) {
+  return Object.freeze({ name: e });
+}
+function ln(e) {
+  return !("fn" in e);
+}
+const W = Object.freeze([]);
+function le(e) {
+  return e === void 0 ? W : Array.isArray(e) ? e : [e];
+}
+class is {
+  labelSystems = /* @__PURE__ */ new Map();
+  sortedCache = /* @__PURE__ */ new Map();
+  systemIndex = /* @__PURE__ */ new Map();
+  systemLastRun = /* @__PURE__ */ new Map();
+  // Only systems carrying a run condition or set membership (#576). The hot
+  // loop skips the per-system gate probe entirely when this is empty, so a
+  // schedule that uses no conditions runs byte-for-byte the pre-#576 path.
+  gatedSystems = /* @__PURE__ */ new Map();
+  // Live set configuration, read at sort time (ordering) and run time
+  // (conditions) so `configureSet` is order-independent w.r.t. `addSystems`.
+  setConditions = /* @__PURE__ */ new Map();
+  setOrdering = /* @__PURE__ */ new Map();
+  nextInsertionOrder = 0;
+  // The opt-in compute backend (#622), or null (the default — pure-TS). When
+  // set, a scheduled system carrying a `backendHandle` runs `backend.run(...)`
+  // instead of its `fn`. `null` is the byte-for-byte pre-#622 path: `runLabel`
+  // hoists this to a local and only reads `desc.backendHandle` when non-null,
+  // so a no-backend ECS never touches the routing field.
+  _backend = null;
+  /** Dev-diagnostic sink (`ECSOptions.onWarn`); defaults to `console.warn`.
+   * The only schedule diagnostic today is `warnDroppedEdge`. */
+  onWarn;
+  constructor(t) {
+    this.onWarn = t ?? ((n) => console.warn(n));
+    for (let n = 0; n < ce.length; n++)
+      this.labelSystems.set(ce[n], []);
+    this.labelSystems.set("FIXED_UPDATE", []);
+    for (let n = 0; n < de.length; n++)
+      this.labelSystems.set(de[n], []);
+  }
+  addSystems(t, ...n) {
+    for (const r of n) {
+      const s = "system" in r, o = s ? r.system : r, i = s ? r.ordering : void 0, c = s ? le(r.runIf) : W, a = s ? le(r.set) : W, l = {
+        descriptor: o,
+        insertionOrder: this.nextInsertionOrder++,
+        before: new Set(i?.before ?? []),
+        after: new Set(i?.after ?? []),
+        conditions: c,
+        sets: a
+      };
+      this.labelSystems.get(t).push(l), this.systemIndex.set(o, t), this.systemLastRun.set(o, 0), (c.length > 0 || a.length > 0) && this.gatedSystems.set(o, l), this.sortedCache.delete(t);
+    }
+  }
+  /**
+   * Configure a `SystemSet` (#576) — its shared run condition(s) and/or
+   * ordering, inherited by every member. Additive and order-independent w.r.t.
+   * `addSystems`: conditions accumulate (ANDed), ordering targets union, and
+   * a member added before or after this call picks the configuration up.
+   */
+  configureSet(t, n) {
+    const r = le(n.runIf);
+    if (r.length > 0) {
+      const s = this.setConditions.get(t);
+      s === void 0 ? this.setConditions.set(t, [...r]) : s.push(...r);
+    }
+    if (n.before !== void 0 || n.after !== void 0) {
+      let s = this.setOrdering.get(t);
+      s === void 0 && (s = { before: /* @__PURE__ */ new Set(), after: /* @__PURE__ */ new Set() }, this.setOrdering.set(t, s));
+      for (const o of n.before ?? W) s.before.add(o);
+      for (const o of n.after ?? W) s.after.add(o);
+      this.sortedCache.clear();
+    }
+  }
+  removeSystem(t) {
+    const n = this.systemIndex.get(t);
+    if (n === void 0) return;
+    const r = this.labelSystems.get(n), s = r.findIndex((o) => o.descriptor === t);
+    if (s !== -1) {
+      const o = r.length - 1;
+      s !== o && (r[s] = r[o]), r.pop();
+      for (const i of r)
+        i.before.delete(t), i.after.delete(t);
+    }
+    this.systemIndex.delete(t), this.systemLastRun.delete(t), this.gatedSystems.delete(t), this.sortedCache.delete(n);
+  }
+  /** Attach (or, with `null`, detach) the opt-in compute backend (#622). Driven
+   * by `ECS.attachBackend`; routes any scheduled system carrying a
+   * `backendHandle` to `backend.run(handle)` in place of its `fn`. */
+  setBackend(t) {
+    this._backend = t;
+  }
+  runStartup(t, n) {
+    for (const r of ce)
+      this.runLabel(r, t, at, n);
+  }
+  runUpdate(t, n, r) {
+    for (const s of de)
+      this.runLabel(s, t, n, r);
+  }
+  runFixedUpdate(t, n, r) {
+    this.runLabel("FIXED_UPDATE", t, n, r);
+  }
+  hasFixedSystems() {
+    return this.labelSystems.get(
+      "FIXED_UPDATE"
+      /* FIXED_UPDATE */
+    ).length > 0;
+  }
+  getAllSystems() {
+    const t = [];
+    for (const n of this.labelSystems.values())
+      for (const r of n)
+        t.push(r.descriptor);
+    return t;
+  }
+  hasSystem(t) {
+    return this.systemIndex.has(t);
+  }
+  clear() {
+    for (const t of this.labelSystems.values())
+      t.length = 0;
+    this.sortedCache.clear(), this.systemIndex.clear(), this.systemLastRun.clear(), this.gatedSystems.clear(), this.setConditions.clear(), this.setOrdering.clear();
+  }
+  runLabel(t, n, r, s) {
+    const o = this.getSorted(t), i = this.gatedSystems.size > 0, c = this._backend, a = i ? /* @__PURE__ */ new Map() : void 0;
+    for (let l = 0; l < o.length; l++) {
+      const d = o[l];
+      if (i) {
+        const _ = this.gatedSystems.get(d);
+        if (_ !== void 0 && !this.shouldRun(_, n, a)) continue;
+      }
+      n.lastRunTick = this.systemLastRun.get(d) ?? 0;
+      const f = c !== null ? d.backendHandle : void 0;
+      try {
+        f !== void 0 ? c.run(f) : d.fn?.(n, r);
+      } finally {
+      }
+      this.systemLastRun.set(d, s);
+    }
+    n.flush();
+  }
+  /**
+   * Whether a gated system runs this tick — the AND of its own conditions and
+   * every set it belongs to. A set's conditions are evaluated at most once per
+   * phase (memoized in `setVerdicts`) and the verdict gates every member of the
+   * set uniformly; a `configureSet` between phases is still honored because the
+   * memo lives only for a single `runLabel` pass. Short-circuits on the first
+   * `false`. The system's own conditions evaluate per system, in canonical order.
+   *
+   * #731 SEMANTIC NOTE: this evaluates a set's conditions once-per-set-per-phase
+   * rather than once-per-member. Equivalent for pure RunConditions; observably
+   * different only if a set condition reads state mutated earlier in the SAME
+   * phase (resources write immediately). That is intentional — the set gates as a
+   * unit, so all its members share one verdict for the phase.
+   */
+  shouldRun(t, n, r) {
+    if (t.conditions.length > 0 && !this.evalConditions(t.conditions, n))
+      return !1;
+    for (let s = 0; s < t.sets.length; s++) {
+      const o = t.sets[s];
+      let i = r.get(o);
+      if (i === void 0) {
+        const c = this.setConditions.get(o);
+        i = c === void 0 || c.length === 0 ? !0 : this.evalConditions(c, n), r.set(o, i);
+      }
+      if (!i) return !1;
+    }
+    return !0;
+  }
+  /** Evaluate a condition list with AND semantics. Each predicate runs inside a
+   * reads-only `accessCheck` span (dev), so a condition that reads an
+   * undeclared resource — or attempts any mutation — throws. */
+  evalConditions(t, n) {
+    for (let r = 0; r < t.length; r++) {
+      const s = t[r];
+      let o;
+      try {
+        o = s.evaluate(n);
+      } finally {
+      }
+      if (!o) return !1;
+    }
+    return !0;
+  }
+  getSorted(t) {
+    const n = this.sortedCache.get(t);
+    if (n !== void 0) return n;
+    const r = this.labelSystems.get(t), s = this.sortSystems(r, t);
+    return this.sortedCache.set(t, s), s;
+  }
+  /**
+   * Delegates to the shared topologicalSort utility.
+   * Builds the dependency edge map from before/after constraints, then
+   * catches any cycle TypeError and re-throws as ECSError.
+   */
+  sortSystems(t, n) {
+    if (t.length === 0) return [];
+    const r = [], s = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map();
+    for (const d of t) {
+      r.push(d.descriptor), s.set(d.descriptor, d.insertionOrder), o.add(d.descriptor);
+      for (let f = 0; f < d.sets.length; f++) {
+        const _ = d.sets[f];
+        let g = i.get(_);
+        g === void 0 && (g = [], i.set(_, g)), g.push(d.descriptor);
+      }
+    }
+    const c = /* @__PURE__ */ new Map();
+    for (const d of t)
+      c.set(d.descriptor, []);
+    for (const d of t) {
+      this.resolveEdges(
+        d.descriptor,
+        d.before,
+        "before",
+        o,
+        i,
+        c,
+        n
+      ), this.resolveEdges(d.descriptor, d.after, "after", o, i, c, n);
+      for (let f = 0; f < d.sets.length; f++) {
+        const _ = this.setOrdering.get(d.sets[f]);
+        _ !== void 0 && (this.resolveEdges(
+          d.descriptor,
+          _.before,
+          "before",
+          o,
+          i,
+          c,
+          n
+        ), this.resolveEdges(
+          d.descriptor,
+          _.after,
+          "after",
+          o,
+          i,
+          c,
+          n
+        ));
+      }
+    }
+    const a = (d, f) => s.get(d) - s.get(f), l = (d) => d.name ?? `system_${d.id}`;
+    try {
+      return tt(r, c, a, l);
+    } catch (d) {
+      throw d instanceof TypeError ? new S(
+        w.CIRCULAR_SYSTEM_DEPENDENCY,
+        `Circular system dependency detected in ${n}: ${d.message}`
+      ) : d;
+    }
+  }
+  /**
+   * Add the topo edges for one ordering list (#576). For `"before"` the source
+   * runs before each target (edge source→target); for `"after"` it runs after
+   * each target (edge target→source). A `SystemSet` target expands to every
+   * member within this phase (self-edges skipped, so a member ordered against
+   * its own set is a no-op); a descriptor target absent from this phase is
+   * dropped — with a dev warning only for a concrete system, since a set
+   * legitimately expands to nothing when its members live in another phase.
+   */
+  resolveEdges(t, n, r, s, o, i, c) {
+    for (const a of n) {
+      if (ln(a)) {
+        const l = o.get(a);
+        if (l === void 0) continue;
+        for (let d = 0; d < l.length; d++) {
+          const f = l[d];
+          f !== t && this.addDirectedEdge(t, f, r, i);
+        }
+        continue;
+      }
+      s.has(a) && this.addDirectedEdge(t, a, r, i);
+    }
+  }
+  /** Push one directed edge into the adjacency map. Both endpoints are known to
+   * be in this phase (callers guard), so `edges.get(...)` is non-null. */
+  addDirectedEdge(t, n, r, s) {
+    r === "before" ? s.get(t).push(n) : s.get(n).push(t);
+  }
+  /**
+   * Dev-only diagnostic for an ordering edge that was dropped during sort.
+   *
+   * Cross-label ordering is impossible by design (`nodeSet` is per-label), so
+   * a target registered in *another* phase is skipped silently — that's the
+   * intended isolation. But a target unknown to *every* phase is almost
+   * certainly a typo or a system that was never scheduled; without this warning
+   * the constraint vanishes and the system runs in insertion-order tiebreak as
+   * if unconstrained, with nothing to distinguish mistake from intent. Compiled
+   * out of production builds by the `DEV` guards at the call sites.
+   */
+  warnDroppedEdge(t, n, r, s) {
+    if (this.systemIndex.has(n)) return;
+    const o = (i) => i.name ?? `system_${i.id}`;
+    this.onWarn(
+      `Schedule[${s}]: \`${o(t)}\` declares \`${r}\` ordering against \`${o(n)}\`, which is not registered in any phase — the constraint is ignored. Check for a typo or a missing add_systems() call.`
+    );
+  }
+}
+const ne = 1024, se = 1024 * ne, Me = 64 * ne, X = 256 * se, $e = 3, un = 64, fn = 8, Pe = 4 * se, xe = (e) => 2 ** Math.ceil(Math.log2(Math.max(1, e))), Q = (e) => 2 ** Math.floor(Math.log2(Math.max(1, e))), F = (e, t, n) => Math.min(n, Math.max(t, e)), I = (e) => e >= se ? `${(e / se).toFixed(1)} MiB` : e >= ne ? `${(e / ne).toFixed(0)} KiB` : `${e} B`;
+function R(e, t) {
+  if (!Number.isInteger(t) || t <= 0)
+    throw new S(
+      w.INVALID_MEMORY_OPTIONS,
+      `memory.${e} must be a positive integer (got ${t})`
+    );
+}
+function as(e) {
+  const t = ["budget", "maxBytes", "wasm", "allocator", "heap", "shared"].filter(
+    (s) => e !== void 0 && e[s] !== void 0
+  );
+  if (t.length > 1)
+    throw new S(
+      w.INVALID_MEMORY_OPTIONS,
+      `memory takes at most one of budget | maxBytes | wasm | allocator | heap | shared (got: ${t.join(", ")})`
+    );
+  const n = e?.columnCapacity;
+  if (n !== void 0 && R("column_capacity", n), e?.budget !== void 0) {
+    const { entities: s } = e.budget, o = e.budget.archetypes ?? fn, i = e.budget.bytesPerEntity ?? un;
+    if (R("budget.entities", s), R("budget.archetypes", o), R("budget.bytes_per_entity", i), s > 1 << 20)
+      throw new S(
+        w.INVALID_MEMORY_OPTIONS,
+        `memory.budget.entities=${s} exceeds the EntityID index space (1<<20 = ${1 << 20})`
+      );
+    const c = n ?? F(xe(Math.ceil(s / o)), 64, 1 << 20), a = F(xe(s * 2), 4096, 1 << 20), l = a * D, d = s * i * $e, f = ze(
+      Math.max(l + d, Pe),
+      Me
+    );
+    return {
+      source: "budget",
+      allocator: K(f),
+      columnCapacity: c,
+      entityIndexCapacity: a,
+      capBytes: f,
+      intentLabel: `budget of ${s} entities`,
+      budgetEntities: s,
+      derivation: [
+        `column_capacity = ${n !== void 0 ? `${c} (pinned)` : `pow2(${s}/${o} per archetype) = ${c}`}`,
+        `entity_index = pow2(2 × ${s}) = ${a} slots × ${D} B = ${I(l)}`,
+        `columns = ${s} × ${i} B × ${$e} (double+holes headroom) = ${I(d)}`,
+        `cap = align64K(max(index + columns, ${I(Pe)} floor)) = ${I(f)}`
+      ],
+      wasmMemory: null
+    };
+  }
+  if (e?.maxBytes !== void 0) {
+    R("maxBytes", e.maxBytes);
+    const s = n ?? B, o = F(
+      Q(e.maxBytes / 4 / D),
+      4096,
+      v
+    );
+    return {
+      source: "max_bytes",
+      allocator: K(e.maxBytes),
+      columnCapacity: s,
+      entityIndexCapacity: o,
+      capBytes: e.maxBytes,
+      intentLabel: `explicit cap of ${I(e.maxBytes)}`,
+      budgetEntities: null,
+      derivation: [
+        `cap = ${I(e.maxBytes)} (caller-declared)`,
+        `column_capacity = ${s} (${n !== void 0 ? "pinned" : "default"})`,
+        `entity_index = floor_pow2(cap/4 ÷ ${D} B) = ${o} slots`
+      ],
+      wasmMemory: null
+    };
+  }
+  if (e?.wasm !== void 0) {
+    const s = e.wasm, o = n ?? B;
+    if (s.memory !== void 0) {
+      if (!(s.memory.buffer instanceof SharedArrayBuffer))
+        throw new S(
+          w.INVALID_MEMORY_OPTIONS,
+          "memory.wasm.memory must be constructed with `shared: true` — the SAB substrate requires a SharedArrayBuffer-backed WebAssembly.Memory (ADR-0004 / ADR-0018)"
+        );
+      return {
+        source: "wasm",
+        allocator: we(s.memory),
+        columnCapacity: o,
+        entityIndexCapacity: v,
+        // The JS API hides a Memory's `maximum`; the caller declared it.
+        capBytes: null,
+        intentLabel: "caller-supplied WebAssembly.Memory",
+        budgetEntities: null,
+        derivation: [
+          "backing = wasm_memory_allocator(memory) — zero-copy with the sim (is_in_place ✓)",
+          "cap = the Memory's own `maximum` (declared by the caller; not readable from JS)",
+          `column_capacity = ${o} (${n !== void 0 ? "pinned" : "default"})`
+        ],
+        wasmMemory: s.memory
+      };
+    }
+    R("wasm.maximum_pages", s.maximumPages);
+    const i = s.initialPages ?? Math.min(32, s.maximumPages);
+    if (R("wasm.initial_pages", i), i > s.maximumPages)
+      throw new S(
+        w.INVALID_MEMORY_OPTIONS,
+        `memory.wasm.initial_pages (${i}) exceeds maximum_pages (${s.maximumPages})`
+      );
+    const c = new WebAssembly.Memory({
+      initial: i,
+      maximum: s.maximumPages,
+      shared: !0
+    }), a = s.maximumPages * Me, l = F(
+      Q(a / 4 / D),
+      4096,
+      v
+    );
+    return {
+      source: "wasm",
+      allocator: we(c),
+      columnCapacity: o,
+      entityIndexCapacity: l,
+      capBytes: a,
+      intentLabel: `engine-constructed WebAssembly.Memory (max ${s.maximumPages} pages)`,
+      budgetEntities: null,
+      derivation: [
+        `cap = ${s.maximumPages} pages × 64 KiB = ${I(a)} (Memory maximum)`,
+        `initial = ${i} pages (${s.initialPages !== void 0 ? "declared" : "default"})`,
+        `entity_index = floor_pow2(cap/4 ÷ ${D} B) = ${l} slots`,
+        `column_capacity = ${o} (${n !== void 0 ? "pinned" : "default"})`
+      ],
+      wasmMemory: c
+    };
+  }
+  if (e?.allocator !== void 0) {
+    if (e.allocator.isInPlace !== !0)
+      throw new S(
+        w.INVALID_MEMORY_OPTIONS,
+        "memory.allocator must declare `is_in_place: true` (ADR-0008): a live Store's flush loops hoist entity-index views across grows, so a non-in-place allocator (e.g. DEFAULT_SAB_ALLOCATOR) corrupts the entity→row mapping. Use growable_sab_allocator / wasm_memory_allocator; non-in-place allocators are snapshot/test sizing only."
+      );
+    const s = n ?? B, o = e.capBytesHint;
+    return o !== void 0 && R("cap_bytes_hint", o), {
+      source: "allocator",
+      allocator: e.allocator,
+      columnCapacity: s,
+      entityIndexCapacity: v,
+      capBytes: o ?? null,
+      intentLabel: o !== void 0 ? `custom in-place allocator (cap hint ${I(o)})` : "custom in-place allocator",
+      budgetEntities: null,
+      derivation: [
+        "backing = caller allocator (is_in_place ✓ checked at construction)",
+        o !== void 0 ? `cap = ${I(o)} (caller hint — diagnostics only; the allocator owns the real cap)` : "cap = allocator-owned (no hint)",
+        `column_capacity = ${s} (${n !== void 0 ? "pinned" : "default"})`
+      ],
+      wasmMemory: null
+    };
+  }
+  if (e?.heap !== void 0) {
+    e.heap.maxBytes !== void 0 && R("heap.maxBytes", e.heap.maxBytes);
+    const s = e.heap.maxBytes ?? X, o = n ?? B, i = F(
+      Q(s / 4 / D),
+      4096,
+      v
+    );
+    return {
+      source: "heap",
+      allocator: K(s),
+      columnCapacity: o,
+      entityIndexCapacity: i,
+      capBytes: s,
+      intentLabel: `pure-TS heap backing (${I(s)} growable cap, no SharedArrayBuffer)`,
+      budgetEntities: null,
+      derivation: [
+        `backing = heap_arraybuffer_allocator(${I(s)}) — resizable ArrayBuffer, no SAB / no COOP+COEP (is_in_place ✓)`,
+        "trade-off: no worker offload / no WASM backend (both need a transferable SharedArrayBuffer)",
+        `column_capacity = ${o} (${n !== void 0 ? "pinned" : "default"})`,
+        `entity_index = floor_pow2(cap/4 ÷ ${D} B) = ${i} slots`
+      ],
+      wasmMemory: null
+    };
+  }
+  if (e?.shared !== void 0) {
+    e.shared.maxBytes !== void 0 && R("shared.maxBytes", e.shared.maxBytes);
+    const s = e.shared.maxBytes ?? X, o = n ?? B, i = F(
+      Q(s / 4 / D),
+      4096,
+      v
+    );
+    return {
+      source: "shared",
+      allocator: st(s),
+      columnCapacity: o,
+      entityIndexCapacity: i,
+      capBytes: s,
+      intentLabel: `shared SharedArrayBuffer backing (${I(s)} growable cap, needs COOP/COEP)`,
+      budgetEntities: null,
+      derivation: [
+        `backing = growable_sab_allocator(${I(s)}) — growable SharedArrayBuffer (is_in_place ✓); needs cross-origin isolation`,
+        "enables worker offload + a WASM compute backend (transferable SharedArrayBuffer)",
+        `column_capacity = ${o} (${n !== void 0 ? "pinned" : "default"})`,
+        `entity_index = floor_pow2(cap/4 ÷ ${D} B) = ${i} slots`
+      ],
+      wasmMemory: null
+    };
+  }
+  const r = n ?? B;
+  return {
+    source: "default",
+    allocator: K(),
+    columnCapacity: r,
+    entityIndexCapacity: v,
+    capBytes: X,
+    intentLabel: `default sizing (${I(X)} growable cap)`,
+    budgetEntities: null,
+    derivation: [
+      `cap = ${I(X)} (heap_arraybuffer_allocator default)`,
+      `column_capacity = ${r} (${n !== void 0 ? "pinned" : "DEFAULT_COLUMN_CAPACITY"})`,
+      `entity_index = ${v} slots (full EntityID space, ~12 MiB virtual)`
+    ],
+    wasmMemory: null
+  };
+}
+function cs(e, t) {
+  return { def: e, values: t };
+}
+function ue(e, t) {
+  switch (t.kind) {
+    case "spawn": {
+      const n = e.commands.spawn();
+      for (const r of t.components)
+        e.commands.add(n, r.def, r.values);
+      return t.onSpawned?.(n), n;
+    }
+    case "despawn":
+      e.commands.despawn(t.eid);
+      return;
+    case "add_component":
+      e.commands.add(t.eid, t.def, t.values);
+      return;
+    case "remove_component":
+      e.commands.remove(t.eid, t.def);
+      return;
+    case "set_field":
+      e.setField(t.eid, t.def, t.field, t.value);
+      return;
+    case "disable":
+      e.commands.disable(t.eid);
+      return;
+    case "enable":
+      e.commands.enable(t.eid);
+      return;
+    default:
+      return ot(t, "HostCommand kind");
+  }
+}
+class _n {
+  queued = [];
+  spawn(t, n) {
+    this.queued.push({ kind: "spawn", components: t, onSpawned: n });
+  }
+  despawn(t) {
+    this.queued.push({ kind: "despawn", eid: t });
+  }
+  addComponent(t, n, r) {
+    this.queued.push({ kind: "add_component", eid: t, def: n, values: r });
+  }
+  removeComponent(t, n) {
+    this.queued.push({ kind: "remove_component", eid: t, def: n });
+  }
+  /** Set `field` of `def` on `eid`. Applied IMMEDIATELY at the drain, unlike the
+   * deferred structural ops — so `def` must already be on `eid`. Do NOT
+   * `addComponent`/`spawn` `def` and `setField` it in the same frame: the add is
+   * still pending its flush when the immediate set runs (carry the value in
+   * `addComponent`/`spawnEntry` instead). `applyHostCommand` throws an
+   * actionable error in `DEV` if you do. */
+  setField(t, n, r, s) {
+    this.queued.push({ kind: "set_field", eid: t, def: n, field: r, value: s });
+  }
+  disable(t) {
+    this.queued.push({ kind: "disable", eid: t });
+  }
+  enable(t) {
+    this.queued.push({ kind: "enable", eid: t });
+  }
+  /** Enqueue a pre-built command. The path for a SAB-ring codec, an editor's
+   * reified inverse, or a replay log — all of which produce `HostCommand` data
+   * directly rather than calling the typed sugar above. */
+  push(t) {
+    this.queued.push(t);
+  }
+  /** Commands buffered but not yet applied. */
+  pending() {
+    return this.queued.length;
+  }
+  /** Drop every buffered command without applying it (M15) — e.g. abandoning
+   * queued edits on a scene unload. Returns how many were dropped. Does not
+   * touch commands already drained into the world. */
+  clear() {
+    const t = this.queued.length;
+    return this.queued.length = 0, t;
+  }
+  /**
+   * Apply and clear every buffered command. Called by the blessed apply system
+   * inside its schedule span; not part of the host-facing surface. Returns the
+   * count applied.
+   *
+   * `tap`, when present, is invoked with each command in apply order just before
+   * it is applied — the record/replay hook ({@link HostCommandRecorder}). It is
+   * an OPT-IN observer: the tap-free path keeps the original tight loop, so an
+   * un-recorded drain pays nothing (#702).
+   */
+  drain(t, n) {
+    const r = this.queued.length;
+    if (r === 0) return 0;
+    if (n === void 0)
+      for (let s = 0; s < r; s++) ue(t, this.queued[s]);
+    else
+      for (let s = 0; s < r; s++) {
+        const o = this.queued[s];
+        n(o), ue(t, o);
+      }
+    return this.queued.splice(0, r), r;
+  }
+}
+const Je = M - 1;
+function hn(e) {
+  if (e === Ee)
+    throw new U(
+      "cannot bind op_code 0 (reserved as the command-ring empty-slot marker)"
+    );
+  if (e < 0 || e > 255 || !Number.isInteger(e))
+    throw new U(`command op_code must be a u8 in [1, 255] (got ${e})`);
+}
+function oe(e) {
+  const t = new Uint8Array(Je);
+  return new DataView(t.buffer).setUint32(0, e, !0), t;
+}
+function ie(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength).getUint32(0, !0);
+}
+function ds(e, t) {
+  return {
+    encode(n) {
+      if (n.kind !== "set_field")
+        throw new U(
+          `ringSetFieldCodec encodes a "set_field" command (got "${n.kind}")`
+        );
+      const r = new Uint8Array(Je), s = new DataView(r.buffer);
+      return s.setUint32(0, n.eid, !0), s.setFloat64(4, n.value, !0), r;
+    },
+    decode(n) {
+      const r = new DataView(n.buffer, n.byteOffset, n.byteLength);
+      return {
+        kind: "set_field",
+        // boundary: branded-ID bridging — a decoded `u32` is an `EntityID` handle.
+        eid: r.getUint32(0, !0),
+        // schema-erased into the flat HostCommand union (the callable def is invariant in S).
+        def: e,
+        field: t,
+        value: r.getFloat64(4, !0)
+      };
+    }
+  };
+}
+function ls() {
+  return {
+    encode(e) {
+      if (e.kind !== "despawn")
+        throw new U(
+          `ring_despawn_codec encodes a "despawn" command (got "${e.kind}")`
+        );
+      return oe(e.eid);
+    },
+    decode: (e) => ({ kind: "despawn", eid: ie(e) })
+  };
+}
+function us() {
+  return {
+    encode(e) {
+      if (e.kind !== "disable")
+        throw new U(
+          `ring_disable_codec encodes a "disable" command (got "${e.kind}")`
+        );
+      return oe(e.eid);
+    },
+    decode: (e) => ({ kind: "disable", eid: ie(e) })
+  };
+}
+function fs() {
+  return {
+    encode(e) {
+      if (e.kind !== "enable")
+        throw new U(
+          `ring_enable_codec encodes an "enable" command (got "${e.kind}")`
+        );
+      return oe(e.eid);
+    },
+    decode: (e) => ({ kind: "enable", eid: ie(e) })
+  };
+}
+function _s(e) {
+  return {
+    encode(t) {
+      if (t.kind !== "remove_component")
+        throw new U(
+          `ringRemoveComponentCodec encodes a "remove_component" command (got "${t.kind}")`
+        );
+      return oe(t.eid);
+    },
+    decode: (t) => ({ kind: "remove_component", eid: ie(t), def: e })
+  };
+}
+class hs {
+  appliers = /* @__PURE__ */ new Map();
+  /** Bind a raw ctx-aware applier to `opCode`. Re-binding replaces. */
+  on(t, n) {
+    return hn(t), this.appliers.set(t, n), this;
+  }
+  /** Unbind `opCode` (M15). Returns whether a binding was removed; subsequent
+   * slots carrying it hit the unknown-opcode path. */
+  off(t) {
+    return this.appliers.delete(t);
+  }
+  /** Bind a `HostCommand` codec to `opCode`: each matching slot is decoded and
+   * run through `applyHostCommand` — the SAME dispatch the typed queue uses.
+   * A drain-time `tap` (record/replay, #702) sees the decoded command before it
+   * applies, so ring-sourced commands share one log with the typed transport. */
+  onCommand(t, n) {
+    return this.on(t, (r, s, o) => {
+      const i = n.decode(s);
+      o?.(i), ue(r, i);
+    });
+  }
+  /** Drain every pending slot, dispatching each to its bound applier. Unbound
+   * opcodes are skipped (the read head still advances — matching
+   * `drainCommandRing` / `CommandDispatcher`). Returns slots drained. `tap`,
+   * when present, is forwarded to each applier as the record/replay hook (#702);
+   * only `onCommand`-bound (generic `HostCommand`) opcodes surface to it. */
+  drain(t, n, r, s) {
+    return Dt(n, r, (o, i) => {
+      const c = this.appliers.get(o);
+      c !== void 0 && c(t, i, s);
+    });
+  }
+}
+const mn = /* @__PURE__ */ new Set([
+  $.PRE_STARTUP,
+  $.STARTUP,
+  $.POST_STARTUP
+]), fe = /* @__PURE__ */ new WeakMap();
+function ms(e, t) {
+  const n = fe.get(t);
+  if (n === void 0) return !1;
+  for (const r of n) e.removeSystem(r);
+  return fe.delete(t), t.clear(), !0;
+}
+function gs(e, t) {
+  const n = new _n(), r = [];
+  fe.set(n, r);
+  const s = t?.name ?? "host_command_apply", o = t?.ring, i = t?.recorder, c = i?.record, a = t?.schedules ?? [$.PRE_STARTUP, $.PRE_UPDATE];
+  if (i !== void 0 && a.includes($.FIXED_UPDATE))
+    throw new S(
+      w.INVALID_RECORDER_SCHEDULE,
+      "install_host_command_seam: a recorder cannot drain on SCHEDULE.FIXED_UPDATE — it would log the fixed-step dt instead of the host update(dt) and diverge on replay. Use a variable-update phase (PRE_UPDATE/UPDATE/POST_UPDATE)."
+    );
+  for (const l of a) {
+    const d = !mn.has(l), f = e.registerSystem({
+      name: `${s}:${l}`,
+      // `reads`/`writes` are required by `SystemConfig` but empty here: the
+      // apply system declares nothing because it mutates components not known
+      // at registration. Full world access: the host may queue mutations to
+      // anything. The deferred-flush apply point is unchanged, so structural
+      // safety holds; `exclusive` only waives the DEV access check.
+      reads: [],
+      writes: [],
+      exclusive: !0,
+      fn: (_, g) => {
+        if (i !== void 0 && d && i.openTick(_.ecsTick, g), n.drain(_, c), o !== void 0) {
+          const y = e.columnStore, u = y.header.commandRingOff;
+          u !== 0 && o.drain(_, y.view, u, c);
+        }
+      }
+    });
+    e.addSystems(l, f), r.push(f);
+  }
+  return n;
+}
+export {
+  ee as $,
+  Kt as A,
+  $e as B,
+  $n as C,
+  X as D,
+  S as E,
+  es as F,
+  en as G,
+  hs as H,
+  ts as I,
+  Rn as J,
+  qn as K,
+  ze as L,
+  P as M,
+  wn as N,
+  ye as O,
+  We as P,
+  j as Q,
+  Cn as R,
+  m as S,
+  Hn as T,
+  In as U,
+  zn as V,
+  Xn as W,
+  gt as X,
+  ke as Y,
+  Ne as Z,
+  re as _,
+  un as a,
+  Qn as a0,
+  ns as a1,
+  p as a2,
+  Zn as a3,
+  ss as a4,
+  Jn as a5,
+  xn as a6,
+  J as a7,
+  v as a8,
+  kn as a9,
+  _n as aA,
+  cs as aB,
+  Ue as aC,
+  An as aD,
+  Wn as aa,
+  N as ab,
+  ge as ac,
+  me as ad,
+  Kn as ae,
+  Jt as af,
+  qe as ag,
+  Sn as ah,
+  Ye as ai,
+  Bn as aj,
+  Mn as ak,
+  jn as al,
+  z as am,
+  Gn as an,
+  Yn as ao,
+  Vn as ap,
+  is as aq,
+  On as ar,
+  bn as as,
+  Nn as at,
+  Dn as au,
+  $ as av,
+  os as aw,
+  gs as ax,
+  ms as ay,
+  ue as az,
+  fn as b,
+  rs as c,
+  ds as d,
+  ls as e,
+  us as f,
+  fs as g,
+  _s as h,
+  Je as i,
+  vn as j,
+  Ln as k,
+  _e as l,
+  Un as m,
+  Se as n,
+  ft as o,
+  lt as p,
+  ut as q,
+  as as r,
+  Pn as s,
+  Fn as t,
+  Zt as u,
+  yn as v,
+  Tn as w,
+  w as x,
+  B as y,
+  k as z
+};