@oasys/oecs 0.5.4 → 0.6.0

package/dist/plugins/editor.development.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function o(r,t,e){return`${r}:${t.id}:${e}`}const a=new WeakMap;class h{constructor(t,e){this._readField=t,this._shadow=e,a.set(this,{forward:[],inverse:[]})}_staged=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}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}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}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(t){return this._txn.forward.push({kind:"disable",eid:t}),this._txn.inverse.push({kind:"enable",eid:t}),this}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=[];_listeners=[];_shadow=new Map;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))}setField(t,e,s,n){return this.transaction(i=>i.setField(t,e,s,n))}add(t,e,s){return this.transaction(n=>n.add(t,e,s))}remove(t,e,s){return this.transaction(n=>n.remove(t,e,s))}disable(t){return this.transaction(e=>e.disable(t))}enable(t){return this.transaction(e=>e.enable(t))}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(){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}clear(){this._undoStack.length=0,this._redoStack.length=0,this._shadow.clear(),this._notify()}depths(){return{undo:this._undoStack.length,redo:this._redoStack.length}}get canUndo(){return this._undoStack.length>0}get canRedo(){return this._redoStack.length>0}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()}committedField(t,e,s){return this._readField(t,e,s)}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}_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}_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)}}}exports.Editor=u;exports.TransactionBuilder=h;exports.fieldHandle=c;

package/dist/{extensions/editor/index.development.js → plugins/editor.development.js}

