@oasys/oecs 0.5.4 → 0.6.0

package/dist/{extensions → plugins}/editor/editor.d.cts

@@ -1,15 +1,15 @@
 import { ComponentDef, ComponentHandle, ComponentSchema, EntityID, CompleteFieldValues, HostCommand, HostCommandQueue, SpawnEntries } from '../../core/ecs/index.cjs';
 /**
- * Reads the committed value of one `(entity, component, field)` slot — the editor
+ * 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 `ecs.getField`; `undefined` for an unknown slot falls back to `0`.
+ * to a live read channel, such as a `@oasys/oecs/solid` view, or to
+ * `ecs.getField`. `undefined` for an unknown slot falls back to `0`.
  */
 export type FieldReader = (entityId: 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
+ * internally (the spawn and despawn id finalizers patch a slot at apply time) but the
  * type handed back from {@link Editor.transaction} is read-only.
  */
 export interface EditorTransaction {
@@ -17,24 +17,24 @@ export interface EditorTransaction {
     readonly inverse: readonly HostCommand[];
 }
 /**
- * Accumulates the `forward`/`inverse` commands for ONE transaction. Each method
+ * Accumulates the `forward` and `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
+ * shadow and 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.
+ * Obtained from {@link Editor.transaction}. Never constructed directly.
  */
 export declare class TransactionBuilder {
-    private readonly readField;
-    private readonly shadow;
-    /** Values staged by THIS build, layered over the editor's shared shadow. Kept
+    private readonly _readField;
+    private readonly _shadow;
+    /** 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`. */
-    private readonly staged;
+     * 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`. */
+    private readonly _staged;
     /** @internal */
-    constructor(readField: FieldReader, shadow: Map<string, number>);
+    constructor(_readField: FieldReader, _shadow: Map<string, number>);
     private get _txn();
     /**
      * Spawn an entity carrying `components`. Inverse: despawn the created entity,
@@ -45,26 +45,26 @@ export declare class TransactionBuilder {
     spawn<Defs extends readonly ComponentDef[]>(components: SpawnEntries<Defs>, onSpawned?: (entityId: EntityID) => void): this;
     /**
      * Despawn `entityId`. 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
+     * 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<Defs extends readonly ComponentDef[]>(entityId: EntityID, restore: SpawnEntries<Defs>): 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,
+     * 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, value: number): 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, values: CompleteFieldValues<S>): 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): this;
     /** Disable `entityId`. Inverse: enable it. */
@@ -73,40 +73,40 @@ export declare class TransactionBuilder {
     enable(entityId: 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`
+ * The editor's undo and redo manager over a {@link HostCommandQueue}. Each action is a
+ * reified {@link EditorTransaction} pushed onto the undo stack. `undo()` and `redo()`
+ * enqueue its inverse and 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;
-    /** onChange subscribers — see {@link onChange}. */
-    private readonly listeners;
+    private readonly _queue;
+    private readonly _readField;
+    private readonly _undoStack;
+    private readonly _redoStack;
+    /** onChange subscribers, see {@link onChange}. */
+    private readonly _listeners;
     /** Per-`(entity, component, field)` shadow of edited values, for inverse correctness. */
-    private readonly shadow;
-    constructor(queue: HostCommandQueue, readField: FieldReader);
+    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.
+     * 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(build: (tx: TransactionBuilder) => void): EditorTransaction;
     /** Spawn `components` as its own undo entry. `onSpawned` reports the new id. */
     spawn<Defs extends readonly ComponentDef[]>(components: SpawnEntries<Defs>, onSpawned?: (entityId: EntityID) => void): EditorTransaction;
-    /** Despawn `entityId` as its own undo entry; `restore` recreates it on undo. */
+    /** Despawn `entityId` as its own undo entry. `restore` recreates it on undo. */
     despawn<Defs extends readonly ComponentDef[]>(entityId: EntityID, restore: SpawnEntries<Defs>): EditorTransaction;
     /** Set one field as its own undo entry. */
     setField<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, value: number): EditorTransaction;
     /** Attach a component as its own undo entry. Bare `add` (see `TransactionBuilder.add`). */
     add<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, values: CompleteFieldValues<S>): EditorTransaction;
-    /** 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): EditorTransaction;
     /** Disable `entityId` as its own undo entry. */
     disable(entityId: EntityID): EditorTransaction;
@@ -114,7 +114,7 @@ export declare class Editor {
     enable(entityId: 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
+     * 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;
@@ -126,47 +126,47 @@ export declare class Editor {
     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. */
+    /** Current stack depths, for an "Undo (3)" or "Redo" affordance. */
     depths(): {
         undo: number;
         redo: number;
     };
-    /** `true` when `undo()` would do something — allocation-free. */
+    /** `true` when `undo()` would do something, allocation-free. */
     get canUndo(): boolean;
-    /** `true` when `redo()` would do something — allocation-free. */
+    /** `true` when `redo()` would do something, allocation-free. */
     get canRedo(): boolean;
     /**
-     * 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(cb: () => void): () => void;
-    private notify;
+    private _notify;
     /** 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(entityId: EntityID, def: ComponentDef, field: string): number | undefined;
     /**
      * 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(entityId: 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;
+    private _commit;
+    /** Keep the setField shadow in step with the commands only enqueued. */
+    private _applyShadow;
 }
 //# sourceMappingURL=editor.d.ts.map

package/dist/{extensions → plugins}/editor/editor.d.ts

@@ -1,15 +1,15 @@
 import { ComponentDef, ComponentHandle, ComponentSchema, EntityID, CompleteFieldValues, HostCommand, HostCommandQueue, SpawnEntries } from '../../core/ecs/index.js';
 /**
- * Reads the committed value of one `(entity, component, field)` slot — the editor
+ * 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 `ecs.getField`; `undefined` for an unknown slot falls back to `0`.
+ * to a live read channel, such as a `@oasys/oecs/solid` view, or to
+ * `ecs.getField`. `undefined` for an unknown slot falls back to `0`.
  */
 export type FieldReader = (entityId: 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
+ * internally (the spawn and despawn id finalizers patch a slot at apply time) but the
  * type handed back from {@link Editor.transaction} is read-only.
  */
 export interface EditorTransaction {
@@ -17,24 +17,24 @@ export interface EditorTransaction {
     readonly inverse: readonly HostCommand[];
 }
 /**
- * Accumulates the `forward`/`inverse` commands for ONE transaction. Each method
+ * Accumulates the `forward` and `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
+ * shadow and 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.
+ * Obtained from {@link Editor.transaction}. Never constructed directly.
  */
 export declare class TransactionBuilder {
-    private readonly readField;
-    private readonly shadow;
-    /** Values staged by THIS build, layered over the editor's shared shadow. Kept
+    private readonly _readField;
+    private readonly _shadow;
+    /** 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`. */
-    private readonly staged;
+     * 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`. */
+    private readonly _staged;
     /** @internal */
-    constructor(readField: FieldReader, shadow: Map<string, number>);
+    constructor(_readField: FieldReader, _shadow: Map<string, number>);
     private get _txn();
     /**
      * Spawn an entity carrying `components`. Inverse: despawn the created entity,
@@ -45,26 +45,26 @@ export declare class TransactionBuilder {
     spawn<Defs extends readonly ComponentDef[]>(components: SpawnEntries<Defs>, onSpawned?: (entityId: EntityID) => void): this;
     /**
      * Despawn `entityId`. 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
+     * 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<Defs extends readonly ComponentDef[]>(entityId: EntityID, restore: SpawnEntries<Defs>): 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,
+     * 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, value: number): 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, values: CompleteFieldValues<S>): 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): this;
     /** Disable `entityId`. Inverse: enable it. */
@@ -73,40 +73,40 @@ export declare class TransactionBuilder {
     enable(entityId: 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`
+ * The editor's undo and redo manager over a {@link HostCommandQueue}. Each action is a
+ * reified {@link EditorTransaction} pushed onto the undo stack. `undo()` and `redo()`
+ * enqueue its inverse and 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;
-    /** onChange subscribers — see {@link onChange}. */
-    private readonly listeners;
+    private readonly _queue;
+    private readonly _readField;
+    private readonly _undoStack;
+    private readonly _redoStack;
+    /** onChange subscribers, see {@link onChange}. */
+    private readonly _listeners;
     /** Per-`(entity, component, field)` shadow of edited values, for inverse correctness. */
-    private readonly shadow;
-    constructor(queue: HostCommandQueue, readField: FieldReader);
+    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.
+     * 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(build: (tx: TransactionBuilder) => void): EditorTransaction;
     /** Spawn `components` as its own undo entry. `onSpawned` reports the new id. */
     spawn<Defs extends readonly ComponentDef[]>(components: SpawnEntries<Defs>, onSpawned?: (entityId: EntityID) => void): EditorTransaction;
-    /** Despawn `entityId` as its own undo entry; `restore` recreates it on undo. */
+    /** Despawn `entityId` as its own undo entry. `restore` recreates it on undo. */
     despawn<Defs extends readonly ComponentDef[]>(entityId: EntityID, restore: SpawnEntries<Defs>): EditorTransaction;
     /** Set one field as its own undo entry. */
     setField<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, value: number): EditorTransaction;
     /** Attach a component as its own undo entry. Bare `add` (see `TransactionBuilder.add`). */
     add<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, values: CompleteFieldValues<S>): EditorTransaction;
-    /** 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<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): EditorTransaction;
     /** Disable `entityId` as its own undo entry. */
     disable(entityId: EntityID): EditorTransaction;
@@ -114,7 +114,7 @@ export declare class Editor {
     enable(entityId: 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
+     * 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;
@@ -126,47 +126,47 @@ export declare class Editor {
     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. */
+    /** Current stack depths, for an "Undo (3)" or "Redo" affordance. */
     depths(): {
         undo: number;
         redo: number;
     };
-    /** `true` when `undo()` would do something — allocation-free. */
+    /** `true` when `undo()` would do something, allocation-free. */
     get canUndo(): boolean;
-    /** `true` when `redo()` would do something — allocation-free. */
+    /** `true` when `redo()` would do something, allocation-free. */
     get canRedo(): boolean;
     /**
-     * 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(cb: () => void): () => void;
-    private notify;
+    private _notify;
     /** 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(entityId: EntityID, def: ComponentDef, field: string): number | undefined;
     /**
      * 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(entityId: 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;
+    private _commit;
+    /** Keep the setField shadow in step with the commands only enqueued. */
+    private _applyShadow;
 }
 //# sourceMappingURL=editor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../src/plugins/editor/editor.ts"],"names":[],"mappings":"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"}

package/dist/{extensions → plugins}/editor/field_handle.d.cts

@@ -2,38 +2,38 @@ import { ComponentDef, ComponentSchema, EntityID } from '../../core/ecs/index.cj
 import { Editor } from './editor.cjs';
 /**
  * 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
+ * live channel, tracked when read inside 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`
+     * The field's current value through the live 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.
+     * 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. */
+    /** 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
+     * if none, an untracked 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.
+     * channel catches up, so it does not outlive the edit. It does not subscribe,
+     * so it is no substitute for `value` inside a tracking scope. `value` is the
+     * source of truth.
      */
     readonly pending: number | undefined;
 }
 /**
  * Build a {@link FieldHandle} for one `(entityId, def, field)` slot. `read` is the
- * tracked read of the reactive channel for this field (e.g.
- * `() => sync.map.get(entityId)?.x`); `set` routes through `editor.setField`, so the
+ * tracked read of the live channel for this field, for example
+ * `() => view.cell(entityId)()?.x`. `set` routes through `editor.setField`, so the
  * edit is queued, batched, and undoable.
  *
  * `read` is optional: omitted, the handle reads through the editor's own
  * committed-channel reader (`editor.committedField`). That default is correct
- * but NOT reactive — supply the channel thunk when the handle's `value` must
+ * but untracked, so pass the channel thunk when the handle's `value` must
  * subscribe inside a tracking scope.
  */
 export declare function fieldHandle<S extends ComponentSchema>(editor: Editor, entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, read?: () => number | undefined): FieldHandle;

package/dist/{extensions → plugins}/editor/field_handle.d.ts

@@ -2,38 +2,38 @@ import { ComponentDef, ComponentSchema, EntityID } from '../../core/ecs/index.js
 import { Editor } from './editor.js';
 /**
  * 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
+ * live channel, tracked when read inside 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`
+     * The field's current value through the live 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.
+     * 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. */
+    /** 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
+     * if none, an untracked 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.
+     * channel catches up, so it does not outlive the edit. It does not subscribe,
+     * so it is no substitute for `value` inside a tracking scope. `value` is the
+     * source of truth.
      */
     readonly pending: number | undefined;
 }
 /**
  * Build a {@link FieldHandle} for one `(entityId, def, field)` slot. `read` is the
- * tracked read of the reactive channel for this field (e.g.
- * `() => sync.map.get(entityId)?.x`); `set` routes through `editor.setField`, so the
+ * tracked read of the live channel for this field, for example
+ * `() => view.cell(entityId)()?.x`. `set` routes through `editor.setField`, so the
  * edit is queued, batched, and undoable.
  *
  * `read` is optional: omitted, the handle reads through the editor's own
  * committed-channel reader (`editor.committedField`). That default is correct
- * but NOT reactive — supply the channel thunk when the handle's `value` must
+ * but untracked, so pass the channel thunk when the handle's `value` must
  * subscribe inside a tracking scope.
  */
 export declare function fieldHandle<S extends ComponentSchema>(editor: Editor, entityId: EntityID, def: ComponentDef<S>, field: string & keyof S, read?: () => number | undefined): FieldHandle;

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

@@ -0,0 +1 @@
+{"version":3,"file":"field_handle.d.ts","sourceRoot":"","sources":["../../../src/plugins/editor/field_handle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;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;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,eAAe,EACpD,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,EACvB,IAAI,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,GAC7B,WAAW,CAcb"}

package/dist/plugins/editor/index.d.cts

@@ -0,0 +1,22 @@
+/**
+ * The host write seam's editor layer.
+ *
+ * Reified undo and redo, and the inspector field handle, built on the shipped
+ * typed `HostCommandQueue`. Undo and redo are application policy, so this ships
+ * on its own subpath and not in the world core. A caller constructs an `Editor`
+ * itself, and a world installs nothing for it. It pulls no third-party
+ * dependency, because the field handle reads through a caller-supplied thunk.
+ *
+ *   - `Editor`, reified `EditorTransaction`s on undo and redo stacks, with
+ *     transaction grouping. `undo()` and `redo()` enqueue the inverse and forward on the
+ *     same bus, applied at the next schedule head (undo is only another command).
+ *   - `fieldHandle`, pairs a read of a live channel 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/solid`, whose
+ * `ecs.solid.component` and `ecs.solid.singleton` views are the read side the
+ * field handle reads through.
+ */
+export { Editor, TransactionBuilder, type EditorTransaction, type FieldReader } from './editor.cjs';
+export { fieldHandle, type FieldHandle } from './field_handle.cjs';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,22 @@
+/**
+ * The host write seam's editor layer.
+ *
+ * Reified undo and redo, and the inspector field handle, built on the shipped
+ * typed `HostCommandQueue`. Undo and redo are application policy, so this ships
+ * on its own subpath and not in the world core. A caller constructs an `Editor`
+ * itself, and a world installs nothing for it. It pulls no third-party
+ * dependency, because the field handle reads through a caller-supplied thunk.
+ *
+ *   - `Editor`, reified `EditorTransaction`s on undo and redo stacks, with
+ *     transaction grouping. `undo()` and `redo()` enqueue the inverse and forward on the
+ *     same bus, applied at the next schedule head (undo is only another command).
+ *   - `fieldHandle`, pairs a read of a live channel 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/solid`, whose
+ * `ecs.solid.component` and `ecs.solid.singleton` views are the read side the
+ * field handle reads through.
+ */
+export { Editor, TransactionBuilder, type EditorTransaction, type FieldReader } from './editor.js';
+export { fieldHandle, type FieldHandle } from './field_handle.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/editor/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;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/plugins/editor.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/plugins/editor.d.cts

@@ -0,0 +1 @@
+export * from "./editor/index.cjs";

package/dist/plugins/editor.d.ts

@@ -0,0 +1 @@
+export * from "./editor/index.js";