@oasys/oecs 0.3.0 → 0.4.0

package/dist/extensions/editor/editor.d.ts

@@ -0,0 +1,149 @@
+import { ComponentDef, ComponentHandle, ComponentSchema, EntityID, FieldValues, HostCommand, HostCommandQueue, SpawnEntry } from '../../core/ecs';
+/**
+ * Reads the committed value of one `(entity, component, field)` slot — the editor
+ * uses it to seed a `setField` inverse with the value the edit replaced. Wire it
+ * to the reactive read channel (e.g. a `reactiveMap`/`reactiveStruct` projection)
+ * or to `world.getField`; `undefined` for an unknown slot falls back to `0`.
+ */
+export type FieldReader = (eid: EntityID, def: ComponentDef, field: string) => number | undefined;
+/**
+ * A reified, undoable unit of editor work: the `forward` commands and their
+ * `inverse`, both plain `HostCommand` data on the one bus. The arrays are mutable
+ * internally (the spawn/despawn id finalizers patch a slot at apply time) but the
+ * type handed back from {@link Editor.transaction} is read-only.
+ */
+export interface EditorTransaction {
+    readonly forward: readonly HostCommand[];
+    readonly inverse: readonly HostCommand[];
+}
+/** Internal, mutable transaction the id-finalizers patch in place. */
+interface MutableTxn {
+    forward: HostCommand[];
+    inverse: HostCommand[];
+}
+/**
+ * Accumulates the `forward`/`inverse` commands for ONE transaction. Each method
+ * appends a forward command and its inverse, computing the inverse from the
+ * shadow / read channel where needed. Spawn and despawn install id-finalizers
+ * (via `HostCommand.onSpawned`) that patch the apply-time id into the right slot.
+ *
+ * Obtained from {@link Editor.transaction}; not constructed directly.
+ */
+export declare class TransactionBuilder {
+    private readonly readField;
+    private readonly shadow;
+    /** @internal */
+    readonly _txn: MutableTxn;
+    /** @internal */
+    constructor(readField: FieldReader, shadow: Map<string, number>);
+    /**
+     * Spawn an entity carrying `components`. Inverse: despawn the created entity,
+     * finalized once the spawn applies (the id only exists post-flush). `onSpawned`
+     * also forwards the new id to the caller. The finalizer re-fires on redo, so the
+     * inverse tracks the current id.
+     */
+    spawn(components: readonly SpawnEntry[], onSpawned?: (eid: EntityID) => void): this;
+    /**
+     * Despawn `eid`. Inverse: respawn from `restore` (the components+values to
+     * recreate — read them from the channel before despawning). Undo respawns the
+     * DATA, not the identity: the new entity gets a fresh id, and the respawn's
+     * `onSpawned` rewrites this despawn's target so redo removes the respawned
+     * entity rather than the dead original.
+     */
+    despawn(eid: EntityID, restore: readonly SpawnEntry[]): this;
+    /**
+     * Set `field` of `def` on `eid` to `value`. Inverse: set it back to the value
+     * this edit replaced — read from the shadow (so stacked edits before a commit
+     * invert correctly) or, failing that, the read channel (`0` if unknown).
+     */
+    setField<S extends ComponentSchema>(eid: EntityID, def: ComponentDef<S>, field: string & keyof S, value: number): this;
+    /** Add `def` (with complete `values`) to `eid`. Inverse: remove it. */
+    addComponent<S extends ComponentSchema>(eid: EntityID, def: ComponentDef<S>, values: FieldValues<S>): this;
+    /**
+     * Remove `def` from `eid`. Inverse: re-add it from `restore` (the field values
+     * to recreate — read them from the channel before removing).
+     */
+    removeComponent<S extends ComponentSchema>(eid: EntityID, def: ComponentDef<S>, restore: FieldValues<S>): this;
+    /** Disable `eid`. Inverse: enable it. */
+    disable(eid: EntityID): this;
+    /** Enable `eid`. Inverse: disable it. */
+    enable(eid: EntityID): this;
+}
+/**
+ * The editor's undo/redo manager over a {@link HostCommandQueue}. Each action is a
+ * reified {@link EditorTransaction} pushed onto the undo stack; `undo()`/`redo()`
+ * enqueue its inverse/forward on the SAME bus. The single-action methods
+ * (`spawn`, `setField`, …) are sugar for one-command transactions; `transaction`
+ * groups several into one undo entry.
+ *
+ * Construct with the queue and a {@link FieldReader} for the committed read
+ * channel (used to seed `setField` inverses).
+ */
+export declare class Editor {
+    private readonly queue;
+    private readonly readField;
+    private readonly undoStack;
+    private readonly redoStack;
+    /** Per-`(entity, component, field)` shadow of edited values, for inverse correctness. */
+    private readonly shadow;
+    constructor(queue: HostCommandQueue, readField: FieldReader);
+    /**
+     * 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(build: (tx: TransactionBuilder) => void): EditorTransaction;
+    /** Spawn `components` as its own undo entry. `onSpawned` reports the new id. */
+    spawn(components: readonly SpawnEntry[], onSpawned?: (eid: EntityID) => void): EditorTransaction;
+    /** Despawn `eid` as its own undo entry; `restore` recreates it on undo. */
+    despawn(eid: EntityID, restore: readonly SpawnEntry[]): EditorTransaction;
+    /** Set one field as its own undo entry. */
+    setField<S extends ComponentSchema>(eid: EntityID, def: ComponentDef<S>, field: string & keyof S, value: number): EditorTransaction;
+    /** Add a component as its own undo entry. */
+    addComponent<S extends ComponentSchema>(eid: EntityID, def: ComponentDef<S>, values: FieldValues<S>): EditorTransaction;
+    /** Remove a component as its own undo entry; `restore` re-adds it on undo. */
+    removeComponent<S extends ComponentSchema>(eid: EntityID, def: ComponentDef<S>, restore: FieldValues<S>): EditorTransaction;
+    /** Disable `eid` as its own undo entry. */
+    disable(eid: EntityID): EditorTransaction;
+    /** Enable `eid` as its own undo entry. */
+    enable(eid: EntityID): EditorTransaction;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): boolean;
+    /** Drop both stacks (e.g. on load). Does not touch the world. */
+    clear(): void;
+    /** Current stack depths — for an "Undo (3)" / "Redo" affordance. */
+    depths(): {
+        undo: number;
+        redo: number;
+    };
+    /**
+     * 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), the entry is dropped and this returns `undefined` — so `pending` does
+     * not outlive its set→commit window and shadow a later external write. 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(eid: EntityID, def: ComponentHandle, field: string): number | undefined;
+    /** Enqueue forward commands, record the transaction, clear redo, sync shadow. */
+    private commit;
+    /** Keep the setField shadow in step with the commands just enqueued. */
+    private applyShadow;
+}
+export {};
+//# sourceMappingURL=editor.d.ts.map

