effectable 1.0.0 → 1.1.0-canary.10

package/build/component/GraphRuntime.d.ts

@@ -4,10 +4,14 @@
  * Responsibilities:
  * - Materialize a VirtualServiceNode tree into real component instances (Fiber tree).
  * - Fiber-like reconcile: diff current vs next trees by key + type, assign effectTags.
+ *   Reconciliation mutates the live graph (not an isolated work-in-progress tree).
  * - Drive lifecycle via LifecycleEngine: startup in topological order (children before parent),
- *   shutdown in reverse order (parent before children).
+ *   shutdown in the same order (children before parent).
  * - Inject contexts (@UseContext) and bind refs on mount.
  * - Pass updated props into existing instances during reconcile.
+ * - Serialize all graph operations through a single operation queue.
+ * - Fail-stop on unrecoverable errors: mark runtime FAILED, reject later reconcile,
+ *   unmount stays safe.
  *
  * Current limitations:
  * - Work loop is synchronous (no priority lanes — next increment).
@@ -22,6 +26,22 @@ import type { FiberEffectTag, FiberInspectNode, VirtualServiceNode } from './typ
 import type { ContextScope } from './context';
 import type { RuntimeCommand, RuntimeEvent, RuntimeQuery } from '../runtime/types';
 import type { RuntimeBusesBundle } from '../runtime/BusDecorators';
+/**
+ * Runtime state literals.
+ * Private to GraphRuntime; reduced set without mounting/reconciling.
+ */
+declare const RUNTIME_STATE: {
+    readonly IDLE: "idle";
+    readonly ACTIVE: "active";
+    readonly FAILED: "failed";
+    readonly UNMOUNTING: "unmounting";
+    readonly UNMOUNTED: "unmounted";
+};
+/**
+ * Runtime state type derived from RUNTIME_STATE.
+ * Not exported from package index (internal diagnostic only).
+ */
+type RuntimeState = (typeof RUNTIME_STATE)[keyof typeof RUNTIME_STATE];
 /**
  * Runtime engine for a declarative component tree.
  *
@@ -35,13 +55,28 @@ import type { RuntimeBusesBundle } from '../runtime/BusDecorators';
 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;
+    /**
+     * Backing field for {@link GraphRuntime.state}. Writes and most reads go
+     * through the accessor; post-await re-reads use `_state` (TS 6 still narrows getters).
+     */
+    private _state;
+    /**
+     * Runtime state machine.
+     * IDLE → ACTIVE (on mount) → FAILED | UNMOUNTING → UNMOUNTED.
+     * FAILED is terminal: subsequent reconcile rejects, unmount is safe.
+     */
+    private get state();
+    private set state(value);
+    /**
+     * Terminal error captured by failStop().
+     * Stored to reject later reconcile calls with the same error.
+     */
+    private terminalError;
     /**
      * Runtime buses for auto-wiring decorators on nodes (optional, set in {@link GraphRuntime.mount}).
      */
