@oasys/oecs 0.4.0 → 0.5.1

package/dist/extensions/editor/editor.d.cts

@@ -0,0 +1,172 @@
+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
+ * 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`.
+ */
+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
+ * type handed back from {@link Editor.transaction} is read-only.
+ */
+export interface EditorTransaction {
+    readonly forward: readonly HostCommand[];
+    readonly inverse: readonly 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;
+    /** 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;
+    /** @internal */
+    constructor(readField: FieldReader, shadow: Map<string, number>);
+    private get _txn();
+    /**
+     * 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<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
+     * `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,
+     * 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
+     * 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`.
+     */
+    remove<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): this;
+    /** Disable `entityId`. Inverse: enable it. */
+    disable(entityId: EntityID): this;
+    /** Enable `entityId`. Inverse: disable it. */
+    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`
+ * 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;
+    /** 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<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<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`. */
+    remove<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): EditorTransaction;
+    /** Disable `entityId` as its own undo entry. */
+    disable(entityId: EntityID): EditorTransaction;
+    /** Enable `entityId` as its own undo entry. */
+    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
+     * 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;
+    };
+    /** `true` when `undo()` would do something — allocation-free (M10). */
+    get canUndo(): boolean;
+    /** `true` when `redo()` would do something — allocation-free (M10). */
+    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
+     * of polling `depths()` per frame (M10). Returns an unsubscribe function.
+     * Callbacks run synchronously in subscription order; read `canUndo` /
+     * `canRedo` / `depths()` inside.
+     */
+    onChange(cb: () => void): () => void;
+    private notify;
+    /** Read one committed `(entity, component, field)` slot through the reader
+     * this editor was constructed with — the default read for `fieldHandle`
+     * when no channel thunk is supplied (M11). */
+    committedField(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
+     * inspector echo an edit between the `set` and the tick that commits it.
+     *
+     * Self-resolving: once the read channel reports the shadowed value (the edit
+     * landed) — or reports `undefined` (the slot is gone: entity despawned or
+     * component removed) — the entry is dropped and this returns `undefined`, so
+     * `pending` does not outlive its set→commit window and shadow a later external
+     * write, nor a dead slot's lifetime. The one
+     * residual: if an external write changes the field to a *different* value within
+     * the same window before this is next consulted, `pending` can read stale until
+     * the next edit to the slot. `value` (the read channel) is always the source of
+     * truth; `pending` is only the optimistic bridge.
+     */
+    pendingField(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;
+}
+//# sourceMappingURL=editor.d.ts.map

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

@@ -1,11 +1,11 @@
-import { ComponentDef, ComponentHandle, ComponentSchema, EntityID, FieldValues, HostCommand, HostCommandQueue, SpawnEntry } from '../../core/ecs';
+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
  * 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`.
+ * or to `ecs.getField`; `undefined` for an unknown slot falls back to `0`.
  */
-export type FieldReader = (eid: EntityID, def: ComponentDef, field: string) => number | undefined;
+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
@@ -16,11 +16,6 @@ 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
@@ -32,42 +27,50 @@ interface MutableTxn {
 export declare class TransactionBuilder {
     private readonly readField;
     private readonly shadow;
-    /** @internal */
-    readonly _txn: MutableTxn;
+    /** 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;
     /** @internal */
     constructor(readField: FieldReader, shadow: Map<string, number>);
+    private get _txn();
     /**
      * 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;
+    spawn<Defs extends readonly ComponentDef[]>(components: SpawnEntries<Defs>, onSpawned?: (entityId: EntityID) => void): this;
     /**
-     * Despawn `eid`. Inverse: respawn from `restore` (the components+values to
+     * 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
      * `onSpawned` rewrites this despawn's target so redo removes the respawned
      * entity rather than the dead original.
      */
-    despawn(eid: EntityID, restore: readonly SpawnEntry[]): this;
+    despawn<Defs extends readonly ComponentDef[]>(entityId: EntityID, restore: SpawnEntries<Defs>): 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).
+     * Set `field` of `def` on `entityId` to `value`. Inverse: set it back to the value
+     * this edit replaced — read from the staged overlay / shadow (so stacked edits,
+     * within one build or before a commit, invert correctly) or, failing that, the
+     * read channel (`0` if unknown).
      */
-    setField<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;
+    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
+     * the queue's `add`), not `addComponent`. */
+    add<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, values: CompleteFieldValues<S>): this;
     /**
-     * Remove `def` from `eid`. Inverse: re-add it from `restore` (the field values
-     * to recreate — read them from the channel before removing).
+     * 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`.
      */
-    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;
+    remove<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): this;
+    /** Disable `entityId`. Inverse: enable it. */
+    disable(entityId: EntityID): this;
+    /** Enable `entityId`. Inverse: disable it. */
+    enable(entityId: EntityID): this;
 }
 /**
  * The editor's undo/redo manager over a {@link HostCommandQueue}. Each action is a
@@ -84,6 +87,8 @@ export declare class Editor {
     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);
@@ -94,19 +99,19 @@ export declare class Editor {
      */
     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;
