@oasys/oecs 0.5.1 → 0.5.3

package/dist/extensions/editor/index.development.js

@@ -0,0 +1,239 @@
+function o(r, t, e) {
+  return `${r}:${t.id}:${e}`;
+}
+const a = /* @__PURE__ */ new WeakMap();
+class h {
+  /** @internal */
+  constructor(t, e) {
+    this.readField = t, this.shadow = e, a.set(this, { forward: [], inverse: [] });
+  }
+  /** Values staged by THIS build, layered over the editor's shared shadow. Kept
+   * transaction-local so an aborted build (the callback throws before commit)
+   * leaves the shared shadow untouched — a phantom staged value would poison
+   * `pendingField` and seed the NEXT edit's inverse with a value the world never
+   * held. The one merge point into the shared shadow is commit's `applyShadow`. */
+  staged = /* @__PURE__ */ new Map();
+  get _txn() {
+    return a.get(this);
+  }
+  spawn(t, e) {
+    const s = {
+      kind: "despawn",
+      eid: 0
+    };
+    return this._txn.inverse.push(s), this._txn.forward.push({
+      kind: "spawn",
+      components: t,
+      onSpawned: (n) => {
+        s.eid = n, e?.(n);
+      }
+    }), this;
+  }
+  despawn(t, e) {
+    const s = { kind: "despawn", eid: t };
+    return this._txn.forward.push(s), this._txn.inverse.push({
+      kind: "spawn",
+      components: e,
+      onSpawned: (n) => {
+        s.eid = n;
+      }
+    }), this;
+  }
+  /**
+   * Set `field` of `def` on `entityId` to `value`. Inverse: set it back to the value
+   * this edit replaced — read from the staged overlay / shadow (so stacked edits,
+   * within one build or before a commit, invert correctly) or, failing that, the
+   * read channel (`0` if unknown).
+   */
+  setField(t, e, s, n) {
+    const i = o(t, e, s), d = this.staged.get(i) ?? this.shadow.get(i) ?? this.readField(t, e, s) ?? 0;
+    return this.staged.set(i, n), this._txn.forward.push({ kind: "set_field", eid: t, def: e, field: s, value: n }), this._txn.inverse.push({ kind: "set_field", eid: t, def: e, field: s, value: d }), this;
+  }
+  /** Attach `def` (with complete `values`) to `entityId`. Inverse: remove it.
+   * Bare `add` — the namespaced-handle grammar (matches `ctx.commands.add` and
+   * the queue's `add`), not `addComponent`. */
+  add(t, e, s) {
+    return this._txn.forward.push({ kind: "add_component", eid: t, def: e, values: s }), this._txn.inverse.push({ kind: "remove_component", eid: t, def: e }), this;
+  }
+  /**
+   * Detach `def` from `entityId`. Inverse: re-add it from `restore` (the field values
+   * to recreate — read them from the channel before removing). Bare `remove` — see `add`.
+   */
+  remove(t, e, s) {
+    return this._txn.forward.push({ kind: "remove_component", eid: t, def: e }), this._txn.inverse.push({
+      kind: "add_component",
+      eid: t,
+      def: e,
+      values: s
+    }), this;
+  }
+  /** Disable `entityId`. Inverse: enable it. */
+  disable(t) {
+    return this._txn.forward.push({ kind: "disable", eid: t }), this._txn.inverse.push({ kind: "enable", eid: t }), this;
+  }
+  /** Enable `entityId`. Inverse: disable it. */
+  enable(t) {
+    return this._txn.forward.push({ kind: "enable", eid: t }), this._txn.inverse.push({ kind: "disable", eid: t }), this;
+  }
+}
+class u {
+  constructor(t, e) {
+    this.queue = t, this.readField = e;
+  }
+  undoStack = [];
+  redoStack = [];
+  /** onChange subscribers — see {@link onChange}. */
+  listeners = [];
+  /** Per-`(entity, component, field)` shadow of edited values, for inverse correctness. */
+  shadow = /* @__PURE__ */ new Map();
+  /**
+   * Group several actions into ONE undo entry. Build them on the passed
+   * {@link TransactionBuilder}; the whole group commits (enqueues its forward
+   * commands) and lands on the undo stack atomically, clearing the redo stack.
+   */
+  transaction(t) {
+    const e = new h(this.readField, this.shadow);
+    return t(e), this.commit(a.get(e));
+  }
+  spawn(t, e) {
+    return this.transaction((s) => s.spawn(t, e));
+  }
+  despawn(t, e) {
+    return this.transaction((s) => s.despawn(t, e));
+  }
+  /** Set one field as its own undo entry. */
+  setField(t, e, s, n) {
+    return this.transaction((i) => i.setField(t, e, s, n));
+  }
+  /** Attach a component as its own undo entry. Bare `add` (see `TransactionBuilder.add`). */
+  add(t, e, s) {
+    return this.transaction((n) => n.add(t, e, s));
+  }
+  /** Detach a component as its own undo entry; `restore` re-adds it on undo. Bare `remove`. */
+  remove(t, e, s) {
+    return this.transaction((n) => n.remove(t, e, s));
+  }
+  /** Disable `entityId` as its own undo entry. */
+  disable(t) {
+    return this.transaction((e) => e.disable(t));
+  }
+  /** Enable `entityId` as its own undo entry. */
+  enable(t) {
+    return this.transaction((e) => e.enable(t));
+  }
+  /**
+   * Undo the most recent transaction: enqueue its inverse commands (in reverse
+   * order — a group unwinds last-action-first) on the bus and move it to the redo
+   * stack. Returns `false` if the undo stack is empty.
+   */
+  undo() {
+    const t = this.undoStack.pop();
+    if (t === void 0) return !1;
+    const e = t.inverse.slice().reverse();
+    for (const s of e) this.queue.push(s);
+    return this.applyShadow(e), this.redoStack.push(t), this.notify(), !0;
+  }
+  /**
+   * Redo the most recently undone transaction: re-enqueue its forward commands on
+   * the bus and move it back to the undo stack. Returns `false` if the redo stack
+   * is empty.
+   */
+  redo() {
+    const t = this.redoStack.pop();
+    if (t === void 0) return !1;
+    for (const e of t.forward) this.queue.push(e);
+    return this.applyShadow(t.forward), this.undoStack.push(t), this.notify(), !0;
+  }
+  /** Drop both stacks (e.g. on load). Does not touch the world. */
+  clear() {
+    this.undoStack.length = 0, this.redoStack.length = 0, this.shadow.clear(), this.notify();
+  }
+  /** Current stack depths — for an "Undo (3)" / "Redo" affordance. */
+  depths() {
+    return { undo: this.undoStack.length, redo: this.redoStack.length };
+  }
+  /** `true` when `undo()` would do something — allocation-free (M10). */
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  /** `true` when `redo()` would do something — allocation-free (M10). */
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  /**
+   * Subscribe to undo/redo-stack changes: fires after every commit, undo,
+   * redo, and clear — the push signal an "Undo (3)" affordance needs instead
+   * of polling `depths()` per frame (M10). Returns an unsubscribe function.
+   * Callbacks run synchronously in subscription order; read `canUndo` /
+   * `canRedo` / `depths()` inside.
+   */
+  onChange(t) {
+    return this.listeners.push(t), () => {
+      const e = this.listeners.indexOf(t);
+      e !== -1 && this.listeners.splice(e, 1);
+    };
+  }
+  notify() {
+    for (const t of this.listeners.slice()) t();
+  }
+  /** Read one committed `(entity, component, field)` slot through the reader
+   * this editor was constructed with — the default read for `fieldHandle`
+   * when no channel thunk is supplied (M11). */
+  committedField(t, e, s) {
+    return this.readField(t, e, s);
+  }
+  /**
+   * The pending value the editor believes for a field that the committed read
+   * channel has NOT caught up to yet (the shadow), or `undefined` if none. Lets an
+   * inspector echo an edit between the `set` and the tick that commits it.
+   *
+   * Self-resolving: once the read channel reports the shadowed value (the edit
+   * landed) — or reports `undefined` (the slot is gone: entity despawned or
+   * component removed) — the entry is dropped and this returns `undefined`, so
+   * `pending` does not outlive its set→commit window and shadow a later external
+   * write, nor a dead slot's lifetime. The one
+   * residual: if an external write changes the field to a *different* value within
+   * the same window before this is next consulted, `pending` can read stale until
+   * the next edit to the slot. `value` (the read channel) is always the source of
+   * truth; `pending` is only the optimistic bridge.
+   */
+  pendingField(t, e, s) {
+    const n = o(t, e, s), i = this.shadow.get(n);
+    if (i === void 0) return;
+    const d = this.readField(t, e, s);
+    if (d === i || d === void 0) {
+      this.shadow.delete(n);
+      return;
+    }
+    return i;
+  }
+  /** Enqueue forward commands, record the transaction, clear redo, sync shadow. */
+  commit(t) {
+    if (t.forward.length === 0) return t;
+    for (const e of t.forward) this.queue.push(e);
+    return this.applyShadow(t.forward), this.undoStack.push(t), this.redoStack.length = 0, this.notify(), t;
+  }
+  /** Keep the setField shadow in step with the commands just enqueued. */
+  applyShadow(t) {
+    for (const e of t)
+      e.kind === "set_field" && this.shadow.set(o(e.eid, e.def, e.field), e.value);
+  }
+}
+function c(r, t, e, s, n) {
+  return {
+    get value() {
+      return n !== void 0 ? n() : r.committedField(t, e, s);
+    },
+    set(i) {
+      r.setField(t, e, s, i);
+    },
+    get pending() {
+      return r.pendingField(t, e, s);
+    }
+  };
+}
+export {
+  u as Editor,
+  h as TransactionBuilder,
+  c as fieldHandle
+};