package/dist/extensions/editor/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../src/extensions/editor/editor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,eAAe,EACf,QAAQ,EACR,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,MAAM,gBAAgB,CAAC;AAExB;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAElG;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;CACzC;AAED,sEAAsE;AACtE,UAAU,UAAU;IACnB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,OAAO,EAAE,WAAW,EAAE,CAAC;CACvB;AAOD;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAM7B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IANxB,gBAAgB;IAChB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAgC;IAEzD,gBAAgB;gBAEE,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAG7C;;;;;OAKG;IACH,KAAK,CAAC,UAAU,EAAE,SAAS,UAAU,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI;IAyBnF;;;;;;OAMG;IACH,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI;IAiB5D;;;;OAIG;IACH,QAAQ,CAAC,CAAC,SAAS,eAAe,EACjC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,EACvB,KAAK,EAAE,MAAM,GACX,IAAI;IASP,uEAAuE;IACvE,YAAY,CAAC,CAAC,SAAS,eAAe,EACrC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GACpB,IAAI;IAMP;;;OAGG;IACH,eAAe,CAAC,CAAC,SAAS,eAAe,EACxC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GACrB,IAAI;IAWP,yCAAyC;IACzC,OAAO,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;IAM5B,yCAAyC;IACzC,MAAM,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;CAK3B;AAED;;;;;;;;;GASG;AACH,qBAAa,MAAM;IAOjB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAP3B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,yFAAyF;IACzF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;gBAGlC,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,WAAW;IAGxC;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,kBAAkB,KAAK,IAAI,GAAG,iBAAiB;IAMvE,gFAAgF;IAChF,KAAK,CACJ,UAAU,EAAE,SAAS,UAAU,EAAE,EACjC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,IAAI,GACjC,iBAAiB;IAIpB,2EAA2E;IAC3E,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,iBAAiB;IAIzE,2CAA2C;IAC3C,QAAQ,CAAC,CAAC,SAAS,eAAe,EACjC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,EACvB,KAAK,EAAE,MAAM,GACX,iBAAiB;IAIpB,6CAA6C;IAC7C,YAAY,CAAC,CAAC,SAAS,eAAe,EACrC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GACpB,iBAAiB;IAIpB,8EAA8E;IAC9E,eAAe,CAAC,CAAC,SAAS,eAAe,EACxC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GACrB,iBAAiB;IAIpB,2CAA2C;IAC3C,OAAO,CAAC,GAAG,EAAE,QAAQ,GAAG,iBAAiB;IAIzC,0CAA0C;IAC1C,MAAM,CAAC,GAAG,EAAE,QAAQ,GAAG,iBAAiB;IAIxC;;;;OAIG;IACH,IAAI,IAAI,OAAO;IAUf;;;;OAIG;IACH,IAAI,IAAI,OAAO;IASf,iEAAiE;IACjE,KAAK,IAAI,IAAI;IAMb,oEAAoE;IACpE,MAAM,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAIxC;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAepF,iFAAiF;IACjF,OAAO,CAAC,MAAM;IAYd,wEAAwE;IACxE,OAAO,CAAC,WAAW;CAOnB"}