@@ -5,14 +5,14 @@ const a = /* @__PURE__ */ new WeakMap();
 class h {
   /** @internal */
   constructor(t, e) {
-    this.readField = t, this.shadow = e, a.set(this, { forward: [], inverse: [] });
+    this._readField = t, this._shadow = e, a.set(this, { forward: [], inverse: [] });
   }
-  /** Values staged by THIS build, layered over the editor's shared shadow. Kept
+  /** 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();
+   * 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);
   }
@@ -41,23 +41,40 @@ class h {
   }
   /**
    * 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,
+   * this edit replaced, read from the staged overlay and 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;
+    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
+   * 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;
+    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`.
+   * 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({
@@ -78,22 +95,22 @@ class h {
 }
 class u {
   constructor(t, e) {
-    this.queue = t, this.readField = e;
+    this._queue = t, this._readField = e;
   }
-  undoStack = [];
-  redoStack = [];
-  /** onChange subscribers — see {@link onChange}. */
-  listeners = [];
+  _undoStack = [];
+  _redoStack = [];
+  /** onChange subscribers, see {@link onChange}. */
+  _listeners = [];
   /** Per-`(entity, component, field)` shadow of edited values, for inverse correctness. */
-  shadow = /* @__PURE__ */ new Map();
+  _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.
+   * Group several actions into one undo entry. Build them on the passed
+   * {@link TransactionBuilder}. The whole group commits, which 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));
+    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));
@@ -109,7 +126,7 @@ class u {
   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`. */
+  /** 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));
   }
@@ -123,15 +140,15 @@ class u {
   }
   /**
    * 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
+   * 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();
+    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;
+    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
@@ -139,87 +156,87 @@ class u {
    * is empty.
    */
   redo() {
-    const t = this.redoStack.pop();
+    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;
+    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();
+    this._undoStack.length = 0, this._redoStack.length = 0, this._shadow.clear(), this._notify();
   }
-  /** Current stack depths — for an "Undo (3)" / "Redo" affordance. */
+  /** Current stack depths, for an "Undo (3)" or "Redo" affordance. */
   depths() {
-    return { undo: this.undoStack.length, redo: this.redoStack.length };
+    return { undo: this._undoStack.length, redo: this._redoStack.length };
   }
-  /** `true` when `undo()` would do something — allocation-free. */
+  /** `true` when `undo()` would do something, allocation-free. */
   get canUndo() {
-    return this.undoStack.length > 0;
+    return this._undoStack.length > 0;
   }
-  /** `true` when `redo()` would do something — allocation-free. */
+  /** `true` when `redo()` would do something, allocation-free. */
   get canRedo() {
-    return this.redoStack.length > 0;
+    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
+   * Subscribe to undo-stack and 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. Returns an unsubscribe function.
-   * Callbacks run synchronously in subscription order; read `canUndo` /
-   * `canRedo` / `depths()` inside.
+   * Callbacks run synchronously in subscription order. Read `canUndo`,
+   * `canRedo` and `depths()` inside.
    */
   onChange(t) {
-    return this.listeners.push(t), () => {
-      const e = this.listeners.indexOf(t);
-      e !== -1 && this.listeners.splice(e, 1);
+    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();
+  _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`
+   * this editor was constructed with, the default read for `fieldHandle`
    * when no channel thunk is supplied. */
   committedField(t, e, s) {
-    return this.readField(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
+   * 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
+   * 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.
+   * truth. `pending` is only the optimistic bridge.
    */
   pendingField(t, e, s) {
-    const n = o(t, e, s), i = this.shadow.get(n);
+    const n = o(t, e, s), i = this._shadow.get(n);
     if (i === void 0) return;
-    const d = this.readField(t, e, s);
+    const d = this._readField(t, e, s);
     if (d === i || d === void 0) {
-      this.shadow.delete(n);
+      this._shadow.delete(n);
       return;
     }
     return i;
   }
   /** Enqueue forward commands, record the transaction, clear redo, sync shadow. */
-  commit(t) {
+  _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;
+    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) {
+  /** Keep the setField shadow in step with the commands only enqueued. */
+  _applyShadow(t) {
     for (const e of t)
-      e.kind === "set_field" && this.shadow.set(o(e.eid, e.def, e.field), e.value);
+      e.kind === "set_field" && this._shadow.set(o(e.eid, e.def, e.field), e.value);
   }
 }
-function c(r, t, e, s, n) {
+function _(r, t, e, s, n) {
   return {
     get value() {
       return n !== void 0 ? n() : r.committedField(t, e, s);
@@ -235,5 +252,5 @@ function c(r, t, e, s, n) {
 export {
   u as Editor,
   h as TransactionBuilder,
-  c as fieldHandle
+  _ as fieldHandle
 };

package/dist/{extensions/editor/index.js → plugins/editor.js}

@@ -5,14 +5,14 @@ const a = /* @__PURE__ */ new WeakMap();
 class h {
   /** @internal */
   constructor(t, e) {
-    this.readField = t, this.shadow = e, a.set(this, { forward: [], inverse: [] });
+    this._readField = t, this._shadow = e, a.set(this, { forward: [], inverse: [] });
   }
-  /** Values staged by THIS build, layered over the editor's shared shadow. Kept
+  /** 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();
+   * 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);
   }
@@ -41,23 +41,40 @@ class h {
   }
   /**
    * 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,
+   * this edit replaced, read from the staged overlay and 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;
+    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
+   * 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;
+    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`.
+   * 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({
@@ -78,22 +95,22 @@ class h {
 }
 class u {
   constructor(t, e) {
-    this.queue = t, this.readField = e;
+    this._queue = t, this._readField = e;
   }
-  undoStack = [];
-  redoStack = [];
-  /** onChange subscribers — see {@link onChange}. */
-  listeners = [];
+  _undoStack = [];
+  _redoStack = [];
+  /** onChange subscribers, see {@link onChange}. */
+  _listeners = [];
   /** Per-`(entity, component, field)` shadow of edited values, for inverse correctness. */
-  shadow = /* @__PURE__ */ new Map();
+  _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.
+   * Group several actions into one undo entry. Build them on the passed
+   * {@link TransactionBuilder}. The whole group commits, which 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));
+    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));
@@ -109,7 +126,7 @@ class u {
   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`. */
+  /** 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));
   }
@@ -123,15 +140,15 @@ class u {
   }
   /**
    * 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
+   * 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();
+    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;
+    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
@@ -139,87 +156,87 @@ class u {
    * is empty.
    */
   redo() {
-    const t = this.redoStack.pop();
+    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;
+    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();
+    this._undoStack.length = 0, this._redoStack.length = 0, this._shadow.clear(), this._notify();
   }
-  /** Current stack depths — for an "Undo (3)" / "Redo" affordance. */
+  /** Current stack depths, for an "Undo (3)" or "Redo" affordance. */
   depths() {
-    return { undo: this.undoStack.length, redo: this.redoStack.length };
+    return { undo: this._undoStack.length, redo: this._redoStack.length };
   }
-  /** `true` when `undo()` would do something — allocation-free. */
+  /** `true` when `undo()` would do something, allocation-free. */
   get canUndo() {
-    return this.undoStack.length > 0;
+    return this._undoStack.length > 0;
   }
-  /** `true` when `redo()` would do something — allocation-free. */
+  /** `true` when `redo()` would do something, allocation-free. */
   get canRedo() {
-    return this.redoStack.length > 0;
+    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
+   * Subscribe to undo-stack and 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. Returns an unsubscribe function.
-   * Callbacks run synchronously in subscription order; read `canUndo` /
-   * `canRedo` / `depths()` inside.
+   * Callbacks run synchronously in subscription order. Read `canUndo`,
+   * `canRedo` and `depths()` inside.
    */
   onChange(t) {
-    return this.listeners.push(t), () => {
-      const e = this.listeners.indexOf(t);
-      e !== -1 && this.listeners.splice(e, 1);
+    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();
+  _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`
+   * this editor was constructed with, the default read for `fieldHandle`
    * when no channel thunk is supplied. */
   committedField(t, e, s) {
-    return this.readField(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
+   * 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
+   * 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.
+   * truth. `pending` is only the optimistic bridge.
    */
   pendingField(t, e, s) {
-    const n = o(t, e, s), i = this.shadow.get(n);
+    const n = o(t, e, s), i = this._shadow.get(n);
     if (i === void 0) return;
-    const d = this.readField(t, e, s);
+    const d = this._readField(t, e, s);
     if (d === i || d === void 0) {
-      this.shadow.delete(n);
+      this._shadow.delete(n);
       return;
     }
     return i;
   }
   /** Enqueue forward commands, record the transaction, clear redo, sync shadow. */
-  commit(t) {
+  _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;
+    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) {
+  /** Keep the setField shadow in step with the commands only enqueued. */
+  _applyShadow(t) {
     for (const e of t)
-      e.kind === "set_field" && this.shadow.set(o(e.eid, e.def, e.field), e.value);
+      e.kind === "set_field" && this._shadow.set(o(e.eid, e.def, e.field), e.value);
   }
 }
-function c(r, t, e, s, n) {
+function _(r, t, e, s, n) {
   return {
     get value() {
       return n !== void 0 ? n() : r.committedField(t, e, s);
@@ -235,5 +252,5 @@ function c(r, t, e, s, n) {
 export {
   u as Editor,
   h as TransactionBuilder,
-  c as fieldHandle
+  _ as fieldHandle
 };

package/dist/plugins/events/event_channel.d.cts

@@ -0,0 +1,13 @@
+import { EventReader } from '../../core/ecs/event.cjs';
+export declare class EventChannel {
+    readonly fieldNames: string[];
+    readonly columns: number[][];
+    readonly reader: EventReader<any>;
+    private readonly _readerLen;
+    constructor(fieldNames: string[]);
+    emit(values: Record<string, number>): void;
+    /** Emit a signal (zero-field event). */
+    emitSignal(): void;
+    clear(): void;
+}
+//# sourceMappingURL=event_channel.d.ts.map

package/dist/plugins/events/event_channel.d.ts

@@ -0,0 +1,13 @@
+import { EventReader } from '../../core/ecs/event.js';
+export declare class EventChannel {
+    readonly fieldNames: string[];
+    readonly columns: number[][];
+    readonly reader: EventReader<any>;
+    private readonly _readerLen;
+    constructor(fieldNames: string[]);
+    emit(values: Record<string, number>): void;
+    /** Emit a signal (zero-field event). */
+    emitSignal(): void;
+    clear(): void;
+}
+//# sourceMappingURL=event_channel.d.ts.map

package/dist/plugins/events/event_channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_channel.d.ts","sourceRoot":"","sources":["../../../src/plugins/events/event_channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;KAQK;AAIL,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,sBAAsB,CAAC;AAErE,qBAAa,YAAY;IACxB,SAAgB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IAEpC,SAAgB,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;IAMzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;gBAEpC,UAAU,EAAE,MAAM,EAAE;IAsBzB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAsBjD,wCAAwC;IACjC,UAAU,IAAI,IAAI;IAIlB,KAAK,IAAI,IAAI;CAOpB"}

package/dist/plugins/events/event_registry.d.cts

@@ -0,0 +1,22 @@
+import { EmptyEventSchema, EventDef, EventHooks, EventReader, EventShape } from '../../core/ecs/event.cjs';
+export declare class EventRegistry implements EventHooks {
+    private readonly _channels;
+    private readonly _dirtyChannels;
+    private _nextEventId;
+    private readonly _defsByKey;
+    register<S extends EventShape<S>>(fields: readonly (keyof S & string)[]): EventDef<S>;
+    emit(def: EventDef<any>, values: Record<string, number>): void;
+    emitSignal(def: EventDef<EmptyEventSchema>): void;
+    reader<S extends EventShape<S>>(def: EventDef<S>): EventReader<S>;
+    clear(): void;
+    /** `DEV`-only: total events currently buffered across the dirty channels.
+     * `ECS.update` samples this either side of the settle hooks to assert an
+     * onSet observer emitted nothing, its emissions would be wiped by the
+     * tick-tail `clear` and break the empty-channel-at-boundary invariant that
+     * snapshot and restore rely on. Walks only the dirty list, never the hot emit path. */
+    devBufferedCount(): number;
+    registerByKey<S extends EventShape<S>>(key: symbol, fields: readonly (keyof S & string)[]): EventDef<S>;
+    defByKey(key: symbol): EventDef<any>;
+    hasKey(key: symbol): boolean;
+}
+//# sourceMappingURL=event_registry.d.ts.map

package/dist/plugins/events/event_registry.d.ts

@@ -0,0 +1,22 @@
+import { EmptyEventSchema, EventDef, EventHooks, EventReader, EventShape } from '../../core/ecs/event.js';
+export declare class EventRegistry implements EventHooks {
+    private readonly _channels;
+    private readonly _dirtyChannels;
+    private _nextEventId;
+    private readonly _defsByKey;
+    register<S extends EventShape<S>>(fields: readonly (keyof S & string)[]): EventDef<S>;
+    emit(def: EventDef<any>, values: Record<string, number>): void;
+    emitSignal(def: EventDef<EmptyEventSchema>): void;
+    reader<S extends EventShape<S>>(def: EventDef<S>): EventReader<S>;
+    clear(): void;
+    /** `DEV`-only: total events currently buffered across the dirty channels.
+     * `ECS.update` samples this either side of the settle hooks to assert an
+     * onSet observer emitted nothing, its emissions would be wiped by the
+     * tick-tail `clear` and break the empty-channel-at-boundary invariant that
+     * snapshot and restore rely on. Walks only the dirty list, never the hot emit path. */
+    devBufferedCount(): number;
+    registerByKey<S extends EventShape<S>>(key: symbol, fields: readonly (keyof S & string)[]): EventDef<S>;
+    defByKey(key: symbol): EventDef<any>;
+    hasKey(key: symbol): boolean;
+}
+//# sourceMappingURL=event_registry.d.ts.map

package/dist/plugins/events/event_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_registry.d.ts","sourceRoot":"","sources":["../../../src/plugins/events/event_registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;KAQK;AAIL,OAAO,EAEN,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,MAAM,sBAAsB,CAAC;AAG9B,qBAAa,aAAc,YAAW,UAAU;IAE/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAKhD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAC/C,OAAO,CAAC,YAAY,CAAK;IAIzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyC;IAE7D,QAAQ,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC;IAOrF,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAY9D,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAQjD,MAAM,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAIjE,KAAK,IAAI,IAAI;IAepB;;;;2FAIuF;IAChF,gBAAgB,IAAI,MAAM;IAQ1B,aAAa,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAC3C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,GACnC,QAAQ,CAAC,CAAC,CAAC;IAcP,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC;IAYpC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAGnC"}

package/dist/plugins/events/facade.d.cts

@@ -0,0 +1,26 @@
+import { EventFieldsCover, EventKey, EventReader, EventShape, SignalKey } from '../../core/ecs/event.cjs';
+import { EventRegistry } from './event_registry.cjs';
+/** Event channels and signals. Emit during one `update()`, visible to every
+ * later system in that call, cleared before the next. System-side reads and
+ * emits go through `ctx`. This facade is the host-side surface. */
+export declare class ECSEvents {
+    private readonly _registry;
+    /** @internal constructed by the events plugin. */
+    constructor(registry: EventRegistry);
+    /** Register an event channel at world setup, before anything emits on it.
+     * `fields` must name every schema key, an under-registered channel would
+     * silently drop the missing fields at emit (see `EventFieldsCover`).
+     *
+     * @example
+     * const Damaged = eventKey<{ target: EntityID; amount: number }>("Damaged");
+     * ecs.events.register(Damaged, ["target", "amount"]);
+     * ecs.events.emit(Damaged, { target: e, amount: 10 }); // or ctx.emit inside a system
+     */
+    register<S extends EventShape<S>, const F extends readonly (keyof S & string)[]>(key: EventKey<S>, fields: F & EventFieldsCover<S, F>): void;
+    /** Register a signal (empty-payload event channel). */
+    registerSignal(key: SignalKey): void;
+    emit(key: SignalKey): void;
+    emit<S extends EventShape<S>>(key: EventKey<S>, values: NoInfer<S>): void;
+    read<S extends EventShape<S>>(key: EventKey<S>): EventReader<S>;
+}
+//# sourceMappingURL=facade.d.ts.map