package/dist/extensions/reactive/index.development.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("../../kernel-sw7ScKWu.cjs"),_=require("../../shallow-C5YmTbtb.cjs");class w{constructor(n){this.def=n}_ctx;_eid=0;get eid(){return this._eid}field(n){return this._ctx.getField(this._eid,this.def,n)}}class m{constructor(n){this.def=n}_eid=0;_row=0;cols=new Map;arch;bind(n){this.arch=n,this.cols.clear()}get eid(){return this._eid}field(n){let s=this.cols.get(n);return s===void 0&&(s=this.arch.getColumnRead(this.def,n),this.cols.set(n,s)),s[this._row]}}class v{_ctx;_eid=0;get eid(){return this._eid}field(n,s){return this._ctx.getField(this._eid,n,s)}}function p(l,n,s,r={}){const c=_.reactiveMap(r.eq),a={...r.access,reads:[n,...r.access?.reads??[]]},h=r.grain??"entity",u=r.seedExisting??!0,b=new w(n),y=(i,o)=>{o.isDisabled(i)||(b._ctx=o,b._eid=i,c.set(i,s(b)))};let g;return f.batch(()=>{if(h==="column"){const i=new m(n);g=l.observe(n,{granularity:"archetype",onSet:o=>{i.bind(o);const t=o.entityIds;for(let e=0;e<o.entityCount;e++)i._row=e,i._eid=t[e],c.set(i._eid,s(i))},onAdd:(o,t)=>y(o,t),onRemove:o=>c.delete(o),onDisable:o=>c.delete(o),onEnable:(o,t)=>y(o,t),access:a,yieldExisting:u})}else g=l.observe(n,{granularity:"entity",onSet:(i,o)=>y(i,o),onAdd:(i,o)=>y(i,o),onRemove:i=>c.delete(i),onDisable:i=>c.delete(i),onEnable:(i,o)=>y(i,o),access:a,yieldExisting:u})}),{map:c,dispose:()=>g.dispose()}}function E(l,n,s,r={}){return p(l,n,a=>{const h={};for(let u=0;u<s.length;u++)h[s[u]]=a.field(s[u]);return h},{...r,eq:_.shallow})}function S(l,n,s,r={}){const c=n,a=_.reactiveMap(r.eq),h={...r.access,reads:[...c,...r.access?.reads??[]]},u=r.seedExisting??!0,b=new v,y=(t,e)=>{for(let d=0;d<c.length;d++)if(!t.hasComponent(e,c[d]))return!1;return!0},g=(t,e)=>{e.isDisabled(t)||y(e,t)&&(b._ctx=e,b._eid=t,a.set(t,s(b)))},i=t=>{a.delete(t)};let o;return f.batch(()=>{o=c.map(t=>l.observe(t,{granularity:"entity",onSet:g,onAdd:g,onRemove:i,onDisable:i,onEnable:g,access:h,yieldExisting:u}))}),{map:a,dispose:()=>{for(let t=0;t<o.length;t++)o[t].dispose()}}}function R(l,n,s,r,c={}){const a={};for(let e=0;e<r.length;e++)a[r[e]]=0;const[h,u]=c.into??_.reactiveStruct(a,c.eq),b=f.untrack(()=>r.map(e=>h[e])),y={...c.access,reads:[n,...c.access?.reads??[]]},g=c.seedExisting??!0,i=e=>{for(let d=0;d<r.length;d++)u[r[d]](e.getField(s,n,r[d]))},o=()=>{for(let e=0;e<r.length;e++)u[r[e]](b[e])};let t;return f.batch(()=>{t=l.observe(n,{granularity:"entity",onSet:(e,d)=>{e===s&&i(d)},onAdd:(e,d)=>{e===s&&!d.isDisabled(s)&&i(d)},onRemove:e=>{e===s&&o()},onDisable:e=>{e===s&&o()},onEnable:(e,d)=>{e===s&&i(d)},access:y,yieldExisting:g})}),{struct:h,dispose:()=>t.dispose()}}function T(l,n,s,r,c={}){const a=c.into??_.reactiveArray(new Array(r.length).fill(0),c.eq),h=f.untrack(()=>a.snapshot());if(c.into!==void 0&&h.length!==r.length)throw new Error(`syncSingletonToArray: into.length (${h.length}) must equal fields.length (${r.length})`);const u={...c.access,reads:[n,...c.access?.reads??[]]},b=c.seedExisting??!0,y=new Array(r.length),g=t=>{for(let e=0;e<r.length;e++)y[e]=t.getField(s,n,r[e]);a.reconcile(y)},i=()=>a.reconcile(h);let o;return f.batch(()=>{o=l.observe(n,{granularity:"entity",onSet:(t,e)=>{t===s&&g(e)},onAdd:(t,e)=>{t===s&&!e.isDisabled(s)&&g(e)},onRemove:t=>{t===s&&i()},onDisable:t=>{t===s&&i()},onEnable:(t,e)=>{t===s&&g(e)},access:u,yieldExisting:b})}),{array:a,dispose:()=>o.dispose()}}function x(l,n){f.batch(()=>l.update(n))}exports.shallow=_.shallow;exports.batchedUpdate=x;exports.syncComponentToMap=p;exports.syncFieldsToMap=E;exports.syncJoinToMap=S;exports.syncSingletonToArray=T;exports.syncSingletonToStruct=R;