package/dist/extensions/editor/field_handle.d.ts

@@ -0,0 +1,35 @@
+import { ComponentDef, ComponentSchema, EntityID } from '../../core/ecs';
+import { Editor } from './editor';
+/**
+ * A two-way handle on one `(entity, component, field)` slot. `value` reads the
+ * reactive channel (tracked, if read in a tracking scope); `set` enqueues an
+ * undoable `setField` command via the editor.
+ */
+export interface FieldHandle {
+    /**
+     * The field's current value through the reactive read channel — `undefined`
+     * until the channel has it (e.g. before the spawn's first commit). Read inside
+     * a tracking scope to subscribe to the channel; the value reflects the last
+     * COMMITTED tick, so a fresh `set` shows up on the next tick.
+     */
+    readonly value: number | undefined;
+    /** Enqueue an undoable `setField` for this slot; applied at the next tick. */
+    set(value: number): void;
+    /**
+     * The editor's pending (not-yet-committed) value for this slot, or `undefined`
+     * if none — a NON-reactive read of the editor shadow, for an optimistic echo
+     * between the `set` and its commit. Self-resolves to `undefined` once the read
+     * channel catches up, so it does not outlive the edit. Not a substitute for
+     * `value` in a tracking scope (it does not subscribe); `value` is the source of
+     * truth.
+     */
+    readonly pending: number | undefined;
+}
+/**
+ * Build a {@link FieldHandle} for one `(eid, def, field)` slot. `read` is the
+ * tracked read of the reactive channel for this field (e.g.
+ * `() => sync.map.get(eid)?.x`); `set` routes through `editor.setField`, so the
+ * edit is queued, batched, and undoable.
+ */
+export declare function fieldHandle<S extends ComponentSchema>(editor: Editor, eid: EntityID, def: ComponentDef<S>, field: string & keyof S, read: () => number | undefined): FieldHandle;
+//# sourceMappingURL=field_handle.d.ts.map

package/dist/extensions/editor/field_handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field_handle.d.ts","sourceRoot":"","sources":["../../../src/extensions/editor/field_handle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,8EAA8E;IAC9E,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,eAAe,EACpD,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,EACvB,IAAI,EAAE,MAAM,MAAM,GAAG,SAAS,GAC5B,WAAW,CAYb"}

