effectable 0.1.0

package/build/component/GraphRuntime.d.ts

@@ -0,0 +1,457 @@
+/**
+ * GraphRuntime — runtime engine for materialization, reconcile, and lifecycle of a component tree.
+ *
+ * Responsibilities:
+ * - Materialize a VirtualServiceNode tree into real component instances (Fiber tree).
+ * - Fiber-like reconcile: diff current vs next trees by key + type, assign effectTags.
+ * - Drive lifecycle via LifecycleEngine: startup in topological order (children before parent),
+ *   shutdown in reverse order (parent before children).
+ * - Inject contexts (@UseContext) and bind refs on mount.
+ * - Pass updated props into existing instances during reconcile.
+ *
+ * Current limitations:
+ * - Work loop is synchronous (no priority lanes — next increment).
+ * - Component.setState() and connect selector updates schedule automatic subtree reconcile
+ *   via a dirty-fiber queue with microtask coalescing; manual reconcile remains a force-update API.
+ * - ContextProvider is handled as a special case in buildScope.
+ *
+ * @module Effectable/component/GraphRuntime
+ */
+import type { Component } from './Component';
+import type { FiberEffectTag, FiberInspectNode, VirtualServiceNode } from './types';
+import type { ContextScope } from './context';
+import type { RuntimeCommand, RuntimeEvent, RuntimeQuery } from '../runtime/types';
+import type { RuntimeBusesBundle } from '../runtime/BusDecorators';
+/**
+ * Runtime engine for a declarative component tree.
+ *
+ * Usage:
+ * ```typescript
+ * const runtime = await GraphRuntime.mount(h(AppRoot));
+ * await runtime.reconcile(h(AppRoot, { newProp: 1 }));
+ * await runtime.unmount();
+ * ```
+ */
+export declare class GraphRuntime {
+    /** Current root fiber tree (current tree). */
+    private currentRoot;
+    /** Whether unmount has completed. */
+    private unmounted;
+    /**
+     * Entry counter for {@link continueStableReconcileAsync} (test/debug probe).
+     * Not reset automatically — compare before/after around reconcile.
+     */
+    private stableAsyncContinueCount;
+    /**
+     * Runtime buses for auto-wiring decorators on nodes (optional, set in {@link GraphRuntime.mount}).
+     */
+    private effectableRuntimeBuses;
+    /**
+     * Depth-indexed pool of Map objects for keyedCurrentMap in reconcileChildren.
+     * Index is recursion depth, which provides re-entrancy safety for nested calls.
+     * Map.clear() instead of new Map() yields 5.1x speedup.
+     */
+    private readonly keyedMapPool;
+    /**
+     * Current reconcileChildren recursion depth.
+     * Incremented before async work, decremented in finally.
+     */
+    private reconcileDepth;
+    /**
+     * Set of fiber nodes whose `compose()` subtrees need rebuild.
+     * Holds only a “minimal cover”: if an ancestor is already in the set, a descendant is not added.
+     */
+    private readonly dirtyFibers;
+    /** `true` — a microtask flush is already queued. */
+    private flushScheduled;
+    /** `true` — automatic dirty-fiber flush is in progress (re-entrancy guard). */
+    private flushing;
+    /**
+     * Promise of the current/scheduled dirty-flush (microtask).
+     * Manual `reconcile` awaits it to avoid overlapping an in-flight flush.
+     */
+    private activeFlush;
+    /**
+     * Number of consecutive dirty-flush passes in the current microtask chain.
+     * Reset when the queue is empty after a pass or on manual `reconcile`.
+     */
+    private dirtyFlushPassCount;
+    /**
+     * Optional hook invoked when automatic reconcile (dirty-fiber flush) fails.
+     * Set via the fourth argument of {@link GraphRuntime.mount}.
+     */
+    private onAutoReconcileError;
+    /**
+     * Instances are created only via {@link GraphRuntime.mount}; direct `new GraphRuntime()` is unavailable externally.
+     */
+    private constructor();
+    /**
+     * Auto-wires runtime-bus decorators onto the instance before {@link LifecycleEngine.runStartup}.
+     *
+     * @template P
+     * @param {Component<unknown, P>} instance - node instance
+     * @param {RuntimeFiber<P>} fiber - node fiber (stores disposer)
+     * @returns {void}
+     */
+    private attachEffectableRuntimeBusWiring;
+    /**
+     * Removes runtime-bus registrations created by {@link attachEffectableRuntimeBusWiring}.
+     *
+     * @param {RuntimeFiber<unknown>} fiber - node fiber
+     * @returns {void}
+     */
+    private disposeEffectableRuntimeBusWiring;
+    /**
+     * Injects the scheduler hook onto the component instance after successful startup.
+     * The hook is called from {@link Component.setState} and enqueues the fiber for automatic reconcile.
+     *
+     * If `setState` ran during startup (pre-mount buffer), schedules reconcile immediately.
+     *
+     * @param {Component<unknown, unknown>} instance - mounted instance
+     * @param {RuntimeFiber<unknown>} fiber - instance fiber (captured in the closure)
+     * @returns {void}
+     */
+    private injectUpdateHook;
+    /**
+     * Pre-mount buffer: `setState` during `onMount` cannot yet schedule reconcile
+     * (the live hook is injected after startup). Marks the fiber; {@link injectUpdateHook}
+     * after startup will call {@link scheduleUpdate}
+     * (deferred until the mount pass completes).
+     *
+     * @param {Component<unknown, unknown>} instance - instance before/during startup
+     * @param {RuntimeFiber<unknown>} fiber - instance fiber
+     * @returns {void}
+     */
+    private injectPreMountUpdateHook;
+    /**
+     * Removes the scheduler hook from the instance before unmount.
+     * After removal, `setState()` no longer triggers automatic reconcile.
+     *
+     * @param {Component<unknown, unknown>} instance - instance being unmounted
+     * @returns {void}
+     */
+    private clearUpdateHook;
+    /**
+     * Adds a fiber to the dirty queue with ancestor deduplication and schedules a microtask flush.
+     *
+     * Deduplication:
+     * - If an ancestor of the fiber is already queued → skip (ancestor covers the subtree).
+     * - If descendants of the fiber are queued → remove them (fiber covers their subtrees).
+     *
+     * @param {RuntimeFiber<unknown>} fiber - fiber whose subtree needs rebuild
+     * @returns {void}
+     */
+    private scheduleUpdate;
+    /**
+     * Queues one dirty-flush microtask and publishes {@link activeFlush} for await from `reconcile`.
+     *
+     * @returns {void}
+     */
+    private scheduleDirtyFlushMicrotask;
+    /**
+     * Flushes accumulated dirty fibers.
+     * Called from the microtask queued by {@link scheduleUpdate}.
+     * Guarded by the `flushing` flag against re-entrancy.
+     * The chain of repeat passes is capped by {@link GRAPH_RUNTIME_MAX_DIRTY_FLUSH_PASSES}.
+     *
+     * @returns {Promise<void>}
+     */
+    private flushDirtyFibers;
+    /**
+     * Rebuilds the `compose()` subtree of one dirty fiber without updating its props.
+     *
+     * Used for automatic reconcile after `setState()`: the instance already updated `state`,
+     * we only need to call `compose()` again and diff children.
+     *
+     * @param {RuntimeFiber<unknown>} fiber - fiber whose subtree needs rebuild
+     * @returns {void | Promise<void>}
+     */
+    private reconcileDirtyFiber;
+    /**
+     * Mounts a component tree and returns a running GraphRuntime.
+     * Builds the fiber tree, injects contexts, runs lifecycle in order:
+     * child nodes first, then the parent.
+     *
+     * @param {VirtualServiceNode<P>} root - root virtual node
+     * @param {ContextScope} initialScope - initial context scope (empty by default)
+     * @returns {Promise<GraphRuntime>} running runtime
+     * @throws {Error} if any node's startup failed
+     */
+    static mount<P = unknown>(root: VirtualServiceNode<P>, initialScope?: ContextScope, runtimeBuses?: RuntimeBusesBundle<RuntimeCommand, RuntimeQuery, RuntimeEvent>, onAutoReconcileError?: (err: unknown) => void): Promise<GraphRuntime>;
+    /**
+     * Reconciles against a new tree.
+     * Builds a work-in-progress tree, computes effectTags, applies changes:
+     * - PLACE: create and mount a new node
+     * - UPDATE: update props on an existing instance, call onUpdate
+     * - DELETE: unmount and destroy a node
+     *
+     * @param {VirtualServiceNode<P>} nextTree - new virtual tree
+     * @returns {Promise<void>}
+     * @throws {Error} if the runtime is already unmounted
+     */
+    reconcile<P = unknown>(nextTree: VirtualServiceNode<P>): Promise<void>;
+    /**
+     * Fully unmounts the component tree.
+     * Calls onUnmount for each node in reverse order (children before parent) and
+     * moves stages to destroyed via LifecycleEngine.
+     *
+     * @returns {Promise<void>}
+     */
+    unmount(): Promise<void>;
+    /**
+     * Returns the root component instance (for testing and introspection).
+     *
+     * @returns {Component<unknown, unknown> | null}
+     */
+    getRootInstance(): Component<unknown, unknown> | null;
+    /**
+     * Whether the runtime is active (unmount has not been called).
+     *
+     * @returns {boolean}
+     */
+    isActive(): boolean;
+    /**
+     * Readonly snapshot of the root fiber tree for test/debug introspection.
+     * Does not export mutable RuntimeFiber; returns null after unmount.
+     *
+     * @returns {FiberInspectNode | null} root snapshot or null
+     */
+    inspectRootFiber(): FiberInspectNode | null;
+    /**
+     * Entity tests only: nulls the root fiber `instance`
+     * to exercise the UPDATE guard when `fiber.instance === null`.
+     * Do not use in the production control plane.
+     *
+     * @returns {void}
+     */
+    nullRootInstanceForTests(): void;
+    /**
+     * Number of {@link continueStableReconcileAsync} calls since runtime creation.
+     * Test/debug probe; not a production API.
+     *
+     * @returns {number} accumulated counter
+     */
+    getStableAsyncContinueCount(): number;
+    /**
+     * Builds a deep readonly {@link FiberInspectNode} from a RuntimeFiber.
+     *
+     * @param {RuntimeFiber} fiber - source fiber
+     * @returns {FiberInspectNode} node snapshot
+     */
+    private toFiberInspectNode;
+    /**
+     * Creates a RuntimeFiber for a virtual node: instantiates the component,
+     * injects contexts, builds the child scope (for ContextProvider),
+     * recursively materializes children, binds ref, runs lifecycle.
+     *
+     * Returns {@link RuntimeFiber} synchronously if the whole subtree is sync
+     * (up to 116x speedup for a tree of 16 sync children); otherwise a Promise.
+     * `await` works correctly with either union branch.
+     *
+     * @param {VirtualServiceNode<P>} vnode - virtual node
+     * @param {RuntimeFiber | null} parentFiber - parent fiber
+     * @param {ContextScope} parentScope - parent scope
+     * @returns {RuntimeFiber<P> | Promise<RuntimeFiber<P>>}
+     */
+    private materialize;
+    /**
+     * Async continuation of {@link materialize} after a child returned a Promise.
+     * Finishes remaining child fibers with `await`, then runs parent startup.
+     *
+     * @param {RuntimeFiber<P>} fiber - current fiber
+     * @param {Component<unknown, P>} instance - component instance
+     * @param {LifecycleEngine} engine - lifecycle engine
+     * @param {VirtualServiceNode<P>} vnode - virtual node
+     * @param {VirtualServiceNode[]} childVnodes - all child vnodes
+     * @param {RuntimeFiber<unknown>[]} childFibers - already materialized child fibers
+     * @param {Promise<RuntimeFiber<unknown>>} pending - Promise for the current child
+     * @param {number} pendingIdx - index of the current child
+     * @returns {Promise<RuntimeFiber<P>>}
+     */
+    private continueMaterializeAsync;
+    /**
+     * Async finalization of {@link materialize} when child fibers were gathered synchronously but {@link LifecycleEngine.runStartup} returned a Promise.
+     *
+     * @template P node props type
+     * @param {RuntimeFiber<P>} fiber - fiber of the subtree root node
+     * @param {LifecycleEngine} engine - lifecycle engine for this node
+     * @param {RuntimeFiber<unknown>[]} childFibers - already mounted child fibers (for rollback on error)
+     * @param {PromiseLike<import('./lifecycle').LifecycleTransitionResult>} pendingStartup - Promise of the `runStartup` result
+     * @returns {Promise<RuntimeFiber<P>>} ready fiber, or rollback children and rethrow
+     */
+    private finalizeMaterializeAsync;
+    /**
+     * Unmounts already-mounted children when parent startup fails.
+     * Returns sync void if all demounts are sync, otherwise a Promise.
+     *
+     * @param {RuntimeFiber<unknown>[]} childFibers
+     * @returns {void | Promise<void>}
+     */
+    private destroyChildrenOnError;
+    /**
+     * Runs fiber-like reconcile for a single node.
+     * If type and key match — UPDATE: update props, reconcile children.
+     * If they differ — DELETE the old node, PLACE the new one.
+     *
+     * @param {RuntimeFiber<P>} current - current fiber
+     * @param {VirtualServiceNode<P>} nextVnode - new virtual node
+     * @param {RuntimeFiber | null} parentFiber - parent fiber
+     * @param {ContextScope} parentScope - parent scope
+     * @returns {Promise<RuntimeFiber<P>>}
+     */
+    private reconcileFiber;
+    /**
+     * Updates an existing fiber: applies new props to the instance,
+     * calls onUpdate, recursively diffs children.
+     *
+     * @param {RuntimeFiber<P>} current - current fiber
+     * @param {VirtualServiceNode<P>} nextVnode - new virtual node
+     * @param {RuntimeFiber | null} parentFiber - parent fiber
+     * @param {ContextScope} parentScope - parent scope
+     * @returns {Promise<RuntimeFiber<P>>}
+     */
+    private updateFiber;
+    /**
+     * Fiber cleanup after update/compose error: `runFailedCleanup` + bus dispose.
+     * Does not leave the node in `ready`.
+     *
+     * @param {RuntimeFiber<unknown>} fiber - fiber that failed
+     * @returns {void | Promise<void>}
+     */
+    private runFiberFailedCleanup;
+    /**
+     * Applies the reconcile result to the current fiber in-place.
+     * In-place mutation instead of spread: 0 heap allocations on UPDATE
+     * (3.09x speedup). Safe: RuntimeFiber is private.
+     *
+     * @param {RuntimeFiber<P>} current - current fiber
+     * @param {VirtualServiceNode<P>} nextVnode - new vnode
+     * @param {RuntimeFiber<unknown> | null} parentFiber - parent fiber
+     * @param {ContextScope} parentScope - parent scope
+     * @param {RuntimeFiber<unknown>[]} nextChildren - new child fibers
+     * @returns {void}
+     */
+    private applyFiberUpdate;
+    /**
+     * Diffs children: matches current and next child nodes by key+type.
+     * Nodes without a key are matched by position.
+     * Extra current nodes — DELETE; new unpaired nodes — PLACE.
+     *
+     * Optimizations:
+     * - isStableChildren fast-path (9.31x): if children are stable (N≤32, same type+key) — indexed loop without Map.
+     * - Skip keyedCurrentMap (6.06x): if there are no keyed children — do not create a Map at all.
+     * - Depth-indexed Map pool (5.1x): with keyed children, reuse Map via clear() instead of new Map().
+     *
+     * @param {RuntimeFiber[]} currentChildren - current child fibers
+     * @param {VirtualServiceNode[]} nextVnodes - new child virtual nodes
+     * @param {RuntimeFiber} parentFiber - parent fiber
+     * @param {ContextScope} childScope - scope for child nodes
+     * @returns {Promise<RuntimeFiber[]>}
+     */
+    private reconcileChildren;
+    /**
+     * Async continuation of the stable fast-path reconcile after an async child.
+     *
+     * @param {RuntimeFiber<unknown>[]} resultSoFar - already gathered sync children
+     * @param {PromiseLike<RuntimeFiber<unknown>>} pending - Promise for the current child
+     * @param {number} pendingIdx - index of the pending child
+     * @param {VirtualServiceNode[]} nextVnodes - all new vnodes
+     * @param {RuntimeFiber<unknown>[]} currentChildren - all current fibers
+     * @param {RuntimeFiber<unknown>} parentFiber - parent fiber
+     * @param {ContextScope} childScope - children scope
+     * @returns {Promise<RuntimeFiber<unknown>[]>}
+     */
+    private continueStableReconcileAsync;
+    /**
+     * Full-diff reconcile: keyed/unkeyed Map + destroy orphans.
+     * Always async — internal branching is too complex for an efficient sync path.
+     *
+     * @param {RuntimeFiber<unknown>[]} currentChildren - current child fibers
+     * @param {VirtualServiceNode[]} nextVnodes - new vnodes
+     * @param {RuntimeFiber<unknown>} parentFiber - parent fiber
+     * @param {ContextScope} childScope - children scope
+     * @returns {Promise<RuntimeFiber<unknown>[]>}
+     */
+    private reconcileChildrenFullDiff;
+    /**
+     * Whether children are stable: same count, same type and key per position.
+     * Only for N≤32 — with more children the check does not pay off.
+     * When children are stable, reconcileChildren skips the full diff (9.31x speedup).
+     *
+     * @param {RuntimeFiber<unknown>[]} current - current child fibers
+     * @param {VirtualServiceNode[]} next - new child virtual nodes
+     * @returns {boolean} true if children are stable and the fast-path may be used
+     */
+    private isStableChildren;
+    /**
+     * Returns a Map from the depth-indexed pool for the current recursion depth.
+     * On first visit to a depth — creates a new Map (lazy alloc).
+     * Repeated calls at the same depth get an already-cleared Map.
+     *
+     * @returns {Map<string, RuntimeFiber<unknown>>} Map for the current recursion depth
+     */
+    private acquireKeyedMap;
+    /**
+     * Clears the Map for the current recursion depth and returns it to the pool.
+     * Called in finally after the keyed diff completes.
+     *
+     * @returns {void}
+     */
+    private releaseKeyedMap;
+    /**
+     * Unmounts a fiber and its entire subtree.
+     * Order: children first (recursively), then the parent.
+     * Afterward: clears ref.current.
+     *
+     * Returns `void` synchronously if the whole subtree is sync (up to 266x speedup
+     * on an 85-node tree); otherwise a Promise. `await` works correctly with either union branch.
+     *
+     * @param {RuntimeFiber} fiber - fiber to destroy
+     * @returns {void | Promise<void>}
+     */
+    private destroyFiber;
+    /**
+     * Async continuation of {@link destroyFiber} after one of the children returned a Promise.
+     *
+     * @param {RuntimeFiber<unknown>} fiber - current fiber
+     * @param {Fiber[]} children - children list
+     * @param {number} pendingIdx - index of the pending child
+     * @param {PromiseLike<void>} pending - Promise from destroying the child
+     * @returns {Promise<void>}
+     */
+    private continueDestroyAsync;
+    /**
+     * Async finalization of {@link destroyFiber} when children were destroyed synchronously
+     * but `runShutdown` returned a Promise.
+     *
+     * @param {RuntimeFiber<unknown>} fiber
+     * @param {PromiseLike<unknown>} pendingShutdown
+     * @returns {Promise<void>}
+     */
+    private finalizeDestroyAsync;
+    /**
+     * Returns the list of child VirtualServiceNode: first from the instance's compose(),
+     * then from explicit vnode children (fallback).
+     *
+     * @param {Component<unknown, unknown>} instance - component instance
+     * @param {VirtualServiceNode[]} explicitChildren - children from vnode.children
+     * @returns {VirtualServiceNode[]}
+     */
+    private getChildVnodes;
+    /**
+     * Builds the child scope: if the instance is a ContextProvider — extends the scope with its values.
+     *
+     * @param {Component<unknown, unknown>} instance - component instance
+     * @param {ContextScope} parentScope - parent scope
+     * @returns {ContextScope}
+     */
+    private buildChildScope;
+}
+/**
+ * Creates a node effectTag from a situation (identity helper for {@link FiberEffectTag}).
+ *
+ * @param {FiberEffectTag} tag - value from {@link FIBER_EFFECT_TAG} or null
+ * @returns {FiberEffectTag}
+ */
+export declare function makeFiberEffectTag(tag: FiberEffectTag): FiberEffectTag;
+//# sourceMappingURL=GraphRuntime.d.ts.map

package/build/component/GraphRuntime.d.ts.map

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