@sdux-vault/shared 0.6.0 → 0.7.0

package/types/sdux-vault-shared.d.ts

@@ -5,6 +5,7 @@ import { Observable, Subject } from 'rxjs';
  * This declaration defines the global attachment points used to expose runtime singletons.
  */
 declare global {
+    /** Augments the global Window with an optional SDuX runtime attachment point. */
     interface Window {
         /**
          * Optional container for globally exposed SDuX runtime instances.
@@ -22,17 +23,21 @@ declare global {
  * in Vault license validation (behaviors and controllers).
  */
 interface LicensableClassContext {
+    /** Key identifying the FeatureCell subject to license validation. */
     readonly featureCellKey: string;
+    /** Optional license payload provided during FeatureCell registration. */
     readonly licensePayload?: unknown;
 }
 
+/**
+ * Context provided to behavior class constructors during instantiation.
+ */
 interface BehaviorClassContext extends LicensableClassContext {
-    /**
-     * The unique key of the FeatureCell that this behavior instance is
-     * operating within. Used to scope behavior execution to a specific cell.
-     */
+    /** Key of the FeatureCell this behavior instance operates within. */
     readonly featureCellKey: string;
+    /** Optional consumer-supplied configuration for this behavior. */
     readonly behaviorConfig?: unknown;
+    /** Optional license payload for behaviors requiring license validation. */
     readonly licensePayload?: unknown;
 }
 
@@ -80,9 +85,6 @@ interface VaultErrorShape {
  * Defines the immutable snapshot shape representing FeatureCell state at a specific moment.
  * This interface exposes loading, value, and error indicators used by consumers to reason about current state.
  *
- * --RelatedStart--
- * VaultErrorShape
- * --RelatedEnd--
  */
 interface StateSnapshotShape<T> {
     /**
@@ -119,6 +121,7 @@ interface StateSnapshotShape<T> {
  */
 type VaultErrorCallback<T> = (error: VaultErrorShape, state: Readonly<StateSnapshotShape<T>>) => void;
 
+/** Enumeration of state emission event classifications. */
 declare const StateEmitTypes: {
     readonly IncomingPipeline: "Incoming Pipeline";
     readonly FinalizePipeline: "Finalize Pipeline";
@@ -129,19 +132,26 @@ declare const StateEmitTypes: {
     readonly DenyController: "Deny Controller";
     readonly TabSync: "Tab Sync";
 };
+/** Union type derived from StateEmitTypes values. */
 type StateEmitType = (typeof StateEmitTypes)[keyof typeof StateEmitTypes];
 
+/** Shape wrapping a state snapshot with its emission type and options. */
 interface StateEmitSnapshotShape<T> {
+    /** The state snapshot at the time of emission. */
     snapshot: StateSnapshotShape<T>;
+    /** Optional configuration passed with the emission. */
     options: unknown | undefined;
+    /** Classification of the state emission event. */
     type: StateEmitType;
 }
 
+/** Enumeration of pipeline operation modes. */
 declare const OperationTypes: {
     readonly Merge: "merge";
     readonly Replace: "replace";
     readonly Initialize: "initialize";
 };
+/** Union type derived from OperationTypes values. */
 type OperationType = (typeof OperationTypes)[keyof typeof OperationTypes];
 
 /**
@@ -217,6 +227,7 @@ interface HttpResourceRefShape<T> {
     hasValue(): boolean;
 }
 
+/** Factory function type that lazily produces a state value or a Promise of one. */
 type DeferredType<T> = () => T | undefined | null | Promise<T | undefined | null>;
 
 /**
@@ -239,12 +250,14 @@ interface StateInputShape<T> {
     error?: unknown;
 }
 
+/** Shape wrapping a deferred value factory with optional loading and error state. */
 type DeferredFactory<T> = Partial<{
     loading: boolean;
     value: DeferredType<T>;
     error: unknown;
 }>;
 
+/** Union of all accepted state input forms for pipeline ingestion. */
 type StateInputType<T> = T | StateInputShape<T> | DeferredFactory<T> | DeferredType<T> | HttpResourceRefShape<T> | Observable<T> | undefined | null;
 
 /**
@@ -333,20 +346,34 @@ interface InsightConfig {
     wantsErrors?: boolean;
 }
 
+/** Enumeration of conductor decision outcomes after controller voting. */
 declare const DecisionOutcomeTypes: {
     readonly Abort: "abort";
     readonly Abstain: "abstain";
     readonly Deny: "deny";
 };
+/** Union type derived from DecisionOutcomeTypes values. */
 type DecisionOutcomeType = (typeof DecisionOutcomeTypes)[keyof typeof DecisionOutcomeTypes];
 
+/** Shape representing the outcome of a controller voting round. */
 interface ControllerDecisionShape {
+    /** Trace identifier for the pipeline operation under evaluation. */
     traceId: string;
+    /** Normalized decision outcome used by the conductor. */
     outcome: DecisionOutcomeType;
 }
 
+/**
+ * Context supplied to a controller during pipeline admission voting.
+ */
 interface ControllerContext<T> {
+    /**
+     * Trace identifier for the current pipeline operation.
+     */
     traceId: string;
+    /**
+     * Key identifying the FeatureCell associated with this operation.
+     */
     featureCellKey: string;
     /** Immutable snapshot of the current cell state. */
     snapshot: Readonly<StateSnapshotShape<T>>;
@@ -356,100 +383,656 @@ interface ControllerContext<T> {
     operation: OperationType;
 }
 
+/** Union of context types accepted by VaultMonitor lifecycle methods. */
 type VaultMonitorContext<T> = BehaviorContext<T> | ControllerContext<T> | FeatureCellExtensionContext<T>;
 
 /**
- * Public interface for the VaultMonitor singleton.
- *
- * This interface defines the full DevTools-visible monitoring API
- * without exposing implementation details.
+ * Contract for the VaultMonitor singleton exposing the full DevTools-visible
+ * monitoring API without implementation details.
  */
 interface VaultMonitorContract {
+    /**
+     * Activates global insight tracking with the supplied configuration.
+     *
+     * @param definition - The insight configuration to activate.
+     */
     activateGlobalInsights(definition: InsightConfig): void;
+    /**
+     * Signals the start of an after-tap lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startAfterTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of an after-tap lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endAfterTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a before-tap lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startBeforeTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a before-tap lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endBeforeTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a compute-merge lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startComputeMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a compute-merge lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endComputeMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a clear-persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startClearPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a clear-persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endClearPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a core callback-error lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startCoreCallbackError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a core callback-error lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endCoreCallbackError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a core emit-state lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startCoreEmitState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a core emit-state lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endCoreEmitState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a core error lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startCoreError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a core error lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endCoreError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a core state lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startCoreState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a core state lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endCoreState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a destroy lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startDestroy<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a destroy lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endDestroy<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a decrypt lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startDecrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a decrypt lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endDecrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of an encrypt lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startEncrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of an encrypt lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endEncrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a filter lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startFilter<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a filter lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endFilter<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a global error lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startGlobalError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a global error lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endGlobalError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Records that an ingress source has been subscribed.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param source - The ingress source identifier.
+     */
     ingressSubscribed<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, source: string): void;
+    /**
+     * Records that an ingress source has completed.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param source - The ingress source identifier.
+     */
     ingressCompleted<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, source: string): void;
+    /**
+     * Signals the start of an interceptor lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startInterceptor<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of an interceptor lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endInterceptor<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of an initialized lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startInitialized<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of an initialized lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endInitialized<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a load-persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startLoadPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a load-persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endLoadPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a merge lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a merge lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of an operator lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startOperator<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of an operator lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endOperator<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a persist lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a reducer lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startReducer<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a reducer lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endReducer<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Registers a FeatureCell for monitoring.
+     *
+     * @param cellKey - The FeatureCell key to register.
+     * @param insight - Optional insight configuration for the cell.
+     */
     registerCell(cellKey: string, insight?: InsightConfig): void;
+    /**
+     * Signals the start of a replace lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startReplace<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a replace lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endReplace<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a reset lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startReset<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a reset lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endReset<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Signals the start of a resolve lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startResolve<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a resolve lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endResolve<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a set-initial-value lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startSetInitialValue<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a set-initial-value lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     endSetInitialValue<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a stepwise lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startStepwise<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a stepwise lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - Optional result payload.
+     */
     endStepwise<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    /**
+     * Records that the conductor denied a pipeline operation.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     notifyConductorDeny<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Records that the conductor triggered a revote.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     conductorRevote<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Records that the conductor aborted a pipeline operation.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     conductorAbort<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Records a license validation attempt for a FeatureCell.
+     *
+     * @param cell - The FeatureCell key.
+     * @param featureCellKey - The target cell key under validation.
+     */
     conductorLicenseAttempt(cell: string, featureCellKey: string): void;
+    /**
+     * Records that a license validation was approved.
+     *
+     * @param cell - The FeatureCell key.
+     * @param featureCellKey - The target cell key that was approved.
+     */
     conductorLicenseApproved(cell: string, featureCellKey: string): void;
+    /**
+     * Records that a license validation was denied.
+     *
+     * @param cell - The FeatureCell key.
+     * @param featureCellKey - The target cell key that was denied.
+     */
     conductorLicenseDenied(cell: string, featureCellKey: string): void;
+    /**
+     * Signals the start of a controller attempt lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startControllerAttempt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a controller attempt lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - The attempt result payload.
+     */
     endControllerAttempt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: unknown): void;
+    /**
+     * Records that a controller attempt was restarted.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - The restart reason.
+     */
     restartControllerAttempt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: string): void;
+    /**
+     * Records a controller failure event.
+     *
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param error - The error that caused the failure.
+     */
     controllerFailure<T>(behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, error: unknown): void;
+    /**
+     * Records a controller finalize event.
+     *
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     controllerFinalize<T>(behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Records a controller success event.
+     *
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     controllerSuccess<T>(behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the start of a controller vote lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startControllerVote<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of a controller vote lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - The controller decision result.
+     */
     endControllerVote<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: ControllerDecisionShape): void;
+    /**
+     * Records that the conductor crashed during execution.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param error - The error that caused the crash.
+     */
     conductorCrashed<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, error: unknown): void;
+    /**
+     * Records a runtime error encountered during pipeline execution.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param error - The runtime error.
+     */
     runtimeError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, error: unknown): void;