package/dist/extensions/reactive/index.development.js

@@ -0,0 +1,215 @@
+import { b as f, u as _ } from "../../kernel-Cz2Kxlwl.js";
+import { r as m, s as E, a as p, b as w } from "../../shallow-9S1pY_Iw.js";
+class v {
+  constructor(n) {
+    this.def = n;
+  }
+  _ctx;
+  _eid = 0;
+  get eid() {
+    return this._eid;
+  }
+  field(n) {
+    return this._ctx.getField(this._eid, this.def, n);
+  }
+}
+class R {
+  constructor(n) {
+    this.def = n;
+  }
+  _eid = 0;
+  _row = 0;
+  cols = /* @__PURE__ */ new Map();
+  arch;
+  /** Bind to an archetype for one dispatch (drops the previous column cache). */
+  bind(n) {
+    this.arch = n, this.cols.clear();
+  }
+  get eid() {
+    return this._eid;
+  }
+  field(n) {
+    let s = this.cols.get(n);
+    return s === void 0 && (s = this.arch.getColumnRead(this.def, n), this.cols.set(n, s)), s[this._row];
+  }
+}
+class x {
+  _ctx;
+  _eid = 0;
+  get eid() {
+    return this._eid;
+  }
+  field(n, s) {
+    return this._ctx.getField(this._eid, n, s);
+  }
+}
+function A(l, n, s, r = {}) {
+  const c = m(r.eq), a = {
+    ...r.access,
+    reads: [n, ...r.access?.reads ?? []]
+  }, h = r.grain ?? "entity", u = r.seedExisting ?? !0, b = new v(n), y = (o, i) => {
+    i.isDisabled(o) || (b._ctx = i, b._eid = o, c.set(o, s(b)));
+  };
+  let g;
+  return f(() => {
+    if (h === "column") {
+      const o = new R(n);
+      g = l.observe(n, {
+        granularity: "archetype",
+        onSet: (i) => {
+          o.bind(i);
+          const t = i.entityIds;
+          for (let e = 0; e < i.entityCount; e++)
+            o._row = e, o._eid = t[e], c.set(o._eid, s(o));
+        },
+        onAdd: (i, t) => y(i, t),
+        onRemove: (i) => c.delete(i),
+        // Disable = soft remove from the channel; enable = re-add (#677). The
+        // column sweep is bounded by enabled rows, so a disabled row would never
+        // refresh — drop it on disable, republish on enable.
+        onDisable: (i) => c.delete(i),
+        onEnable: (i, t) => y(i, t),
+        access: a,
+        yieldExisting: u
+      });
+    } else
+      g = l.observe(n, {
+        granularity: "entity",
+        onSet: (o, i) => y(o, i),
+        onAdd: (o, i) => y(o, i),
+        onRemove: (o) => c.delete(o),
+        onDisable: (o) => c.delete(o),
+        onEnable: (o, i) => y(o, i),
+        access: a,
+        yieldExisting: u
+      });
+  }), { map: c, dispose: () => g.dispose() };
+}
+function q(l, n, s, r = {}) {
+  return A(l, n, (a) => {
+    const h = {};
+    for (let u = 0; u < s.length; u++) h[s[u]] = a.field(s[u]);
+    return h;
+  }, { ...r, eq: E });
+}
+function M(l, n, s, r = {}) {
+  const c = n, a = m(r.eq), h = {
+    ...r.access,
+    reads: [...c, ...r.access?.reads ?? []]
+  }, u = r.seedExisting ?? !0, b = new x(), y = (t, e) => {
+    for (let d = 0; d < c.length; d++) if (!t.hasComponent(e, c[d])) return !1;
+    return !0;
+  }, g = (t, e) => {
+    e.isDisabled(t) || y(e, t) && (b._ctx = e, b._eid = t, a.set(t, s(b)));
+  }, o = (t) => {
+    a.delete(t);
+  };
+  let i;
+  return f(() => {
+    i = c.map(
+      (t) => l.observe(t, {
+        granularity: "entity",
+        onSet: g,
+        onAdd: g,
+        onRemove: o,
+        // Disabling any joined component soft-removes the entity from the
+        // channel; enabling re-evaluates membership and republishes (#677). A
+        // disable fires once per carried joined component — `dropRow` is
+        // idempotent, and `publishIfMember` re-checks the full join.
+        onDisable: o,
+        onEnable: g,
+        access: h,
+        yieldExisting: u
+      })
+    );
+  }), {
+    map: a,
+    dispose: () => {
+      for (let t = 0; t < i.length; t++) i[t].dispose();
+    }
+  };
+}
+function T(l, n, s, r, c = {}) {
+  const a = {};
+  for (let e = 0; e < r.length; e++) a[r[e]] = 0;
+  const [h, u] = c.into ?? p(a, c.eq), b = _(() => r.map((e) => h[e])), y = {
+    ...c.access,
+    reads: [n, ...c.access?.reads ?? []]
+  }, g = c.seedExisting ?? !0, o = (e) => {
+    for (let d = 0; d < r.length; d++) u[r[d]](e.getField(s, n, r[d]));
+  }, i = () => {
+    for (let e = 0; e < r.length; e++) u[r[e]](b[e]);
+  };
+  let t;
+  return f(() => {
+    t = l.observe(n, {
+      granularity: "entity",
+      onSet: (e, d) => {
+        e === s && o(d);
+      },
+      onAdd: (e, d) => {
+        e === s && !d.isDisabled(s) && o(d);
+      },
+      onRemove: (e) => {
+        e === s && i();
+      },
+      onDisable: (e) => {
+        e === s && i();
+      },
+      onEnable: (e, d) => {
+        e === s && o(d);
+      },
+      access: y,
+      yieldExisting: g
+    });
+  }), { struct: h, dispose: () => t.dispose() };
+}
+function C(l, n, s, r, c = {}) {
+  const a = c.into ?? w(new Array(r.length).fill(0), c.eq), h = _(() => a.snapshot());
+  if (c.into !== void 0 && h.length !== r.length)
+    throw new Error(
+      `syncSingletonToArray: into.length (${h.length}) must equal fields.length (${r.length})`
+    );
+  const u = {
+    ...c.access,
+    reads: [n, ...c.access?.reads ?? []]
+  }, b = c.seedExisting ?? !0, y = new Array(r.length), g = (t) => {
+    for (let e = 0; e < r.length; e++) y[e] = t.getField(s, n, r[e]);
+    a.reconcile(y);
+  }, o = () => a.reconcile(h);
+  let i;
+  return f(() => {
+    i = l.observe(n, {
+      granularity: "entity",
+      onSet: (t, e) => {
+        t === s && g(e);
+      },
+      onAdd: (t, e) => {
+        t === s && !e.isDisabled(s) && g(e);
+      },
+      onRemove: (t) => {
+        t === s && o();
+      },
+      onDisable: (t) => {
+        t === s && o();
+      },
+      onEnable: (t, e) => {
+        t === s && g(e);
+      },
+      access: u,
+      yieldExisting: b
+    });
+  }), { array: a, dispose: () => i.dispose() };
+}
+function F(l, n) {
+  f(() => l.update(n));
+}
+export {
+  F as batchedUpdate,
+  E as shallow,
+  A as syncComponentToMap,
+  q as syncFieldsToMap,
+  M as syncJoinToMap,
+  C as syncSingletonToArray,
+  T as syncSingletonToStruct
+};