@@ -81,10 +116,45 @@ export declare class GraphRuntime {
      * Set via the fourth argument of {@link GraphRuntime.mount}.
      */
     private onAutoReconcileError;
+    /**
+     * Operation queue: serializes reconcile and unmount.
+     * Each operation is a Promise-returning function executed sequentially.
+     */
+    private operationQueue;
+    /**
+     * Whether an operation is currently running.
+     */
+    private operationInProgress;
+    /**
+     * Cached unmount promise for concurrent unmount callers.
+     */
+    private cachedUnmountPromise;
+    /**
+     * Pending fail-stop teardown work.
+     * When failStop nulls currentRoot but destroy is async, this tracks the in-flight cleanup.
+     * unmount() must await this before concluding teardown is finished.
+     */
+    private pendingTeardown;
     /**
      * Instances are created only via {@link GraphRuntime.mount}; direct `new GraphRuntime()` is unavailable externally.
      */
     private constructor();
+    /**
+     * Fail-stop: mark the runtime as failed, disable scheduling, tear down the graph best-effort.
+     * After fail-stop:
+     * - state is FAILED
+     * - terminalError is set
+     * - currentRoot is null (even if destroyFiber throws)
+     * - later reconcile() rejects with the terminal error
+     * - unmount() is safe and joinable
+     *
+     * No failed reconcile leaves the runtime active with a partial graph.
+     * Primary-error rules: cleanup errors attached as rollbackErrors, never replace primary.
+     *
+     * @param {Error} error - unrecoverable error that triggered fail-stop
+     * @returns {void | Promise<void>}
+     */
+    private failStop;
     /**
      * Auto-wires runtime-bus decorators onto the instance before {@link LifecycleEngine.runStartup}.
      *
@@ -101,6 +171,97 @@ export declare class GraphRuntime {
      * @returns {void}
      */
     private disposeEffectableRuntimeBusWiring;
+    /**
+     * Identity-safe ref clearing: clears ref.current only if it still points to the expected owner.
+     * Prevents an old rollback from clearing a ref that a newer materialization already reused.
+     * No cast required (Component | null → unknown | null is assignable).
+     *
+     * @param {RefObject<unknown>} ref - ref object
+     * @param {Component<unknown, unknown>} expectedOwner - expected current owner
+     * @returns {void}
+     */
+    private clearRefSafe;
+    /**
+     * Centralized ref ownership transition.
+     * Handles every ref binding/clearing operation: add, remove, replace.
+     *
+     * Rules:
+     * - Clear previousRef only if it still points to expectedPreviousOwner (identity-safe).
+     * - Bind nextRef to instance if nextRef is provided.
+     * - previousRef and nextRef can be the same object (ref reuse) or different (ref swap).
+     * - Do not let an old disposer clear a newer owner.
+     *
+     * No casts: Component | null → unknown | null is assignable (widening).
+     *
+     * @param {RefObject<unknown> | undefined} previousRef - ref to clear (can be undefined if no previous ref)
+     * @param {Component<unknown, unknown> | null} expectedPreviousOwner - expected owner of previousRef (null if unknown)
+     * @param {RefObject<unknown> | undefined} nextRef - ref to bind to instance (can be undefined if removing ref)
+     * @param {Component<unknown, unknown> | null} instance - instance to bind nextRef to (null when clearing only)
+     * @returns {void}
+     */
+    private commitRef;
+    /**
+     * Finalize fiber destroy: dispose wiring, clear ref, update status.
+     * Collects errors when collectErrors is provided (best-effort cleanup).
+     * When collectErrors is null, errors are thrown immediately.
+     *
+     * Uses commitRef for identity-safe ref clearing.
+     *
+     * @param {RuntimeFiber<unknown>} fiber - fiber being finalized
+     * @param {Error[] | null} collectErrors - array to collect errors (null to throw)
+     * @returns {void}
+     */
+    private finalizeFiberDestroy;
+    /**
+     * Transactional rollback for failed fiber materialization.
+     * Releases acquired resources in reverse acquisition order:
+     * 1. disable scheduler hook
+     * 2. dispose runtime bus registrations
+     * 3. clear bound ref (identity-safe)
+     * 4. run failed-startup cleanup
+     * 5. destroy mounted children in reverse order
+     * 6. unlink the partial fiber
+     * Cleanup is best-effort: one failure does not skip remaining steps.
+     * Preserves the original materialization error; cleanup errors are attached.
+     * Rollback is idempotent.
+     *
+     * @param {RuntimeFiber<P>} fiber - fiber being rolled back
+     * @param {Error} primaryError - original materialization/startup error
+     * @returns {void | Promise<void>}
+     */
+    private rollbackFailedMaterialization;
+    /**
+     * Async continuation of rollback child destruction after one child's destroy returned a Promise.
+     *
+     * @param {RuntimeFiber<unknown>[]} children - mounted children
+     * @param {number} lastIdx - index of the last processed child
+     * @param {Promise<void>} pending - Promise from destroying the previous child
+     * @param {Error} primaryError - original materialization error
+     * @param {Error[]} cleanupErrors - accumulated cleanup errors
+     * @param {RuntimeFiber<unknown>} fiber - parent fiber being rolled back
+     * @param {Component<unknown, unknown> | null} instance - parent instance (for post-child cleanup)
+     * @returns {Promise<void>}
+     */
+    private continueRollbackDestroyAsync;
+    /**
+     * After rollback destroyed children: run parent failed-cleanup only when startup
+     * actually ran (`status !== 'registered'`), then attach cleanup errors and rethrow.
+     *
+     * @param {RuntimeFiber<unknown>} fiber - parent fiber being rolled back
+     * @param {Component<unknown, unknown> | null} instance - parent instance
+     * @param {Error} primaryError - original materialization error
+     * @param {Error[]} cleanupErrors - accumulated cleanup errors
+     * @returns {void | Promise<void>} always rejects via {@link finalizeRollback}
+     */
+    private finishRollbackParentCleanup;
+    /**
+     * Attaches cleanup errors to the primary error and rethrows.
+     *
+     * @param {Error} primaryError - original materialization error
+     * @param {Error[]} cleanupErrors - cleanup errors
+     * @returns {never}
+     */
+    private finalizeRollback;
     /**
      * 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.
@@ -113,10 +274,12 @@ export declare class GraphRuntime {
      */
     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).