+    /**
+     * Records a warning message during pipeline execution.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param message - The warning message.
+     */
     warn<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, message: string): void;
+    /**
+     * Signals the start of an error-transform lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     */
     startErrorTransform<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    /**
+     * Signals the end of an error-transform lifecycle event.
+     *
+     * @param cell - The FeatureCell key.
+     * @param behaviorKey - The behavior key.
+     * @param ctx - The monitor context for this operation.
+     * @param payload - The transformed error shape.
+     */
     endErrorTransform<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: VaultErrorShape): void;
 }
 
+/** Runtime context provided to behavior extensions for interacting with a FeatureCell. */
 interface FeatureCellExtensionContext<T> {
+    /** Observable that emits when the FeatureCell is destroyed. */
     destroyed$: Observable<void>;
+    /** Unique key identifying the FeatureCell. */
     featureCellKey: string;
+    /**
+     * Merges incoming state into the current FeatureCell state.
+     *
+     * @param incoming - The state input to merge.
+     * @param options - Optional merge configuration.
+     */
     mergeState(incoming: StateInputType<T>, options?: unknown): Promise<void>;
+    /**
+     * Replaces the current FeatureCell state with the provided input.
+     *
+     * @param input - The state input to set.
+     * @param options - Optional replacement configuration.
+     */
     replaceState(input: StateInputType<T>, options?: unknown): Promise<void>;
+    /** Observable that emits when the FeatureCell is reset. */
     reset$: Observable<void>;
+    /** Observable stream of state-emit snapshots from the FeatureCell. */
     state$: Observable<StateEmitSnapshotShape<T>>;
+    /** Reference to the Vault monitor for diagnostics and tracing. */
     vaultMonitor: VaultMonitorContract;
+    /** Optional configuration options for the extension context. */
     options?: unknown;
 }
 
