@oasys/oecs 0.5.3 → 0.6.0

package/dist/host_commands-CwxVQS1z.js

@@ -0,0 +1,1524 @@
+import { D as Ve, w as ce, g as He, h as Ge } from "./shared-BKl12xF1.js";
+class we extends Error {
+  constructor(t, n, o) {
+    super(t), this.isOperational = n, this.context = o, this.name = this.constructor.name, typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, this.constructor);
+  }
+}
+var be = /* @__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))(be || {});
+class ke extends we {
+  constructor(t, n, o) {
+    super(n, !1, o), this.category = t, this.name = "AssertionError";
+  }
+}
+function Zt(e, t, n) {
+  return e;
+}
+function en(e) {
+  return e;
+}
+function We(e, t) {
+  throw new ke(
+    be.ASSERTION_FAIL_UNREACHABLE,
+    `Unhandled ${t}: ${String(e)}`
+  );
+}
+var m = /* @__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.UNKNOWN_PHASE = "UNKNOWN_PHASE", e.CIRCULAR_PHASE_DEPENDENCY = "CIRCULAR_PHASE_DEPENDENCY", 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.INVALID_EVENT_ID = "INVALID_EVENT_ID", 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.QUERY_TERM_DENSE_PATH = "QUERY_TERM_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.ROW_TICKS_NOT_TRACKED = "ROW_TICKS_NOT_TRACKED", 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.ARCHETYPE_ROW_INVARIANT = "ARCHETYPE_ROW_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.INVALID_SYSTEM_ID = "INVALID_SYSTEM_ID", e.PARTITION_APPEND_NEEDS_ENTITY_ROW = "PARTITION_APPEND_NEEDS_ENTITY_ROW", e.PARTITION_BULK_INTO_DISABLED = "PARTITION_BULK_INTO_DISABLED", e.STRUCTURAL_DURING_ITERATION = "STRUCTURAL_DURING_ITERATION", e.BACKEND_ALREADY_ATTACHED = "BACKEND_ALREADY_ATTACHED", e.DETERMINISM_DISABLED = "DETERMINISM_DISABLED", e.SNAPSHOT_RESTORE_FAILED = "SNAPSHOT_RESTORE_FAILED", 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.INVALID_TEMPLATE = "INVALID_TEMPLATE", e.PLUGIN_NOT_INSTALLED = "PLUGIN_NOT_INSTALLED", e.PLUGIN_ALREADY_INSTALLED = "PLUGIN_ALREADY_INSTALLED", e.PLUGIN_SURFACE_COLLISION = "PLUGIN_SURFACE_COLLISION", e.WORKERS_ATTACHED = "WORKERS_ATTACHED", e.WORKERS_NEED_SHARED_BACKING = "WORKERS_NEED_SHARED_BACKING", e.WORKERS_HOST_CANNOT_PARK = "WORKERS_HOST_CANNOT_PARK", e.WORKERS_COUNT_INVALID = "WORKERS_COUNT_INVALID", e.WORKERS_ENTRY_UNREACHABLE = "WORKERS_ENTRY_UNREACHABLE", e.PARALLEL_ACCESS = "PARALLEL_ACCESS", e.PARALLEL_KERNEL_MODULE = "PARALLEL_KERNEL_MODULE", e.PARALLEL_KERNEL_FAILED = "PARALLEL_KERNEL_FAILED", e))(m || {});
+class E extends we {
+  constructor(t, n, o) {
+    super(n ?? t, !0, o), this.category = t, this.name = "ECSError";
+  }
+}
+function tn(e) {
+  return e instanceof E;
+}
+class nn extends E {
+  constructor(t) {
+    super("SNAPSHOT_RESTORE_FAILED", t), this.name = "ECSRestoreError";
+  }
+}
+const on = -1, sn = -1, rn = Object.freeze(/* @__PURE__ */ Object.create(null)), an = 2654435769, cn = 1367130551, Xe = 1024, dn = 0, Ke = 31, _n = 1 / 60, ln = 4, un = 0, F = 20, Le = (1 << F) - 1, ze = Le, je = Ke - F, oe = (1 << je) - 1, En = oe, mn = oe - 1, fn = oe << F | ze, An = (e, t) => t << F | e, de = (e) => e & Le, _e = (e) => e >> F, In = (e, t, n) => new E(
+  m.ENTITY_NOT_ALIVE,
+  `${e}: entity ${t} (index ${de(t)}, generation ${_e(
+    t
+  )}) is not alive${n ? `, ${n}` : ""}. It was destroyed, never created, or the handle is stale. Guard with isAlive() first`,
+  { entity: t, index: de(t), generation: _e(t), op: e }
+), se = /* @__PURE__ */ new WeakMap();
+function Tn(e, t) {
+  se.set(e, t);
+}
+function pn(e) {
+  return se.get(e);
+}
+function Qe(e) {
+  const t = se.get(e);
+  return t !== void 0 ? `'${t}' (component ${e.id})` : `component ${e.id}`;
+}
+const qe = 827148627, Je = 1, Re = 4, Ze = 52, g = {
+  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
+}, V = 12, C = {
+  region_id: 0,
+  byte_offset: 4,
+  byte_length: 8
+}, Ce = 16, x = {
+  component_id: 0,
+  field_id: 2,
+  type_tag: 4,
+  byte_off: 8,
+  stride: 12
+}, Pe = 40, P = {
+  archetype_id: 0,
+  component_mask: 4,
+  row_count: 20,
+  row_capacity: 24,
+  column_count: 28,
+  enabled_count: 32,
+  entity_ids_off: 36
+}, A = {
+  u8: 0,
+  i8: 1,
+  u16: 2,
+  i16: 3,
+  u32: 4,
+  i32: 5,
+  f32: 6,
+  f64: 7
+}, le = Object.freeze({
+  [A.u8]: 1,
+  [A.i8]: 1,
+  [A.u16]: 2,
+  [A.i16]: 2,
+  [A.u32]: 4,
+  [A.i32]: 4,
+  [A.f32]: 4,
+  [A.f64]: 8
+}), hn = {
+  u8: A.u8,
+  i8: A.i8,
+  u16: A.u16,
+  i16: A.i16,
+  u32: A.u32,
+  i32: A.i32,
+  f32: A.f32,
+  f64: A.f64
+};
+function et(e, t, n) {
+  e.setUint16(t + x.component_id, n.componentId, !0), e.setUint16(t + x.field_id, n.fieldId, !0), e.setUint8(t + x.type_tag, n.typeTag), e.setUint32(t + x.byte_off, n.byteOff, !0), e.setUint16(t + x.stride, n.stride, !0);
+}
+const gn = Re * 32;
+function Me(e, t = Pe) {
+  return t + e * Ce;
+}
+function tt(e, t, n) {
+  e.setUint32(t + P.archetype_id, n.archetypeId, !0);
+  for (let s = 0; s < Re; s++)
+    e.setUint32(
+      t + P.component_mask + s * 4,
+      n.componentMask[s] ?? 0,
+      !0
+    );
+  e.setUint32(t + P.row_count, n.rowCount, !0), e.setUint32(t + P.row_capacity, n.rowCapacity, !0), e.setUint32(t + P.column_count, n.columns.length, !0), e.setUint32(t + P.enabled_count, n.enabledCount, !0), e.setUint32(t + P.entity_ids_off, 0, !0);
+  let o = t + Pe;
+  for (let s = 0; s < n.columns.length; s++)
+    et(e, o, n.columns[s]), o += Ce;
+  return o;
+}
+function nt(e, t, n) {
+  let o = t;
+  for (let s = 0; s < n.length; s++)
+    o = tt(e, o, n[s]);
+  return o;
+}
+function ot(e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++)
+    t += Me(e[n].columns.length);
+  return t;
+}
+function st(e, t) {
+  e.setUint32(g.magic, t.magic, !0), e.setUint32(g.sim_abi_version, t.simAbiVersion, !0), e.setUint32(g.view_stamp, t.viewStamp, !0), e.setUint32(g.capacity, t.capacity, !0), e.setUint32(g.archetype_count, t.archetypeCount, !0), e.setUint32(g.layout_descriptor_off, t.layoutDescriptorOff, !0), e.setUint32(g.command_ring_off, t.commandRingOff, !0), e.setUint32(g.action_ring_off, t.actionRingOff, !0), e.setUint32(g.entity_index_off, t.entityIndexOff, !0), e.setUint32(g.event_ring_off, t.eventRingOff, !0), e.setUint32(g.region_table_off, t.regionTableOff, !0), e.setUint32(g.region_table_count, t.regionTableCount, !0), e.setUint32(g.bindings_off, t.bindingsOff, !0);
+}
+const Ue = 16, U = 16, Nn = 256, O = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+}, re = 0;
+function ue(e) {
+  return Ue + e * U;
+}
+function rt(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class b extends Error {
+  constructor(t) {
+    super(t), this.name = "CommandRingError";
+  }
+}
+function it(e, t, n) {
+  if (!rt(n))
+    throw new b(
+      `command ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  e.setUint32(t + O.write_head, 0, !0), e.setUint32(t + O.read_head, 0, !0), e.setUint32(t + O.capacity_slots, n, !0), e.setUint32(t + O.overflow_flag, 0, !0);
+}
+function at(e, t) {
+  return e.getUint32(t + O.write_head, !0);
+}
+function ct(e, t) {
+  return e.getUint32(t + O.read_head, !0);
+}
+function dt(e, t) {
+  return e.getUint32(t + O.capacity_slots, !0);
+}
+function _t(e, t, n) {
+  if (n.byteLength !== U - 1)
+    throw new b(
+      `outPayload must be ${U - 1} bytes (got ${n.byteLength})`
+    );
+  const o = at(e, t), s = ct(e, t);
+  if (o === s) return re;
+  const i = dt(e, t), _ = s & i - 1, d = t + Ue + _ * U, c = e.getUint8(d), l = new Uint8Array(
+    e.buffer,
+    e.byteOffset + d + 1,
+    U - 1
+  );
+  return n.set(l), e.setUint32(t + O.read_head, s + 1 >>> 0, !0), c;
+}
+function lt(e, t, n) {
+  let o = 0;
+  const s = new Uint8Array(U - 1);
+  for (; ; ) {
+    const i = _t(e, t, s);
+    if (i === re) return o;
+    n(i, s.slice()), o++;
+  }
+}
+const z = 16, R = 12, k = {
+  length: 0,
+  capacity: 4
+  // 8..16: pad to 16-byte alignment so the i32 arrays start aligned.
+}, Ee = 1 << 20;
+function me(e) {
+  if (e < 0 || !Number.isInteger(e))
+    throw new ve(
+      `entity index capacity must be a non-negative integer (got ${e})`
+    );
+  return z + e * R;
+}
+function ut(e) {
+  return e + z;
+}
+function Et(e, t) {
+  return e + z + t * 4;
+}
+function mt(e, t) {
+  return e + z + t * 8;
+}
+class ve extends Error {
+  constructor(t) {
+    super(t), this.name = "EntityIndexError";
+  }
+}
+function ft(e, t, n) {
+  if (n < 0 || !Number.isInteger(n))
+    throw new ve(
+      `entity index capacity must be a non-negative integer (got ${n})`
+    );
+  e.setUint32(t + k.length, 0, !0), e.setUint32(t + k.capacity, n, !0);
+}
+function yn(e, t, n) {
+  return {
+    generations: new Int32Array(e, ut(t), n),
+    archetypes: new Int32Array(e, Et(t, n), n),
+    rows: new Int32Array(e, mt(t, n), n)
+  };
+}
+const At = 16, It = 16, Sn = 256, v = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+};
+function fe(e) {
+  return At + e * It;
+}
+function Tt(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class pt extends Error {
+  constructor(t) {
+    super(t), this.name = "EventRingError";
+  }
+}
+function ht(e, t, n) {
+  if (!Tt(n))
+    throw new pt(
+      `event ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  e.setUint32(t + v.write_head, 0, !0), e.setUint32(t + v.read_head, 0, !0), e.setUint32(t + v.capacity_slots, n, !0), e.setUint32(t + v.overflow_flag, 0, !0);
+}
+const gt = 16, Nt = 16, Dn = 256, $ = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+}, yt = $.write_head / 4, St = $.read_head / 4, Dt = $.capacity_slots / 4, Ot = $.overflow_flag / 4;
+function wt(e, t) {
+  return new Int32Array(e.buffer, e.byteOffset + t, 4);
+}
+function Ae(e) {
+  return gt + e * Nt;
+}
+function bt(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class Ie extends Error {
+  constructor(t) {
+    super(t), this.name = "ActionRingError";
+  }
+}
+function Lt(e, t, n) {
+  if (!bt(n))
+    throw new Ie(
+      `action ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  if ((e.byteOffset + t) % 4 !== 0)
+    throw new Ie(
+      `action ring header must be 4-byte aligned for Atomics (view.byteOffset ${e.byteOffset} + ringOff ${t} is not a multiple of 4)`
+    );
+  const o = wt(e, t);
+  Atomics.store(o, yt, 0), Atomics.store(o, St, 0), Atomics.store(o, Dt, n), Atomics.store(o, Ot, 0);
+}
+const H = [
+  {
+    name: "command_ring",
+    headerOff: "command_ring_off",
+    sizeFromOptions: (e) => e.commandRingCapacitySlots !== void 0 ? ue(e.commandRingCapacitySlots) : 0,
+    init: (e, t, n) => it(e, t, n.commandRingCapacitySlots),
+    regionBytes: (e, t) => ue(e.getUint32(t + O.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.commandRingCapacitySlots = e.getUint32(
+        t + O.capacity_slots,
+        !0
+      );
+    }
+  },
+  {
+    name: "entity_index",
+    headerOff: "entity_index_off",
+    sizeFromOptions: (e) => e.entityIndexCapacity !== void 0 ? me(e.entityIndexCapacity) : 0,
+    init: (e, t, n) => ft(e, t, n.entityIndexCapacity),
+    regionBytes: (e, t) => me(e.getUint32(t + k.capacity, !0)),
+    readOptions: (e, t, n) => {
+      n.entityIndexCapacity = e.getUint32(t + k.capacity, !0);
+    }
+  },
+  {
+    name: "event_ring",
+    headerOff: "event_ring_off",
+    sizeFromOptions: (e) => e.eventRingCapacitySlots !== void 0 ? fe(e.eventRingCapacitySlots) : 0,
+    init: (e, t, n) => ht(e, t, n.eventRingCapacitySlots),
+    regionBytes: (e, t) => fe(e.getUint32(t + v.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.eventRingCapacitySlots = e.getUint32(
+        t + v.capacity_slots,
+        !0
+      );
+    }
+  },
+  {
+    name: "action_ring",
+    headerOff: "action_ring_off",
+    sizeFromOptions: (e) => e.actionRingCapacitySlots !== void 0 ? Ae(e.actionRingCapacitySlots) : 0,
+    init: (e, t, n) => Lt(e, t, n.actionRingCapacitySlots),
+    regionBytes: (e, t) => Ae(e.getUint32(t + $.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.actionRingCapacitySlots = e.getUint32(
+        t + $.capacity_slots,
+        !0
+      );
+    }
+  }
+];
+class G extends Error {
+  constructor(t) {
+    super(t), this.name = "RegionRegistryError";
+  }
+}
+function Be(e) {
+  return e * V;
+}
+function ie(e, t) {
+  const n = e.getUint32(g.region_table_count, !0);
+  if (t + Be(n) > e.byteLength)
+    throw new G(
+      `region table of ${n} entries at byte ${t} overruns the buffer (${e.byteLength} bytes)`
+    );
+  return n;
+}
+function Rt(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (let n = 0; n < e.length; n++) {
+    const o = e[n];
+    if (!Number.isInteger(o.id) || o.id <= 0)
+      throw new G(
+        `region "${o.name}" has invalid id ${o.id}, region ids must be positive integers (0 is the absent sentinel)`
+      );
+    if (t.has(o.id))
+      throw new G(
+        `duplicate region id ${o.id} (region "${o.name}"), ids must be distinct within a consumer's region set`
+      );
+    if (t.add(o.id), !Number.isInteger(o.bytes) || o.bytes <= 0)
+      throw new G(
+        `region "${o.name}" (id ${o.id}) has invalid byte size ${o.bytes}, must be a positive integer`
+      );
+  }
+}
+function Ct(e, t, n) {
+  e.setUint32(t + C.region_id, n.regionId, !0), e.setUint32(t + C.byte_offset, n.byteOffset, !0), e.setUint32(t + C.byte_length, n.byteLength, !0);
+}
+function $e(e, t) {
+  return {
+    regionId: e.getUint32(t + C.region_id, !0),
+    byteOffset: e.getUint32(t + C.byte_offset, !0),
+    byteLength: e.getUint32(t + C.byte_length, !0)
+  };
+}
+function Pt(e, t, n) {
+  for (let o = 0; o < n.length; o++)
+    Ct(e, t + o * V, n[o]);
+}
+function Mt(e, t, n) {
+  const o = new Array(n);
+  for (let s = 0; s < n; s++)
+    o[s] = $e(e, t + s * V);
+  return o;
+}
+function On(e) {
+  const t = e.getUint32(g.region_table_off, !0);
+  if (t === 0) return [];
+  const n = ie(e, t);
+  return Mt(e, t, n);
+}
+function wn(e, t) {
+  const n = e.getUint32(g.region_table_off, !0);
+  if (n === 0) return 0;
+  const o = ie(e, n);
+  for (let s = 0; s < o; s++) {
+    const i = n + s * V;
+    if (e.getUint32(i + C.region_id, !0) === t)
+      return e.getUint32(i + C.byte_offset, !0);
+  }
+  return 0;
+}
+function bn(e, t) {
+  const n = e.getUint32(g.region_table_off, !0);
+  if (n === 0) return null;
+  const o = ie(e, n);
+  for (let s = 0; s < o; s++) {
+    const i = $e(e, n + s * V);
+    if (i.regionId === t) return i;
+  }
+  return null;
+}
+function Ut(e, t) {
+  return e << 16 | t;
+}
+const ae = 2 ** 31;
+class Ye extends Error {
+  constructor(t) {
+    super(
+      `SAB column layout offset ${t} reaches or exceeds the 2³¹ (${ae}-byte) ceiling. Past 2 GiB the signed-32-bit bitwise alignment math wraps to a negative or misaligned offset. This is a structural limit independent of the allocator cap, so a single store cannot back more than 2 GiB of column data.`
+    ), this.name = "StoreLayoutOverflowError";
+  }
+}
+function xe(e, t) {
+  if (e + t > ae)
+    throw new Ye(e);
+  return e + (t - 1) & ~(t - 1);
+}
+function vt(e, t, n, o, s) {
+  const i = t + o;
+  switch (n) {
+    case A.u8:
+      return new Uint8Array(e, i, s);
+    case A.i8:
+      return new Int8Array(e, i, s);
+    case A.u16:
+      return new Uint16Array(e, i, s);
+    case A.i16:
+      return new Int16Array(e, i, s);
+    case A.u32:
+      return new Uint32Array(e, i, s);
+    case A.i32:
+      return new Int32Array(e, i, s);
+    case A.f32:
+      return new Float32Array(e, i, s);
+    case A.f64:
+      return new Float64Array(e, i, s);
+  }
+}
+function Bt(e, t, n = 0) {
+  const s = ot(
+    e.map((d) => ({
+      archetypeId: d.archetypeId,
+      componentMask: d.componentMask,
+      rowCount: 0,
+      enabledCount: 0,
+      rowCapacity: d.rowCapacity,
+      columns: d.columns.map((c) => ({
+        componentId: c.componentId,
+        fieldId: c.fieldId,
+        typeTag: c.typeTag,
+        byteOff: 0,
+        stride: le[c.typeTag]
+      }))
+    }))
+  ) + n;
+  let i = t + s;
+  const _ = new Array(e.length);
+  for (let d = 0; d < e.length; d++) {
+    const c = e[d], l = new Array(c.columns.length);
+    for (let f = 0; f < c.columns.length; f++) {
+      const p = c.columns[f], T = le[p.typeTag];
+      i = xe(i, T), l[f] = {
+        componentId: p.componentId,
+        fieldId: p.fieldId,
+        typeTag: p.typeTag,
+        byteOff: i,
+        stride: T
+      }, i += T * c.rowCapacity;
+    }
+    _[d] = {
+      archetypeId: c.archetypeId,
+      componentMask: c.componentMask,
+      rowCount: 0,
+      enabledCount: 0,
+      rowCapacity: c.rowCapacity,
+      columns: l
+    };
+  }
+  if (i > ae)
+    throw new Ye(i);
+  return { descriptors: _, totalBytes: i, regionBytes: s };
+}
+const W = 16;
+function $t(e) {
+  if (!Number.isInteger(e) || e < 0)
+    throw new RangeError(`createColumnStore: storeBase must be an integer >= 0, got ${e}`);
+  if (e % W !== 0)
+    throw new RangeError(
+      `createColumnStore: storeBase must be a multiple of ${W}, got ${e}`
+    );
+}
+function Yt(e) {
+  let t = 0;
+  for (const [, n] of e) t += Me(n.columnsInOrder.length);
+  return t;
+}
+function Ln(e) {
+  const t = e;
+  return typeof t._regionBytes == "number" && typeof t._allocator == "function" && typeof t._reservedDescriptorBytes == "number";
+}
+function Rn(e, t = Ve, n = {}) {
+  const o = n.storeBase ?? 0;
+  $t(o);
+  const s = {};
+  let i = Ze;
+  for (let h = 0; h < H.length; h++) {
+    const w = H[h], Y = w.sizeFromOptions(n);
+    s[w.headerOff] = Y === 0 ? 0 : i, i += Y;
+  }
+  const _ = n.regions ?? [];
+  Rt(_);
+  const d = _.length, c = d > 0 ? i : 0;
+  i += Be(d);
+  const l = new Array(d);
+  for (let h = 0; h < _.length; h++) {
+    const w = _[h];
+    l[h] = { regionId: w.id, byteOffset: i, byteLength: w.bytes }, i += w.bytes;
+  }
+  const f = n.bindingsRegionBytes ?? 0, p = f === 0 ? 0 : i;
+  i += f;
+  const T = i, { descriptors: S, totalBytes: N, regionBytes: a } = Bt(
+    e,
+    T,
+    n.reservedDescriptorBytes ?? 0
+  ), r = t(o + N), u = new DataView(r, o), D = {
+    magic: qe,
+    simAbiVersion: Je,
+    viewStamp: 0,
+    capacity: N,
+    archetypeCount: e.length,
+    layoutDescriptorOff: T,
+    bindingsOff: p,
+    regionTableOff: c,
+    regionTableCount: d,
+    // `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: s.command_ring_off,
+    entityIndexOff: s.entity_index_off,
+    eventRingOff: s.event_ring_off,
+    actionRingOff: s.action_ring_off
+  };
+  st(u, D), f > 0 && new Uint8Array(r, o + p, f).fill(0);
+  for (let h = 0; h < H.length; h++) {
+    const w = H[h], Y = s[w.headerOff];
+    Y !== 0 && w.init(u, Y, n);
+  }
+  c !== 0 && Pt(u, c, l);
+  for (let h = 0; h < _.length; h++)
+    _[h].init(u, l[h].byteOffset);
+  nt(u, T, S);
+  const y = xt(r, o, S);
+  return {
+    buffer: r,
+    view: u,
+    header: D,
+    storeBase: o,
+    archetypes: y,
+    _regionBytes: a,
+    _allocator: t,
+    // Carry the headroom policy with the store so the realloc slow path
+    // (`optionsFromOld`) can re-reserve the same margin.
+    _reservedDescriptorBytes: n.reservedDescriptorBytes ?? 0,
+    _usedDescriptorBytes: Yt(y)
+  };
+}
+function xt(e, t, n) {
+  const o = /* @__PURE__ */ new Map();
+  for (let s = 0; s < n.length; s++) {
+    const i = n[s], _ = new Array(i.columns.length), d = /* @__PURE__ */ new Map();
+    for (let c = 0; c < i.columns.length; c++) {
+      const l = i.columns[c], f = {
+        componentId: l.componentId,
+        fieldId: l.fieldId,
+        typeTag: l.typeTag,
+        byteOff: l.byteOff,
+        stride: l.stride,
+        view: vt(e, t, l.typeTag, l.byteOff, i.rowCapacity)
+      };
+      _[c] = f, d.set(Ut(l.componentId, l.fieldId), f);
+    }
+    o.set(i.archetypeId, {
+      archetypeId: i.archetypeId,
+      componentMask: i.componentMask,
+      rowCapacity: i.rowCapacity,
+      columns: d,
+      columnsInOrder: _
+    });
+  }
+  return o;
+}
+const Te = 2147483647, pe = /* @__PURE__ */ new WeakMap();
+function Ft(e) {
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set();
+  for (let a = 0; a < e.writes.length; a++) {
+    const r = e.writes[a].id;
+    n.add(r), t.add(r), o.add(r);
+  }
+  for (let a = 0; a < e.reads.length; a++)
+    t.add(e.reads[a].id);
+  for (let a = 0; a < e.spawns.length; a++) {
+    const r = e.spawns[a];
+    for (let u = 0; u < r.length; u++)
+      o.add(r[u].id);
+  }
+  for (let a = 0; a < e.transitions.length; a++) {
+    const r = e.transitions[a];
+    if (r.add)
+      for (let u = 0; u < r.add.length; u++)
+        o.add(r.add[u].id);
+    if (r.remove)
+      for (let u = 0; u < r.remove.length; u++)
+        s.add(r.remove[u].id);
+  }
+  for (let a = 0; a < e.despawns.length; a++)
+    s.add(e.despawns[a].id);
+  for (let a = 0; a < e.resourceReads.length; a++)
+    i.add(e.resourceReads[a]);
+  for (let a = 0; a < e.resourceWrites.length; a++) {
+    const r = e.resourceWrites[a];
+    _.add(r), i.add(r);
+  }
+  const p = e.sparseWrites;
+  if (p !== void 0)
+    for (let a = 0; a < p.length; a++) {
+      const r = p[a];
+      c.add(r), d.add(r);
+    }
+  const T = e.sparseReads;
+  if (T !== void 0)
+    for (let a = 0; a < T.length; a++) d.add(T[a]);
+  const S = e.relationWrites;
+  if (S !== void 0)
+    for (let a = 0; a < S.length; a++) {
+      const r = S[a];
+      f.add(r), l.add(r);
+    }
+  const N = e.relationReads;
+  if (N !== void 0)
+    for (let a = 0; a < N.length; a++) l.add(N[a]);
+  return {
+    reads: t,
+    writes: n,
+    addAllowed: o,
+    removeAllowed: s,
+    hasDespawns: e.despawns.length > 0,
+    resourceReads: i,
+    resourceWrites: _,
+    sparseReads: d,
+    sparseWrites: c,
+    relationReads: l,
+    relationWrites: f
+  };
+}
+function Vt(e) {
+  const t = pe.get(e);
+  if (t !== void 0) return t;
+  const n = Ft(e);
+  return pe.set(e, n), n;
+}
+const he = /* @__PURE__ */ new WeakMap();
+function Ht(e) {
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+  if (e.reads !== void 0)
+    for (let o = 0; o < e.reads.length; o++) t.add(e.reads[o].id);
+  if (e.resourceReads !== void 0)
+    for (let o = 0; o < e.resourceReads.length; o++)
+      n.add(e.resourceReads[o]);
+  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 Gt(e) {
+  const t = he.get(e);
+  if (t !== void 0) return t;
+  const n = Ht(e);
+  return he.set(e, n), n;
+}
+class kt {
+  _activeSystem = null;
+  _activeSets = null;
+  // The label used in violation messages. Tracks `_activeSystem` for a system span,
+  // but a run-condition span has no descriptor, only this name, so the
+  // failure helpers read the label here rather than off `_activeSystem`.
+  _activeName = null;
+  // An `_exclusive` system has full world access: every check_* below
+  // passes for the whole span. Kept as an explicit flag (rather than leaving
+  // `_activeSets` null) so `isActive()` stays truthful inside the span.
+  _exclusive = !1;
+  enter(t) {
+    this._activeSystem = t, this._activeName = t.name ?? `system_${t.id}`, this._exclusive = t.exclusive === !0, this._activeSets = this._exclusive ? null : Vt(t);
+  }
+  /** Open a reads-only span for a run condition. No descriptor, a
+   * condition can gate a whole SystemSet, so it isn't attributable to one
+   * system, only its declared `reads` and `resourceReads` and a name for diagnostics.
+   * Paired with `leave()`. */
+  enterCondition(t) {
+    this._activeSystem = null, this._activeName = t.name, this._activeSets = Gt(t);
+  }
+  leave() {
+    this._activeSystem = null, this._activeName = null, this._activeSets = null, this._exclusive = !1;
+  }
+  isActive() {
+    return this._activeSets !== null || this._exclusive;
+  }
+  /** Current system descriptor, if any. Null during a run-condition span. */
+  current() {
+    return this._activeSystem;
+  }
+  assertRead(t) {
+    this._activeSets !== null && (this._activeSets.reads.has(t.id) || this._failComponent("read", t, "reads"));
+  }
+  assertWrite(t) {
+    this._activeSets !== null && (this._activeSets.writes.has(t.id) || this._failComponent("write", t, "writes"));
+  }
+  assertAdd(t) {
+    this._activeSets !== null && (this._activeSets.addAllowed.has(t.id) || this._failComponent("addComponent", t, "spawns, transitions.add or writes"));
+  }
+  assertRemove(t) {
+    this._activeSets !== null && (this._activeSets.removeAllowed.has(t.id) || this._failComponent("removeComponent", t, "despawns or transitions.remove"));
+  }
+  assertDespawn() {
+    if (this._activeSets === null || this._activeSets.hasDespawns) return;
+    const t = this._activeName;
+    throw new E(
+      m.ACCESS_UNDECLARED,
+      `system '${t}' called despawn but did not declare any despawns. Name the components it removes in 'despawns'`,
+      { system: t, op: "despawn" }
+    );
+  }
+  assertResourceRead(t) {
+    if (this._activeSets === null) return;
+    const n = t;
+    this._activeSets.resourceReads.has(n) || this._failResource("read", t, "resourceReads");
+  }
+  assertResourceWrite(t) {
+    if (this._activeSets === null) return;
+    const n = t;
+    this._activeSets.resourceWrites.has(n) || this._failResource("write", t, "resourceWrites");
+  }
+  // --- Sparse component and relation checks ---
+  // Keyed against the dedicated sparse and relation sets, not the dense
+  // `reads` and `writes` sets, the id spaces are disjoint by construction (see
+  // file header). `def as unknown as number` recovers the SparseComponentID or
+  // the RelationID the branded handle erases to at runtime.
+  assertSparseRead(t) {
+    if (this._activeSets === null) return;
+    const n = t;
+    this._activeSets.sparseReads.has(n) || this._failSparse("read", n, "sparseReads");
+  }
+  assertSparseWrite(t) {
+    if (this._activeSets === null) return;
+    const n = t;
+    this._activeSets.sparseWrites.has(n) || this._failSparse("write", n, "sparseWrites");
+  }
+  assertRelationRead(t) {
+    if (this._activeSets === null) return;
+    const n = t;
+    this._activeSets.relationReads.has(n) || this._failRelation("read", n, "relationReads");
+  }
+  assertRelationWrite(t) {
+    if (this._activeSets === null) return;
+    const n = t;
+    this._activeSets.relationWrites.has(n) || this._failRelation("write", n, "relationWrites");
+  }
+  /** A `(*, T)` wildcard (`Query.forEachRelatedTo`) 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, only keyed on the reserved sentinel id
+   * (which computeSets folds into `relationReads` like any other entry). */
+  assertRelationReadAny() {
+    this._activeSets !== null && (this._activeSets.relationReads.has(Te) || this._failRelation(
+      "(*, T) wildcard read",
+      Te,
+      "relationReads (as ANY_RELATION)"
+    ));
+  }
+  // --- Optional query-term scope ---
+  // The dense iterators of `Query` and `ChangedQuery` push the iterating
+  // query's `terms.optionalTerms` 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 a re-entrant or
+  // nested `forEach`. The optional scope is independent of the per-system
+  // `enter` and `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: 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();
+  }
+  assertOptionalFetch(t) {
+    const n = this._optionalScopes.length;
+    if (n === 0) return;
+    const o = this._optionalScopes[n - 1], s = t.id;
+    for (let i = 0; i < o.length; i++)
+      if (o[i] === s) return;
+    throw new E(
+      m.OPTIONAL_TERM_NOT_DECLARED,
+      `getOptionalColumnRead fetched optional component ${s} but the iterating query did not declare it. Add .optional(component) to the query before the fetch`
+    );
+  }
+  _failComponent(t, n, o) {
+    const s = this._activeName, i = Qe(n);
+    throw new E(
+      m.ACCESS_UNDECLARED,
+      `system '${s}' performed ${t} on ${i} but did not declare it. Add it to '${o}'`,
+      { system: s, op: t, component: n.id }
+    );
+  }
+  _failSparse(t, n, o) {
+    const s = this._activeName;
+    throw new E(
+      m.ACCESS_UNDECLARED,
+      `system '${s}' performed ${t} on sparse component ${n} but did not declare it. Add it to '${o}'`,
+      { system: s, op: t, sparse: n }
+    );
+  }
+  _failRelation(t, n, o) {
+    const s = this._activeName;
+    throw new E(
+      m.ACCESS_UNDECLARED,
+      `system '${s}' performed ${t} on relation ${n} but did not declare it. Add it to '${o}'`,
+      { system: s, op: t, relation: n }
+    );
+  }
+  _failResource(t, n, o) {
+    const s = this._activeName, i = n.description ?? "<unnamed>";
+    throw new E(
+      m.ACCESS_UNDECLARED,
+      `system '${s}' performed resource ${t} on '${i}' but did not declare it. Add the resource key to '${o}'`,
+      { system: s, op: t, resource: i }
+    );
+  }
+}
+const Cn = new kt();
+function Pn(e, t) {
+  return new E(
+    m.PLUGIN_NOT_INSTALLED,
+    `${t} needs the ${e} plugin, which this world did not install. Pass it at construction: ECS.create({ plugins: [${e}()] }), imported from @oasys/oecs/${e}`,
+    { plugin: e }
+  );
+}
+function Mn(e) {
+  return new E(
+    m.PLUGIN_ALREADY_INSTALLED,
+    `${e} is already installed on this world. Pass each plugin once to ECS.create`,
+    { plugin: e }
+  );
+}
+var Z = /* @__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))(Z || {});
+function ge(e) {
+  if (typeof e != "string") return e.loop;
+  switch (e) {
+    case "PRE_STARTUP":
+    case "STARTUP":
+    case "POST_STARTUP":
+      return "startup";
+    case "FIXED_UPDATE":
+      return "fixed";
+    case "PRE_UPDATE":
+    case "UPDATE":
+    case "POST_UPDATE":
+      return "update";
+  }
+}
+function Ne(e) {
+  return typeof e == "string" ? e : e.name;
+}
+const X = 1024, K = 1024 * X, B = 64 * X, ee = B;
+function Un(e, t = 0) {
+  if (!Number.isFinite(t) || t < 0)
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `storeBaseAbove: extraBytes must be a finite number >= 0, got ${String(t)}`
+    );
+  const n = e?.__heap_base, o = typeof n == "object" && n !== null && "value" in n ? n.value : n;
+  if (typeof o != "number" || !Number.isFinite(o))
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `storeBaseAbove: the module exports no numeric '__heap_base', got ${String(o)}. Link with --export=__heap_base, or pass memory.storeBase by hand.`
+    );
+  const s = Math.ceil((o + t) / B) * B;
+  return Math.max(ee, s);
+}
+const q = 256 * K, ye = 3, Wt = 64, Xt = 8, Se = 4 * K, De = (e) => 2 ** Math.ceil(Math.log2(Math.max(1, e))), Kt = (e) => 2 ** Math.floor(Math.log2(Math.max(1, e))), J = (e, t, n) => Math.min(n, Math.max(t, e)), I = (e) => e >= K ? `${(e / K).toFixed(1)} MiB` : e >= X ? `${(e / X).toFixed(0)} KiB` : `${e} B`;
+function zt(e, t) {
+  if (e === void 0) return t ? ee : 0;
+  if (!Number.isInteger(e) || e < 0)
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `memory.storeBase must be an integer >= 0, got ${e}`
+    );
+  if (e % W !== 0)
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `memory.storeBase must be a multiple of ${W}, got ${e}. The alignment keeps every column on its element boundary.`
+    );
+  if (t && e === 0)
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `memory.storeBase is 0, and a header at address 0 is unreadable from a safe build of a WASM module. Pass a storeBase of at least one page (${ee}), above the module's own data.`
+    );
+  return e;
+}
+function M(e, t) {
+  if (!Number.isInteger(t) || t <= 0)
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `memory.${e} must be a positive integer (got ${t})`
+    );
+}
+const Oe = {
+  budget: "{ budget: { entities: N } } → { entities: N }",
+  heap: '{ heap: { maxBytes: X } } → { maxBytes: X, backing: "heap" }',
+  shared: '{ shared: { maxBytes: X } } → { maxBytes: X, backing: "shared" }',
+  wasm: "{ wasm: W } → { backing: { wasm: W } }",
+  allocator: "{ allocator: A } → { backing: { allocator: A } }",
+  capBytesHint: "{ capBytesHint: X } → { maxBytes: X }"
+};
+function jt(e) {
+  const t = Object.prototype.hasOwnProperty, n = Object.keys(Oe).filter((o) => t.call(e, o));
+  if (n.length !== 0)
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `${n.map((o) => `memory.${o}`).join(" and ")} ${n.length > 1 ? "were" : "was"} removed in 0.6. Sizing and backing are now two independent fields, so every combination of them is expressible. Rewrite as: ` + n.map((o) => Oe[o]).join(". ")
+    );
+}
+function vn(e) {
+  e !== void 0 && jt(e);
+  const t = e?.entities, n = e?.maxBytes, o = e?.columnCapacity, s = e?.backing ?? "heap", i = typeof s == "object" && s.wasm !== void 0, _ = zt(e?.storeBase, i);
+  if (o !== void 0 && M("columnCapacity", o), n !== void 0 && M("maxBytes", n), t === void 0) {
+    for (const r of ["archetypes", "bytesPerEntity"])
+      if (e?.[r] !== void 0)
+        throw new E(
+          m.INVALID_MEMORY_OPTIONS,
+          `memory.${r} shapes the sizing derived from memory.entities, which was not given. Add memory.entities, or drop memory.${r}.`
+        );
+  }
+  let d, c, l = null;
+  const f = [];
+  if (t !== void 0) {
+    const r = e?.archetypes ?? Xt, u = e?.bytesPerEntity ?? Wt;
+    if (M("entities", t), M("archetypes", r), M("bytesPerEntity", u), t > 1 << 20)
+      throw new E(
+        m.INVALID_MEMORY_OPTIONS,
+        `memory.entities=${t} exceeds the EntityID index space (1<<20 = ${1 << 20})`
+      );
+    d = o ?? J(De(Math.ceil(t / r)), 64, 1 << 20), c = J(De(t * 2), 4096, 1 << 20);
+    const D = c * R, y = t * u * ye;
+    l = xe(
+      Math.max(D + y, Se),
+      B
+    ), f.push(
+      `columnCapacity = ${o !== void 0 ? `${d} (pinned)` : `pow2(${t}/${r} per archetype) = ${d}`}`,
+      `entityIndex = pow2(2 × ${t}) = ${c} slots × ${R} B = ${I(D)}`,
+      `columns = ${t} × ${u} B × ${ye} (double+holes headroom) = ${I(y)}`
+    );
+  } else
+    d = o ?? Xe, c = Ee, f.push(
+      `columnCapacity = ${d} (${o !== void 0 ? "pinned" : "default"})`
+    );
+  const p = (r) => J(Kt(r / 4 / R), 4096, Ee), T = t !== void 0 ? n !== void 0 ? "entities+maxBytes" : "entities" : n !== void 0 ? "maxBytes" : "default", S = (r) => n !== void 0 ? `${I(r)} (caller-declared maxBytes; the ${I(l ?? r)} the entity count implies is overridden)` : `align64K(max(index + columns, ${I(Se)} floor)) = ${I(r)}`, N = (r, u, D, y, L) => (t === void 0 && (c = p(r)), {
+    source: u,
+    sizing: T,
+    allocator: D,
+    columnCapacity: d,
+    entityIndexCapacity: c,
+    capBytes: r,
+    storeBase: _,
+    intentLabel: y,
+    budgetEntities: t ?? null,
+    derivation: [
+      ...L,
+      ..._ > 0 ? [`storeBase = ${I(_)}, the store writes nothing below it`] : [],
+      ...f,
+      t === void 0 ? `entityIndex = floor_pow2(cap/4 ÷ ${R} B) = ${c} slots` : `cap = ${S(r)}`
+    ],
+    wasmMemory: null
+  });
+  if (typeof s == "object" && s.wasm !== void 0) {
+    const r = s.wasm;
+    if (r.memory !== void 0) {
+      if (!(r.memory.buffer instanceof SharedArrayBuffer))
+        throw new E(
+          m.INVALID_MEMORY_OPTIONS,
+          "memory.backing.wasm.memory must be constructed with `shared: true`, the SAB substrate requires a SharedArrayBuffer-backed WebAssembly.Memory"
+        );
+      const L = n ?? q;
+      return t === void 0 && (c = p(Math.max(L - _, 0))), {
+        source: "wasm",
+        sizing: T,
+        allocator: ce(r.memory),
+        columnCapacity: d,
+        entityIndexCapacity: c,
+        capBytes: L,
+        storeBase: _,
+        intentLabel: `caller-supplied WebAssembly.Memory (declared cap ${I(L)})`,
+        budgetEntities: t ?? null,
+        derivation: [
+          "backing = wasm_memory_allocator(memory), zero-copy with a WASM compute backend (is_in_place ✓)",
+          n !== void 0 ? `cap = ${I(L)} (caller-declared maxBytes; the Memory's own maximum is not readable from JS)` : `cap = ${I(L)} (default; the Memory's own maximum is not readable from JS)`,
+          `storeBase = ${I(_)}, the module owns every byte below it`,
+          ...f,
+          t === void 0 ? `entityIndex = floor_pow2((cap - storeBase)/4 ÷ ${R} B) = ${c} slots` : "entityIndex sized from the entity count above"
+        ],
+        wasmMemory: r.memory
+      };
+    }
+    M("backing.wasm.maximumPages", r.maximumPages);
+    const u = r.initialPages ?? Math.min(32, r.maximumPages);
+    if (M("backing.wasm.initialPages", u), u > r.maximumPages)
+      throw new E(
+        m.INVALID_MEMORY_OPTIONS,
+        `memory.backing.wasm.initialPages (${u}) exceeds maximumPages (${r.maximumPages})`
+      );
+    if (n !== void 0)
+      throw new E(
+        m.INVALID_MEMORY_OPTIONS,
+        `memory.maxBytes (${I(n)}) cannot be given beside memory.backing.wasm.maximumPages (${r.maximumPages} pages = ${I(r.maximumPages * B)}), the Memory's page maximum IS the ceiling. Declare it once, in pages.`
+      );
+    const D = new WebAssembly.Memory({
+      initial: u,
+      maximum: r.maximumPages,
+      shared: !0
+    }), y = r.maximumPages * B;
+    return t === void 0 && (c = p(Math.max(y - _, 0))), {
+      source: "wasm",
+      sizing: T,
+      allocator: ce(D),
+      columnCapacity: d,
+      entityIndexCapacity: c,
+      capBytes: y,
+      storeBase: _,
+      intentLabel: `engine-constructed WebAssembly.Memory (max ${r.maximumPages} pages)`,
+      budgetEntities: t ?? null,
+      derivation: [
+        `cap = ${r.maximumPages} pages × 64 KiB = ${I(y)} (Memory maximum)`,
+        `initial = ${u} pages (${r.initialPages !== void 0 ? "declared" : "default"})`,
+        `storeBase = ${I(_)}, the module owns every byte below it`,
+        ...f,
+        t === void 0 ? `entityIndex = floor_pow2((cap - storeBase)/4 ÷ ${R} B) = ${c} slots` : "entityIndex sized from the entity count above"
+      ],
+      wasmMemory: D
+    };
+  }
+  if (typeof s == "object" && s.allocator !== void 0) {
+    if (s.allocator.isInPlace !== !0)
+      throw new E(
+        m.INVALID_MEMORY_OPTIONS,
+        "memory.backing.allocator must declare `isInPlace: true`. A live Store's flush loops hoist entity-index views across grows, so an allocator that is not in-place (DEFAULT_SAB_ALLOCATOR, for example) corrupts the entity→row mapping. Use growableSabAllocator, fixedSabAllocator or wasmMemoryAllocator. An allocator that is not in-place is for snapshot and test sizing only."
+      );
+    const r = n ?? null;
+    return t === void 0 && r !== null && (c = p(r)), {
+      source: "allocator",
+      sizing: T,
+      allocator: s.allocator,
+      columnCapacity: d,
+      entityIndexCapacity: c,
+      capBytes: r,
+      storeBase: _,
+      intentLabel: r !== null ? `custom in-place allocator (declared cap ${I(r)})` : "custom in-place allocator",
+      budgetEntities: t ?? null,
+      derivation: [
+        "backing = caller allocator (is_in_place ✓ checked at construction)",
+        r !== null ? `cap = ${I(r)} (caller-declared; the allocator owns the real ceiling)` : "cap = allocator-owned (no maxBytes declared)",
+        ...f,
+        t !== void 0 ? "entityIndex sized from the entity count above" : r !== null ? `entityIndex = floor_pow2(cap/4 ÷ ${R} B) = ${c} slots` : `entityIndex = ${c} slots (default, no entity count and no declared cap)`
+      ],
+      wasmMemory: null
+    };
+  }
+  if (s === "shared") {
+    const r = n ?? l ?? q;
+    return N(
+      r,
+      "shared",
+      He(r),
+      `shared SharedArrayBuffer backing (${I(r)} growable cap, needs COOP and COEP)`,
+      [
+        `backing = growable_sab_allocator(${I(r)}), growable SharedArrayBuffer (is_in_place ✓), needs cross-origin isolation`,
+        "enables worker offload + a WASM compute backend (transferable SharedArrayBuffer)"
+      ]
+    );
+  }
+  if (s !== "heap")
+    throw new E(
+      m.INVALID_MEMORY_OPTIONS,
+      `memory.backing must be "heap", "shared", { wasm }, or { allocator } (got ${JSON.stringify(s)})`
+    );
+  const a = n ?? l ?? q;
+  return N(
+    a,
+    "heap",
+    Ge(a),
+    T === "default" ? `default sizing (${I(a)} reserved cap)` : t !== void 0 ? `budget of ${t} entities` : `explicit cap of ${I(a)}`,
+    [
+      `backing = heap_arraybuffer_allocator(${I(a)}), fixed ArrayBuffer reserved at the cap, no SAB and no COOP+COEP (is_in_place ✓)`,
+      "trade-off: no worker offload and no WASM backend (both need a transferable SharedArrayBuffer)"
+    ]
+  );
+}
+function Bn(e, t) {
+  return { def: e, values: t };
+}
+function te(e, t) {
+  switch (t.kind) {
+    case "spawn": {
+      const n = e.commands.spawn();
+      for (const o of t.components)
+        e.commands.add(n, o.def, o.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 We(t, "HostCommand kind");
+  }
+}
+class Qt {
+  _pending = [];
+  spawn(t, n) {
+    return this._pending.push({ kind: "spawn", components: t, onSpawned: n }), this;
+  }
+  despawn(t) {
+    return this._pending.push({ kind: "despawn", eid: t }), this;
+  }
+  /** Attach `def` (with complete `values`) to `entityId` (deferred to the
+   * drain). The namespaced-handle grammar, the queue is a commands buffer, so
+   * it drops the noun (`add`, not `addComponent`), matching `ctx.commands.add`
+   * and the queue's own bare `spawn`, `despawn`, `disable` and `enable`. Values are
+   * complete (transport carries explicit intent per field, see `spawnEntry`),
+   * unlike the authoring-side bundle sugar. */
+  add(t, n, o) {
+    return this._pending.push({ kind: "add_component", eid: t, def: n, values: o }), this;
+  }
+  /** Detach `def` from `entityId` (deferred to the drain). Bare `remove`
+   * matching `ctx.commands.remove`, see `add`. */
+  remove(t, n) {
+    return this._pending.push({ kind: "remove_component", eid: t, def: n }), this;
+  }
+  /** Set `field` of `def` on `entityId`. Applied immediately at the drain, unlike
+   * the deferred structural ops, so `def` must already be on `entityId`. Do not
+   * `add` and `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
+   * `add` or `spawnEntry` instead). `applyHostCommand` throws an
+   * actionable error in `DEV` if you do. */
+  setField(t, n, o, s) {
+    return this._pending.push({
+      kind: "set_field",
+      eid: t,
+      def: n,
+      field: o,
+      value: s
+    }), this;
+  }
+  disable(t) {
+    return this._pending.push({ kind: "disable", eid: t }), this;
+  }
+  enable(t) {
+    return this._pending.push({ kind: "enable", eid: t }), this;
+  }
+  /** 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) {
+    return this._pending.push(t), this;
+  }
+  /** Commands buffered but not yet applied. */
+  get pendingCount() {
+    return this._pending.length;
+  }
+  /** Drop every buffered command without applying it, 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._pending.length;
+    return this._pending.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 immediately before
+   * it is applied, the record and 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.
+   */
+  drain(t, n) {
+    const o = this._pending.length;
+    if (o === 0) return 0;
+    if (n === void 0)
+      for (let s = 0; s < o; s++) te(t, this._pending[s]);
+    else
+      for (let s = 0; s < o; s++) {
+        const i = this._pending[s];
+        n(i), te(t, i);
+      }
+    return this._pending.splice(0, o), o;
+  }
+}
+const Fe = U - 1;
+function qt(e) {
+  if (e === re)
+    throw new b(
+      "cannot bind opCode 0 (reserved as the command-ring empty-slot marker)"
+    );
+  if (e < 0 || e > 255 || !Number.isInteger(e))
+    throw new b(`command opCode must be a u8 in [1, 255] (got ${e})`);
+}
+function j(e) {
+  const t = new Uint8Array(Fe);
+  return new DataView(t.buffer).setUint32(0, e, !0), t;
+}
+function Q(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength).getUint32(0, !0);
+}
+function $n(e, t) {
+  return {
+    encode(n) {
+      if (n.kind !== "set_field")
+        throw new b(
+          `ringSetFieldCodec encodes a "set_field" command (got "${n.kind}")`
+        );
+      const o = new Uint8Array(Fe), s = new DataView(o.buffer);
+      return s.setUint32(0, n.eid, !0), s.setFloat64(4, n.value, !0), o;
+    },
+    decode(n) {
+      const o = new DataView(n.buffer, n.byteOffset, n.byteLength);
+      return {
+        kind: "set_field",
+        // boundary: branded-ID bridging, a decoded `u32` is an `EntityID` handle.
+        eid: o.getUint32(0, !0),
+        // schema-erased into the flat HostCommand union (the callable def is invariant in S).
+        def: e,
+        field: t,
+        value: o.getFloat64(4, !0)
+      };
+    }
+  };
+}
+function Yn() {
+  return {
+    encode(e) {
+      if (e.kind !== "despawn")
+        throw new b(
+          `ringDespawnCodec encodes a "despawn" command (got "${e.kind}")`
+        );
+      return j(e.eid);
+    },
+    decode: (e) => ({ kind: "despawn", eid: Q(e) })
+  };
+}
+function xn() {
+  return {
+    encode(e) {
+      if (e.kind !== "disable")
+        throw new b(
+          `ringDisableCodec encodes a "disable" command (got "${e.kind}")`
+        );
+      return j(e.eid);
+    },
+    decode: (e) => ({ kind: "disable", eid: Q(e) })
+  };
+}
+function Fn() {
+  return {
+    encode(e) {
+      if (e.kind !== "enable")
+        throw new b(
+          `ringEnableCodec encodes an "enable" command (got "${e.kind}")`
+        );
+      return j(e.eid);
+    },
+    decode: (e) => ({ kind: "enable", eid: Q(e) })
+  };
+}
+function Vn(e) {
+  return {
+    encode(t) {
+      if (t.kind !== "remove_component")
+        throw new b(
+          `ringRemoveComponentCodec encodes a "remove_component" command (got "${t.kind}")`
+        );
+      return j(t.eid);
+    },
+    decode: (t) => ({ kind: "remove_component", eid: Q(t), def: e })
+  };
+}
+class Hn {
+  _appliers = /* @__PURE__ */ new Map();
+  /** Bind a raw ctx-aware applier to `opCode`. Re-binding replaces. */
+  on(t, n) {
+    return qt(t), this._appliers.set(t, n), this;
+  }
+  /** Unbind `opCode`. 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 and replay) 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, (o, s, i) => {
+      const _ = n.decode(s);
+      i?.(_), te(o, _);
+    });
+  }
+  /** Drain every pending slot, dispatching each to its bound applier. Unbound
+   * opcodes are skipped (the read head still advances, matching
+   * `drainCommandRing` and `CommandDispatcher`). Returns slots drained. `tap`,
+   * when present, is forwarded to each applier as the record and replay hook.
+   * Only an `onCommand`-bound (generic `HostCommand`) opcode surfaces to it. */
+  drain(t, n, o, s) {
+    return lt(n, o, (i, _) => {
+      const d = this._appliers.get(i);
+      d !== void 0 && d(t, _, s);
+    });
+  }
+}
+const ne = /* @__PURE__ */ new WeakMap();
+function Gn(e, t) {
+  const n = ne.get(t);
+  if (n === void 0) return !1;
+  for (const o of n) e.removeSystem(o);
+  return ne.delete(t), t.clear(), !0;
+}
+function kn(e, t) {
+  const n = new Qt(), o = [];
+  ne.set(n, o);
+  const s = t?.name ?? "host_command_apply", i = t?.ring, _ = t?.recorder, d = _?.record, c = t?.schedules ?? [
+    Z.PRE_STARTUP,
+    Z.PRE_UPDATE
+  ];
+  if (_ !== void 0) {
+    for (const l of c)
+      if (ge(l) === "fixed")
+        throw new E(
+          m.INVALID_RECORDER_SCHEDULE,
+          `installHostCommandSeam: a recorder cannot drain at ${Ne(l)}, a phase of the fixed loop. It would log the fixed timestep and not the host update dt, so a replay would diverge. Drain at a phase of the update loop instead.`
+        );
+  }
+  for (const l of c) {
+    const f = ge(l) !== "startup", p = e.registerSystem({
+      name: `${s}:${Ne(l)}`,
+      // `reads` and `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: (T, S) => {
+        if (_ !== void 0 && f && _.openTick(T.ecsTick, S), n.drain(T, d), i !== void 0) {
+          const N = e.columnStore, a = N.header.commandRingOff;
+          a !== 0 && i.drain(T, N.view, a, d);
+        }
+      }
+    });
+    e.addSystems(l, p), o.push(p);
+  }
+  return n;
+}
+export {
+  Re as $,
+  dn as A,
+  ye as B,
+  g as C,
+  q as D,
+  E,
+  Rn as F,
+  xe as G,
+  Hn as H,
+  Le as I,
+  ae as J,
+  Ye as K,
+  H as L,
+  ze as M,
+  sn as N,
+  On as O,
+  Ln as P,
+  wn as Q,
+  En as R,
+  gn as S,
+  A as T,
+  on as U,
+  tt as V,
+  ee as W,
+  Me as X,
+  xt as Y,
+  Yt as Z,
+  le as _,
+  m as a,
+  k as a0,
+  Ee as a1,
+  yn as a2,
+  bn as a3,
+  P as a4,
+  Pe as a5,
+  Ce as a6,
+  rn as a7,
+  en as a8,
+  In as a9,
+  F as aa,
+  Dn as ab,
+  Nn as ac,
+  Sn as ad,
+  Z as ae,
+  un as af,
+  _n as ag,
+  ln as ah,
+  an as ai,
+  cn as aj,
+  Un as ak,
+  kn as al,
+  Gn as am,
+  te as an,
+  Qt as ao,
+  Bn as ap,
+  nn as aq,
+  Te as ar,
+  tn as as,
+  Wt as b,
+  Xt as c,
+  Cn as d,
+  $n as e,
+  Yn as f,
+  xn as g,
+  Fn as h,
+  Vn as i,
+  Fe as j,
+  An as k,
+  _e as l,
+  oe as m,
+  mn as n,
+  fn as o,
+  Pn as p,
+  Mn as q,
+  vn as r,
+  Tn as s,
+  pn as t,
+  Qe as u,
+  Zt as v,
+  hn as w,
+  Xe as x,
+  de as y,
+  Ut as z
+};