+     * Pre-mount buffer: `setState` 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).
+     *
+     * Injected before child materialization so descendant `onMount` callbacks that
+     * `setState` an ancestor are buffered instead of silently dropped.
      *
      * @param {Component<unknown, unknown>} instance - instance before/during startup
      * @param {RuntimeFiber<unknown>} fiber - instance fiber
@@ -138,13 +301,38 @@ export declare class GraphRuntime {
      * - 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).
      *
+     * Skip scheduling when runtime is FAILED.
+     *
      * @param {RuntimeFiber<unknown>} fiber - fiber whose subtree needs rebuild
      * @returns {void}
      */
     private scheduleUpdate;
+    /**
+     * Enqueues an operation and starts the queue processor if idle.
+     * Operations are executed sequentially; concurrent callers await the same in-flight operation.
+     * Serialize all graph mutations.
+     *
+     * @param {() => Promise<void>} operation - operation to enqueue
+     * @returns {Promise<void>}
+     */
+    private enqueueOperation;
+    /**
+     * Processes the operation queue: runs operations one at a time.
+     * Single serialized owner of tree mutations.
+     * Errors from individual operations are propagated to their callers but do not stop the queue.
+     *
+     * @returns {Promise<void>}
+     */
+    private processOperationQueue;
     /**
      * Queues one dirty-flush microtask and publishes {@link activeFlush} for await from `reconcile`.
      *
+     * Skip scheduling when runtime is not ACTIVE (IDLE / FAILED / UNMOUNTING / UNMOUNTED),
+     * a public graph operation is in flight, or an async flush is already running. Callers that
+     * mutate `dirtyFibers` during those windows must kick this method again after the tree is
+     * ACTIVE and idle ({@link GraphRuntime.mount} / {@link processOperationQueue}), or after the
+     * outer flush finishes (end-of-pass kick).
+     *
      * @returns {void}
      */
     private scheduleDirtyFlushMicrotask;