package/dist/extensions/solid/index.development.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("solid-js"),i=require("../../interop-T1HZ-Dpa.cjs");function l(e){const[t,o]=u.createSignal(e());return u.onCleanup(i.subscribe(e,s=>o(()=>s))),t}function c(e){return{keys:l(()=>e.keys()),cell:t=>l(()=>e.get(t))}}function f(e){const t={},o=Object.keys(e),s=new Set(o);for(const n of o)t[n]=l(()=>e[n]);return new Proxy({},{get:(n,r)=>s.has(r)?t[r]():Reflect.get(n,r),has:(n,r)=>s.has(r),ownKeys:()=>o,getOwnPropertyDescriptor:(n,r)=>s.has(r)?{get:()=>t[r](),enumerable:!0,configurable:!0}:void 0,set:(n,r)=>{throw new TypeError(`fromKernelStruct view is read-only: write through the kernel struct's setters (set.${String(r)}(value)), not the bridged view`)}})}function a(e){return l(()=>e.snapshot())}exports.fromKernel=l;exports.fromKernelArray=a;exports.fromKernelMap=c;exports.fromKernelStruct=f;

package/dist/extensions/solid/index.development.js

@@ -0,0 +1,40 @@
+import { createSignal as u, onCleanup as c } from "solid-js";
+import { s as f } from "../../interop-DqxleBo7.js";
+function i(e) {
+  const [t, o] = u(e());
+  return c(f(e, (s) => o(() => s))), t;
+}
+function g(e) {
+  return {
+    keys: i(() => e.keys()),
+    cell: (t) => i(() => e.get(t))
+  };
+}
+function h(e) {
+  const t = {}, o = Object.keys(e), s = new Set(o);
+  for (const n of o)
+    t[n] = i(() => e[n]);
+  return new Proxy({}, {
+    get: (n, r) => s.has(r) ? t[r]() : Reflect.get(n, r),
+    has: (n, r) => s.has(r),
+    ownKeys: () => o,
+    getOwnPropertyDescriptor: (n, r) => s.has(r) ? { get: () => t[r](), enumerable: !0, configurable: !0 } : void 0,
+    // Read surface only (`Readonly<T>`, POLISH_AUDIT #8) — mirrors the kernel
+    // struct proxy's trap so a JS-side assignment fails loudly instead of
+    // sticking a non-reactive value on the hidden target.
+    set: (n, r) => {
+      throw new TypeError(
+        `fromKernelStruct view is read-only: write through the kernel struct's setters (set.${String(r)}(value)), not the bridged view`
+      );
+    }
+  });
+}
+function y(e) {
+  return i(() => e.snapshot());
+}
+export {
+  i as fromKernel,
+  y as fromKernelArray,
+  g as fromKernelMap,
+  h as fromKernelStruct
+};