@@ -461,6 +1044,7 @@ interface FeatureCellExtensionContext<T> {
 interface FeatureCellExtension<TEntity> {
 }
 
+/** Extensible interface for FeatureCell fluent API methods added by behaviors. */
 interface FeatureCellFluentApi<TEntity> {
 }
 
@@ -509,45 +1093,51 @@ declare const BehaviorTypes: {
  * This type should not be manually extended—add new values to `BehaviorTypes`
  * instead.
  *
- * --RelatedStart--
- * BehaviorTypes
- * --RelatedEnd--
  */
 type BehaviorType = (typeof BehaviorTypes)[keyof typeof BehaviorTypes];
 
+/**
+ * Static-side contract for behavior classes used by the behavior factory.
+ */
 interface BehaviorClassContract<T = any> {
     /**
      * Creates a new behavior instance.
      *
      * @param behaviorKey - Unique key assigned by the behavior factory.
-     * @param behaviorCtx - The behaviorCtxfor dependency resolution.
+     * @param behaviorCtx - Class-level context for dependency resolution.
      */
     new (behaviorKey: string, behaviorCtx: BehaviorClassContext): BehaviorContract<T>;
+    /** Pipeline stage in which this behavior participates. */
     readonly type: BehaviorType;
-    /**
-     * Unique identifier assigned to this behavior instance. Used by the
-     * orchestrator, diagnostics, and devtools for behavior correlation.
-     */
+    /** Unique identifier assigned to this behavior class. */
     readonly key: string;
+    /** Whether errors from this behavior halt the pipeline. */
+    readonly critical: boolean;
     /**
-     * If the actions of the behavior are critical in regards to error handling.
-     * True means the pipeline should VAULT_NOOP and stop the pipeline flow on any errors
-     * False means that pipeline should log any error and continue
+     * Optional hook that installs a fluent API onto the FeatureCell.
+     *
+     * @param cell - The FeatureCell shape to extend.
+     * @param behaviorConfigs - Map of behavior configuration entries.
      */
-    readonly critical: boolean;
     installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
+    /** Whether this behavior requires consumer-supplied configuration. */
     readonly wantsConfig?: boolean;
+    /** Configuration key used to locate behavior options in the config registry. */
     readonly configKey?: string;
 }
 
+/** Static-side contract for interceptor behavior classes. */
 interface InterceptorBehaviorClassContract<T> extends BehaviorClassContract<T> {
 }
 
+/** Static-side contract for operator behavior classes. */
 interface OperatorsBehaviorClassContract<T> extends BehaviorClassContract<T> {
 }
 
+/** Callback type invoked when the core emits a state snapshot. */
 type CoreEmitStateCallback<T, E = void> = (snapshot: StateSnapshotShape<T>) => E;
 
+/** Callback type invoked with the current value during a tap lifecycle event. */
 type TapCallback<T> = (current: T) => void;
 
 /**
@@ -580,18 +1170,6 @@ type ReducerFunction<T> = (current: T) => T;
 /**
  * Defines the builder contract used to configure and initialize a FeatureCell.
  * This interface exposes the fluent configuration surface for registering behaviors, callbacks, and operators prior to activation.
- *
- * --RelatedStart--
- * FeatureCellExtension
- * FeatureCellFluentApi
- * CoreEmitStateCallback
- * TapCallback
- * VaultErrorCallback
- * FilterFunction
- * InterceptorBehaviorClassContract
- * OperatorsBehaviorClassContract
- * ReducerFunction
- * --RelatedEnd--
  */
 interface CellBuilderContract<T> extends FeatureCellExtension<T>, FeatureCellFluentApi<T> {
     /**
@@ -621,7 +1199,7 @@ interface CellBuilderContract<T> extends FeatureCellExtension<T>, FeatureCellFlu
     emitStates(emitStates: CoreEmitStateCallback<T>[]): CellBuilderContract<T>;
     /**
      * Registers error functions to run during the error stage.
-     *CellBuilderContract
+     *
      * @param errors - Error functions that may block or transform values.
      * @returns The same builder instance for fluent chaining.
      */
@@ -633,13 +1211,15 @@ interface CellBuilderContract<T> extends FeatureCellExtension<T>, FeatureCellFlu
      * @returns The same builder instance for fluent chaining.
      */
     filters(filters: FilterFunction<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers a deferred hydration source for the FeatureCell.
+     *
+     * @param incoming - Deferred value used to hydrate the cell state.
+     * @returns The builder instance for fluent chaining.
+     */
     hydrate(incoming: DeferredType<T>): CellBuilderContract<T>;
     /**
      * Finalizes the builder configuration and activates the FeatureCell.
-     *
-     * Implementations may perform synchronous or asynchronous setup.
-     *
-     * @returns The builder instance, or a Promise resolving when initialization completes.
      */
     initialize(): void;
     /**
@@ -667,7 +1247,9 @@ interface CellBuilderContract<T> extends FeatureCellExtension<T>, FeatureCellFlu
 
 /**
  * Defines the public base contract for a FeatureCell instance.
- * This interface exposes the full builder, lifecycle, and state update surface required to configure, initialize, and interact with a FeatureCell at runtime.
+ *
+ * FeatureCellBaseShape describes the builder, lifecycle, and state update
+ * surface required to configure, initialize, and interact with a FeatureCell.
  */
 interface FeatureCellBaseShape<T> extends FeatureCellExtension<T>, FeatureCellFluentApi<T> {
     /**
@@ -714,6 +1296,12 @@ interface FeatureCellBaseShape<T> extends FeatureCellExtension<T>, FeatureCellFl
      * @returns The builder instance for fluent chaining.
      */
     filters(filters: FilterFunction<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers a deferred hydration source for the FeatureCell.
+     *
+     * @param incoming - Deferred value used to hydrate the cell state.
+     * @returns The builder instance for fluent chaining.
+     */
     hydrate(incoming: DeferredType<T>): CellBuilderContract<T>;
     /**
      * Finalizes builder configuration and activates the FeatureCell.
@@ -735,8 +1323,8 @@ interface FeatureCellBaseShape<T> extends FeatureCellExtension<T>, FeatureCellFl
     /**
      * Performs a merge-style state update using the configured merge behavior.
      *
-     * @param incoming Structured state input to be merged.
-     * @param options Optional merge behavior configuration.
+     * @param incoming - Structured state input to be merged.
+     * @param options - Optional merge behavior configuration.
      */
     mergeState(incoming: StateInputType<T>, options?: unknown): void;
     /**
@@ -756,8 +1344,8 @@ interface FeatureCellBaseShape<T> extends FeatureCellExtension<T>, FeatureCellFl
     /**
      * Performs a replace-style state update that fully replaces the current state.
      *
-     * @param incoming Structured state input to replace the current state.
-     * @param options Optional merge behavior configuration.
+     * @param incoming - Structured state input to replace the current state.
+     * @param options - Optional merge behavior configuration.
      */
     replaceState(incoming: StateInputType<T>, options?: unknown): void;
     /**
@@ -769,17 +1357,16 @@ interface FeatureCellBaseShape<T> extends FeatureCellExtension<T>, FeatureCellFl
      */
     reset$?: Observable<void>;
     /**
-     * Observable that emits when the FeatureCell has been reset.
+     * Observable that emits state snapshots whenever the FeatureCell state changes.
      */
     state$: Observable<StateEmitSnapshotShape<T>>;
     /**
-     * Dev-mode testing hook.
-     * Only defined when DevMode.active === true.
-     * Non-enumerable and not part of runtime API.
+     * Dev-mode testing hook that resolves once all pending pipeline activity has settled.
      */
     vaultSettled?: () => Promise<void>;
 }
 
+/** Function signature for behavior extension methods added to the FeatureCell. */
 type BehaviorExtFunction = (...args: any[]) => unknown;
 /**
  * A map of extension function names to their implementation functions.
@@ -789,50 +1376,75 @@ type BehaviorExtFunction = (...args: any[]) => unknown;
  */
 type BehaviorExtension = Partial<Record<string, BehaviorExtFunction>>;
 /**
- * Base interface implemented by all behavior types in the SDuX/ Vault
- * pipeline. Behaviors participate in specific pipeline stages based on
- * their declared BehaviorType, and may optionally expose additional
- * FeatureCell APIs through the `extendCellAPI()` hook.
+ * Base interface implemented by all behavior types in the Vault pipeline.
  *
- * @typeParam T - The FeatureCell state value type handled by this behavior.
- * @typeParam E - The shape of the extension API returned by this behavior.
+ * Behaviors participate in specific pipeline stages based on their declared
+ * BehaviorType, and may optionally expose additional FeatureCell APIs through
+ * the extendCellAPI hook.
  */
 interface BehaviorContract<T = unknown, E extends BehaviorExtension = BehaviorExtension> {
     /**
-     * Declares the pipeline classification for this behavior. The orchestrator
-     * uses this to determine the execution order in the upstream and persist
-     * stages.
+     * Pipeline classification for this behavior used to determine execution order.
      */
     readonly type: BehaviorType;
     /**
-     * Unique identifier assigned to this behavior instance. Used by the
-     * orchestrator, diagnostics, and devtools for behavior correlation.
+     * Unique identifier assigned to this behavior instance.
      */
     readonly key: string;
     /**
-     * If the actions of the behavior are critical in regards to error handling.
-     * True means the pipeline should VAULT_NOOP and stop the pipeline flow on any errors
-     * False means that pipeline should log any error and continue
+     * Whether this behavior is critical for pipeline error handling.
      */
     readonly critical: boolean;
     /**
-     * Optional list of extension function names that this behavior is permitted
-     * to override when multiple behaviors contribute conflicting API keys.
-     * Behaviors without explicit override permission may not replace an
-     * existing API entry.
+     * Extension function names this behavior is permitted to override.
      */
     allowOverride?: string[];
+    /**
+     * Extends the FeatureCell with additional APIs backed by this behavior.
+     *
+     * @param ctx - Extension context used to observe state and merge updates.
+     * @returns The extension API surface, or void if no extensions are provided.
+     */
     extendCellAPI?(ctx: FeatureCellExtensionContext<T>): E | void;
+    /**
+     * Teardown hook invoked when the behavior instance is destroyed.
+     *
+     * @param ctx - Pipeline behavior context.
+     */
     destroy(ctx?: BehaviorContext<T>): void;
+    /**
+     * Resets the behavior to its initial state.
+     *
+     * @param ctx - Pipeline behavior context.
+     */
     reset(ctx?: BehaviorContext<T>): void;
+    /**
+     * Installs fluent configuration APIs onto a FeatureCell instance.
+     *
+     * @param cell - FeatureCell instance to augment.
+     * @param behaviorConfigs - Registry used to store behavior configuration.
+     */
     installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
 }
 
+/** Contract for behaviors that invoke consumer error callbacks on pipeline errors. */
 interface ErrorCallbackBehaviorContract<T> extends BehaviorContract<T> {
+    /** Identifies this behavior as a core error callback behavior. */
     type: 'coreErrorCallback';
+    /**
+     * Invokes the consumer error callback with the current error and state.
+     *
+     * @param current - The current Vault error shape.
+     * @param state - The state snapshot at the time of error.
+     * @param oldschoolCallback - The consumer-supplied error callback.
+     */
     callbackError(current: VaultErrorShape, state: StateSnapshotShape<T>, oldschoolCallback: VaultErrorCallback<T>): Promise<void>;
 }
 
+/**
+ * Abstract base class for error callback behaviors that execute consumer-supplied
+ * error handlers during the error stage of the Vault pipeline.
+ */
 declare abstract class AbstractErrorCallbackBehavior<T> implements ErrorCallbackBehaviorContract<T> {
     readonly behaviorCtx: BehaviorClassContext;
     /** Indicates that this error behavior is critical and always executed. */
@@ -848,27 +1460,40 @@ declare abstract class AbstractErrorCallbackBehavior<T> implements ErrorCallback
      * @param behaviorCtx - Behavior class context providing injector access and extensibility hooks.
      */
     constructor(key: string, behaviorCtx: BehaviorClassContext);
-    abstract callbackError(current: VaultErrorShape, state: StateSnapshotShape<T>, oldschoolCallback: VaultErrorCallback<T>): Promise<void>;
     /**
-     * Lifecycle hook invoked when the behavior instance is destroyed.
+     * Executes the consumer-supplied error callback against the current error and state.
      *
-     * Error behaviors do not allocate runtime resources and therefore require
-     * no cleanup. A diagnostic entry is logged for lifecycle visibility.
+     * @param current - The error shape describing the pipeline failure.
+     * @param state - The state snapshot at the time of the error.
+     * @param oldschoolCallback - Consumer-supplied error callback to invoke.
+     * @returns A promise that resolves when the callback completes.
+     */
+    abstract callbackError(current: VaultErrorShape, state: StateSnapshotShape<T>, oldschoolCallback: VaultErrorCallback<T>): Promise<void>;
+    /**
+     * Teardown hook invoked when the behavior instance is destroyed.
      */
     destroy(): void;
     /**
-     * Lifecycle hook invoked when the behavior instance is reset.
-     *
-     * Error behaviors hold no internal state, making this a no-operation.
-     * The hook ensures lifecycle uniformity across all behaviors.
+     * Resets the error behavior to its initial state.
      */
     reset(): void;
 }
 
+/** Sentinel symbol that signals the pipeline to skip the current operation. */
 declare const VAULT_NOOP: unique symbol;
 
+/** Contract for behaviors that transform pipeline errors before propagation. */
 interface ErrorTransformBehaviorContract<T> extends BehaviorContract<T> {
+    /** Identifies this behavior as an error transform behavior. */
     type: 'errorTransform';
+    /**
+     * Transforms a raw error into a normalized shape or signals a NOOP.
+     *
+     * @param error - The raw error thrown during pipeline execution.
+     * @param current - The current Vault error shape.
+     * @param previousStateSnapshot - The state snapshot before the error occurred.
+     * @returns The transformed error value, or VAULT_NOOP to skip.
+     */
     transformError(error: unknown, current: VaultErrorShape, previousStateSnapshot: StateSnapshotShape<T>): Promise<unknown | typeof VAULT_NOOP>;
 }
 
@@ -876,12 +1501,6 @@ interface ErrorTransformBehaviorContract<T> extends BehaviorContract<T> {
  * Abstract base behavior for transforming errors during pipeline execution.
  * This class defines the contract and lifecycle hooks required for error transformation behaviors.
  *
- * --RelatedStart--
- * ErrorTransformBehaviorContract
- * BehaviorClassContext
- * StateSnapshotShape
- * VaultErrorShape
- * --RelatedEnd--
  */
 declare abstract class AbstractErrorTransformBehavior<T> implements ErrorTransformBehaviorContract<T> {
     readonly behaviorCtx: BehaviorClassContext;
@@ -923,16 +1542,25 @@ declare abstract class AbstractErrorTransformBehavior<T> implements ErrorTransfo
     reset(): void;
 }
 
+/** Runtime context supplied to controller class instances during pipeline execution. */
 interface ControllerClassContext extends LicensableClassContext {
+    /** Unique key of the FeatureCell this controller is attached to. */
     featureCellKey: string;
+    /** Requests a revote for the pipeline identified by the trace ID. */
     requestRevote: (traceId: string) => void;
+    /** Requests an abort for the pipeline identified by the trace ID. */
     requestAbort: (traceId: string) => void;
+    /** Signals that the license was denied for the given trace. */
     licenseDenied?: (traceId: string) => void;
+    /** Signals that the license was approved for the given trace. */
     licenseApproved?: (traceId: string) => void;
+    /** Optional configuration object for this controller. */
     readonly controllerConfig?: unknown;
+    /** Optional license payload associated with this controller. */
     readonly licensePayload?: unknown;
 }
 
+/** Enumeration of message types dispatched to controllers during pipeline orchestration. */
 declare const ControllerMessageTypes: {
     readonly Attempt: "attempt";
     readonly Failure: "failure";
@@ -940,42 +1568,62 @@ declare const ControllerMessageTypes: {
     readonly Success: "success";
     readonly Vote: "vote";
 };
+/** Union type derived from ControllerMessageTypes values. */
 type ControllerMessageType = (typeof ControllerMessageTypes)[keyof typeof ControllerMessageTypes];
 
+/** Base shape shared by all controller message variants. */
 interface ControllerMessageBaseShape {
+    /** Discriminant identifying the message type. */
     type: ControllerMessageType;
+    /** Trace identifier linking this message to a pipeline operation. */
     traceId: string;
 }
 
+/** Message shape dispatched to controllers during a pipeline attempt. */
 interface ControllerAttemptMessageShape<T> extends ControllerMessageBaseShape {
+    /** Discriminant identifying this as an attempt message. */
     type: typeof ControllerMessageTypes.Attempt;
+    /** Controller context for the current pipeline operation. */
     ctx: ControllerContext<T>;
 }
 
+/** Message shape dispatched to controllers when a pipeline operation fails. */
 interface ControllerFailMessageShape<T> extends ControllerMessageBaseShape {
+    /** Discriminant identifying this as a failure message. */
     type: typeof ControllerMessageTypes.Failure;
+    /** Controller context for the current pipeline operation. */
     ctx: ControllerContext<T>;
+    /** Error that caused the pipeline failure. */
     error: VaultErrorShape | unknown;
 }
 
+/** Message shape dispatched to controllers when a pipeline operation finalizes. */
 interface ControllerFinalizeMessageShape extends ControllerMessageBaseShape {
+    /** Discriminant identifying this as a finalize message. */
     type: typeof ControllerMessageTypes.Finalize;
 }
 
+/** Message shape dispatched to controllers when a pipeline operation succeeds. */
 interface ControllerSuccessMessageShape<T> extends ControllerMessageBaseShape {
+    /** Discriminant identifying this as a success message. */
     type: typeof ControllerMessageTypes.Success;
+    /** Controller context for the current pipeline operation. */
     ctx: ControllerContext<T>;
 }
 
+/** Discriminated union of all controller message shapes. */
 type ControllerMessageShape<T> = ControllerAttemptMessageShape<T> | ControllerSuccessMessageShape<T> | ControllerFailMessageShape<T> | ControllerFinalizeMessageShape;
 
+/** Enumeration of votes a controller may cast during pipeline admission. */
 declare const ControllerVotes: {
     readonly Abstain: "abstain";
     readonly Abort: "abort";
     readonly Deny: "deny";
 };
+/** Union type derived from ControllerVotes values. */
 type ControllerVote = (typeof ControllerVotes)[keyof typeof ControllerVotes];
 
+/** Enumeration of controller category classifications. */
 declare const ControllerTypes: {
     readonly CoreAbstain: "coreAbstain";
     readonly Error: "error";
@@ -985,32 +1633,77 @@ declare const ControllerTypes: {
     readonly Stepwise: "stepwise";
     readonly TabSync: "tabSync";
 };
+/** Union type derived from ControllerTypes values. */
 type ControllerType = (typeof ControllerTypes)[keyof typeof ControllerTypes];
 
+/** Instance-side contract that all controllers must implement. */
 interface ControllerContract<T = unknown> {
+    /** Controller category classification. */
     readonly type: ControllerType;
+    /** Unique identifier for this controller instance. */
     readonly key: string;
+    /** Whether errors from this controller halt the pipeline. */
     readonly critical: boolean;
+    /**
+     * Processes an incoming controller message and returns a vote.
+     *
+     * @param msg - The controller message to evaluate.
+     * @returns An observable emitting the controller vote or void.
+     */
     handleMessage(msg: ControllerMessageShape<T>): Observable<ControllerVote | void>;
+    /** Tears down the controller and releases resources. */
     destroy(): void;
+    /** Resets the controller to its initial state. */
     reset(): void;
+    /**
+     * Optional hook that installs a fluent API onto the FeatureCell.
+     *
+     * @param cell - The FeatureCell shape to extend.
+     * @param behaviorConfigs - Map of behavior configuration entries.
+     */
     installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
 }
 
+/**
+ * Abstract base class for active controllers that react to external error
+ * state changes and participate in pipeline admission voting.
+ */
 declare abstract class AbstractActiveController<T> implements ControllerContract<T> {
     #private;
     protected readonly ctx: ControllerClassContext;
+    /** Unique identifier for this controller instance. */
     readonly key: string;
+    /** Controller type classification determined by the subclass. */
     abstract readonly type: ControllerType;
+    /** Whether errors from this controller halt the pipeline. */
     readonly critical = false;
+    /** Tracks whether the global error service currently holds an error. */
     protected hasError: boolean;
+    /** Trace identifier from the most recent pipeline operation. */
     protected traceId: string | null;
+    /**
+     * Creates an active controller and subscribes to the global error stream.
+     *
+     * @param key - Unique controller identifier supplied by the factory.
+     * @param ctx - Class-level context providing revote and lifecycle access.
+     */
     constructor(key: string, ctx: ControllerClassContext);
-    /** Child classes override to react to external error toggles */
+    /**
+     * Hook invoked when the external error state changes.
+     *
+     * @param _newErrorState - The updated error state flag.
+     */
     protected onExternalTrigger(_newErrorState: boolean): void;
-    /** All controllers must implement this */
+    /**
+     * Processes an incoming controller message and returns a vote.
+     *
+     * @param msg - The controller message to evaluate.
+     * @returns An observable emitting the controller vote or void.
+     */
     abstract handleMessage(msg: ControllerMessageShape<T>): Observable<ControllerVote | void>;
+    /** Tears down the controller and unsubscribes from the error stream. */
     destroy(): void;
+    /** Resets the controller to its initial state. */
     reset(): void;
 }
 
@@ -1052,8 +1745,11 @@ interface ObjectDeepMergeConfig {
     stripNulls?: boolean;
 }
 
+/** Shape representing a license entry registered with the Vault. */
 interface VaultLicensingShape {
+    /** Unique identifier for the license. */
     licenseId: string;
+    /** Opaque license payload supplied by the consumer. */
     payload: unknown;
 }
 
@@ -1070,6 +1766,7 @@ interface VaultLicensingShape {
  * - `'log'`   — standard log events, warnings, and errors are logged
  * - `'debug'` — all debug-level information is emitted
  */
+/** Enumeration of Vault log verbosity levels. */
 declare const LogLevelTypes: {
     readonly Off: "off";
     readonly Error: "error";
@@ -1077,8 +1774,12 @@ declare const LogLevelTypes: {
     readonly Log: "log";
     readonly Debug: "debug";
 };
+/** Union type derived from LogLevelTypes values. */
 type LogLevelType = (typeof LogLevelTypes)[keyof typeof LogLevelTypes];
 
+/**
+ * Configuration options supplied to Vault at initialization.
+ */
 interface VaultConfig {
     /**
      * Enables development-mode diagnostics and additional internal checks.
@@ -1124,8 +1825,10 @@ interface VaultConfig {
     bypassLicensing?: boolean;
 }
 
+/** Symbol key used to attach behavior metadata to a behavior class. */
 declare const BEHAVIOR_META: unique symbol;
 
+/** Symbol key used to attach controller metadata to a controller class. */
 declare const CONTROLLER_META: unique symbol;
 
 /**
@@ -1152,51 +1855,64 @@ declare const DEVTOOLS_AGGREGATE_KEY_CONSTANT = "vault::devtools::aggregate:feat
  */
 declare const DEVTOOLS_LOGGING_KEY_CONSTANT = "vault::devtools::logging::feature::cell";
 
+/** Sentinel symbol that signals the pipeline to clear the current state. */
 declare const VAULT_CLEAR_STATE: unique symbol;
 
+/** Sentinel symbol that signals the pipeline to continue processing. */
 declare const VAULT_CONTINUE: unique symbol;
 
+/** Sentinel symbol that signals the pipeline to halt execution. */
 declare const VAULT_STOP: unique symbol;
 
+/**
+ * Extended behavior class context providing direct state access for tab-sync behaviors.
+ */
 interface TabSyncBehaviorClassContext extends BehaviorClassContext {
     /**
      * Live reference to the FeatureCell's mutable state snapshot.
-     * Provided so the tab-sync behavior can commit state outside the
-     * pipeline call stack without waiting for preparePipelineIncoming.
      */
     readonly lastSnapshot: StateSnapshotShape<unknown>;
     /**
      * Subject used to emit state snapshots to the FeatureCell.
-     * Same lifetime as the FeatureCell itself.
      */
     readonly state$: Subject<StateEmitSnapshotShape<unknown>>;
 }
 
+/**
+ * Metadata shape describing a registered behavior's static configuration.
+ */
 interface BehaviorMetaShape {
     /**
-     * The pipeline stage in which this behavior participates.
-     * Determines when the orchestrator invokes the behavior.
+     * Pipeline stage in which this behavior participates.
      */
     type: BehaviorType;
     /**
-     * Unique identifier for this behavior. Used for diagnostics,
-     * devtools visualization, and orchestrator classification.
+     * Unique identifier for this behavior.
      */
     key: string;
     /**
-     * Indicates whether this behavior is critical. Critical behaviors
-     * are mandatory and must always run when present in the pipeline.
+     * Whether this behavior is critical to pipeline execution.
      */
     critical: boolean;
     /**
      * Optional resolve strategy associated with this behavior.
-     * Only set for resolution behaviors that determine how state
-     * is initially derived (e.g., value, http, observable).
      */
     resolveType?: ResolveType;
+    /**
+     * Whether this behavior requires consumer-supplied configuration.
+     */
     wantsConfig?: boolean;
+    /**
+     * Configuration key used to locate behavior options in the config registry.
+     */
     configKey?: string;
+    /**
+     * Whether this behavior requires a valid license to operate.
+     */
     needsLicense?: boolean;
+    /**
+     * License identifier used for license validation.
+     */
     licenseId?: string;
 }
 
@@ -1219,18 +1935,33 @@ interface BehaviorMetaShape {
  */
 declare function VaultBehavior(meta: BehaviorMetaShape): (target: any) => void;
 
+/** Metadata shape describing a registered controller's static configuration. */
 interface ControllerMetaShape {
+    /** Controller category classification. */
     type: ControllerType;
+    /** Unique identifier for this controller. */
     key: string;
+    /** Whether this controller is critical to pipeline execution. */
     critical?: boolean;
+    /** Whether this controller requires consumer-supplied configuration. */
     wantsConfig?: boolean;
+    /** Configuration key used to locate controller options in the config registry. */
     configKey?: string;
+    /** Whether this controller requires a valid license to operate. */
     needsLicense?: boolean;
+    /** License identifier used for license validation. */
     licenseId?: string;
 }
 
+/**
+ * Class decorator that attaches controller metadata to the target class.
+ *
+ * @param meta - The controller metadata shape to apply.
+ * @returns A class decorator function.
+ */
 declare function VaultController(meta: ControllerMetaShape): (target: any) => void;
 
+/** Enumeration of usage-specific Vault error sub-kind classifications. */
 declare const VaultErrorUsageKindTypes: {
     readonly Encryption: "VaultErrorEncryption";
     readonly License: "VaultErrorLicense";
@@ -1238,58 +1969,94 @@ declare const VaultErrorUsageKindTypes: {
     readonly PromiseFactoryRequired: "VaultErrorUsagePromiseFactoryRequired";
     readonly Usage: "VaultErrorUsage";
 };
+/** Union type derived from VaultErrorUsageKindTypes values. */
 type VaultErrorUsageKindType = (typeof VaultErrorUsageKindTypes)[keyof typeof VaultErrorUsageKindTypes];
 
+/** Enumeration of top-level Vault error kind classifications. */
 declare const VaultErrorKindTypes: {
     readonly Usage: "VaultErrorUsage";
     readonly VaultError: "VaultError";
 };
+/** Union type of all Vault error kind values including usage sub-kinds. */
 type VaultErrorKindType = (typeof VaultErrorKindTypes)[keyof typeof VaultErrorKindTypes] | (typeof VaultErrorUsageKindTypes)[keyof typeof VaultErrorUsageKindTypes];
 
+/** Enumeration of Vault error name identifiers. */
 declare const VaultErrorNameTypes: {
     readonly EncryptionIntegrity: "VaultErrorEncryptionIntegrity";
     readonly License: "VaultErrorLicense";
     readonly Usage: "VaultErrorUsage";
     readonly VaultError: "VaultError";
 };
+/** Union type derived from VaultErrorNameTypes values. */
 type VaultErrorNameType = (typeof VaultErrorNameTypes)[keyof typeof VaultErrorNameTypes];
 
+/**
+ * Base error class for all Vault-specific errors. Extends the native Error
+ * with a typed name and kind for structured error classification.
+ */
 declare class VaultError extends Error {
+    /** Classification kind used to categorize this error in diagnostics. */
     readonly kind: VaultErrorKindType;
+    /**
+     * Creates a new VaultError instance with prototype chain correction.
+     *
+     * @param message - Human-readable description of the error.
+     * @param name - Typed error name used for identification.
+     * @param kind - Error kind used for diagnostic classification.
+     */
     constructor(message: string, name?: VaultErrorNameType, kind?: VaultErrorKindType);
 }
 
 /**
- * Thrown when encrypted payload integrity verification fails.
- *
- * This occurs when AES-GCM authentication fails during decryption.
- * Causes may include:
- *
- * - Tampered ciphertext
- * - Modified IV
- * - Incorrect encryption key
- * - Corrupted storage payload
- *
- * AES-GCM provides authenticated encryption, so any modification to the
- * encrypted envelope will cause the WebCrypto decrypt operation to throw.
+ * Thrown when an encrypted payload fails AES-GCM integrity verification
+ * during decryption, indicating tampered, corrupted, or mismatched key data.
  */
 declare class VaultEncryptionIntegrityError extends VaultError {
+    /** Creates the error with a descriptive integrity-failure message. */
     constructor();
 }
 
+/**
+ * Thrown when a behavior or controller fails license validation.
+ */
 declare class VaultLicenseError extends VaultError {
+    /**
+     * Creates a license validation error.
+     *
+     * @param message - Description of the license violation.
+     * @param kind - Usage-kind classification for diagnostics.
+     */
     constructor(message: string, kind?: VaultErrorUsageKindType);
 }
 
+/**
+ * Base error for Vault API usage violations detected at runtime.
+ */
 declare class VaultUsageError extends VaultError {
+    /**
+     * Creates a usage error with the specified message and kind.
+     *
+     * @param message - Description of the usage violation.
+     * @param kind - Usage-kind classification for diagnostics.
+     */
     constructor(message: string, kind?: VaultErrorUsageKindType);
 }
 
+/**
+ * Thrown when an eager Promise is passed directly to the state pipeline
+ * instead of a deferred factory function.
+ */
 declare class VaultUsagePromiseError extends VaultUsageError {
+    /** Creates the error with a descriptive usage-violation message. */
     constructor();
 }
 
+/**
+ * Thrown when a Promise-based state method receives a raw value instead
+ * of a factory function that returns a Promise.
+ */
 declare class VaultUsagePromiseFactoryRequiredError extends VaultUsageError {
+    /** Creates the error with a descriptive usage-violation message. */
     constructor();
 }
 
@@ -1297,9 +2064,6 @@ declare class VaultUsagePromiseFactoryRequiredError extends VaultUsageError {
  * Represents the possible result of a core emit operation.
  * This type indicates either an intentional no-op signal or the absence of an emitted state.
  *
- * --RelatedStart--
- * VAULT_NOOP
- * --RelatedEnd--
  */
 type CoreEmitStateResult = typeof VAULT_NOOP | undefined;
 
@@ -1317,14 +2081,17 @@ interface CoreEmitStateBehaviorContract<T> extends BehaviorContract<T> {
     emitState(snapshot: StateSnapshotShape<T>, callback: CoreEmitStateCallback<T>): CoreEmitStateResult;
 }
 
+/** Enumeration of event boundary positions within a lifecycle span. */
 declare const EventBoundaryTypes: {
     readonly End: "end";
     readonly Notification: "notification";
     readonly Start: "start";
     readonly Unknown: "unknown";
 };
+/** Union type derived from EventBoundaryTypes values. */
 type EventBoundaryType = (typeof EventBoundaryTypes)[keyof typeof EventBoundaryTypes];
 
+/** Enumeration of monitor event category classifications. */
 declare const EventTypes: {
     readonly Conductor: "conductor";
     readonly Controller: "controller";
@@ -1332,15 +2099,12 @@ declare const EventTypes: {
     readonly Stage: "stage";
     readonly Unknown: "unknown";
 };
+/** Union type derived from EventTypes values. */
 type EventType = (typeof EventTypes)[keyof typeof EventTypes];
 
 /**
  * Describes the shape of a pipeline event emitted during FeatureCell execution.
  * This interface defines the core event contract used for diagnostics, Devtools inspection, and lifecycle tracking.
- *
- * --RelatedStart--
- * StateSnapshotShape
- * --RelatedEnd--
  */
 interface EventShape<T = any> {
     /**
@@ -1375,6 +2139,9 @@ interface EventShape<T = any> {
      * The event name describing the lifecycle transition or action.
      */
     name: string;
+    /**
+     * Classification of the event within the pipeline lifecycle.
+     */
     type: EventType;
     /**
      * The event boundary type.
@@ -1394,10 +2161,6 @@ interface EventShape<T = any> {
  * Defines the contract for an event bus responsible for emitting and observing pipeline and queue events.
  * This interface provides methods for publishing events and subscribing to their corresponding event streams.
  *
- * --RelatedStart--
- * EventShape
- * EventQueueShape
- * --RelatedEnd--
  */
 interface EventBusContract {
     /**
@@ -1414,6 +2177,7 @@ interface EventBusContract {
     pipeline$(): Observable<EventShape>;
 }
 
+/** Enumeration of license validation statuses for FeatureCell registration. */
 declare const VaultRegistrationLicenseStatusTypes: {
     readonly NotRequired: "not-required";
     readonly Pending: "pending";
@@ -1421,36 +2185,62 @@ declare const VaultRegistrationLicenseStatusTypes: {
     readonly Timeout: "timeout";
     readonly Valid: "valid";
 };
+/** Union type derived from VaultRegistrationLicenseStatusTypes values. */
 type VaultRegistrationLicenseStatusType = (typeof VaultRegistrationLicenseStatusTypes)[keyof typeof VaultRegistrationLicenseStatusTypes];
 
+/** Shape describing a registered behavior or controller entity within a FeatureCell. */
 interface VaultRegistrationEntityShape {
+    /** Unique identifier for this entity. */
     key: string;
+    /** Entity type classification string. */
     type: string;
+    /** Whether this entity is critical to pipeline execution. */
     critical?: boolean;
+    /** Whether this entity requires a valid license. */
     needsLicense?: boolean;
+    /** Current license validation status for this entity. */
     validLicense?: VaultRegistrationLicenseStatusType;
+    /** License identifier associated with this entity. */
     licenseId?: string;
 }
 
+/** Shape tracking the count of fluent API registrations on a FeatureCell. */
 interface VaultRegistrationFluentApiShape {
+    /** Number of registered filter functions. */
     filters: number;
+    /** Number of registered reducer functions. */
     reducers: number;
+    /** Number of registered before-tap callbacks. */
     beforeTaps: number;
+    /** Number of registered after-tap callbacks. */
     afterTaps: number;
+    /** Number of registered emit-state callbacks. */
     emitStateCallbacks: number;
+    /** Number of registered error callbacks. */
     errorCallbacks: number;
 }
 
+/** Shape representing the full registration record of a FeatureCell in the Vault. */
 interface VaultRegistrationShape {
+    /** Unique key identifying the registered FeatureCell. */
     key: string;
+    /** Factory returning a promise that resolves when the vault has settled. */
     vaultSettled?: () => Promise<void>;
+    /** Map of registered behavior entities keyed by behavior key. */
     behaviors?: Map<string, VaultRegistrationEntityShape>;
+    /** Map of registered controller entities keyed by controller key. */
     controllers?: Map<string, VaultRegistrationEntityShape>;
+    /** Read-only snapshot of fluent API registration counts. */
     fluentApis?: Readonly<VaultRegistrationFluentApiShape>;
+    /** Whether all behaviors have completed registration. */
     behaviorsRegistered?: boolean;
+    /** Whether all controllers have completed registration. */
     controllersRegistered?: boolean;
 }
 
+/**
+ * Shape of the global SDuX runtime namespace attached to the window object.
+ */
 interface SDuXShape {
     /**
      * Global Vault monitor instance.
@@ -1460,6 +2250,9 @@ interface SDuXShape {
      * Global Vault event bus instance.
      */
     vaultEventBus?: EventBusContract;
+    /**
+     * Optional debug widget configuration for devtools integration.
+     */
     debugWidget?: {
         versions?: Record<string, string>;
         injected?: boolean;
@@ -1526,6 +2319,7 @@ type InterceptorStateType<T> = StateInputType<T> | typeof VAULT_STOP;
  */
 type PipelinePersistValue<T> = T | undefined;
 
+/** Union of all valid upstream values that a pipeline stage may produce. */
 type PipelineUpstreamValue<T> = T | undefined | typeof VAULT_NOOP | typeof VAULT_CLEAR_STATE | typeof VAULT_CONTINUE;
 
 /**
@@ -1540,6 +2334,7 @@ type PipelineUpstreamValue<T> = T | undefined | typeof VAULT_NOOP | typeof VAULT
  */
 type PipelineValue<T> = T | undefined;
 
+/** Union of all terminal pipeline values including the stop sentinel. */
 type FinalState<T> = PipelineUpstreamValue<T> | typeof VAULT_STOP;
 
 /**
@@ -1614,6 +2409,9 @@ interface DevPipelineObserverBehaviorContract extends BehaviorContract {
     emitError(cellKey: string, error: VaultErrorShape): void;
 }
 
+/**
+ * Contract for encryption behaviors that protect persisted state values.
+ */
 interface EncryptBehaviorContract<T> extends BehaviorContract<T> {
     /**
      * Encrypts a plain or already-processed state value before persistence.
@@ -1634,41 +2432,84 @@ interface EncryptBehaviorContract<T> extends BehaviorContract<T> {
     decryptState(ctx: BehaviorContext<T>, encrypted: PipelinePersistValue<T>): Promise<PipelinePersistValue<T>> | PipelinePersistValue<T>;
 }
 
+/**
+ * Contract for filter behaviors that selectively pass or reject state updates.
+ */
 interface FilterBehaviorContract<T> extends BehaviorContract<T> {
     /** Identifies this behavior as a filter behavior. */
     type: 'filter';
+    /**
+     * Applies the filter function against the current pipeline value.
+     *
+     * @param current - The upstream pipeline value to evaluate.
+     * @param filter - The filter function that determines acceptance.
+     * @returns The filtered pipeline value.
+     */
     applyFilter(current: PipelineUpstreamValue<T>, filter: FilterFunction<T>): PipelineUpstreamValue<T>;
 }
 
+/**
+ * Contract for interceptor behaviors that preprocess incoming state before resolve.
+ */
 interface InterceptorBehaviorContract<T> extends BehaviorContract<T> {
     /**
      * Applies the interceptor logic for the incoming state packet.
      *
-     * @param ctx - The behavior execution context containing the incoming
-     * state and lifecycle metadata for the current pipeline operation.
-     * @returns A promise that resolves to a transformed or replacement
-     * {@link StateInputType} value, or `undefined` when no modification is
-     * necessary.
+     * @param ctx - The behavior execution context for the current pipeline operation.
+     * @returns A transformed state value, or undefined when no modification is necessary.
      */
     applyInterceptor(ctx: BehaviorContext<T>): Promise<InterceptorStateType<T>>;
 }
 
+/** Contract for merge behaviors that combine current and incoming state. */
 interface MergeBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Computes the merged result of the current and next pipeline values.
+     *
+     * @param currentValue - The existing state value.
+     * @param nextValue - The incoming candidate value.
+     * @param options - Optional merge configuration.
+     * @returns The merged pipeline value.
+     */
     computeMerge(currentValue: PipelineUpstreamValue<T> | undefined, nextValue: PipelineUpstreamValue<T> | undefined, options?: MergeConfig): PipelineUpstreamValue<T> | undefined;
 }
 
+/** Contract for operator behaviors that transform pipeline values. */
 interface OperatorBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Applies the operator transformation to the current pipeline value.
+     *
+     * @param value - The upstream pipeline value to transform.
+     * @returns A promise resolving to the transformed pipeline value.
+     */
     applyOperator(value: PipelineUpstreamValue<T>): Promise<PipelineUpstreamValue<T>>;
 }
 
+/**
+ * Contract for persistence behaviors that save and restore FeatureCell state.
+ */
 interface PersistBehaviorContract<T> extends BehaviorContract<T> {
     /** Identifies this behavior as a persistence behavior. */
     type: 'persist';
+    /**
+     * Persists the current state snapshot to the configured storage.
+     *
+     * @param current - The pipeline persist value to store.
+     */
     persistState(current: PipelinePersistValue<T>): Promise<void> | void;
+    /** Clears the persisted state from storage. */
     clearState(): void;
+    /**
+     * Loads the previously persisted state from storage.
+     *
+     * @returns The restored persist value.
+     */
     loadState(): PipelinePersistValue<T>;
 }
 
+/**
+ * Contract for reducer-stage behaviors that transform pipeline state.
+ */
 interface ReduceBehaviorContract<T> extends BehaviorContract<T> {
     /** Pipeline behavior type identifier for reducer-stage execution. */
     type: 'reduce';
@@ -1682,46 +2523,120 @@ interface ReduceBehaviorContract<T> extends BehaviorContract<T> {
     applyReducer(current: PipelineUpstreamValue<T>, reducer: ReducerFunction<T>): T;
 }
 
+/**
+ * Contract for resolve behaviors that derive initial state from an external source.
+ */
 interface ResolveBehaviorContract<T> extends BehaviorContract<T> {
     /** Resolve strategy used by this behavior (value, HTTP resource, observable, etc.). */
     resolveType: 'http-resource' | 'observable' | 'promise' | 'value';
+    /**
+     * Computes the resolved state value for the current pipeline operation.
+     *
+     * @param ctx - The behavior execution context for the current pipeline run.
+     * @returns The resolved state value, synchronously or as a promise.
+     */
     computeResolve(ctx: BehaviorContext<T>): Promise<PipelineUpstreamValue<T>> | PipelineUpstreamValue<T>;
 }
 
+/** Contract for stepwise behaviors that compare current and candidate state. */
 interface StepwiseBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Evaluates whether the candidate value should replace the current state.
+     *
+     * @param current - The current state value.
+     * @param candidate - The candidate pipeline value.
+     * @param pipelineId - Trace identifier for the current pipeline run.
+     * @returns A promise resolving to the accepted pipeline value.
+     */
     evaluateStepwise(current: T | undefined, candidate: PipelineUpstreamValue<T>, pipelineId: string): Promise<PipelineUpstreamValue<T>>;
 }
 
+/** Contract for after-tap behaviors that observe state after pipeline resolution. */
 interface AfterTapBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Invokes the tap callback with the current pipeline value after resolution.
+     *
+     * @param current - The upstream pipeline value.
+     * @param tap - The tap callback to invoke.
+     */
     applyAfterTap(current: PipelineUpstreamValue<T>, tap: TapCallback<T>): void;
 }
 
+/** Contract for before-tap behaviors that observe state before pipeline resolution. */
 interface BeforeTapBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Invokes the tap callback with the current pipeline value before resolution.
+     *
+     * @param current - The upstream pipeline value.
+     * @param tap - The tap callback to invoke.
+     */
     applyBeforeTap(current: PipelineUpstreamValue<T>, tap: TapCallback<T>): void;
 }
 
+/** Static-side contract for controller classes used by the controller factory. */
 interface ControllerClassContract<T = any> {
+    /**
+     * Creates a new controller instance.
+     *
+     * @param controllerKey - Unique key assigned by the controller factory.
+     * @param controllerCtx - Class-level context for dependency resolution.
+     */
     new (controllerKey: string, controllerCtx: ControllerClassContext): ControllerContract<T>;
+    /** Pipeline stage in which this controller participates. */
     readonly type: ControllerType;
+    /** Unique identifier assigned to this controller class. */
     readonly key: string;
+    /** Whether errors from this controller halt the pipeline. */
     readonly critical: boolean;
+    /**
+     * Optional hook that installs a fluent API onto the FeatureCell.
+     *
+     * @param cell - The FeatureCell shape to extend.
+     * @param behaviorConfigs - Map of behavior configuration entries.
+     */
     installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
 }
 
+/** Contract for the public-facing Vault error service. */
 interface VaultErrorServiceContract {
+    /** Observable stream of the current error state. */
     readonly error$: Observable<VaultErrorShape | null>;
+    /** Clears the current error state. */
     clear(): void;
+    /** Whether an active error is currently present. */
     get hasError(): boolean;
 }
 
+/** Contract for the internal private error service used by VaultErrorService. */
 interface VaultPrivateErrorServiceContract {
+    /**
+     * Publishes a new error or clears the current error.
+     *
+     * @param error - The error shape to publish, or null to clear.
+     */
     setError(error: VaultErrorShape | null): void;
+    /**
+     * Returns an observable of the current error state.
+     *
+     * @returns Observable emitting the current error or null.
+     */
     getError(): Observable<VaultErrorShape | null>;
+    /** Resets the error state to null. */
     clear(): void;
 }
 
+/**
+ * Returns the singleton VaultErrorService instance, creating it on first call.
+ *
+ * @returns The shared VaultErrorService instance.
+ */
 declare function VaultErrorService(): VaultErrorServiceContract;
 
+/**
+ * Returns the singleton VaultPrivateErrorService instance, creating it on first call.
+ *
+ * @returns The shared private error service instance.
+ */
 declare function VaultPrivateErrorService(): VaultPrivateErrorServiceContract;
 
 /**
@@ -1759,16 +2674,37 @@ declare function defineBehaviorKey(domain: string, name: string): string;
  */
 declare function validateBehaviorKey(key: string): boolean;
 
+/**
+ * Creates a normalized controller key following the Vault key format.
+ *
+ * @param domain - The logical domain or category of the controller.
+ * @param name - The specific controller name within the domain.
+ * @returns A normalized controller key string.
+ */
 declare function defineControllerKey(domain: string, name: string): string;
+/**
+ * Validates whether a string conforms to the Vault controller key format.
+ *
+ * @param key - The controller key string to validate.
+ * @returns `true` if the key matches the required pattern.
+ */
 declare function validateControllerKey(key: string): boolean;
 
+/**
+ * Determines whether a value conforms to the DeferredFactory contract.
+ *
+ * @param value - The value to inspect.
+ * @returns `true` if the value is an object with a callable `value` property.
+ */
 declare function isDeferredFactory<T = unknown>(value: unknown): value is DeferredFactory<T>;
 
+/** Singleton accessor for Vault development mode state. */
 declare const DevMode: {
     readonly active: boolean;
     setDevMode(isDevMode: boolean): void;
 };
 
+/** Singleton accessor that detects whether code is running in a test environment. */
 declare const isTestEnv: {
     readonly active: boolean;
 };
@@ -1785,6 +2721,12 @@ declare const isTestEnv: {
  */
 declare function createVaultError(err: unknown, featureCellKey: string): VaultErrorShape;
 
+/**
+ * Creates an immutable copy of a value using structuredClone with a deepFreeze fallback.
+ *
+ * @param value - The value to isolate.
+ * @returns An immutable copy of the value.
+ */
 declare const isolateValue: <T>(value: T) => T;
 
 /**
@@ -1811,7 +2753,17 @@ declare const vaultLog: (...args: any[]) => void;
  * @param args - Console arguments to log.
  */
 declare const vaultDebug: (...args: any[]) => void;
+/**
+ * Sets the global Vault log level threshold.
+ *
+ * @param level - The log level to apply.
+ */
 declare function setVaultLogLevel(level: LogLevelType): void;
+/**
+ * Returns the current global Vault log level.
+ *
+ * @returns The active log level threshold.
+ */
 declare function getVaultLogLevel(): LogLevelType;
 
 /**
@@ -1821,7 +2773,19 @@ declare function getVaultLogLevel(): LogLevelType;
  * @returns `true` if the value is the `VAULT_NOOP` sentinel.
  */
 declare const isVaultNoop: <T>(current: FinalState<T>) => boolean;
+/**
+ * Indicates whether a final pipeline value represents the clear-state sentinel.
+ *
+ * @param current - The computed pipeline result.
+ * @returns `true` if the value is the `VAULT_CLEAR_STATE` sentinel.
+ */
 declare const isVaultClearState: <T>(current: FinalState<T>) => boolean;
+/**
+ * Indicates whether a final pipeline value represents the continue sentinel.
+ *
+ * @param current - The computed pipeline result.
+ * @returns `true` if the value is the `VAULT_CONTINUE` sentinel.
+ */
 declare const isVaultContinue: <T>(current: FinalState<T>) => boolean;
 /**
  * Checks whether a value is exactly `null`.
@@ -1852,10 +2816,34 @@ declare const isDefined: (current: unknown) => boolean;
  * @returns `true` for `null` or `undefined`, otherwise `false`.
  */
 declare const isNullish: (current: unknown) => current is null | undefined;
+/**
+ * Determines whether a value is a function.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a function.
+ */
 declare const isFunction: (value: unknown) => value is (...args: any[]) => unknown;
+/**
+ * Determines whether a value is a non-null object.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is an object and not null.
+ */
 declare const isObject: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Determines whether a value conforms to the StateInputShape contract.
+ *
+ * @param value - The value to inspect.
+ * @returns `true` if the value is a plain object with recognized state keys or is empty.
+ */
 declare const isStateInputShape: <T>(value: unknown) => value is StateInputShape<T>;
 
+/**
+ * Determines whether a value is a thenable Promise-like object.
+ *
+ * @param value - The value to inspect.
+ * @returns `true` if the value has a callable `then` property.
+ */
 declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
 
 /**
@@ -1896,6 +2884,12 @@ declare function isHttpResourceRef<T>(obj: any): obj is HttpResourceRefShape<T>;
  */
 declare function safeStringify(value: unknown): string;
 
+/**
+ * Registers a package version on the global SDuX debug widget when dev mode is active.
+ *
+ * @param packageName - The npm package name to register.
+ * @param version - The semver version string.
+ */
 declare const registerVersion: (packageName: string, version: string) => void;
 
 export { AbstractActiveController, AbstractErrorCallbackBehavior, AbstractErrorTransformBehavior, BEHAVIOR_META, BehaviorTypes, CONTROLLER_META, ControllerMessageTypes, ControllerTypes, ControllerVotes, DEVTOOLS_AGGREGATE_KEY_CONSTANT, DEVTOOLS_LOGGING_KEY_CONSTANT, DecisionOutcomeTypes, DevMode, EventBoundaryTypes, EventTypes, LogLevelTypes, OperationTypes, ResolveTypes, StateEmitTypes, VAULT_CLEAR_STATE, VAULT_CONTINUE, VAULT_NOOP, VAULT_STOP, VaultBehavior, VaultController, VaultEncryptionIntegrityError, VaultError, VaultErrorKindTypes, VaultErrorNameTypes, VaultErrorService, VaultErrorUsageKindTypes, VaultLicenseError, VaultPrivateErrorService, VaultUsageError, VaultUsagePromiseError, VaultUsagePromiseFactoryRequiredError, createVaultError, defineBehaviorKey, defineControllerKey, getVaultLogLevel, isDeferredFactory, isDefined, isFunction, isHttpResourceRef, isNull, isNullish, isObject, isPromise, isStateInputShape, isTestEnv, isUndefined, isVaultClearState, isVaultContinue, isVaultNoop, isolateValue, registerVersion, safeStringify, setVaultLogLevel, validateBehaviorKey, validateControllerKey, vaultDebug, vaultError, vaultLog, vaultWarn };