@sdux-vault/core 0.0.9

package/fesm2022/sdux-vault-core.mjs

@@ -0,0 +1,1841 @@
+import { registerVersion, BehaviorTypes, vaultDebug, VAULT_CLEAR_STATE, vaultWarn, VaultBehavior, defineBehaviorKey, AbstractErrorCallbackBehavior, createVaultError, safeStringify, vaultError, VAULT_NOOP, ResolveTypes, isUndefined, isDeferredFactory, isFunction, isHttpResourceRef, isolateValue, isNullish, isStateInputShape, isNull, StateEmitTypes, isDefined, isVaultNoop, isVaultClearState } from '@sdux-vault/shared';
+import { __decorate } from 'tslib';
+import { isPipelineTerminal, createFeatureCellToken, registerFeatureCell, FeatureCellClass, VaultCore } from '@sdux-vault/engine';
+import { Observable, EMPTY, takeUntil, take, isObservable, firstValueFrom } from 'rxjs';
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > lib > behaviors > observable > interface > from-observable-behavior.interface.ts
+// Updated: 2026-03-30 18:53
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const __fromObservable = true;
+
+var observableExt = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    __fromObservable: __fromObservable
+});
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > lib > behaviors > promise > interface > from-promise-behavior.interface.ts
+// Updated: 2026-03-30 18:54
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const __fromPromise_extension = true;
+
+var promiseExt = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    __fromPromise_extension: __fromPromise_extension
+});
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > lib > behaviors > resolve > from-stream > interface > from-stream-behavior.interface.ts
+// Updated: 2026-03-30 18:27
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const __fromStream_extension = true;
+
+var streamExt = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    __fromStream_extension: __fromStream_extension
+});
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > extensions > index.ts
+// Updated: 2026-03-30 18:48
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+// This file exists ONLY for side effects
+// Register ALL behavior extensions
+void observableExt;
+void promiseExt;
+void streamExt;
+const __core_extensions_loaded = true;
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > lib > version > version.register.ts
+// Updated: 2026-03-03 08:07
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const SDUX_PACKAGE = '@sdux-vault/core';
+const SDUX_VERSION = '0.0.9';
+registerVersion(SDUX_PACKAGE, SDUX_VERSION);
+
+/**
+ * Shallow object merge behavior for the Vault merge stage.
+ *
+ * This behavior performs a one-level object merge where the incoming
+ * object spreads over the existing state. Non-object values, arrays,
+ * and `null` values bypass merging and are returned directly.
+ *
+ * The behavior also supports optional merge configuration, such as
+ * `clearUndefined`, which determines whether an `undefined` incoming
+ * value should clear the current state.
+ *
+ * This merge strategy is marked as a core, critical behavior and must
+ * always be present when selected as the FeatureCell’s merge behavior.
+ *
+ * @typeParam T - The state value type processed during merge.
+ */
+let withObjectShallowMergeBehavior = class withObjectShallowMergeBehavior {
+    behaviorCtx;
+    /** Static metadata used for orchestrator behavior classification. */
+    static type;
+    /** Unique identifier for behavior diagnostics and devtools. */
+    static key;
+    /** Indicates this merge behavior is pipeline-critical. */
+    static critical = true;
+    /** Pipeline behavior type identifier. */
+    type = BehaviorTypes.Merge;
+    /** Unique merge behavior instance identifier. */
+    key;
+    /** Instance-level criticality flag. */
+    critical = true;
+    /**
+     * Creates a new shallow object merge behavior instance.
+     *
+     * @param key - Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx - BehaviorCtx for future extensibility hooks.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Computes the shallow merge result between the current state and
+     * the incoming value. Non-object inputs bypass merging and are
+     * forwarded directly. When `clearUndefined=true`, an undefined
+     * incoming value clears the state.
+     *
+     * @param currentValue - The current FeatureCell state value.
+     * @param nextValue - The incoming value to merge into the current state.
+     * @param options - Optional merge configuration including `clearUndefined`.
+     * @returns The merged or forwarded next state value.
+     */
+    computeMerge(currentValue, nextValue, options) {
+        const curr = currentValue;
+        const next = nextValue;
+        const clear = options?.clearUndefined ?? false;
+        vaultDebug(`${this.key} shallow merge (clearUndefined=${clear})`);
+        if (next === undefined && !clear) {
+            vaultDebug(`${this.key} next undefined, preserve current`);
+            return curr;
+        }
+        if (next === undefined && clear) {
+            vaultDebug(`${this.key} next undefined & clear=true → return undefined`);
+            return VAULT_CLEAR_STATE;
+        }
+        if (curr == null ||
+            next == null ||
+            typeof curr !== 'object' ||
+            typeof next !== 'object' ||
+            Array.isArray(curr) ||
+            Array.isArray(next)) {
+            vaultDebug(`${this.key} non-object merge return next`);
+            return next;
+        }
+        vaultDebug(`${this.key} shallow merge curr & next`);
+        return { ...curr, ...next };
+    }
+    /**
+     * Invoked when the behavior instance is destroyed.
+     * This merge behavior maintains no internal resources.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the shallow merge behavior.
+     *
+     * Object shallow merge is a fully stateless, pure merge strategy.
+     * It holds no timers, caches, or internal merge state, meaning
+     * there is nothing to reset. This lifecycle hook exists solely
+     * to support the FeatureCell reset pipeline and to provide a
+     * diagnostic signal for DevTools and monitoring systems.
+     *
+     * After reset, the behavior continues to function identically.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withObjectShallowMergeBehavior = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.Merge,
+        key: defineBehaviorKey('Core', 'ObjectMerge'),
+        critical: true
+    })
+], withObjectShallowMergeBehavior);
+
+var withCoreErrorCallbackBehavior_1;
+/**
+ * Core error callback behavior for invoking legacy error handlers.
+ *
+ * This behavior executes an optional consumer-supplied error callback when a
+ * pipeline error occurs, forwarding the normalized error and an immutable
+ * snapshot of the FeatureCell state without altering error flow.
+ */
+let withCoreErrorCallbackBehavior = class withCoreErrorCallbackBehavior extends AbstractErrorCallbackBehavior {
+    static { withCoreErrorCallbackBehavior_1 = this; }
+    /**
+     * Static behavior type identifier used for orchestrator classification.
+     */
+    static type;
+    /**
+     * Static behavior key used for diagnostics and tooling.
+     */
+    static key;
+    /**
+     * Indicates that this behavior is critical within the pipeline.
+     */
+    static critical;
+    /**
+     * Indicates that this error callback behavior is always executed.
+     */
+    critical = withCoreErrorCallbackBehavior_1.critical;
+    /**
+     * Creates a new core error callback behavior instance.
+     *
+     * @param key Unique behavior identifier.
+     * @param behaviorCtx Behavior class context for dependency access.
+     */
+    constructor(key, behaviorCtx) {
+        super(key, behaviorCtx);
+    }
+    /**
+     * Invokes a legacy error callback with the normalized error and state snapshot.
+     *
+     * @param current The normalized error value.
+     * @param state Immutable snapshot of the FeatureCell state.
+     * @param oldschoolCallback Optional legacy callback function.
+     * @returns Resolves after callback execution completes.
+     */
+    async callbackError(current, state, oldschoolCallback) {
+        if (typeof oldschoolCallback !== 'function') {
+            vaultWarn(`${this.key} handleError skipped - "${oldschoolCallback}" is not a function.`);
+        }
+        else {
+            try {
+                await oldschoolCallback(current, state);
+            }
+            catch (err) {
+                vaultWarn(`${this.key} oldschoolCallback threw: ${err}`);
+            }
+        }
+        return;
+    }
+};
+withCoreErrorCallbackBehavior = withCoreErrorCallbackBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.CoreErrorCallback,
+        key: defineBehaviorKey('Core', 'ErrorCallback'),
+        critical: true
+    })
+], withCoreErrorCallbackBehavior);
+
+/**
+ * Core error behavior used internally by the Vault orchestrator.
+ *
+ * This behavior represents the **first step** in the error-handling pipeline.
+ * It is intentionally minimal and exists solely to normalize any thrown value—
+ * regardless of type—into a canonical ResourceStateError using
+ * resourceError.
+ *
+ * ## Responsibilities
+ * - Convert `unknown` errors into a well-structured `ResourceStateError`
+ * - Provide a deterministic starting point for all addon error behaviors
+ * - Guarantee error normalization before transformations occur
+ *
+ * All richer behaviors (mapping, retries, notifications, old-school callbacks)
+ * are implemented as **addon error behaviors** layered after this one.
+ */
+let withCoreErrorBehavior = class withCoreErrorBehavior {
+    behaviorCtx;
+    /** Behavior type metadata assigned by the decorator. */
+    static type;
+    /**
+     * Unique behavior key assigned by the decorator. */
+    static key;
+    /** Indicates this behavior participates critically in the pipeline. */
+    static critical;
+    /** Indicates that this error behavior is critical and always executed. */
+    critical = true;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /** Behavior type for orchestrator registration. */
+    type = BehaviorTypes.CoreError;
+    /**
+     * Creates a new Core Error Behavior instance.
+     *
+     * @param key - Runtime identifier assigned by the behavior factory.
+     * @param behaviorCtx - Behavior context providing injector access and
+     *                      future extensibility hooks.
+     *
+     * This constructor performs no allocation of runtime resources. It simply
+     * stores metadata required by the orchestrator and devtools.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Normalizes an unknown error into a {@link VaultErrorShape}.
+     *
+     * This is the *only* operation performed by the core error behavior.
+     * Additional behaviors further down the pipeline may inspect or transform
+     * the returned structure.
+     *
+     * @param error - The raw error thrown during pipeline execution.
+     * @param feaetureCellKey - The FeatureCell key where the error originated.
+     * @returns A canonical `ResourceStateError` created from the raw value.
+     */
+    handleError(error, featureCellKey) {
+        return createVaultError(error, featureCellKey);
+    }
+    /**
+     * Lifecycle hook invoked when the behavior instance is destroyed.
+     *
+     * Core behaviors maintain no internal resources and therefore perform no
+     * cleanup. This method logs a devtools-friendly "noop" warning to help
+     * with behavior lifecycle introspection.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the behavior instance.
+     *
+     * This behavior maintains no internal mutable state. The reset hook exists
+     * strictly for lifecycle symmetry across all behavior types and to support
+     * devtools state introspection.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreErrorBehavior = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.CoreError,
+        key: defineBehaviorKey('Core', 'Error'),
+        critical: true
+    })
+], withCoreErrorBehavior);
+
+/**
+ * Core filter behavior for Vault.
+ *
+ * This behavior participates in the filter stage of the pipeline.
+ * A filter function receives the current state and may return:
+ * - the same state
+ * - a transformed state of the same structural type
+ * - `undefined` to indicate that the state update should be aborted
+ *
+ * This behavior enforces type alignment between the incoming value
+ * and the filtered result, ensuring that filters cannot mutate or
+ * reshape the state into an incompatible type. When a mismatch is
+ * detected, a controlled Vault error is thrown.
+ *
+ * Filters MUST be pure and must not mutate the incoming value.
+ *
+ * @typeParam T - The state type handled by this filter behavior.
+ */
+let withCoreFilterBehavior = class withCoreFilterBehavior {
+    behaviorCtx;
+    /** Static behavior type used for pipeline classification. */
+    static type;
+    /** Unique behavior key used for introspection and diagnostics. */
+    static key;
+    /** Indicates that filter behavior is required in the pipeline. */
+    static critical;
+    /** Instance-level criticality flag. */
+    type = BehaviorTypes.Filter;
+    /** Indicates that this behavior must always run as part of filtering. */
+    critical = true;
+    /** Unique identifier for this filter behavior instance. */
+    key;
+    /**
+     * Creates a new filter behavior instance.
+     *
+     * @param key - Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx - BehaviorCtx for future extensibility hooks.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Applies the provided filter function to the current state.
+     *
+     * If the filter returns `undefined`, the state update is aborted.
+     * Filter output must preserve the shape of:
+     * - arrays
+     * - plain objects
+     * - primitives
+     *
+     * Structural mismatches result in a thrown Vault error.
+     * Filters must not mutate the incoming value and should remain pure.
+     *
+     * @param current - The current value before filtering.
+     * @param filter - A pure filter function that may transform or reject the value.
+     * @returns The filtered value, or `undefined` to abort the update.
+     */
+    applyFilter(current, filter) {
+        vaultDebug(`${this.key} applyFilter called with "${safeStringify(current)}".`);
+        if (current === undefined) {
+            vaultDebug(`${this.key} applyFilter skipped - not a valid plain state. The current type is ${typeof current}. Undefined returned.`);
+            return undefined;
+        }
+        if (typeof filter !== 'function') {
+            vaultDebug(`${this.key} applyFilter skipped. The filter type is ${typeof filter}. "${safeStringify(current)}" returned.`);
+            return current;
+        }
+        let next;
+        try {
+            next = filter(current);
+            // eslint-disable-next-line
+        }
+        catch (err) {
+            vaultError(`${this.key} filter execution failed`, err.message);
+            throw err;
+        }
+        if (next === undefined) {
+            vaultDebug(`${this.key} Filter returned undefined. state rejected.`);
+            return VAULT_NOOP;
+        }
+        if (this.#handleArrayLogic(current, next))
+            return next;
+        if (this.#handleObjectLogic(current, next))
+            return next;
+        this.#handlePrimitiveLogic(current, next);
+        vaultDebug(`${this.key} applyFilter returned with "${safeStringify(next)}".`);
+        return next;
+    }
+    /**
+     * Performs type validation when filtering array state values.
+     *
+     * Ensures the filtered output remains an array when the input was an array.
+     *
+     * @param current - The pre-filter state value.
+     * @param next - The filtered state value.
+     * @returns `true` if array handling was applied.
+     */
+    #handleArrayLogic(current, next) {
+        if (Array.isArray(current)) {
+            if (!Array.isArray(next)) {
+                this.#typeAlignmentDebug(current, next);
+                throw new Error(`[vault] Filter returned non-array for array input.`);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Performs type validation when filtering object-based state values.
+     *
+     * Ensures the filter returns a valid non-null object of compatible structure.
+     *
+     * @param current - The pre-filter state value.
+     * @param next - The filtered state value.
+     * @returns `true` if object handling was applied.
+     */
+    #handleObjectLogic(current, next) {
+        if (current !== null && typeof current === 'object') {
+            if (typeof next !== 'object' || next === null || Array.isArray(next)) {
+                this.#typeAlignmentDebug(current, next);
+                throw new Error(`[vault] Filter returned invalid object for object input.`);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Performs type validation for primitive state values.
+     *
+     * Ensures the filter output matches the primitive type of the input.
+     *
+     * @param current - The pre-filter primitive value.
+     * @param next - The filtered primitive value.
+     */
+    #handlePrimitiveLogic(current, next) {
+        if (typeof next !== typeof current) {
+            this.#typeAlignmentDebug(current, next);
+            throw new Error(`[vault] Filter returned a value of incorrect type. Expected "${typeof current}", got "${typeof next}".`);
+        }
+    }
+    /**
+     * Emits detailed debug output when filter output does not align with the input type.
+     *
+     * @param current - The original state value.
+     * @param next - The returned filter value.
+     */
+    #typeAlignmentDebug(current, next) {
+        vaultDebug(`${this.key} The types not aligned. Current type: "${typeof current}". Next type: ${typeof next}. "${safeStringify(next)}" returned.`);
+    }
+    /**
+     * Invoked during behavior teardown.
+     * This behavior maintains no internal resources and requires no cleanup.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the filter behavior.
+     *
+     * Since core filters do not maintain internal state, this reset operation
+     * performs no functional work. It exists to support the FeatureCell reset
+     * lifecycle and provides a diagnostic hook for DevTools and monitoring.
+     *
+     * After reset, the behavior continues operating identically to before.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreFilterBehavior = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.Filter,
+        key: defineBehaviorKey('Core', 'Filter'),
+        critical: true
+    })
+], withCoreFilterBehavior);
+
+var withArrayMergeBehavior_1;
+/**
+ * Array merge behavior for Vault.
+ *
+ * This merge strategy replaces arrays rather than merging them, ensuring
+ * predictable and immutable updates for list-like state. All non-array values
+ * are returned directly without transformation.
+ *
+ * This behavior is marked as critical, ensuring it participates in every
+ * merge pipeline unless explicitly replaced by a custom merge behavior.
+ *
+ * @typeParam T - The pipeline state value type handled by this behavior.
+ */
+let withArrayMergeBehavior = class withArrayMergeBehavior {
+    static { withArrayMergeBehavior_1 = this; }
+    behaviorCtx;
+    /** Static behavior type used by the orchestrator. */
+    static type;
+    /** Static unique key assigned to this behavior. */
+    static key;
+    /** Indicates this behavior is required for merge processing. */
+    static critical = true;
+    /** Instance-level merge behavior type identifier. */
+    type = withArrayMergeBehavior_1.type;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /** Flags this behavior instance as critical within the pipeline. */
+    critical = withArrayMergeBehavior_1.critical;
+    /**
+     * Creates a new array merge behavior instance.
+     *
+     * @param key - Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx - BehaviorCtx for future extensibility hooks.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Computes the merged state value using array-replacement semantics.
+     *
+     * - If `nextValue` is undefined and `clearUndefined` is false,
+     *   the current value is preserved.
+     * - If `nextValue` is undefined and `clearUndefined` is true,
+     *   the merge resolves to `undefined`.
+     * - If both values are arrays, a shallow clone of `nextValue`
+     *   is returned to maintain immutability.
+     * - All other values pass through as-is.
+     *
+     * @param currentValue - The existing state value.
+     * @param nextValue - The incoming state value to merge.
+     * @param options - Optional merge configuration.
+     * @returns The merged pipeline value.
+     */
+    computeMerge(currentValue, nextValue, options) {
+        const curr = currentValue;
+        const next = nextValue;
+        const clear = options?.clearUndefined ?? false;
+        vaultDebug(`${this.key} merge called (clear: ${clear})`);
+        if (next === undefined && !clear) {
+            vaultDebug(`${this.key} computeMerge skipped. The next value "${next}" and clear is "${clear}`);
+            return curr;
+        }
+        if (next === undefined && clear) {
+            vaultDebug(`${this.key} computeMerge skipped. The next value "${next}" and clear is "${clear}`);
+            return VAULT_CLEAR_STATE;
+        }
+        if (Array.isArray(curr) && Array.isArray(next)) {
+            vaultDebug(`${this.key} merging array. Return clone of next`);
+            return [...next];
+        }
+        vaultDebug(`${this.key} non-array branch. Return next`);
+        return next;
+    }
+    /**
+     * Performs teardown when the behavior instance is destroyed.
+     * This merge behavior maintains no resources and requires no cleanup.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the merge behavior.
+     *
+     * Array merge is a fully stateless behavior and maintains no internal
+     * resources, configuration mutations, or cached values. As a result,
+     * this reset operation performs no functional work and simply emits a
+     * diagnostic event for DevTools and monitoring.
+     *
+     * After reset, this behavior continues to operate identically to before.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withArrayMergeBehavior = withArrayMergeBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.Merge,
+        key: defineBehaviorKey('Core', 'ArrayMerge'),
+        critical: true
+    })
+], withArrayMergeBehavior);
+
+/**
+ * Extends a FeatureCell with a `fromObservable` helper for observable-based state sources.
+ *
+ * This function installs a placeholder implementation that accepts an observable
+ * and exposes it as a stream of `VaultStateRef<T>` values, with the runtime behavior
+ * replaced by the corresponding pipeline behavior when installed.
+ *
+ * @param cell The FeatureCell instance to extend.
+ */
+function extendFromObservable(cell) {
+    /**
+     * Wraps an observable source for integration with the FeatureCell pipeline.
+     *
+     * @param source$ Observable emitting raw state values.
+     * @returns Observable emitting vault state references.
+     */
+    cell.fromObservable = function (source$) {
+        return source$;
+    };
+}
+
+var withCoreFromObservableBehavior_1;
+/**
+ * Extension behavior that enables FeatureCells to resolve state from observable sources.
+ *
+ * This behavior augments the FeatureCell API with a `fromObservable` method that
+ * converts a single observable emission into a normalized state envelope and
+ * binds subscription lifetime to the cell lifecycle.
+ *
+ * @deprecated
+ * This API exists as a migration bridge for observable-based workflows.
+ * Prefer using `replaceState` or `mergeState` to resolve
+ * observables directly within the pipeline.
+ *
+ * --RelatedStart--
+ * FromObservableBehaviorExtension
+ * withCoreObservableBehavior
+ * replaceState
+ * mergeState
+ * --RelatedEnd--
+ */
+let withCoreFromObservableBehavior = class withCoreFromObservableBehavior {
+    static { withCoreFromObservableBehavior_1 = this; }
+    behaviorCtx;
+    /** Extension function used to attach observable APIs to the FeatureCell. */
+    static extension = extendFromObservable;
+    /** Static behavior type used for pipeline classification. */
+    static type;
+    /** Static behavior key used for diagnostics and introspection. */
+    static key;
+    /** Resolve type associated with observable-based resolution. */
+    static resolveType;
+    /** Indicates whether this behavior is required by the pipeline. */
+    static critical;
+    /** Instance-level behavior type identifier. */
+    type = withCoreFromObservableBehavior_1.type;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /** Indicates that this behavior is optional within the pipeline. */
+    critical = withCoreFromObservableBehavior_1.critical;
+    /** Resolve type for this behavior instance. */
+    resolveType = withCoreFromObservableBehavior_1.resolveType;
+    /**
+     * Creates a new observable extension behavior instance.
+     *
+     * @param key Unique identifier assigned by the behavior factory.
+     * @param behaviorCtx Behavior class context used for configuration access.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Extends the FeatureCell API with observable-based resolution support.
+     *
+     * @param ctx FeatureCell extension context providing lifecycle signals.
+     * @returns An extension object exposing the `fromObservable` API.
+     */
+    extendCellAPI(ctx) {
+        return {
+            fromObservable: (source$) => new Observable((observer) => {
+                vaultDebug(`${this.key} fromObservable called.`);
+                const destroy$ = ctx.destroyed$ ?? EMPTY;
+                const reset$ = ctx.reset$ ?? EMPTY;
+                const subscription = source$.pipe(takeUntil(reset$), takeUntil(destroy$), take(1)).subscribe({
+                    next: (value) => {
+                        vaultDebug(`${this.key} fromObservable emitted value "${safeStringify(value)}".`);
+                        observer.next({
+                            loading: false,
+                            value,
+                            error: null
+                        });
+                    },
+                    error: (err) => {
+                        const error = createVaultError(err, ctx.featureCellKey);
+                        observer.error(error);
+                        vaultDebug(`${this.key} fromObservable emitted error "${error.message}".`);
+                    },
+                    complete: () => {
+                        observer.complete();
+                        vaultDebug(`${this.key} fromObservable completed.`);
+                    }
+                });
+                return () => {
+                    subscription.unsubscribe();
+                    vaultDebug(`${this.key} fromObservable subscription unsubscribed.`);
+                };
+            })
+        };
+    }
+    /**
+     * Invoked when the behavior instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the observable extension behavior.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreFromObservableBehavior = withCoreFromObservableBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.FromObservable,
+        key: defineBehaviorKey('Core', 'FromObservable'),
+        critical: false,
+        resolveType: ResolveTypes.Observable
+    })
+], withCoreFromObservableBehavior);
+
+/**
+ * Extends a FeatureCell with promise-based resolution placeholders.
+ *
+ * This function attaches `fromDeferred` and `fromPromise` methods to the
+ * FeatureCell shape as build-time stubs. These methods are replaced at
+ * runtime by the corresponding resolve behavior when installed.
+ *
+ * --RelatedStart--
+ * FeatureCellShape
+ * DeferredFactory
+ * --RelatedEnd--
+ *
+ * @param cell The FeatureCell instance being extended.
+ */
+function extendFromPromise(cell) {
+    /**
+     * Resolves state from a deferred factory using promise semantics.
+     *
+     * @param _incoming Deferred factory that produces the state value.
+     * @returns A promise resolving to a normalized state envelope.
+     */
+    cell.fromDeferred = function (_incoming) {
+        // runtime behavior will replace this implementation
+        throw new Error('[vault] fromDeferred() behavior not installed');
+    };
+    /**
+     * Resolves state from a deferred factory using promise semantics.
+     *
+     * @param _incoming Deferred factory that produces the state value.
+     * @returns A promise resolving to a normalized state envelope.
+     */
+    cell.fromPromise = function (_incoming) {
+        // runtime behavior will replace this implementation
+        throw new Error('[vault] fromPromise() behavior not installed');
+    };
+}
+
+var withCoreFromPromiseBehavior_1;
+/**
+ * Extension behavior that enables promise-based state resolution for FeatureCells.
+ *
+ * This behavior augments a FeatureCell with APIs that accept deferred factories
+ * and resolve their produced values into normalized state inputs. It supports
+ * both promise and deferred invocation semantics while preserving pipeline
+ * loading and error metadata.
+ *
+ * @deprecated
+ * This API exists as a migration bridge for deferred- and promise-based workflows.
+ * Prefer using `replaceState` or `mergeState` to resolve promises
+ * directly within the pipeline.
+ *
+ * --RelatedStart--
+ * FromPromiseBehaviorExtension
+ * DeferredFactory
+ * withCorePromiseBehavior
+ * replaceState
+ * mergeState
+ * --RelatedEnd--
+ */
+let withCoreFromPromiseBehavior = class withCoreFromPromiseBehavior {
+    static { withCoreFromPromiseBehavior_1 = this; }
+    behaviorCtx;
+    /** Static behavior function used to extend the FeatureCell API. */
+    static extension = extendFromPromise;
+    /** Static behavior type used for orchestrator classification. */
+    static type;
+    /** Static behavior key used for diagnostics and tooling. */
+    static key;
+    /** Indicates whether this behavior is required by the pipeline. */
+    static critical;
+    /** Resolve type identifier for promise-based resolution. */
+    static resolveType;
+    /** Instance-level behavior type identifier. */
+    type = withCoreFromPromiseBehavior_1.type;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /** Indicates that this behavior is optional within the pipeline. */
+    critical = withCoreFromPromiseBehavior_1.critical;
+    /** Resolve type identifier for this behavior instance. */
+    resolveType = withCoreFromPromiseBehavior_1.resolveType;
+    /**
+     * Creates a new instance of the promise resolution behavior.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior context providing configuration and lifecycle hooks.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Extends the FeatureCell API with promise-based resolution functions.
+     *
+     * @param ctx FeatureCell extension context used for lifecycle coordination.
+     * @returns An extension object exposing promise-based resolution methods.
+     */
+    extendCellAPI(ctx) {
+        const handleDeferred = (incoming) => new Promise((resolve, reject) => {
+            vaultDebug(`${this.key} fromPromise called.`);
+            if (isUndefined(incoming)) {
+                resolve({
+                    loading: false,
+                    value: undefined,
+                    error: null
+                });
+                return;
+            }
+            if (!isDeferredFactory(incoming)) {
+                const potentialIncoming = incoming;
+                resolve({
+                    loading: potentialIncoming?.loading ?? false,
+                    value: undefined,
+                    error: potentialIncoming?.error ?? null
+                });
+                return;
+            }
+            let result;
+            try {
+                result = incoming.value?.();
+            }
+            catch (err) {
+                const error = createVaultError(err, ctx.featureCellKey);
+                reject(error);
+                return;
+            }
+            Promise.resolve(result)
+                .then((value) => {
+                vaultDebug(`${this.key} fromPromise resolved value: ${safeStringify(value)}`);
+                resolve({
+                    loading: incoming.loading ?? false,
+                    value,
+                    error: incoming.error ?? null
+                });
+            })
+                .catch((err) => {
+                const error = createVaultError(err, ctx.featureCellKey);
+                reject(error);
+            });
+        });
+        return {
+            fromPromise: (incoming) => handleDeferred(incoming),
+            fromDeferred: (incoming) => handleDeferred(incoming)
+        };
+    }
+    /**
+     * Invoked during behavior teardown.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the behavior state.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreFromPromiseBehavior = withCoreFromPromiseBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.FromPromise,
+        key: defineBehaviorKey('Core', 'FromPromise'),
+        critical: false,
+        resolveType: ResolveTypes.Promise
+    })
+], withCoreFromPromiseBehavior);
+
+/**
+ * Core reducer behavior that applies pure reducer functions to state values.
+ *
+ * This behavior participates in the reduce stage of the pipeline and is
+ * responsible for invoking reducer functions supplied by consumers to
+ * transform the current state into a new value. It performs no validation
+ * beyond ensuring the reducer is callable.
+ */
+let withCoreReducerBehavior = class withCoreReducerBehavior {
+    behaviorCtx;
+    /** Static metadata used for orchestrator behavior classification. */
+    static type;
+    /** Unique behavior identifier for diagnostics and devtools. */
+    static key;
+    /** Indicates that reducer behavior is essential to the pipeline. */
+    static critical;
+    /** Instance-level criticality flag. */
+    critical = true;
+    /** Pipeline behavior type identifier. */
+    type = BehaviorTypes.Reduce;
+    /** Unique identifier for this reducer behavior instance. */
+    key;
+    /**
+     * Creates a new reducer behavior instance.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior class context for dependency injection and configuration.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Applies a reducer function to the current state value.
+     *
+     * @param current The current state value before reduction.
+     * @param reducer A reducer function that produces the next state value.
+     * @returns The reduced state value.
+     */
+    applyReducer(current, reducer) {
+        vaultDebug(`${this.key} applyReducer called with "${safeStringify(current)}".`);
+        if (typeof reducer !== 'function') {
+            vaultDebug(`${this.key} applyReducer skipped - reducer is not a function.`);
+            return current;
+        }
+        return reducer(current);
+    }
+    /**
+     * Invoked when the behavior instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the reducer behavior to its initial state.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreReducerBehavior = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.Reduce,
+        key: defineBehaviorKey('Core', 'Reducer'),
+        critical: true
+    })
+], withCoreReducerBehavior);
+
+var withCoreObservableBehavior_1;
+/**
+ * Core resolve behavior that extracts a single value from an RxJS Observable.
+ *
+ * This behavior participates in the resolve stage and handles incoming
+ * Observable values by subscribing once and resolving with the first emitted
+ * value. Resolution is automatically terminated when the FeatureCell is reset
+ * or destroyed.
+ */
+let withCoreObservableBehavior = class withCoreObservableBehavior {
+    static { withCoreObservableBehavior_1 = this; }
+    behaviorCtx;
+    /** Static behavior type used for orchestrator classification. */
+    static type;
+    /** Unique behavior key used for diagnostics and devtools. */
+    static key;
+    /** Indicates whether this behavior is required by the pipeline. */
+    static critical;
+    /** Resolve type classification for observable-based resolution. */
+    static resolveType;
+    /** The pipeline behavior type identifier. */
+    type = BehaviorTypes.Resolve;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /** Indicates that this behavior is optional within the pipeline. */
+    critical = false;
+    /** Resolve type identifier for observable-based resolution. */
+    resolveType = withCoreObservableBehavior_1.resolveType;
+    /**
+     * Creates a new observable resolve behavior instance.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior class context for dependency injection and configuration.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Resolves a state value from an Observable input.
+     *
+     * @param ctx The resolve behavior context containing the incoming value.
+     * @returns The resolved state value or undefined if resolution is skipped.
+     */
+    async computeResolve(ctx) {
+        const incoming = ctx.incoming;
+        vaultDebug(`${this.key} computeResolve called with incoming: ${safeStringify(incoming)}`);
+        if (!isObservable(incoming)) {
+            vaultDebug(`${this.key} computeResolve skipped — incoming is not an Observable.`);
+            return;
+        }
+        vaultDebug(`${this.key} computeResolve detected Observable input.`);
+        const source$ = incoming;
+        const reset$ = ctx.reset$ ?? EMPTY;
+        const destroyed$ = ctx.destroyed$ ?? EMPTY;
+        try {
+            const value = await firstValueFrom(source$.pipe(takeUntil(reset$), takeUntil(destroyed$), take(1)));
+            vaultDebug(`${this.key} computeResolve resolved value: ${safeStringify(value)}`);
+            return value;
+        }
+        catch (err) {
+            const vaultError = createVaultError(err, ctx.featureCellKey);
+            vaultDebug(`${this.key} computeResolve caught error: ${vaultError.message}`);
+            throw vaultError;
+        }
+    }
+    /**
+     * Invoked when the behavior instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the resolve behavior to its initial state.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreObservableBehavior = withCoreObservableBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.Resolve,
+        key: defineBehaviorKey('Core', 'Observable'),
+        critical: false,
+        resolveType: ResolveTypes.Observable
+    })
+], withCoreObservableBehavior);
+
+var withCorePromiseBehavior_1;
+/**
+ * Core resolve behavior that extracts a value from a deferred promise factory.
+ *
+ * This behavior participates in the resolve stage and handles incoming
+ * deferred factories by invoking the factory exactly once and resolving
+ * with the resulting value. Errors are normalized and propagated through
+ * the pipeline error handling contract.
+ */
+let withCorePromiseBehavior = class withCorePromiseBehavior {
+    static { withCorePromiseBehavior_1 = this; }
+    behaviorCtx;
+    /** Static behavior type used for orchestrator classification. */
+    static type;
+    /** Unique behavior key used for diagnostics and devtools. */
+    static key;
+    /** Indicates whether this behavior is required by the pipeline. */
+    static critical;
+    /** Resolve type classification for promise-based resolution. */
+    static resolveType;
+    /** The pipeline behavior type identifier. */
+    type = withCorePromiseBehavior_1.type;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /** Indicates that this behavior is optional within the pipeline. */
+    critical = withCorePromiseBehavior_1.critical;
+    /** Resolve type identifier for promise-based resolution. */
+    resolveType = withCorePromiseBehavior_1.resolveType;
+    /**
+     * Creates a new promise resolve behavior instance.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior class context for dependency injection and configuration.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Resolves a state value from a deferred promise factory.
+     *
+     * @param ctx The resolve behavior context containing the incoming value.
+     * @returns The resolved state value or undefined if resolution is skipped.
+     */
+    async computeResolve(ctx) {
+        const incoming = ctx.incoming;
+        vaultDebug(`${this.key} computeResolve promise called with incoming: ${safeStringify(incoming)}`);
+        if (!(isDeferredFactory(incoming) || isFunction(incoming)) || isUndefined(incoming)) {
+            vaultDebug(`${this.key} computeResolve skipped — incoming is not a deferred factory.`);
+            return;
+        }
+        vaultDebug(`${this.key} computeResolve detected Promise input.`);
+        try {
+            let value;
+            if (isFunction(incoming)) {
+                value = (await incoming?.());
+            }
+            else {
+                value = (await incoming.value?.());
+            }
+            vaultDebug(`${this.key} computeResolve resolved value: ${safeStringify(value)}`);
+            return value;
+        }
+        catch (err) {
+            const vaultError = createVaultError(err, ctx.featureCellKey);
+            vaultDebug(`${this.key} computeResolve caught error: ${vaultError.message}`);
+            throw vaultError;
+        }
+    }
+    /**
+     * Invoked when the behavior instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the resolve behavior to its initial state.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCorePromiseBehavior = withCorePromiseBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.Resolve,
+        key: defineBehaviorKey('Core', 'Promise'),
+        critical: false,
+        resolveType: ResolveTypes.Promise
+    })
+], withCorePromiseBehavior);
+
+var withCoreValueBehavior_1;
+/**
+ * Core resolve behavior that extracts a plain value from an incoming state envelope.
+ *
+ * This behavior participates in the resolve stage and handles direct value-based
+ * state inputs by safely normalizing the contained value. Objects and arrays are
+ * shallow-cloned to preserve immutability guarantees, while null and undefined
+ * values are handled explicitly according to pipeline semantics.
+ */
+let withCoreValueBehavior = class withCoreValueBehavior {
+    static { withCoreValueBehavior_1 = this; }
+    behaviorCtx;
+    /** Static behavior type for orchestrator classification. */
+    static type;
+    /** Static unique behavior identifier. */
+    static key;
+    /** Static flag marking this behavior as pipeline-critical. */
+    static critical;
+    /** Resolve type classification for value-based resolution. */
+    static resolveType;
+    /** Instance-level pipeline type identifier. */
+    type = withCoreValueBehavior_1.type;
+    /** Indicates this resolve behavior is required for pipeline operation. */
+    critical = withCoreValueBehavior_1.critical;
+    /** Unique behavior key for the instance. */
+    key;
+    /** Resolve mode indicating plain value resolution. */
+    resolveType = withCoreValueBehavior_1.resolveType;
+    /**
+     * Creates a new value resolve behavior instance.
+     *
+     * @param key Unique behavior identifier assigned by the factory.
+     * @param behaviorCtx Behavior class context for dependency injection and configuration.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Resolves a state value from a plain state envelope.
+     *
+     * @param ctx Resolve context containing the incoming state packet.
+     * @returns The normalized resolved value, a clear signal, or undefined.
+     */
+    async computeResolve(ctx) {
+        vaultDebug(`${this.key} computeResolve called with "${safeStringify(ctx.incoming)}".`);
+        const incoming = ctx.incoming;
+        if (!incoming || isHttpResourceRef(incoming)) {
+            vaultDebug(`${this.key} computeResolve skipped - not a valid plain state.`);
+            return;
+        }
+        const { value } = incoming;
+        if (value === undefined) {
+            vaultDebug(`${this.key} value is undefined and resolution skipped.`);
+            return;
+        }
+        if (value === null) {
+            vaultDebug(`${this.key} value is null and clear state returned.`);
+            return VAULT_CLEAR_STATE;
+        }
+        if (Array.isArray(value)) {
+            vaultDebug(`${this.key} array value detected and cloned.`);
+            return [...value];
+        }
+        if (typeof value === 'object') {
+            vaultDebug(`${this.key} object value detected and cloned.`);
+            return { ...value };
+        }
+        vaultDebug(`${this.key} primitive value detected and returned.`);
+        return value;
+    }
+    /**
+     * Invoked when the behavior instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the resolve behavior to its initial state.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreValueBehavior = withCoreValueBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.Resolve,
+        key: defineBehaviorKey('Core', 'Value'),
+        critical: true,
+        resolveType: ResolveTypes.Value
+    })
+], withCoreValueBehavior);
+
+/**
+ * Extends a FeatureCell instance with a placeholder `fromStream` API.
+ *
+ * This function installs a stub implementation that is replaced at runtime
+ * by the corresponding behavior. It defines the method shape so that
+ * consumers may invoke `fromStream` once the behavior is installed.
+ *
+ * @param cell The FeatureCell instance being extended.
+ */
+function extendFromStream(cell) {
+    /**
+     * Bridges a streaming observable source into the FeatureCell pipeline.
+     *
+     * @param _source$ Observable stream emitting values to be resolved.
+     * @param _options Optional stream configuration options.
+     */
+    cell.fromStream = function (_source$, _options) { };
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > lib > behaviors > resolve > from-stream > with-core-from-stream.behavior.ts
+// Updated: 2026-03-02 08:26
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+// --- AI Model File Path (DO NOT DELETE) ---
+var withCoreFromStreamBehavior_1;
+let withCoreFromStreamBehavior = class withCoreFromStreamBehavior {
+    static { withCoreFromStreamBehavior_1 = this; }
+    behaviorCtx;
+    /** Static behavior to extend the cell api dynamically */
+    static extension = extendFromStream;
+    /** Static behavior type used for orchestrator classification. */
+    static type;
+    /** Unique behavior key used for diagnostics and devtools. */
+    static key;
+    /** Indicates whether this behavior is required by the pipeline. */
+    static critical;
+    static resolveType;
+    /** The extension behavior type identifier. */
+    type = withCoreFromStreamBehavior_1.type;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /** Indicates that this behavior is optional within the pipeline. */
+    critical = withCoreFromStreamBehavior_1.critical;
+    resolveType = withCoreFromStreamBehavior_1.resolveType;
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    extendCellAPI(ctx) {
+        return {
+            fromStream: (source$, options) => {
+                const { autoResetError = true } = options ?? {};
+                vaultDebug(`${this.key} fromStream called.`);
+                vaultDebug(`${this.key} fromStream options resolved (autoResetError=${autoResetError}).`);
+                ctx.vaultMonitor.ingressSubscribed(ctx.featureCellKey, this.key, ctx, 'fromStream');
+                vaultDebug(`${this.key} fromStream subscription started.`);
+                source$.pipe(takeUntil(ctx.destroyed$)).subscribe({
+                    next: (incomingItem) => {
+                        vaultDebug(`${this.key} subscription.next called.`);
+                        vaultDebug(`${this.key} incoming value received: "${safeStringify(incomingItem)}".`);
+                        if (autoResetError) {
+                            vaultDebug(`${this.key} autoResetError enabled → clearing error.`);
+                        }
+                        const nextState = autoResetError
+                            ? { value: incomingItem, error: null }
+                            : { value: incomingItem };
+                        ctx.mergeState(nextState);
+                        vaultDebug(`${this.key} mergeState invoked from stream.next.`);
+                    },
+                    error: (err) => {
+                        vaultDebug(`${this.key} subscription.error called.`);
+                        const vaultError = createVaultError(err, this.key);
+                        vaultDebug(`${this.key} stream error converted to VaultError: "${vaultError.message}".`);
+                        ctx.mergeState({ error: vaultError });
+                        vaultDebug(`${this.key} mergeState invoked from stream.error.`);
+                    },
+                    complete: () => {
+                        vaultDebug(`${this.key} subscription.complete called.`);
+                        ctx.vaultMonitor.ingressCompleted(ctx.featureCellKey, this.key, ctx, 'fromStream');
+                        vaultDebug(`${this.key} fromStream completed.`);
+                    }
+                });
+            }
+        };
+    }
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreFromStreamBehavior = withCoreFromStreamBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.FromStream,
+        key: defineBehaviorKey('Core', 'FromStream'),
+        critical: false,
+        resolveType: ResolveTypes.Observable
+    })
+], withCoreFromStreamBehavior);
+
+/**
+ * Core behavior responsible for invoking `emitState` callbacks.
+ *
+ * This behavior executes a consumer-provided callback with the current
+ * immutable state snapshot, allowing external observers to react to
+ * state emission events without mutating pipeline state.
+ *
+ * It is critical to pipeline execution and always runs during emitState
+ * processing when a callback is provided.
+ */
+let withCoreEmitStateBehavior = class withCoreEmitStateBehavior {
+    behaviorCtx;
+    /** Static behavior type used for pipeline classification. */
+    static type;
+    /** Unique behavior key used for introspection and diagnostics. */
+    static key;
+    /** Indicates that emitState behavior is required in the pipeline. */
+    static critical;
+    /** Instance-level pipeline behavior type identifier. */
+    type = BehaviorTypes.CoreEmitState;
+    /** Indicates that this behavior must always run during emitState execution. */
+    critical = true;
+    /** Unique identifier for this emitState behavior instance. */
+    key;
+    /**
+     * Creates a new core emitState behavior instance.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior class context for dependency injection and extensibility.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Executes a provided emitState callback with the current state snapshot.
+     *
+     * If the callback is not a function or throws during execution, the behavior
+     * logs the failure and returns `VAULT_NOOP` without interrupting pipeline flow.
+     *
+     * @param snapshot Immutable snapshot of the current FeatureCell state.
+     * @param callback Consumer-provided emitState callback.
+     * @returns A core emitState result or `VAULT_NOOP` when no action is taken.
+     */
+    // eslint-disable-next-line
+    emitState(snapshot, callback) {
+        vaultDebug(`${this.key} emitState called with "${safeStringify(snapshot)}".`);
+        if (typeof callback !== 'function') {
+            vaultDebug(`${this.key} emitState skipped. The emitState type is ${typeof callback}. "${safeStringify(snapshot)}" returned.`);
+            return VAULT_NOOP;
+        }
+        try {
+            callback(snapshot);
+        }
+        catch (err) {
+            vaultError(`${this.key} emitState execution failed`, safeStringify(err));
+            return VAULT_NOOP;
+        }
+        return;
+    }
+    /**
+     * Performs cleanup when the behavior instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the emitState behavior.
+     *
+     * This behavior does not retain internal state and therefore requires
+     * no reset logic beyond lifecycle participation.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+};
+withCoreEmitStateBehavior = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.CoreEmitState,
+        key: defineBehaviorKey('Core', 'EmitState'),
+        critical: true
+    })
+], withCoreEmitStateBehavior);
+
+/**
+ * Canonical identifier used to mark values or errors originating outside the Vault pipeline.
+ */
+const VAULT_EXTERNAL = 'external';
+
+var withCoreStateBehavior_1;
+/**
+ * Core behavior responsible for committing resolved pipeline outcomes into state.
+ *
+ * This behavior translates pipeline execution results into immutable state
+ * snapshots and emits authoritative state lifecycle events. It coordinates
+ * loading, value, and error transitions and ensures state emission remains
+ * atomic and ordered.
+ */
+let withCoreStateBehavior = class withCoreStateBehavior {
+    static { withCoreStateBehavior_1 = this; }
+    behaviorCtx;
+    /** Static behavior type used for pipeline classification. */
+    static type;
+    /** Unique behavior key used for introspection and diagnostics. */
+    static key;
+    /** Indicates that this behavior is required for pipeline execution. */
+    static critical;
+    /** Instance-level pipeline behavior type identifier. */
+    type = withCoreStateBehavior_1.type;
+    /** Indicates that this behavior must always execute. */
+    critical = withCoreStateBehavior_1.critical;
+    /** Unique identifier for this behavior instance. */
+    key;
+    /**
+     * Creates a new core state behavior instance.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior class context for dependency injection.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Commits partial state changes and emits a single state snapshot event.
+     *
+     * @param ctx Pipeline behavior context containing state references.
+     * @param changes Partial snapshot changes or null.
+     * @param type State emission classification.
+     */
+    #commitState(ctx, changes, type) {
+        vaultDebug(`${this.key} commitState called with: ${safeStringify(changes)}`);
+        try {
+            if (changes) {
+                const safeChanges = isolateValue(changes);
+                Object.assign(ctx.lastSnapshot, safeChanges);
+                ctx.lastSnapshot.hasValue = ctx.lastSnapshot.value !== undefined && ctx.lastSnapshot.value !== null;
+            }
+            const snapshotEmit = {
+                snapshot: isolateValue(ctx.lastSnapshot),
+                type
+            };
+            if (ctx.options) {
+                snapshotEmit.options = ctx.options;
+            }
+            ctx.state$.next(snapshotEmit);
+        }
+        catch (error) {
+            vaultError(`${this.key} an error occurred updating the state`, error);
+        }
+    }
+    /**
+     * Prepares incoming pipeline input and emits an initial incoming state.
+     *
+     * @param ctx Pipeline behavior context.
+     * @returns The incoming value or `VAULT_NOOP`.
+     */
+    preparePipelineIncoming(ctx) {
+        const incoming = ctx.incoming;
+        const changes = {};
+        if (isNullish(incoming) || (isStateInputShape(incoming) && isNull(incoming.value))) {
+            changes.isLoading = false;
+            changes.value = undefined;
+            changes.error = null;
+            this.#commitState(ctx, changes, StateEmitTypes.IncomingPipeline);
+            return VAULT_NOOP;
+        }
+        if (isHttpResourceRef(incoming)) {
+            changes.isLoading = true;
+        }
+        else if (isStateInputShape(incoming)) {
+            if (!isNullish(incoming?.loading)) {
+                changes.isLoading = incoming.loading;
+            }
+            if (isDefined(incoming?.error)) {
+                changes.error = isNull(incoming.error) ? null : createVaultError(incoming.error, VAULT_EXTERNAL);
+            }
+        }
+        if (Object.keys(changes).length > 0) {
+            this.#commitState(ctx, changes, StateEmitTypes.IncomingPipeline);
+        }
+        return incoming;
+    }
+    /**
+     * Finalizes state after pipeline resolution completes.
+     *
+     * @param value Final pipeline output.
+     * @param ctx Pipeline behavior context.
+     */
+    finalizePipelineState(value, ctx) {
+        vaultDebug(`${this.key} - finalizeVaultState`);
+        if (isHttpResourceRef(ctx.incoming)) {
+            this.#commitState(ctx, { isLoading: false }, StateEmitTypes.FinalizePipeline);
+        }
+        if (isVaultNoop(value)) {
+            this.#commitState(ctx, null, StateEmitTypes.FinalizePipeline);
+            return;
+        }
+        if (isNull(value) || isVaultClearState(value)) {
+            this.#commitState(ctx, { value: undefined }, StateEmitTypes.FinalizePipeline);
+            return;
+        }
+        if (!isNullish(value) && !isPipelineTerminal(value)) {
+            this.#commitState(ctx, { value: value }, StateEmitTypes.FinalizePipeline);
+        }
+    }
+    /**
+     * Finalizes state when pipeline execution is stopped.
+     *
+     * @param ctx Pipeline behavior context.
+     */
+    finalizePipelineVaultStop(ctx) {
+        vaultDebug(`${this.key} - finalizePipelineVaultStop`);
+        this.#commitState(ctx, null, StateEmitTypes.FinalizePipeline);
+    }
+    /**
+     * Finalizes state when a pipeline error occurs.
+     *
+     * @param err Normalized vault error or null.
+     * @param ctx Pipeline behavior context.
+     */
+    finalizePipelineError(err, ctx) {
+        vaultDebug(`${this.key} - finalizePipelineError`);
+        this.#commitState(ctx, {
+            error: err,
+            value: ctx.lastSnapshot.value,
+            isLoading: false
+        }, StateEmitTypes.PipelineError);
+    }
+    /**
+     * Finalizes state when a controller abort occurs.
+     *
+     * @param ctx Pipeline behavior context.
+     */
+    finalizeControllerAbort(ctx) {
+        vaultDebug(`${this.key} - finalizeAbort`);
+        this.#commitState(ctx, { isLoading: false }, StateEmitTypes.AbortController);
+    }
+    /**
+     * Finalizes state when a controller deny occurs.
+     *
+     * @param ctx Pipeline behavior context.
+     */
+    finalizeControllerDeny(ctx) {
+        vaultDebug(`${this.key} - finalizeDeny`);
+        this.#commitState(ctx, { isLoading: false }, StateEmitTypes.DenyController);
+    }
+    /**
+     * Emits a terminal destroy state snapshot.
+     *
+     * @param ctx Pipeline behavior context.
+     */
+    destroy(ctx) {
+        vaultWarn(`${this.key} - destroy`);
+        this.#commitState(ctx, { isLoading: false, value: undefined, error: null }, StateEmitTypes.PipelineDestroy);
+    }
+    /**
+     * Emits a terminal reset state snapshot.
+     *
+     * @param ctx Pipeline behavior context.
+     */
+    reset(ctx) {
+        vaultWarn(`${this.key} - reset`);
+        this.#commitState(ctx, { isLoading: false, value: undefined, error: null }, StateEmitTypes.PipelineReset);
+    }
+};
+withCoreStateBehavior = withCoreStateBehavior_1 = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.CoreState,
+        key: defineBehaviorKey('Core', 'State'),
+        critical: true
+    })
+], withCoreStateBehavior);
+
+/**
+ * Abstract base class for tap behaviors in the Vault pipeline.
+ *
+ * This class provides shared execution logic for tap behaviors, which are
+ * permitted to observe pipeline values and perform side effects without
+ * modifying pipeline state. It centralizes validation, logging, and lifecycle
+ * handling common to both pre- and post-reducer tap behaviors.
+ *
+ * @typeParam T - The pipeline state value type observed by the tap.
+ */
+class TapAbstractBehavior {
+    behaviorCtx;
+    /** Static behavior type used for pipeline classification. */
+    static type;
+    /** Static key used to identify the tap behavior. */
+    static key;
+    /** Indicates that tap behaviors participate critically in the pipeline. */
+    static critical = true;
+    /** Instance-level criticality flag. */
+    critical = true;
+    /** Unique identifier for this tap behavior instance. */
+    key;
+    type;
+    /**
+     * Creates a new tap behavior instance.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior class context for dependency injection.
+     */
+    constructor(key, behaviorCtx) {
+        this.behaviorCtx = behaviorCtx;
+        this.key = key;
+    }
+    /**
+     * Executes a tap callback against the current pipeline value.
+     *
+     * The tap callback is invoked for observational or side-effect purposes only.
+     * If the provided callback is not a function, execution is skipped and logged.
+     *
+     * @param current The current pipeline value being observed.
+     * @param tap The tap callback function.
+     */
+    executeTap(current, tap) {
+        vaultDebug(`${this.key} executeTap called with "${safeStringify(current)}".`);
+        if (typeof tap !== 'function') {
+            vaultDebug(`${this.key} executeTap skipped - tap is not a function. Type is "${typeof tap}".`);
+        }
+        tap(current);
+    }
+    /**
+     * Invoked when the behavior instance is destroyed.
+     *
+     * Tap behaviors do not allocate resources or maintain subscriptions, so
+     * destruction performs no cleanup beyond emitting a diagnostic event.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy "noop"`);
+    }
+    /**
+     * Resets the tap behavior.
+     *
+     * Tap behaviors are stateless and require no reset logic. This method exists
+     * solely to participate in the FeatureCell lifecycle and provide diagnostic
+     * visibility.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset "noop"`);
+    }
+}
+
+/**
+ * Core tap behavior executed after reducer completion.
+ *
+ * This behavior allows consumers to observe the finalized pipeline value
+ * after all reducer logic has executed. It delegates tap execution to the
+ * shared tap abstraction and does not modify pipeline state.
+ *
+ * @typeParam T - The pipeline state value type observed by the tap.
+ */
+let withCoreAfterTapBehavior = class withCoreAfterTapBehavior extends TapAbstractBehavior {
+    /** Pipeline behavior type indicating execution occurs after reducers. */
+    type = BehaviorTypes.CoreAfterTap;
+    /**
+     * Executes the provided tap callback after reducer completion.
+     *
+     * The tap is invoked for observational or side-effect purposes only and
+     * does not influence pipeline control flow or state resolution.
+     *
+     * @param current - The finalized pipeline value.
+     * @param tap - The tap callback to invoke.
+     */
+    applyAfterTap(current, tap) {
+        this.executeTap(current, tap);
+    }
+};
+withCoreAfterTapBehavior = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.CoreAfterTap,
+        key: defineBehaviorKey('Core', 'AfterTap'),
+        critical: true
+    })
+], withCoreAfterTapBehavior);
+
+/**
+ * Core tap behavior executed before reducer evaluation.
+ *
+ * This behavior allows consumers to observe or react to the pipeline value
+ * prior to reducer execution. It delegates tap execution to the shared tap
+ * abstraction and does not modify pipeline state or control flow.
+ *
+ * @typeParam T - The pipeline state value type observed by the tap.
+ */
+let withCoreBeforeTapBehavior = class withCoreBeforeTapBehavior extends TapAbstractBehavior {
+    /** Pipeline behavior type indicating execution occurs prior to reducers. */
+    type = BehaviorTypes.CoreBeforeTap;
+    /**
+     * Executes the provided tap callback before reducer evaluation.
+     *
+     * The tap is invoked for observational or side-effect purposes only and
+     * does not influence reducer logic or state resolution.
+     *
+     * @param current - The current pipeline value prior to reduction.
+     * @param tap - The tap callback to invoke.
+     */
+    applyBeforeTap(current, tap) {
+        this.executeTap(current, tap);
+    }
+};
+withCoreBeforeTapBehavior = __decorate([
+    VaultBehavior({
+        type: BehaviorTypes.CoreBeforeTap,
+        key: defineBehaviorKey('Core', 'BeforeTap'),
+        critical: true
+    })
+], withCoreBeforeTapBehavior);
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > lib > factories > feature-cell > feature-cell.ts
+// Updated: 2026-03-02 19:53
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+/**
+ * Creates and registers a Feature Cell using the provided configuration and optional behavior and controller contracts.
+ * This function produces a Feature Cell instance keyed by the descriptor and registers it for later resolution and usage.
+ *
+ * --RelatedStart--
+ * FeatureCellConfig
+ * BehaviorClassContract
+ * ControllerClassContract
+ * FeatureCellShape
+ * --RelatedEnd--
+ *
+ * @param descriptor Configuration descriptor that defines the Feature Cell identity and setup.
+ * @param behaviors Behavior class contracts applied during Feature Cell construction.
+ * @param controllers Controller class contracts applied during Feature Cell construction.
+ * @returns The registered Feature Cell instance.
+ */
+function FeatureCell(descriptor, behaviors = [], controllers = []) {
+    createFeatureCellToken(descriptor.key);
+    registerFeatureCell({
+        key: descriptor.key
+    });
+    return new FeatureCellClass(descriptor, loadDefaultBehaviors(), behaviors, controllers).build();
+}
+function loadDefaultBehaviors() {
+    return [
+        withCoreAfterTapBehavior,
+        withCoreBeforeTapBehavior,
+        withCoreErrorBehavior,
+        withCoreFilterBehavior,
+        withCoreFromObservableBehavior,
+        withCoreFromPromiseBehavior,
+        withCoreFromStreamBehavior,
+        withCoreObservableBehavior,
+        withCorePromiseBehavior,
+        withCoreReducerBehavior,
+        withCoreValueBehavior,
+        withCoreStateBehavior,
+        withCoreErrorCallbackBehavior,
+        withArrayMergeBehavior,
+        withCoreEmitStateBehavior
+    ];
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > lib > factories > vault > vault.ts
+// Updated: 2026-03-02 19:51
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+/**
+ * Initializes the Vault runtime using the provided configuration and prepares the global feature cell registry.
+ * This function establishes the required Vault infrastructure and applies the supplied options for core initialization.
+ *
+ * --RelatedStart--
+ * VaultConfig
+ * --RelatedEnd--
+ *
+ * @param options Configuration options used to initialize the Vault runtime.
+ */
+function Vault(options = {}) {
+    VaultCore(options);
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > core > src > public-api.ts
+// Updated: 2026-03-03 07:37
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { FeatureCell, Vault, __core_extensions_loaded, __fromObservable, __fromPromise_extension, __fromStream_extension, withObjectShallowMergeBehavior };
+//# sourceMappingURL=sdux-vault-core.mjs.map