package/dist/extensions/editor/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function o(i,t,n){return`${i}:${t.id}:${n}`}class a{constructor(t,n){this.readField=t,this.shadow=n}_txn={forward:[],inverse:[]};spawn(t,n){const e={kind:"despawn",eid:0};return this._txn.inverse.push(e),this._txn.forward.push({kind:"spawn",components:t,onSpawned:s=>{e.eid=s,n?.(s)}}),this}despawn(t,n){const e={kind:"despawn",eid:t};return this._txn.forward.push(e),this._txn.inverse.push({kind:"spawn",components:n,onSpawned:s=>{e.eid=s}}),this}setField(t,n,e,s){const r=o(t,n,e),d=this.shadow.get(r)??this.readField(t,n,e)??0;return this.shadow.set(r,s),this._txn.forward.push({kind:"set_field",eid:t,def:n,field:e,value:s}),this._txn.inverse.push({kind:"set_field",eid:t,def:n,field:e,value:d}),this}addComponent(t,n,e){return this._txn.forward.push({kind:"add_component",eid:t,def:n,values:e}),this._txn.inverse.push({kind:"remove_component",eid:t,def:n}),this}removeComponent(t,n,e){return this._txn.forward.push({kind:"remove_component",eid:t,def:n}),this._txn.inverse.push({kind:"add_component",eid:t,def:n,values:e}),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 h{constructor(t,n){this.queue=t,this.readField=n}undoStack=[];redoStack=[];shadow=new Map;transaction(t){const n=new a(this.readField,this.shadow);return t(n),this.commit(n._txn)}spawn(t,n){return this.transaction(e=>e.spawn(t,n))}despawn(t,n){return this.transaction(e=>e.despawn(t,n))}setField(t,n,e,s){return this.transaction(r=>r.setField(t,n,e,s))}addComponent(t,n,e){return this.transaction(s=>s.addComponent(t,n,e))}removeComponent(t,n,e){return this.transaction(s=>s.removeComponent(t,n,e))}disable(t){return this.transaction(n=>n.disable(t))}enable(t){return this.transaction(n=>n.enable(t))}undo(){const t=this.undoStack.pop();if(t===void 0)return!1;const n=t.inverse.slice().reverse();for(const e of n)this.queue.push(e);return this.applyShadow(n),this.redoStack.push(t),!0}redo(){const t=this.redoStack.pop();if(t===void 0)return!1;for(const n of t.forward)this.queue.push(n);return this.applyShadow(t.forward),this.undoStack.push(t),!0}clear(){this.undoStack.length=0,this.redoStack.length=0,this.shadow.clear()}depths(){return{undo:this.undoStack.length,redo:this.redoStack.length}}pendingField(t,n,e){const s=o(t,n,e),r=this.shadow.get(s);if(r!==void 0){if(this.readField(t,n,e)===r){this.shadow.delete(s);return}return r}}commit(t){if(t.forward.length===0)return t;for(const n of t.forward)this.queue.push(n);return this.applyShadow(t.forward),this.undoStack.push(t),this.redoStack.length=0,t}applyShadow(t){for(const n of t)n.kind==="set_field"&&this.shadow.set(o(n.eid,n.def,n.field),n.value)}}function u(i,t,n,e,s){return{get value(){return s()},set(r){i.setField(t,n,e,r)},get pending(){return i.pendingField(t,n,e)}}}exports.Editor=h;exports.TransactionBuilder=a;exports.fieldHandle=u;

package/dist/extensions/editor/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The host write seam's EDITOR layer (#701) — layer 2 of #681 / PATTERNS §85.
+ *
+ * Reified undo/redo + the inspector field-handle, built on the shipped typed
+ * `HostCommandQueue` (#698). Application policy, so it lives here in
+ * `engine-extensions`, not engine core — and it pulls NO third-party / framework
+ * dependency (the field-handle reads through a caller-supplied thunk).
+ *
+ *   - `Editor` — reified `EditorTransaction`s on undo/redo stacks, with
+ *     transaction grouping; `undo()`/`redo()` enqueue the inverse/forward on the
+ *     SAME bus, applied at the next schedule head (undo is just another command).
+ *   - `fieldHandle` — pairs a reactive-channel read with a `setField` command, so
+ *     an inspector field feels two-way while staying safe and undoable.
+ *
+ * Reachable as `@oasys/oecs/editor`. Pair it with
+ * `@oasys/oecs/reactive-sync`'s `syncFieldsToMap` /
+ * `syncSingletonToStruct` for the read channel the field-handle reads through.
+ */
+export { Editor, TransactionBuilder, type EditorTransaction, type FieldReader } from './editor';
+export { fieldHandle, type FieldHandle } from './field_handle';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/editor/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAChG,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/extensions/editor/index.js

@@ -0,0 +1,209 @@
+function o(i, t, n) {
+  return `${i}:${t.id}:${n}`;
+}
+class d {
+  /** @internal */
+  constructor(t, n) {
+    this.readField = t, this.shadow = n;
+  }
+  /** @internal */
+  _txn = { forward: [], inverse: [] };
+  /**
+   * Spawn an entity carrying `components`. Inverse: despawn the created entity,
+   * finalized once the spawn applies (the id only exists post-flush). `onSpawned`
+   * also forwards the new id to the caller. The finalizer re-fires on redo, so the
+   * inverse tracks the current id.
+   */
+  spawn(t, n) {
+    const e = {
+      kind: "despawn",
+      eid: 0
+    };
+    return this._txn.inverse.push(e), this._txn.forward.push({
+      kind: "spawn",
+      components: t,
+      onSpawned: (s) => {
+        e.eid = s, n?.(s);
+      }
+    }), this;
+  }
+  /**
+   * Despawn `eid`. Inverse: respawn from `restore` (the components+values to
+   * recreate — read them from the channel before despawning). Undo respawns the
+   * DATA, not the identity: the new entity gets a fresh id, and the respawn's
+   * `onSpawned` rewrites this despawn's target so redo removes the respawned
+   * entity rather than the dead original.
+   */
+  despawn(t, n) {
+    const e = { kind: "despawn", eid: t };
+    return this._txn.forward.push(e), this._txn.inverse.push({
+      kind: "spawn",
+      components: n,
+      onSpawned: (s) => {
+        e.eid = s;
+      }
+    }), this;
+  }
+  /**
+   * Set `field` of `def` on `eid` to `value`. Inverse: set it back to the value
+   * this edit replaced — read from the shadow (so stacked edits before a commit
+   * invert correctly) or, failing that, the read channel (`0` if unknown).
+   */
+  setField(t, n, e, s) {
+    const r = o(t, n, e), a = this.shadow.get(r) ?? this.readField(t, n, e) ?? 0;
+    return this.shadow.set(r, s), this._txn.forward.push({ kind: "set_field", eid: t, def: n, field: e, value: s }), this._txn.inverse.push({ kind: "set_field", eid: t, def: n, field: e, value: a }), this;
+  }
+  /** Add `def` (with complete `values`) to `eid`. Inverse: remove it. */
+  addComponent(t, n, e) {
+    return this._txn.forward.push({ kind: "add_component", eid: t, def: n, values: e }), this._txn.inverse.push({ kind: "remove_component", eid: t, def: n }), this;
+  }
+  /**
+   * Remove `def` from `eid`. Inverse: re-add it from `restore` (the field values
+   * to recreate — read them from the channel before removing).
+   */
+  removeComponent(t, n, e) {
+    return this._txn.forward.push({ kind: "remove_component", eid: t, def: n }), this._txn.inverse.push({
+      kind: "add_component",
+      eid: t,
+      def: n,
+      values: e
+    }), this;
+  }
+  /** Disable `eid`. Inverse: enable it. */
+  disable(t) {
+    return this._txn.forward.push({ kind: "disable", eid: t }), this._txn.inverse.push({ kind: "enable", eid: t }), this;
+  }
+  /** Enable `eid`. Inverse: disable it. */
+  enable(t) {
+    return this._txn.forward.push({ kind: "enable", eid: t }), this._txn.inverse.push({ kind: "disable", eid: t }), this;
+  }
+}
+class h {
+  constructor(t, n) {
+    this.queue = t, this.readField = n;
+  }
+  undoStack = [];
+  redoStack = [];
+  /** 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 n = new d(this.readField, this.shadow);
+    return t(n), this.commit(n._txn);
+  }
+  /** Spawn `components` as its own undo entry. `onSpawned` reports the new id. */
+  spawn(t, n) {
+    return this.transaction((e) => e.spawn(t, n));
+  }
+  /** Despawn `eid` as its own undo entry; `restore` recreates it on undo. */
+  despawn(t, n) {
+    return this.transaction((e) => e.despawn(t, n));
+  }
+  /** Set one field as its own undo entry. */
+  setField(t, n, e, s) {
+    return this.transaction((r) => r.setField(t, n, e, s));
+  }
+  /** Add a component as its own undo entry. */
+  addComponent(t, n, e) {
+    return this.transaction((s) => s.addComponent(t, n, e));
+  }
+  /** Remove a component as its own undo entry; `restore` re-adds it on undo. */
+  removeComponent(t, n, e) {
+    return this.transaction((s) => s.removeComponent(t, n, e));
+  }
+  /** Disable `eid` as its own undo entry. */
+  disable(t) {
+    return this.transaction((n) => n.disable(t));
+  }
+  /** Enable `eid` as its own undo entry. */
+  enable(t) {
+    return this.transaction((n) => n.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 n = t.inverse.slice().reverse();
+    for (const e of n) this.queue.push(e);
+    return this.applyShadow(n), this.redoStack.push(t), !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 n of t.forward) this.queue.push(n);
+    return this.applyShadow(t.forward), this.undoStack.push(t), !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();
+  }
+  /** Current stack depths — for an "Undo (3)" / "Redo" affordance. */
+  depths() {
+    return { undo: this.undoStack.length, redo: this.redoStack.length };
+  }
+  /**
+   * 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), the entry is dropped and this returns `undefined` — so `pending` does
+   * not outlive its set→commit window and shadow a later external write. 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, n, e) {
+    const s = o(t, n, e), r = this.shadow.get(s);
+    if (r !== void 0) {
+      if (this.readField(t, n, e) === r) {
+        this.shadow.delete(s);
+        return;
+      }
+      return r;
+    }
+  }
+  /** Enqueue forward commands, record the transaction, clear redo, sync shadow. */
+  commit(t) {
+    if (t.forward.length === 0) return t;
+    for (const n of t.forward) this.queue.push(n);
+    return this.applyShadow(t.forward), this.undoStack.push(t), this.redoStack.length = 0, t;
+  }
+  /** Keep the setField shadow in step with the commands just enqueued. */
+  applyShadow(t) {
+    for (const n of t)
+      n.kind === "set_field" && this.shadow.set(o(n.eid, n.def, n.field), n.value);
+  }
+}
+function u(i, t, n, e, s) {
+  return {
+    get value() {
+      return s();
+    },
+    set(r) {
+      i.setField(t, n, e, r);
+    },
+    get pending() {
+      return i.pendingField(t, n, e);
+    }
+  };
+}
+export {
+  h as Editor,
+  d as TransactionBuilder,
+  u as fieldHandle
+};

package/dist/extensions/reactive/ecs_sync.d.ts

@@ -0,0 +1,210 @@
+import { ReactiveArray, ReactiveMap, StructSetters } from '../../core/reactive';
+import { ComponentDef, ComponentSchema, ECS, EntityID, SystemAccessDeclaration } from '../../core/ecs';
+/**
+ * Shallow (one-level) value equality — the recommended `eq` for object-valued
+ * projections. Mirrors zustand `useShallow` / MobX `comparer.shallow`: two objects
+ * are equal iff they have the same own keys with `Object.is`-equal values. Restores
+ * "equal write wakes nobody" for projections that build a fresh object each tick.
+ */
+export declare function shallow(a: object, b: object): boolean;
+/**
+ * A read cursor over one entity's single-component state, handed to a single-
+ * component `Projection`. `field` is column-backed under "column" grain
+ * (sequential), random-access (`getField`) under "entity" grain.
+ *
+ * Lifetime: the cursor is a reused, mutable singleton valid ONLY during the
+ * synchronous `project` call for the current row. Read what you need and return —
+ * never capture `row` (or stash its `field` reads keyed off a later closure): the
+ * next row/tick mutates it in place, so a captured cursor reads stale data.
+ */
+export interface RowReader<S extends ComponentSchema> {
+    /** The current entity (the row being projected). */
+    readonly eid: EntityID;
+    /** Read a field of the synced component for the current row. */
+    field<K extends string & keyof S>(name: K): number;
+}
+/**
+ * A read cursor over a JOINED entity (it carries every component in the join), for
+ * a `JoinProjection`. `field(def, name)` reads any field of any joined component
+ * for the current entity (random-access; the join subscribes to all of them so the
+ * read can never go stale).
+ *
+ * Lifetime: like `RowReader`, a reused mutable singleton valid ONLY during the
+ * synchronous `project` call — never capture it; the next dispatch mutates it.
+ */
+export interface JoinReader {
+    /** The current entity (it has all joined components). */
+    readonly eid: EntityID;
+    /** Read a field of one joined component for the current entity. */
+    field<S extends ComponentSchema, K extends string & keyof S>(def: ComponentDef<S>, name: K): number;
+}
+/** Map one single-component row to the value a UI cell reads. */
+export type Projection<S extends ComponentSchema, V> = (row: RowReader<S>) => V;
+/** Map one joined entity to the value a UI cell reads. */
+export type JoinProjection<V> = (row: JoinReader) => V;
+/** Per-component dirty grain. See the module header for the measured crossover. */
+export type SyncGrain = "entity" | "column";
+export interface EcsMapSyncOptions<V> {
+    /** Dirty grain (default `"entity"`). Use `"column"` for high-churn components. */
+    grain?: SyncGrain;
+    /**
+     * Value equality for the map's per-key no-op skip (default `Object.is`). Pass
+     * `shallow` for object projections, or a content comparator. A fresh object
+     * every tick under the default reference eq wakes the row every frame.
+     */
+    eq?: (a: V, b: V) => boolean;
+    /**
+     * Access surface the projection touches, merged over the synced components'
+     * `reads`. `__DEV__` access-checks the observer callbacks exactly like a system.
+     */
+    access?: Partial<SystemAccessDeclaration>;
+    /**
+     * Replay current matches on registration (default `true`), so a bridge attached
+     * to an already-populated world seeds the map with present state instead of
+     * waking only on the next change. flecs `yieldExisting`.
+     */
+    seedExisting?: boolean;
+}
+export interface EcsMapSync<V> {
+    /** The live channel: a reader of key `eid` subscribes to that entity alone. */
+    readonly map: ReactiveMap<EntityID, V>;
+    /** Unregister the observer(s) and stop publishing. Safe to call more than once. */
+    dispose(): void;
+}
+/**
+ * Sync ONE component's change detection into a `reactiveMap`, keyed by `EntityID`.
+ * A value change publishes the changed rows; a spawn inserts a row and a despawn
+ * deletes it. Returns the map + a disposer. Drive with `batchedUpdate(world, dt)`.
+ *
+ * To read more than one component per row, use `syncJoinToMap` — reading a second
+ * component here goes stale (its changes aren't subscribed).
+ */
+export declare function syncComponentToMap<S extends ComponentSchema, V>(world: ECS, def: ComponentDef<S>, project: Projection<S, V>, opts?: EcsMapSyncOptions<V>): EcsMapSync<V>;
+/**
+ * Sugar over `syncComponentToMap`: project a fixed FIELD LIST into a `{ field:
+ * value }` snapshot, with an automatic `shallow` eq so an unchanged row wakes
+ * nobody. The declarative-field-list model from WatermelonDB `observeWithColumns` /
+ * TanStack `select` — the common "mirror these fields" case without hand-writing
+ * the projection + comparator.
+ *
+ * Allocation note: this builds a fresh object per dirty row and `shallow` does two
+ * `Object.keys` per compare — fine for low-churn. For a HIGH-churn component (the
+ * case you'd pick `grain:"column"` for), prefer `syncComponentToMap` with a scalar
+ * or hand-written-`eq` projection, so the hot path doesn't allocate exactly where
+ * the column grain is meant to keep it cheap.
+ */
+export declare function syncFieldsToMap<S extends ComponentSchema, const F extends readonly (string & keyof S)[]>(world: ECS, def: ComponentDef<S>, fields: F, opts?: Omit<EcsMapSyncOptions<{
+    [K in F[number]]: number;
+}>, "eq">): EcsMapSync<{
+    [K in F[number]]: number;
+}>;
+/**
+ * Sync a multi-component JOIN into a `reactiveMap`. An entity is a member iff it
+ * has EVERY component in `defs`; the projection reads any of them via
+ * `row.field(def, name)`. Change detection subscribes to ALL joined components, so
+ * a write to ANY of them republishes the row — the join can never go stale (the
+ * bug a single-component sync + manual secondary read would have). Spawns/removes
+ * of any joined component re-evaluate membership.
+ *
+ * Entity grain only: a join spans archetypes, so there is no single column to
+ * sweep. Drive with `batchedUpdate(world, dt)`.
+ */
+export declare function syncJoinToMap<V>(world: ECS, defs: readonly ComponentDef[], project: JoinProjection<V>, opts?: Omit<EcsMapSyncOptions<V>, "grain">): EcsMapSync<V>;
+export interface SingletonStructSync<V extends object> {
+    /** The live per-field channel: reading `struct.field` in a tracked scope
+     * subscribes to that field alone (pair with `fromKernelStruct` to render). */
+    readonly struct: V;
+    /** Unregister the observer and stop publishing. Safe to call more than once. */
+    dispose(): void;
+}
+export interface SingletonSyncOptions<V extends object = Record<string, number>> {
+    /**
+     * Access surface the publish touches, merged over the synced def's read.
+     * `__DEV__` access-checks the observer callbacks exactly like a system.
+     */
+    access?: Partial<SystemAccessDeclaration>;
+    /** Replay current state on registration (default `true`). flecs `yieldExisting`. */
+    seedExisting?: boolean;
+    /**
+     * Drive a PRE-CREATED `reactiveStruct` (its `[proxy, set]` pair) instead of
+     * creating a fresh one. Lets the consumer keep the struct at module scope as a
+     * stable "channel" with initial values present before the sync attaches (the
+     * client UI seam: panels import the eager proxy; the sync, set up at world build,
+     * republishes into it via the observer). The seed (`yieldExisting`) overwrites
+     * the eager initials with the entity's current values on registration.
+     */
+    into?: readonly [V, StructSetters<V>];
+}
+/**
+ * Sync ONE singleton entity's single-component state into a `reactiveStruct`,
+ * keyless — the singleton/resource shape (ADR-0024). This is how heterogeneous
+ * ephemeral UI state (net status + latency, FPS/mem, wave timer, hovered hex) joins
+ * the same reactive view as per-entity components: model it as components on a
+ * reserved singleton entity (the flecs / Unity-DOTS "singleton-as-entity" model)
+ * and read it through per-field channels — NOT a separate reactive-resource
+ * subsystem. Resources stay non-reactive internal singletons.
+ *
+ * It reuses the entity-grain ADR-0013 component observer verbatim, filtered to the
+ * one target eid: an `onSet` (or seed `onAdd`) republishes the entity's field values
+ * into the struct via per-field setters. The per-field `Object.is` eq means an
+ * unchanged field writes nothing — "equal write → 0 renders" — and per-field signals
+ * give "1-of-N FIELD → 1 re-render"; drive with `batchedUpdate` for "one tick → one
+ * commit". Because the component change-detection fires on `ctx.setField`, the
+ * in-place write pattern that defeats a `setResource`-keyed resource observer is
+ * handled for free.
+ *
+ * `fields` is explicit: a `ComponentDef` is a branded number at runtime (its schema
+ * is a phantom type), so the field names must be passed — same contract as
+ * `syncFieldsToMap`. Project a subset to channel only what the UI reads.
+ *
+ * A `reactiveStruct` has a fixed field set and no `delete`, so the map adapter's
+ * delete-on-disable (#677 / ADR-0023) has no struct analog: `onRemove`/`onDisable`
+ * **reset the fields to the channel's declared initial values** (`onSet` skips
+ * disabled entities), `onEnable` republishes. The defaults are the channel's own
+ * initials — the eager `into` struct's declared values (e.g. `NetStats.latency = -1`),
+ * or the zeros of a freshly-created one — captured (untracked) at registration, NOT a
+ * blind 0. A singleton is rarely despawned; this keeps the channel well-defined if it is.
+ */
+export declare function syncSingletonToStruct<S extends ComponentSchema, const F extends readonly (string & keyof S)[]>(world: ECS, def: ComponentDef<S>, eid: EntityID, fields: F, opts?: SingletonSyncOptions<{
+    [K in F[number]]: number;
+}>): SingletonStructSync<{
+    [K in F[number]]: number;
+}>;
+export interface SingletonArraySync<T> {
+    /** The live ordered channel: a reader of slot `i` subscribes to that slot alone. */
+    readonly array: ReactiveArray<T>;
+    /** Unregister the observer and stop publishing. Safe to call more than once. */
+    dispose(): void;
+}
+export interface SingletonArraySyncOptions<T> {
+    access?: Partial<SystemAccessDeclaration>;
+    seedExisting?: boolean;
+    /** Drive a PRE-CREATED `reactiveArray` (the module-scope channel) instead of a fresh one. */
+    into?: ReactiveArray<T>;
+    /** Per-slot equality for the array's no-op skip (default `Object.is`). */
+    eq?: (a: T, b: T) => boolean;
+}
+/**
+ * Sync ONE singleton entity's component into a `reactiveArray`, one slot per field
+ * in `fields` order (#685 / ADR-0024) — the ORDERED sibling of `syncSingletonToStruct`,
+ * for positional UI state (the army slots). On every change to the component it
+ * `reconcile`s the array from the field values: a slot whose value is unchanged keeps
+ * its reference (structural sharing), only changed slots wake. `onRemove`/`onDisable`
+ * reset the slots to the channel's DECLARED initial slots (a reactiveArray has no row
+ * delete) — captured (untracked) at registration, so the army channel resets to its
+ * empty sentinel (`EMPTY_SLOT`), NOT a blind 0 that would read as unit type 0.
+ *
+ * `fields` is explicit (a `ComponentDef` is a branded number at runtime). Pair with
+ * `@oasys/oecs/solid`'s `fromKernelArray` + a Solid `<Index>`.
+ */
+export declare function syncSingletonToArray<S extends ComponentSchema>(world: ECS, def: ComponentDef<S>, eid: EntityID, fields: readonly (string & keyof S)[], opts?: SingletonArraySyncOptions<number>): SingletonArraySync<number>;
+/**
+ * Advance the world one tick with every bridge publish coalesced into a single UI
+ * flush. onAdd/onRemove fire mid-tick at flush boundaries and onSet fires at the
+ * tick tail; wrapping the whole update in `batch` defers the effect flush until the
+ * tick completes, so a frame that touched K entities (across any number of syncs on
+ * this world) wakes its readers once, not once per observer dispatch point.
+ * Equivalent to `batch(() => world.update(dt))`.
+ */
+export declare function batchedUpdate(world: ECS, dt: number): void;
+//# sourceMappingURL=ecs_sync.d.ts.map

package/dist/extensions/reactive/ecs_sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecs_sync.d.ts","sourceRoot":"","sources":["../../../src/extensions/reactive/ecs_sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,OAAO,EAMN,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAEX,YAAY,EACZ,eAAe,EACf,GAAG,EACH,QAAQ,EAGR,uBAAuB,EAEvB,MAAM,gBAAgB,CAAC;AAExB;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAWrD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,eAAe;IACnD,oDAAoD;IACpD,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,gEAAgE;IAChE,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC;CACnD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,mEAAmE;IACnE,KAAK,CAAC,CAAC,SAAS,eAAe,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,EAC1D,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,IAAI,EAAE,CAAC,GACL,MAAM,CAAC;CACV;AAED,iEAAiE;AACjE,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,eAAe,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAChF,0DAA0D;AAC1D,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,KAAK,CAAC,CAAC;AAEvD,mFAAmF;AACnF,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE5C,MAAM,WAAW,iBAAiB,CAAC,CAAC;IACnC,kFAAkF;IAClF,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;;OAIG;IACH,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAC7B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC1C;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACvC,mFAAmF;IACnF,OAAO,IAAI,IAAI,CAAC;CAChB;AAiED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,eAAe,EAAE,CAAC,EAC9D,KAAK,EAAE,GAAG,EACV,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,IAAI,GAAE,iBAAiB,CAAC,CAAC,CAAM,GAC7B,UAAU,CAAC,CAAC,CAAC,CAyEf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,CAAC,SAAS,eAAe,EACzB,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,EAE7C,KAAK,EAAE,GAAG,EACV,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,MAAM,EAAE,CAAC,EACT,IAAI,GAAE,IAAI,CAAC,iBAAiB,CAAC;KAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CAAE,CAAC,EAAE,IAAI,CAAM,GACpE,UAAU,CAAC;KAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CAAE,CAAC,CAQ1C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC9B,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,IAAI,GAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAM,GAC5C,UAAU,CAAC,CAAC,CAAC,CA+Df;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,MAAM;IACpD;kFAC8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,gFAAgF;IAChF,OAAO,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAC9E;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC1C,oFAAoF;IACpF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,qBAAqB,CACpC,CAAC,SAAS,eAAe,EACzB,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,EAE7C,KAAK,EAAE,GAAG,EACV,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,CAAC,EACT,IAAI,GAAE,oBAAoB,CAAC;KAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CAAE,CAAM,GAC3D,mBAAmB,CAAC;KAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CAAE,CAAC,CA6DnD;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACpC,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACjC,gFAAgF;IAChF,OAAO,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,yBAAyB,CAAC,CAAC;IAC3C,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,6FAA6F;IAC7F,IAAI,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACxB,0EAA0E;IAC1E,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,eAAe,EAC7D,KAAK,EAAE,GAAG,EACV,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,EACrC,IAAI,GAAE,yBAAyB,CAAC,MAAM,CAAM,GAC1C,kBAAkB,CAAC,MAAM,CAAC,CA2D5B;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAE1D"}