+    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<Defs extends readonly ComponentDef[]>(entityId: EntityID, restore: SpawnEntries<Defs>): 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;
+    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`. */
+    remove<S extends ComponentSchema>(entityId: EntityID, def: ComponentDef<S>, restore: CompleteFieldValues<S>): EditorTransaction;
+    /** Disable `entityId` as its own undo entry. */
+    disable(entityId: EntityID): EditorTransaction;
+    /** Enable `entityId` as its own undo entry. */
+    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
@@ -126,24 +131,42 @@ export declare class Editor {
         undo: number;
         redo: number;
     };
+    /** `true` when `undo()` would do something — allocation-free (M10). */
+    get canUndo(): boolean;
+    /** `true` when `redo()` would do something — allocation-free (M10). */
+    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
+     * of polling `depths()` per frame (M10). Returns an unsubscribe function.
+     * Callbacks run synchronously in subscription order; read `canUndo` /
+     * `canRedo` / `depths()` inside.
+     */
+    onChange(cb: () => void): () => void;
+    private notify;
+    /** Read one committed `(entity, component, field)` slot through the reader
+     * this editor was constructed with — the default read for `fieldHandle`
+     * when no channel thunk is supplied (M11). */
+    committedField(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
      * 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
+     * landed) — or reports `undefined` (the slot is gone: entity despawned or
+     * component removed) — the entry is dropped and this returns `undefined`, so
+     * `pending` does not outlive its set→commit window and shadow a later external
+     * write, nor a dead slot's lifetime. The one
      * residual: if an external write changes the field to a *different* value within
      * the same window before this is next consulted, `pending` can read stale until
      * the next edit to the slot. `value` (the read channel) is always the source of
      * truth; `pending` is only the optimistic bridge.
      */
-    pendingField(eid: EntityID, def: ComponentHandle, field: string): number | undefined;
+    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;
 }
-export {};
 //# sourceMappingURL=editor.d.ts.map

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

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

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

@@ -0,0 +1,40 @@
+import { ComponentDef, ComponentSchema, EntityID } from '../../core/ecs/index.cjs';
+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
+ * 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 `(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
+ * edit is queued, batched, and undoable.
+ *
+ * `read` is optional (M11): 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
+ * 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;
+//# sourceMappingURL=field_handle.d.ts.map

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

@@ -1,5 +1,5 @@
-import { ComponentDef, ComponentSchema, EntityID } from '../../core/ecs';
-import { Editor } from './editor';
+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
@@ -26,10 +26,15 @@ export interface FieldHandle {
     readonly pending: number | undefined;
 }
 /**
- * Build a {@link FieldHandle} for one `(eid, def, field)` slot. `read` is the
+ * 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(eid)?.x`); `set` routes through `editor.setField`, so the
+ * `() => sync.map.get(entityId)?.x`); `set` routes through `editor.setField`, so the
  * edit is queued, batched, and undoable.
+ *
+ * `read` is optional (M11): 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
+ * subscribe inside a tracking scope.
  */
-export declare function fieldHandle<S extends ComponentSchema>(editor: Editor, eid: EntityID, def: ComponentDef<S>, field: string & keyof S, read: () => number | undefined): FieldHandle;
+export declare function fieldHandle<S extends ComponentSchema>(editor: Editor, entityId: 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

@@ -1 +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"}
+{"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;;;;;;;;;;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,CAYb"}

package/dist/extensions/editor/index.cjs

@@ -1 +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;
+"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.d.cts

@@ -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.cjs';
+export { fieldHandle, type FieldHandle } from './field_handle.cjs';
+//# sourceMappingURL=index.d.ts.map

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

@@ -16,6 +16,6 @@
  * `@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';
+export { Editor, TransactionBuilder, type EditorTransaction, type FieldReader } from './editor.js';
+export { fieldHandle, type FieldHandle } from './field_handle.js';
 //# sourceMappingURL=index.d.ts.map