@oasys/oecs 0.5.4 → 0.6.0

package/dist/host_commands-nJvTy88E.js

@@ -0,0 +1,1667 @@
+import { D as Ge, w as de, g as We, h as Xe } from "./shared-BKl12xF1.js";
+class be extends Error {
+  constructor(t, n, s) {
+    super(t), this.isOperational = n, this.context = s, this.name = this.constructor.name, typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, this.constructor);
+  }
+}
+var oe = /* @__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))(oe || {});
+class Le extends be {
+  constructor(t, n, s) {
+    super(n, !1, s), this.category = t, this.name = "AssertionError";
+  }
+}
+const rn = (e) => Number.isInteger(e) && e >= 0;
+function an(e, t, n) {
+  if (!t(e))
+    throw new Le(
+      oe.VALIDATION_FAIL_CONDITION,
+      `Expected value to meet validation: ${n}`
+    );
+  return e;
+}
+function cn(e) {
+  return e;
+}
+function Ke(e, t) {
+  throw new Le(
+    oe.ASSERTION_FAIL_UNREACHABLE,
+    `Unhandled ${t}: ${String(e)}`
+  );
+}
+var E = /* @__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))(E || {});
+class f extends be {
+  constructor(t, n, s) {
+    super(n ?? t, !0, s), this.category = t, this.name = "ECSError";
+  }
+}
+function dn(e) {
+  return e instanceof f;
+}
+class ln extends f {
+  constructor(t) {
+    super("SNAPSHOT_RESTORE_FAILED", t), this.name = "ECSRestoreError";
+  }
+}
+const _n = -1, un = -1, fn = Object.freeze(/* @__PURE__ */ Object.create(null)), En = 2654435769, mn = 1367130551, ze = 1024, An = 0, je = 31, hn = 1 / 60, In = 4, pn = 0, F = 20, Ce = (1 << F) - 1, Pe = Ce, Qe = je - F, z = (1 << Qe) - 1, Tn = z, gn = z - 1, Nn = z << F | Pe, yn = (e, t) => {
+  {
+    if (e < 0 || e > Pe)
+      throw new f(E.EID_MAX_INDEX_OVERFLOW);
+    if (t < 0 || t > z)
+      throw new f(E.EID_MAX_GEN_OVERFLOW);
+  }
+  return t << F | e;
+}, le = (e) => e & Ce, _e = (e) => e >> F, Sn = (e, t, n) => new f(
+  E.ENTITY_NOT_ALIVE,
+  `${e}: entity ${t} (index ${le(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: le(t), generation: _e(t), op: e }
+), re = /* @__PURE__ */ new WeakMap();
+function On(e, t) {
+  re.set(e, t);
+}
+function Dn(e) {
+  return re.get(e);
+}
+function qe(e) {
+  const t = re.get(e);
+  return t !== void 0 ? `'${t}' (component ${e.id})` : `component ${e.id}`;
+}
+const Je = 827148627, Ze = 1, ve = 4, et = 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
+}, Me = 16, x = {
+  component_id: 0,
+  field_id: 2,
+  type_tag: 4,
+  byte_off: 8,
+  stride: 12
+}, Ue = 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
+}, ue = 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
+}), wn = {
+  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 tt(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 Rn = ve * 32;
+function $e(e, t = Ue) {
+  return t + e * Me;
+}
+function nt(e, t, n) {
+  e.setUint32(t + P.archetype_id, n.archetypeId, !0);
+  for (let o = 0; o < ve; o++)
+    e.setUint32(
+      t + P.component_mask + o * 4,
+      n.componentMask[o] ?? 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 s = t + Ue;
+  for (let o = 0; o < n.columns.length; o++)
+    tt(e, s, n.columns[o]), s += Me;
+  return s;
+}
+function st(e, t, n) {
+  let s = t;
+  for (let o = 0; o < n.length; o++)
+    s = nt(e, s, n[o]);
+  return s;
+}
+function ot(e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++)
+    t += $e(e[n].columns.length);
+  return t;
+}
+function rt(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 Be = 16, M = 16, bn = 256, D = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+}, ie = 0;
+function fe(e) {
+  return Be + e * M;
+}
+function it(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class R extends Error {
+  constructor(t) {
+    super(t), this.name = "CommandRingError";
+  }
+}
+function at(e, t, n) {
+  if (!it(n))
+    throw new R(
+      `command ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  e.setUint32(t + D.write_head, 0, !0), e.setUint32(t + D.read_head, 0, !0), e.setUint32(t + D.capacity_slots, n, !0), e.setUint32(t + D.overflow_flag, 0, !0);
+}
+function ct(e, t) {
+  return e.getUint32(t + D.write_head, !0);
+}
+function dt(e, t) {
+  return e.getUint32(t + D.read_head, !0);
+}
+function lt(e, t) {
+  return e.getUint32(t + D.capacity_slots, !0);
+}
+function _t(e, t, n) {
+  if (n.byteLength !== M - 1)
+    throw new R(
+      `outPayload must be ${M - 1} bytes (got ${n.byteLength})`
+    );
+  const s = ct(e, t), o = dt(e, t);
+  if (s === o) return ie;
+  const r = lt(e, t), l = o & r - 1, d = t + Be + l * M, c = e.getUint8(d), _ = new Uint8Array(
+    e.buffer,
+    e.byteOffset + d + 1,
+    M - 1
+  );
+  return n.set(_), e.setUint32(t + D.read_head, o + 1 >>> 0, !0), c;
+}
+function ut(e, t, n) {
+  let s = 0;
+  const o = new Uint8Array(M - 1);
+  for (; ; ) {
+    const r = _t(e, t, o);
+    if (r === ie) return s;
+    n(r, o.slice()), s++;
+  }
+}
+const j = 16, L = 12, G = {
+  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 Ye(
+      `entity index capacity must be a non-negative integer (got ${e})`
+    );
+  return j + e * L;
+}
+function ft(e) {
+  return e + j;
+}
+function Et(e, t) {
+  return e + j + t * 4;
+}
+function mt(e, t) {
+  return e + j + t * 8;
+}
+class Ye extends Error {
+  constructor(t) {
+    super(t), this.name = "EntityIndexError";
+  }
+}
+function At(e, t, n) {
+  if (n < 0 || !Number.isInteger(n))
+    throw new Ye(
+      `entity index capacity must be a non-negative integer (got ${n})`
+    );
+  e.setUint32(t + G.length, 0, !0), e.setUint32(t + G.capacity, n, !0);
+}
+function Ln(e, t, n) {
+  return {
+    generations: new Int32Array(e, ft(t), n),
+    archetypes: new Int32Array(e, Et(t, n), n),
+    rows: new Int32Array(e, mt(t, n), n)
+  };
+}
+const ht = 16, It = 16, Cn = 256, U = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+};
+function Ae(e) {
+  return ht + e * It;
+}
+function pt(e) {
+  return e > 0 && (e & e - 1) === 0;
+}
+class Tt extends Error {
+  constructor(t) {
+    super(t), this.name = "EventRingError";
+  }
+}
+function gt(e, t, n) {
+  if (!pt(n))
+    throw new Tt(
+      `event ring capacity_slots must be a positive power of two (got ${n})`
+    );
+  e.setUint32(t + U.write_head, 0, !0), e.setUint32(t + U.read_head, 0, !0), e.setUint32(t + U.capacity_slots, n, !0), e.setUint32(t + U.overflow_flag, 0, !0);
+}
+const Nt = 16, yt = 16, Pn = 256, B = {
+  write_head: 0,
+  read_head: 4,
+  capacity_slots: 8,
+  overflow_flag: 12
+}, St = B.write_head / 4, Ot = B.read_head / 4, Dt = B.capacity_slots / 4, wt = B.overflow_flag / 4;
+function Rt(e, t) {
+  return new Int32Array(e.buffer, e.byteOffset + t, 4);
+}
+function he(e) {
+  return Nt + e * yt;
+}
+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 s = Rt(e, t);
+  Atomics.store(s, St, 0), Atomics.store(s, Ot, 0), Atomics.store(s, Dt, n), Atomics.store(s, wt, 0);
+}
+const k = [
+  {
+    name: "command_ring",
+    headerOff: "command_ring_off",
+    sizeFromOptions: (e) => e.commandRingCapacitySlots !== void 0 ? fe(e.commandRingCapacitySlots) : 0,
+    init: (e, t, n) => at(e, t, n.commandRingCapacitySlots),
+    regionBytes: (e, t) => fe(e.getUint32(t + D.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.commandRingCapacitySlots = e.getUint32(
+        t + D.capacity_slots,
+        !0
+      );
+    }
+  },
+  {
+    name: "entity_index",
+    headerOff: "entity_index_off",
+    sizeFromOptions: (e) => e.entityIndexCapacity !== void 0 ? me(e.entityIndexCapacity) : 0,
+    init: (e, t, n) => At(e, t, n.entityIndexCapacity),
+    regionBytes: (e, t) => me(e.getUint32(t + G.capacity, !0)),
+    readOptions: (e, t, n) => {
+      n.entityIndexCapacity = e.getUint32(t + G.capacity, !0);
+    }
+  },
+  {
+    name: "event_ring",
+    headerOff: "event_ring_off",
+    sizeFromOptions: (e) => e.eventRingCapacitySlots !== void 0 ? Ae(e.eventRingCapacitySlots) : 0,
+    init: (e, t, n) => gt(e, t, n.eventRingCapacitySlots),
+    regionBytes: (e, t) => Ae(e.getUint32(t + U.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.eventRingCapacitySlots = e.getUint32(
+        t + U.capacity_slots,
+        !0
+      );
+    }
+  },
+  {
+    name: "action_ring",
+    headerOff: "action_ring_off",
+    sizeFromOptions: (e) => e.actionRingCapacitySlots !== void 0 ? he(e.actionRingCapacitySlots) : 0,
+    init: (e, t, n) => Lt(e, t, n.actionRingCapacitySlots),
+    regionBytes: (e, t) => he(e.getUint32(t + B.capacity_slots, !0)),
+    readOptions: (e, t, n) => {
+      n.actionRingCapacitySlots = e.getUint32(
+        t + B.capacity_slots,
+        !0
+      );
+    }
+  }
+];
+class H extends Error {
+  constructor(t) {
+    super(t), this.name = "RegionRegistryError";
+  }
+}
+function xe(e) {
+  return e * V;
+}
+function ae(e, t) {
+  const n = e.getUint32(g.region_table_count, !0);
+  if (t + xe(n) > e.byteLength)
+    throw new H(
+      `region table of ${n} entries at byte ${t} overruns the buffer (${e.byteLength} bytes)`
+    );
+  return n;
+}
+function Ct(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (let n = 0; n < e.length; n++) {
+    const s = e[n];
+    if (!Number.isInteger(s.id) || s.id <= 0)
+      throw new H(
+        `region "${s.name}" has invalid id ${s.id}, region ids must be positive integers (0 is the absent sentinel)`
+      );
+    if (t.has(s.id))
+      throw new H(
+        `duplicate region id ${s.id} (region "${s.name}"), ids must be distinct within a consumer's region set`
+      );
+    if (t.add(s.id), !Number.isInteger(s.bytes) || s.bytes <= 0)
+      throw new H(
+        `region "${s.name}" (id ${s.id}) has invalid byte size ${s.bytes}, must be a positive integer`
+      );
+  }
+}
+function Pt(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 Fe(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 vt(e, t, n) {
+  for (let s = 0; s < n.length; s++)
+    Pt(e, t + s * V, n[s]);
+}
+function Mt(e, t, n) {
+  const s = new Array(n);
+  for (let o = 0; o < n; o++)
+    s[o] = Fe(e, t + o * V);
+  return s;
+}
+function vn(e) {
+  const t = e.getUint32(g.region_table_off, !0);
+  if (t === 0) return [];
+  const n = ae(e, t);
+  return Mt(e, t, n);
+}
+function Mn(e, t) {
+  const n = e.getUint32(g.region_table_off, !0);
+  if (n === 0) return 0;
+  const s = ae(e, n);
+  for (let o = 0; o < s; o++) {
+    const r = n + o * V;
+    if (e.getUint32(r + C.region_id, !0) === t)
+      return e.getUint32(r + C.byte_offset, !0);
+  }
+  return 0;
+}
+function Un(e, t) {
+  const n = e.getUint32(g.region_table_off, !0);
+  if (n === 0) return null;
+  const s = ae(e, n);
+  for (let o = 0; o < s; o++) {
+    const r = Fe(e, n + o * V);
+    if (r.regionId === t) return r;
+  }
+  return null;
+}
+function Ut(e, t) {
+  return e << 16 | t;
+}
+const ce = 2 ** 31;
+class Ve extends Error {
+  constructor(t) {
+    super(
+      `SAB column layout offset ${t} reaches or exceeds the 2³¹ (${ce}-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 ke(e, t) {
+  if (e + t > ce)
+    throw new Ve(e);
+  return e + (t - 1) & ~(t - 1);
+}
+function $t(e, t, n, s, o) {
+  const r = t + s;
+  switch (n) {
+    case A.u8:
+      return new Uint8Array(e, r, o);
+    case A.i8:
+      return new Int8Array(e, r, o);
+    case A.u16:
+      return new Uint16Array(e, r, o);
+    case A.i16:
+      return new Int16Array(e, r, o);
+    case A.u32:
+      return new Uint32Array(e, r, o);
+    case A.i32:
+      return new Int32Array(e, r, o);
+    case A.f32:
+      return new Float32Array(e, r, o);
+    case A.f64:
+      return new Float64Array(e, r, o);
+  }
+}
+function Bt(e, t, n = 0) {
+  const o = 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: ue[c.typeTag]
+      }))
+    }))
+  ) + n;
+  let r = t + o;
+  const l = new Array(e.length);
+  for (let d = 0; d < e.length; d++) {
+    const c = e[d], _ = new Array(c.columns.length);
+    for (let m = 0; m < c.columns.length; m++) {
+      const h = c.columns[m], p = ue[h.typeTag];
+      r = ke(r, p), _[m] = {
+        componentId: h.componentId,
+        fieldId: h.fieldId,
+        typeTag: h.typeTag,
+        byteOff: r,
+        stride: p
+      }, r += p * c.rowCapacity;
+    }
+    l[d] = {
+      archetypeId: c.archetypeId,
+      componentMask: c.componentMask,
+      rowCount: 0,
+      enabledCount: 0,
+      rowCapacity: c.rowCapacity,
+      columns: _
+    };
+  }
+  if (r > ce)
+    throw new Ve(r);
+  return { descriptors: l, totalBytes: r, regionBytes: o };
+}
+const W = 16;
+function Yt(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 xt(e) {
+  let t = 0;
+  for (const [, n] of e) t += $e(n.columnsInOrder.length);
+  return t;
+}
+function $n(e) {
+  const t = e;
+  return typeof t._regionBytes == "number" && typeof t._allocator == "function" && typeof t._reservedDescriptorBytes == "number";
+}
+function Bn(e, t = Ge, n = {}) {
+  const s = n.storeBase ?? 0;
+  Yt(s);
+  const o = {};
+  let r = et;
+  for (let T = 0; T < k.length; T++) {
+    const w = k[T], Y = w.sizeFromOptions(n);
+    o[w.headerOff] = Y === 0 ? 0 : r, r += Y;
+  }
+  const l = n.regions ?? [];
+  Ct(l);
+  const d = l.length, c = d > 0 ? r : 0;
+  r += xe(d);
+  const _ = new Array(d);
+  for (let T = 0; T < l.length; T++) {
+    const w = l[T];
+    _[T] = { regionId: w.id, byteOffset: r, byteLength: w.bytes }, r += w.bytes;
+  }
+  const m = n.bindingsRegionBytes ?? 0, h = m === 0 ? 0 : r;
+  r += m;
+  const p = r, { descriptors: S, totalBytes: N, regionBytes: a } = Bt(
+    e,
+    p,
+    n.reservedDescriptorBytes ?? 0
+  ), i = t(s + N), u = new DataView(i, s), O = {
+    magic: Je,
+    simAbiVersion: Ze,
+    viewStamp: 0,
+    capacity: N,
+    archetypeCount: e.length,
+    layoutDescriptorOff: p,
+    bindingsOff: h,
+    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: o.command_ring_off,
+    entityIndexOff: o.entity_index_off,
+    eventRingOff: o.event_ring_off,
+    actionRingOff: o.action_ring_off
+  };
+  rt(u, O), m > 0 && new Uint8Array(i, s + h, m).fill(0);
+  for (let T = 0; T < k.length; T++) {
+    const w = k[T], Y = o[w.headerOff];
+    Y !== 0 && w.init(u, Y, n);
+  }
+  c !== 0 && vt(u, c, _);
+  for (let T = 0; T < l.length; T++)
+    l[T].init(u, _[T].byteOffset);
+  st(u, p, S);
+  const y = Ft(i, s, S);
+  return {
+    buffer: i,
+    view: u,
+    header: O,
+    storeBase: s,
+    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: xt(y)
+  };
+}
+function Ft(e, t, n) {
+  const s = /* @__PURE__ */ new Map();
+  for (let o = 0; o < n.length; o++) {
+    const r = n[o], l = new Array(r.columns.length), d = /* @__PURE__ */ new Map();
+    for (let c = 0; c < r.columns.length; c++) {
+      const _ = r.columns[c], m = {
+        componentId: _.componentId,
+        fieldId: _.fieldId,
+        typeTag: _.typeTag,
+        byteOff: _.byteOff,
+        stride: _.stride,
+        view: $t(e, t, _.typeTag, _.byteOff, r.rowCapacity)
+      };
+      l[c] = m, d.set(Ut(_.componentId, _.fieldId), m);
+    }
+    s.set(r.archetypeId, {
+      archetypeId: r.archetypeId,
+      componentMask: r.componentMask,
+      rowCapacity: r.rowCapacity,
+      columns: d,
+      columnsInOrder: l
+    });
+  }
+  return s;
+}
+const pe = 2147483647, Te = /* @__PURE__ */ new WeakMap();
+function Vt(e) {
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Set();
+  for (let a = 0; a < e.writes.length; a++) {
+    const i = e.writes[a].id;
+    n.add(i), t.add(i), s.add(i);
+  }
+  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 i = e.spawns[a];
+    for (let u = 0; u < i.length; u++)
+      s.add(i[u].id);
+  }
+  for (let a = 0; a < e.transitions.length; a++) {
+    const i = e.transitions[a];
+    if (i.add)
+      for (let u = 0; u < i.add.length; u++)
+        s.add(i.add[u].id);
+    if (i.remove)
+      for (let u = 0; u < i.remove.length; u++)
+        o.add(i.remove[u].id);
+  }
+  for (let a = 0; a < e.despawns.length; a++)
+    o.add(e.despawns[a].id);
+  for (let a = 0; a < e.resourceReads.length; a++)
+    r.add(e.resourceReads[a]);
+  for (let a = 0; a < e.resourceWrites.length; a++) {
+    const i = e.resourceWrites[a];
+    l.add(i), r.add(i);
+  }
+  const h = e.sparseWrites;
+  if (h !== void 0)
+    for (let a = 0; a < h.length; a++) {
+      const i = h[a];
+      c.add(i), d.add(i);
+    }
+  const p = e.sparseReads;
+  if (p !== void 0)
+    for (let a = 0; a < p.length; a++) d.add(p[a]);
+  const S = e.relationWrites;
+  if (S !== void 0)
+    for (let a = 0; a < S.length; a++) {
+      const i = S[a];
+      m.add(i), _.add(i);
+    }
+  const N = e.relationReads;
+  if (N !== void 0)
+    for (let a = 0; a < N.length; a++) _.add(N[a]);
+  return {
+    reads: t,
+    writes: n,
+    addAllowed: s,
+    removeAllowed: o,
+    hasDespawns: e.despawns.length > 0,
+    resourceReads: r,
+    resourceWrites: l,
+    sparseReads: d,
+    sparseWrites: c,
+    relationReads: _,
+    relationWrites: m
+  };
+}
+function kt(e) {
+  const t = Te.get(e);
+  if (t !== void 0) return t;
+  const n = Vt(e);
+  return Te.set(e, n), n;
+}
+const ge = /* @__PURE__ */ new WeakMap();
+function Ht(e) {
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+  if (e.reads !== void 0)
+    for (let s = 0; s < e.reads.length; s++) t.add(e.reads[s].id);
+  if (e.resourceReads !== void 0)
+    for (let s = 0; s < e.resourceReads.length; s++)
+      n.add(e.resourceReads[s]);
+  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 = ge.get(e);
+  if (t !== void 0) return t;
+  const n = Ht(e);
+  return ge.set(e, n), n;
+}
+class Wt {
+  _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 : kt(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 f(
+      E.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(pe) || this._failRelation(
+      "(*, T) wildcard read",
+      pe,
+      "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 s = this._optionalScopes[n - 1], o = t.id;
+    for (let r = 0; r < s.length; r++)
+      if (s[r] === o) return;
+    throw new f(
+      E.OPTIONAL_TERM_NOT_DECLARED,
+      `getOptionalColumnRead fetched optional component ${o} but the iterating query did not declare it. Add .optional(component) to the query before the fetch`
+    );
+  }
+  _failComponent(t, n, s) {
+    const o = this._activeName, r = qe(n);
+    throw new f(
+      E.ACCESS_UNDECLARED,
+      `system '${o}' performed ${t} on ${r} but did not declare it. Add it to '${s}'`,
+      { system: o, op: t, component: n.id }
+    );
+  }
+  _failSparse(t, n, s) {
+    const o = this._activeName;
+    throw new f(
+      E.ACCESS_UNDECLARED,
+      `system '${o}' performed ${t} on sparse component ${n} but did not declare it. Add it to '${s}'`,
+      { system: o, op: t, sparse: n }
+    );
+  }
+  _failRelation(t, n, s) {
+    const o = this._activeName;
+    throw new f(
+      E.ACCESS_UNDECLARED,
+      `system '${o}' performed ${t} on relation ${n} but did not declare it. Add it to '${s}'`,
+      { system: o, op: t, relation: n }
+    );
+  }
+  _failResource(t, n, s) {
+    const o = this._activeName, r = n.description ?? "<unnamed>";
+    throw new f(
+      E.ACCESS_UNDECLARED,
+      `system '${o}' performed resource ${t} on '${r}' but did not declare it. Add the resource key to '${s}'`,
+      { system: o, op: t, resource: r }
+    );
+  }
+}
+const Yn = new Wt();
+function xn(e, t) {
+  return new f(
+    E.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 Fn(e) {
+  return new f(
+    E.PLUGIN_ALREADY_INSTALLED,
+    `${e} is already installed on this world. Pass each plugin once to ECS.create`,
+    { plugin: e }
+  );
+}
+const Ne = ["/oecs/src/", "/@oasys/oecs/"];
+function Xt(e) {
+  for (let t = 0; t < Ne.length; t++)
+    if (e.includes(Ne[t])) return !0;
+  return !1;
+}
+class Kt {
+  _activeCache = null;
+  _repoRootCache = null;
+  _counts = /* @__PURE__ */ new Map();
+  _callsiteCache = /* @__PURE__ */ new Map();
+  isActive() {
+    if (this._activeCache !== null) return this._activeCache;
+    const n = globalThis.process?.env?.VISUAL_INTEL_TRACE;
+    return this._activeCache = n === "1" || n === "true";
+  }
+  _repoRoot() {
+    if (this._repoRootCache !== null) return this._repoRootCache;
+    const t = globalThis.process;
+    return this._repoRootCache = t?.cwd?.() ?? "";
+  }
+  _resolveCallsite() {
+    return jt(
+      new Error().stack ?? null,
+      this._repoRoot(),
+      this._callsiteCache
+    );
+  }
+  _record(t, n, s) {
+    const o = this._resolveCallsite();
+    if (!o) return;
+    const r = `${t}	${n}	${s}	${o}`;
+    this._counts.set(r, (this._counts.get(r) ?? 0) + 1);
+  }
+  recordEventEmit(t) {
+    this._record("ecs-events", "emit", t);
+  }
+  recordEventRead(t) {
+    this._record("ecs-events", "read", t);
+  }
+  recordResourceRead(t) {
+    this._record("resources", "read", t);
+  }
+  recordResourceWrite(t) {
+    this._record("resources", "write", t);
+  }
+  recordResourceRegister(t) {
+    this._record("resources", "register", t);
+  }
+  recordResourceRemove(t) {
+    this._record("resources", "remove", t);
+  }
+  recordSendAction(t) {
+    this._record("actions", "send_action", t);
+  }
+  recordHandleAction(t) {
+    this._record("actions", "handle_action", t);
+  }
+  snapshot() {
+    const t = {
+      "ecs-events": { emit: [], read: [] },
+      actions: { send_action: [], handle_action: [] },
+      resources: { read: [], write: [], register: [], remove: [] }
+    };
+    for (const [n, s] of this._counts.entries()) {
+      const [o, r, l, d] = n.split("	");
+      if (!o || !r || d === void 0) continue;
+      const _ = { key: o === "actions" ? Number(l) : l, file: d, count: s }, h = t[o][r];
+      h && h.push(_);
+    }
+    for (const n of Object.values(t))
+      for (const s of Object.values(n))
+        s.sort((o, r) => {
+          if (o.file !== r.file) return o.file < r.file ? -1 : 1;
+          const l = String(o.key), d = String(r.key);
+          return l < d ? -1 : l > d ? 1 : 0;
+        });
+    return {
+      schemaVersion: 1,
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      channels: t
+    };
+  }
+  reset() {
+    this._counts.clear(), this._callsiteCache.clear(), this._activeCache = null, this._repoRootCache = null;
+  }
+}
+function zt(e) {
+  const t = /\(([^)]+):\d+:\d+\)\s*$/.exec(e);
+  if (t) return t[1] ?? null;
+  const n = /at\s+([^\s][^()]*?):\d+:\d+\s*$/.exec(e);
+  return n && (n[1] ?? "").trim() || null;
+}
+function jt(e, t, n) {
+  if (!e) return null;
+  const s = e.split(`
+`);
+  for (let o = 0; o < s.length; o++) {
+    const r = s[o], l = n?.get(r);
+    if (l !== void 0) {
+      if (l === null) continue;
+      return l;
+    }
+    const d = zt(r);
+    if (!d) {
+      n?.set(r, null);
+      continue;
+    }
+    if (Xt(d)) {
+      n?.set(r, null);
+      continue;
+    }
+    const c = Qt(d, t);
+    return n?.set(r, c), c;
+  }
+  return null;
+}
+function Qt(e, t) {
+  let n = e;
+  return n.startsWith("file://") && (n = n.slice(7)), t && n.startsWith(t + "/") && (n = n.slice(t.length + 1)), n.replace(/\\/g, "/");
+}
+const Vn = new Kt();
+var ee = /* @__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))(ee || {});
+function ye(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 Se(e) {
+  return typeof e == "string" ? e : e.name;
+}
+const X = 1024, K = 1024 * X, $ = 64 * X, te = $;
+function kn(e, t = 0) {
+  if (!Number.isFinite(t) || t < 0)
+    throw new f(
+      E.INVALID_MEMORY_OPTIONS,
+      `storeBaseAbove: extraBytes must be a finite number >= 0, got ${String(t)}`
+    );
+  const n = e?.__heap_base, s = typeof n == "object" && n !== null && "value" in n ? n.value : n;
+  if (typeof s != "number" || !Number.isFinite(s))
+    throw new f(
+      E.INVALID_MEMORY_OPTIONS,
+      `storeBaseAbove: the module exports no numeric '__heap_base', got ${String(s)}. Link with --export=__heap_base, or pass memory.storeBase by hand.`
+    );
+  const o = Math.ceil((s + t) / $) * $;
+  return Math.max(te, o);
+}
+const J = 256 * K, Oe = 3, qt = 64, Jt = 8, De = 4 * K, we = (e) => 2 ** Math.ceil(Math.log2(Math.max(1, e))), Zt = (e) => 2 ** Math.floor(Math.log2(Math.max(1, e))), Z = (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 en(e, t) {
+  if (e === void 0) return t ? te : 0;
+  if (!Number.isInteger(e) || e < 0)
+    throw new f(
+      E.INVALID_MEMORY_OPTIONS,
+      `memory.storeBase must be an integer >= 0, got ${e}`
+    );
+  if (e % W !== 0)
+    throw new f(
+      E.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 f(
+      E.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 (${te}), above the module's own data.`
+    );
+  return e;
+}
+function v(e, t) {
+  if (!Number.isInteger(t) || t <= 0)
+    throw new f(
+      E.INVALID_MEMORY_OPTIONS,
+      `memory.${e} must be a positive integer (got ${t})`
+    );
+}
+const Re = {
+  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 tn(e) {
+  const t = Object.prototype.hasOwnProperty, n = Object.keys(Re).filter((s) => t.call(e, s));
+  if (n.length !== 0)
+    throw new f(
+      E.INVALID_MEMORY_OPTIONS,
+      `${n.map((s) => `memory.${s}`).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((s) => Re[s]).join(". ")
+    );
+}
+function Hn(e) {
+  e !== void 0 && tn(e);
+  const t = e?.entities, n = e?.maxBytes, s = e?.columnCapacity, o = e?.backing ?? "heap", r = typeof o == "object" && o.wasm !== void 0, l = en(e?.storeBase, r);
+  if (s !== void 0 && v("columnCapacity", s), n !== void 0 && v("maxBytes", n), t === void 0) {
+    for (const i of ["archetypes", "bytesPerEntity"])
+      if (e?.[i] !== void 0)
+        throw new f(
+          E.INVALID_MEMORY_OPTIONS,
+          `memory.${i} shapes the sizing derived from memory.entities, which was not given. Add memory.entities, or drop memory.${i}.`
+        );
+  }
+  let d, c, _ = null;
+  const m = [];
+  if (t !== void 0) {
+    const i = e?.archetypes ?? Jt, u = e?.bytesPerEntity ?? qt;
+    if (v("entities", t), v("archetypes", i), v("bytesPerEntity", u), t > 1 << 20)
+      throw new f(
+        E.INVALID_MEMORY_OPTIONS,
+        `memory.entities=${t} exceeds the EntityID index space (1<<20 = ${1 << 20})`
+      );
+    d = s ?? Z(we(Math.ceil(t / i)), 64, 1 << 20), c = Z(we(t * 2), 4096, 1 << 20);
+    const O = c * L, y = t * u * Oe;
+    _ = ke(
+      Math.max(O + y, De),
+      $
+    ), m.push(
+      `columnCapacity = ${s !== void 0 ? `${d} (pinned)` : `pow2(${t}/${i} per archetype) = ${d}`}`,
+      `entityIndex = pow2(2 × ${t}) = ${c} slots × ${L} B = ${I(O)}`,
+      `columns = ${t} × ${u} B × ${Oe} (double+holes headroom) = ${I(y)}`
+    );
+  } else
+    d = s ?? ze, c = Ee, m.push(
+      `columnCapacity = ${d} (${s !== void 0 ? "pinned" : "default"})`
+    );
+  const h = (i) => Z(Zt(i / 4 / L), 4096, Ee), p = t !== void 0 ? n !== void 0 ? "entities+maxBytes" : "entities" : n !== void 0 ? "maxBytes" : "default", S = (i) => n !== void 0 ? `${I(i)} (caller-declared maxBytes; the ${I(_ ?? i)} the entity count implies is overridden)` : `align64K(max(index + columns, ${I(De)} floor)) = ${I(i)}`, N = (i, u, O, y, b) => (t === void 0 && (c = h(i)), {
+    source: u,
+    sizing: p,
+    allocator: O,
+    columnCapacity: d,
+    entityIndexCapacity: c,
+    capBytes: i,
+    storeBase: l,
+    intentLabel: y,
+    budgetEntities: t ?? null,
+    derivation: [
+      ...b,
+      ...l > 0 ? [`storeBase = ${I(l)}, the store writes nothing below it`] : [],
+      ...m,
+      t === void 0 ? `entityIndex = floor_pow2(cap/4 ÷ ${L} B) = ${c} slots` : `cap = ${S(i)}`
+    ],
+    wasmMemory: null
+  });
+  if (typeof o == "object" && o.wasm !== void 0) {
+    const i = o.wasm;
+    if (i.memory !== void 0) {
+      if (!(i.memory.buffer instanceof SharedArrayBuffer))
+        throw new f(
+          E.INVALID_MEMORY_OPTIONS,
+          "memory.backing.wasm.memory must be constructed with `shared: true`, the SAB substrate requires a SharedArrayBuffer-backed WebAssembly.Memory"
+        );
+      const b = n ?? J;
+      return t === void 0 && (c = h(Math.max(b - l, 0))), {
+        source: "wasm",
+        sizing: p,
+        allocator: de(i.memory),
+        columnCapacity: d,
+        entityIndexCapacity: c,
+        capBytes: b,
+        storeBase: l,
+        intentLabel: `caller-supplied WebAssembly.Memory (declared cap ${I(b)})`,
+        budgetEntities: t ?? null,
+        derivation: [
+          "backing = wasm_memory_allocator(memory), zero-copy with a WASM compute backend (is_in_place ✓)",
+          n !== void 0 ? `cap = ${I(b)} (caller-declared maxBytes; the Memory's own maximum is not readable from JS)` : `cap = ${I(b)} (default; the Memory's own maximum is not readable from JS)`,
+          `storeBase = ${I(l)}, the module owns every byte below it`,
+          ...m,
+          t === void 0 ? `entityIndex = floor_pow2((cap - storeBase)/4 ÷ ${L} B) = ${c} slots` : "entityIndex sized from the entity count above"
+        ],
+        wasmMemory: i.memory
+      };
+    }
+    v("backing.wasm.maximumPages", i.maximumPages);
+    const u = i.initialPages ?? Math.min(32, i.maximumPages);
+    if (v("backing.wasm.initialPages", u), u > i.maximumPages)
+      throw new f(
+        E.INVALID_MEMORY_OPTIONS,
+        `memory.backing.wasm.initialPages (${u}) exceeds maximumPages (${i.maximumPages})`
+      );
+    if (n !== void 0)
+      throw new f(
+        E.INVALID_MEMORY_OPTIONS,
+        `memory.maxBytes (${I(n)}) cannot be given beside memory.backing.wasm.maximumPages (${i.maximumPages} pages = ${I(i.maximumPages * $)}), the Memory's page maximum IS the ceiling. Declare it once, in pages.`
+      );
+    const O = new WebAssembly.Memory({
+      initial: u,
+      maximum: i.maximumPages,
+      shared: !0
+    }), y = i.maximumPages * $;
+    return t === void 0 && (c = h(Math.max(y - l, 0))), {
+      source: "wasm",
+      sizing: p,
+      allocator: de(O),
+      columnCapacity: d,
+      entityIndexCapacity: c,
+      capBytes: y,
+      storeBase: l,
+      intentLabel: `engine-constructed WebAssembly.Memory (max ${i.maximumPages} pages)`,
+      budgetEntities: t ?? null,
+      derivation: [
+        `cap = ${i.maximumPages} pages × 64 KiB = ${I(y)} (Memory maximum)`,
+        `initial = ${u} pages (${i.initialPages !== void 0 ? "declared" : "default"})`,
+        `storeBase = ${I(l)}, the module owns every byte below it`,
+        ...m,
+        t === void 0 ? `entityIndex = floor_pow2((cap - storeBase)/4 ÷ ${L} B) = ${c} slots` : "entityIndex sized from the entity count above"
+      ],
+      wasmMemory: O
+    };
+  }
+  if (typeof o == "object" && o.allocator !== void 0) {
+    if (o.allocator.isInPlace !== !0)
+      throw new f(
+        E.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 i = n ?? null;
+    return t === void 0 && i !== null && (c = h(i)), {
+      source: "allocator",
+      sizing: p,
+      allocator: o.allocator,
+      columnCapacity: d,
+      entityIndexCapacity: c,
+      capBytes: i,
+      storeBase: l,
+      intentLabel: i !== null ? `custom in-place allocator (declared cap ${I(i)})` : "custom in-place allocator",
+      budgetEntities: t ?? null,
+      derivation: [
+        "backing = caller allocator (is_in_place ✓ checked at construction)",
+        i !== null ? `cap = ${I(i)} (caller-declared; the allocator owns the real ceiling)` : "cap = allocator-owned (no maxBytes declared)",
+        ...m,
+        t !== void 0 ? "entityIndex sized from the entity count above" : i !== null ? `entityIndex = floor_pow2(cap/4 ÷ ${L} B) = ${c} slots` : `entityIndex = ${c} slots (default, no entity count and no declared cap)`
+      ],
+      wasmMemory: null
+    };
+  }
+  if (o === "shared") {
+    const i = n ?? _ ?? J;
+    return N(
+      i,
+      "shared",
+      We(i),
+      `shared SharedArrayBuffer backing (${I(i)} growable cap, needs COOP and COEP)`,
+      [
+        `backing = growable_sab_allocator(${I(i)}), growable SharedArrayBuffer (is_in_place ✓), needs cross-origin isolation`,
+        "enables worker offload + a WASM compute backend (transferable SharedArrayBuffer)"
+      ]
+    );
+  }
+  if (o !== "heap")
+    throw new f(
+      E.INVALID_MEMORY_OPTIONS,
+      `memory.backing must be "heap", "shared", { wasm }, or { allocator } (got ${JSON.stringify(o)})`
+    );
+  const a = n ?? _ ?? J;
+  return N(
+    a,
+    "heap",
+    Xe(a),
+    p === "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 Gn(e, t) {
+  return { def: e, values: t };
+}
+function ne(e, t) {
+  switch (t.kind) {
+    case "spawn": {
+      const n = e.commands.spawn();
+      for (const s of t.components)
+        e.commands.add(n, s.def, s.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":
+      if (!e.hasComponent(t.eid, t.def))
+        throw new f(
+          E.COMPONENT_NOT_REGISTERED,
+          `host set_field on entity ${t.eid} targets a component it does not have. If you added that component via a host command this same frame, the add is deferred to the phase flush while set_field is immediate. Carry the value in add_component or in spawnEntry instead of a separate set_field, or set it next frame. (host write seam)`
+        );
+      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 Ke(t, "HostCommand kind");
+  }
+}
+class nn {
+  _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, s) {
+    return this._pending.push({ kind: "add_component", eid: t, def: n, values: s }), 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, s, o) {
+    return this._pending.push({
+      kind: "set_field",
+      eid: t,
+      def: n,
+      field: s,
+      value: o
+    }), 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 s = this._pending.length;
+    if (s === 0) return 0;
+    if (n === void 0)
+      for (let o = 0; o < s; o++) ne(t, this._pending[o]);
+    else
+      for (let o = 0; o < s; o++) {
+        const r = this._pending[o];
+        n(r), ne(t, r);
+      }
+    return this._pending.splice(0, s), s;
+  }
+}
+const He = M - 1;
+function sn(e) {
+  if (e === ie)
+    throw new R(
+      "cannot bind opCode 0 (reserved as the command-ring empty-slot marker)"
+    );
+  if (e < 0 || e > 255 || !Number.isInteger(e))
+    throw new R(`command opCode must be a u8 in [1, 255] (got ${e})`);
+}
+function Q(e) {
+  const t = new Uint8Array(He);
+  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 Wn(e, t) {
+  return {
+    encode(n) {
+      if (n.kind !== "set_field")
+        throw new R(
+          `ringSetFieldCodec encodes a "set_field" command (got "${n.kind}")`
+        );
+      const s = new Uint8Array(He), o = new DataView(s.buffer);
+      return o.setUint32(0, n.eid, !0), o.setFloat64(4, n.value, !0), s;
+    },
+    decode(n) {
+      const s = new DataView(n.buffer, n.byteOffset, n.byteLength);
+      return {
+        kind: "set_field",
+        // boundary: branded-ID bridging, a decoded `u32` is an `EntityID` handle.
+        eid: s.getUint32(0, !0),
+        // schema-erased into the flat HostCommand union (the callable def is invariant in S).
+        def: e,
+        field: t,
+        value: s.getFloat64(4, !0)
+      };
+    }
+  };
+}
+function Xn() {
+  return {
+    encode(e) {
+      if (e.kind !== "despawn")
+        throw new R(
+          `ringDespawnCodec encodes a "despawn" command (got "${e.kind}")`
+        );
+      return Q(e.eid);
+    },
+    decode: (e) => ({ kind: "despawn", eid: q(e) })
+  };
+}
+function Kn() {
+  return {
+    encode(e) {
+      if (e.kind !== "disable")
+        throw new R(
+          `ringDisableCodec encodes a "disable" command (got "${e.kind}")`
+        );
+      return Q(e.eid);
+    },
+    decode: (e) => ({ kind: "disable", eid: q(e) })
+  };
+}
+function zn() {
+  return {
+    encode(e) {
+      if (e.kind !== "enable")
+        throw new R(
+          `ringEnableCodec encodes an "enable" command (got "${e.kind}")`
+        );
+      return Q(e.eid);
+    },
+    decode: (e) => ({ kind: "enable", eid: q(e) })
+  };
+}
+function jn(e) {
+  return {
+    encode(t) {
+      if (t.kind !== "remove_component")
+        throw new R(
+          `ringRemoveComponentCodec encodes a "remove_component" command (got "${t.kind}")`
+        );
+      return Q(t.eid);
+    },
+    decode: (t) => ({ kind: "remove_component", eid: q(t), def: e })
+  };
+}
+class Qn {
+  _appliers = /* @__PURE__ */ new Map();
+  /** Bind a raw ctx-aware applier to `opCode`. Re-binding replaces. */
+  on(t, n) {
+    return sn(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, (s, o, r) => {
+      const l = n.decode(o);
+      r?.(l), ne(s, l);
+    });
+  }
+  /** 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, s, o) {
+    return ut(n, s, (r, l) => {
+      const d = this._appliers.get(r);
+      d !== void 0 && d(t, l, o);
+    });
+  }
+}
+const se = /* @__PURE__ */ new WeakMap();
+function qn(e, t) {
+  const n = se.get(t);
+  if (n === void 0) return !1;
+  for (const s of n) e.removeSystem(s);
+  return se.delete(t), t.clear(), !0;
+}
+function Jn(e, t) {
+  const n = new nn(), s = [];
+  se.set(n, s);
+  const o = t?.name ?? "host_command_apply", r = t?.ring, l = t?.recorder, d = l?.record, c = t?.schedules ?? [
+    ee.PRE_STARTUP,
+    ee.PRE_UPDATE
+  ];
+  if (l !== void 0) {
+    for (const _ of c)
+      if (ye(_) === "fixed")
+        throw new f(
+          E.INVALID_RECORDER_SCHEDULE,
+          `installHostCommandSeam: a recorder cannot drain at ${Se(_)}, 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 _ of c) {
+    const m = ye(_) !== "startup", h = e.registerSystem({
+      name: `${o}:${Se(_)}`,
+      // `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: (p, S) => {
+        if (l !== void 0 && m && l.openTick(p.ecsTick, S), n.drain(p, d), r !== void 0) {
+          const N = e.columnStore, a = N.header.commandRingOff;
+          a !== 0 && r.drain(p, N.view, a, d);
+        }
+      }
+    });
+    e.addSystems(_, h), s.push(h);
+  }
+  return n;
+}
+export {
+  Ft as $,
+  le as A,
+  Oe as B,
+  Ut as C,
+  J as D,
+  f as E,
+  An as F,
+  g as G,
+  Qn as H,
+  Ce as I,
+  Bn as J,
+  ke as K,
+  ce as L,
+  Pe as M,
+  un as N,
+  Ve as O,
+  k as P,
+  vn as Q,
+  Tn as R,
+  Rn as S,
+  A as T,
+  _n as U,
+  $n as V,
+  te as W,
+  Mn as X,
+  P as Y,
+  nt as Z,
+  $e as _,
+  E as a,
+  xt as a0,
+  ue as a1,
+  ve as a2,
+  G as a3,
+  ln as a4,
+  Ee as a5,
+  Ln as a6,
+  Un as a7,
+  Ue as a8,
+  Me as a9,
+  fn as aa,
+  Sn as ab,
+  cn as ac,
+  F as ad,
+  Pn as ae,
+  bn as af,
+  Cn as ag,
+  ee as ah,
+  pn as ai,
+  hn as aj,
+  In as ak,
+  En as al,
+  mn as am,
+  kn as an,
+  Jn as ao,
+  qn as ap,
+  ne as aq,
+  nn as ar,
+  Gn as as,
+  pe as at,
+  dn as au,
+  qt as b,
+  Jt as c,
+  Yn as d,
+  Vn as e,
+  Wn as f,
+  Xn as g,
+  Kn as h,
+  zn as i,
+  jn as j,
+  He as k,
+  yn as l,
+  _e as m,
+  z as n,
+  gn as o,
+  Nn as p,
+  xn as q,
+  Hn as r,
+  Fn as s,
+  On as t,
+  Dn as u,
+  qe as v,
+  an as w,
+  rn as x,
+  wn as y,
+  ze as z
+};