package/dist/{host_commands-BI8pEmjH.js → host_commands-3jyFfWNg.js}

@@ -1,5 +1,5 @@
 import { S as et, t as tt } from "./topological_sort-DK6EjpWa.js";
-import { D as nt, h as K, w as we, g as st } from "./shared-BU1Cd40h.js";
+import { D as nt, h as K, w as we, g as st } from "./shared-DQKK0i-E.js";
 class Be extends Error {
   constructor(t, n, r) {
     super(t), this.isOperational = n, this.context = r, this.name = this.constructor.name, Error.captureStackTrace(this, this.constructor);
@@ -1906,7 +1906,7 @@ function as(e) {
       intentLabel: `pure-TS heap backing (${I(s)} growable cap, no SharedArrayBuffer)`,
       budgetEntities: null,
       derivation: [
-        `backing = heap_arraybuffer_allocator(${I(s)}) — resizable ArrayBuffer, no SAB / no COOP+COEP (is_in_place ✓)`,
+        `backing = heap_arraybuffer_allocator(${I(s)}) — fixed ArrayBuffer reserved at the cap, no SAB / no COOP+COEP (is_in_place ✓)`,
         "trade-off: no worker offload / no WASM backend (both need a transferable SharedArrayBuffer)",
         `column_capacity = ${o} (${n !== void 0 ? "pinned" : "default"})`,
         `entity_index = floor_pow2(cap/4 ÷ ${D} B) = ${i} slots`