@@ -154,6 +342,9 @@ export declare class GraphRuntime {
      * Guarded by the `flushing` flag against re-entrancy.
      * The chain of repeat passes is capped by {@link GRAPH_RUNTIME_MAX_DIRTY_FLUSH_PASSES}.
      *
+     * Respects state (UNMOUNTING/UNMOUNTED/FAILED) to cancel flush when unmount begins or failure occurs.
+     * On unrecoverable error, invokes onAutoReconcileError then fail-stops.
+     *
      * @returns {Promise<void>}
      */
     private flushDirtyFibers;
@@ -180,24 +371,35 @@ export declare class GraphRuntime {
     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:
+     * Diffs the current tree against the new one, 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
      *
+     * All reconcile calls are serialized through the operation queue.
+     * Rejects with terminal error when runtime is FAILED.
+     *
      * @param {VirtualServiceNode<P>} nextTree - new virtual tree
      * @returns {Promise<void>}
-     * @throws {Error} if the runtime is already unmounted
+     * @throws {Error} if the runtime state is UNMOUNTING, UNMOUNTED, or FAILED
      */
     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
+     * Calls onUnmount for each node (children before parent) and
      * moves stages to destroyed via LifecycleEngine.
      *
+     * Unmount is serialized, cached promise returned for concurrent callers.
+     * Safe and joinable even when runtime is FAILED.
+     * Collects cleanup errors when `rejectOnCleanupError: true` is passed.
+     *
+     * @param {object} [options] - unmount options
+     * @param {boolean} [options.rejectOnCleanupError=false] - reject on cleanup errors
      * @returns {Promise<void>}
      */
-    unmount(): Promise<void>;
+    unmount(options?: {
+        rejectOnCleanupError?: boolean;
+    }): Promise<void>;
     /**
      * Returns the root component instance (for testing and introspection).
      *
@@ -205,7 +407,8 @@ export declare class GraphRuntime {
      */
     getRootInstance(): Component<unknown, unknown> | null;
     /**
-     * Whether the runtime is active (unmount has not been called).
+     * Whether the runtime is active (not failed and unmount has not been called).
+     * Returns false when state is FAILED.
      *
      * @returns {boolean}
      */
@@ -232,6 +435,13 @@ export declare class GraphRuntime {
      * @returns {number} accumulated counter
      */
     getStableAsyncContinueCount(): number;
+    /**
+     * Current runtime state.
+     * Test/debug probe; not a production API.
+     *
+     * @returns {RuntimeState} current state
+     */
+    getState(): RuntimeState;
     /**
      * Builds a deep readonly {@link FiberInspectNode} from a RuntimeFiber.
      *
@@ -263,7 +473,7 @@ export declare class GraphRuntime {
      * @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 {ContextScope} childScope - scope for child nodes
      * @param {Promise<RuntimeFiber<unknown>>} pending - Promise for the current child
      * @param {number} pendingIdx - index of the current child
      * @returns {Promise<RuntimeFiber<P>>}
@@ -275,19 +485,10 @@ export declare class GraphRuntime {
      * @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.
@@ -312,10 +513,13 @@ export declare class GraphRuntime {
      */
     private updateFiber;
     /**
-     * Fiber cleanup after update/compose error: `runFailedCleanup` + bus dispose.
-     * Does not leave the node in `ready`.
+     * Fiber cleanup after update/compose error: destroy children first (children → parent),
+     * then `runFailedCleanup` + bus dispose. Does not leave the node in `ready`.
+     * Child destroy / disposer errors are attached to `primaryError.rollbackErrors` when provided
+     * so fail-stop observability still surfaces them (children are no longer destroyed in failStop).
      *
      * @param {RuntimeFiber<unknown>} fiber - fiber that failed
+     * @param {unknown} [primaryError] - originating error to attach cleanup failures onto
      * @returns {void | Promise<void>}
      */
     private runFiberFailedCleanup;
@@ -362,15 +566,35 @@ export declare class GraphRuntime {
      * @returns {Promise<RuntimeFiber<unknown>[]>}
      */
     private continueStableReconcileAsync;
+    /**
+     * Validates that sibling keys are unique within a list.
+     * Follows React v16.5 keyed child reconciliation contract: duplicate keys are invalid.
+     * Throws a descriptive error including the duplicate key and parent component identity.
+     *
+     * @param {Array<{ vnode: { key?: string }; instance?: Component<unknown, unknown> | null }>} items - list of fibers or vnodes
+     * @param {RuntimeFiber<unknown>} parentFiber - parent fiber (for error message)
+     * @param {string} listName - "current" or "next" (for error message)
+     * @returns {void}
+     * @throws {Error} when duplicate keys are detected
+     */
+    private validateUniqueKeys;
     /**
      * Full-diff reconcile: keyed/unkeyed Map + destroy orphans.
      * Always async — internal branching is too complex for an efficient sync path.
      *
+     * Contract: Sibling keys must be unique (React v16.5 keyed child reconciliation).
+     * Validates both current and next children BEFORE any side effects.
+     * Throws deterministic error on duplicate keys to prevent lifecycle leaks.
+     *
+     * HOLE 3: On throw during PLACE, cleans up previously placed new nodes
+     * to prevent lifecycle leaks. Uses identity-safe check against currentChildren Set.
+     *
      * @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>[]>}
+     * @throws {Error} when duplicate keys are detected in current or next children
      */
     private reconcileChildrenFullDiff;
     /**
@@ -406,7 +630,10 @@ export declare class GraphRuntime {
      * 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.
      *
+     * Collects cleanup errors via `collectErrors` parameter (best-effort cleanup).
+     *
      * @param {RuntimeFiber} fiber - fiber to destroy
+     * @param {Error[] | null} collectErrors - array to collect cleanup errors (null to throw immediately)
      * @returns {void | Promise<void>}
      */
     private destroyFiber;
@@ -417,6 +644,7 @@ export declare class GraphRuntime {
      * @param {Fiber[]} children - children list
      * @param {number} pendingIdx - index of the pending child
      * @param {PromiseLike<void>} pending - Promise from destroying the child
+     * @param {Error[] | null} collectErrors - array to collect cleanup errors
      * @returns {Promise<void>}
      */
     private continueDestroyAsync;
@@ -426,6 +654,7 @@ export declare class GraphRuntime {
      *
      * @param {RuntimeFiber<unknown>} fiber
      * @param {PromiseLike<unknown>} pendingShutdown
+     * @param {Error[] | null} collectErrors - array to collect cleanup errors
      * @returns {Promise<void>}
      */
     private finalizeDestroyAsync;
@@ -454,4 +683,5 @@ export declare class GraphRuntime {
  * @returns {FiberEffectTag}
  */
 export declare function makeFiberEffectTag(tag: FiberEffectTag): FiberEffectTag;
+export {};
 //# sourceMappingURL=GraphRuntime.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GraphRuntime.d.ts","sourceRoot":"","sources":["../../src/component/GraphRuntime.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"GraphRuntime.d.ts","sourceRoot":"","sources":["../../src/component/GraphRuntime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAEV,cAAc,EACd,gBAAgB,EAGhB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AASjB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,YAAY,EACb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAyBnE;;;GAGG;AACH,QAAA,MAAM,aAAa;;;;;;CAMT,CAAC;AAEX;;;GAGG;AACH,KAAK,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAsDvE;;;;;;;;;GASG;AACH,qBAAa,YAAY;IACvB,8CAA8C;IAC9C,OAAO,CAAC,WAAW,CAA6B;IAChD;;;OAGG;IACH,OAAO,CAAC,wBAAwB,CAAK;IAErC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAoC;IAElD;;;;OAIG;IACH,OAAO,KAAK,KAAK,GAEhB;IAED,OAAO,KAAK,KAAK,QAEhB;IAED;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAsB;IAE3C;;OAEG;IACH,OAAO,CAAC,sBAAsB,CAId;IAEhB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4C;IAEzE;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAK;IAE3B;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IAErE,oDAAoD;IACpD,OAAO,CAAC,cAAc,CAAS;IAE/B,+EAA+E;IAC/E,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;OAGG;IACH,OAAO,CAAC,WAAW,CAA8B;IAEjD;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAK;IAEhC;;;OAGG;IACH,OAAO,CAAC,oBAAoB,CAAyC;IAErE;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAkC;IAExD;;OAEG;IACH,OAAO,CAAC,mBAAmB,CAAS;IAEpC;;OAEG;IACH,OAAO,CAAC,oBAAoB,CAA8B;IAE1D;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAA8B;IAErD;;OAEG;IACH,OAAO;IAEP;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,QAAQ;IA4ChB;;;;;;;OAOG;IACH,OAAO,CAAC,gCAAgC;IAcxC;;;;;OAKG;IACH,OAAO,CAAC,iCAAiC;IASzC;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY;IAMpB;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,SAAS;IAiBjB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;IA+B5B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,6BAA6B;IA4ErC;;;;;;;;;;;OAWG;YACW,4BAA4B;IAqC1C;;;;;;;;;OASG;IACH,OAAO,CAAC,2BAA2B;IAkCnC;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,wBAAwB;IAUhC;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IAmCtB;;;;;;;OAOG;YACW,gBAAgB;IAkB9B;;;;;;OAMG;YACW,qBAAqB;IAgCnC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,2BAA2B;IAiCnC;;;;;;;;;;OAUG;YACW,gBAAgB;IA8F9B;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IAsD3B;;;;;;;;;OASG;WACiB,KAAK,CAAC,CAAC,GAAG,OAAO,EACnC,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC3B,YAAY,GAAE,YAAkC,EAChD,YAAY,CAAC,EAAE,kBAAkB,CAAC,cAAc,EAAE,YAAY,EAAE,YAAY,CAAC,EAC7E,oBAAoB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAC5C,OAAO,CAAC,YAAY,CAAC;IAiCxB;;;;;;;;;;;;;OAaG;IACU,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAoEnF;;;;;;;;;;;;OAYG;IACU,OAAO,CAAE,OAAO,CAAC,EAAE;QAAE,oBAAoB,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAkFlF;;;;OAIG;IACI,eAAe,IAAK,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAQ7D;;;;;OAKG;IACI,QAAQ,IAAK,OAAO;IAI3B;;;;;OAKG;IACI,gBAAgB,IAAK,gBAAgB,GAAG,IAAI;IAQnD;;;;;;OAMG;IACI,wBAAwB,IAAK,IAAI;IAQxC;;;;;OAKG;IACI,2BAA2B,IAAK,MAAM;IAI7C;;;;;OAKG;IACI,QAAQ,IAAK,YAAY;IAIhC;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAuB1B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,WAAW;IAoKnB;;;;;;;;;;;;;OAaG;YACW,wBAAwB;IA6FtC;;;;;;;;OAQG;YACW,wBAAwB;IA+BtC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;IAwBtB;;;;;;;;;OASG;IACH,OAAO,CAAC,WAAW;IAgGnB;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;IA6F7B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IAqBxB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,iBAAiB;IAoCzB;;;;;;;;;;;OAWG;YACW,4BAA4B;IAyB1C;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;IA6B1B;;;;;;;;;;;;;;;;;OAiBG;YACW,yBAAyB;IA6KvC;;;;;;;;OAQG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAUvB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,YAAY;IA8CpB;;;;;;;;;OASG;YACW,oBAAoB;IA6DlC;;;;;;;;OAQG;YACW,oBAAoB;IAwBlC;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;CAWxB;AAMD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAE,GAAG,EAAE,cAAc,GAAG,cAAc,CAEvE"}