@sdux-vault/engine 0.0.9

package/fesm2022/sdux-vault-engine.mjs

@@ -0,0 +1,4069 @@
+import { registerVersion, vaultDebug, ControllerVotes, ControllerMessageTypes, OperationTypes, vaultWarn, VaultController, defineControllerKey, ControllerTypes, DevMode, DecisionOutcomeTypes, vaultError, defineBehaviorKey, DEVTOOLS_LOGGING_KEY_CONSTANT, DEVTOOLS_AGGREGATE_KEY_CONSTANT, createVaultError, EventTypes, EventBoundaryTypes, setVaultLogLevel, isTestEnv, BEHAVIOR_META, validateBehaviorKey, BehaviorTypes, VAULT_STOP, isVaultNoop, VaultPrivateErrorService, isHttpResourceRef, isFunction, isStateInputShape, isVaultClearState, VAULT_CLEAR_STATE, VAULT_NOOP, VAULT_CONTINUE, isVaultContinue, isolateValue, isUndefined, isDefined, isNullish, ResolveTypes, isPromise, VaultUsagePromiseError, CONTROLLER_META, validateControllerKey, VaultLicenseError } from '@sdux-vault/shared';
+import { of, map, catchError, forkJoin, Subject, ReplaySubject, isObservable, firstValueFrom, tap } from 'rxjs';
+import { __decorate } from 'tslib';
+import { filter } from 'rxjs/operators';
+import { EventBus } from '@sdux-vault/devtools';
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > utils > version > version.register.ts
+// Updated: 2026-03-03 08:09
+//	 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/engine';
+const SDUX_VERSION = '0.0.9';
+registerVersion(SDUX_PACKAGE, SDUX_VERSION);
+
+/**
+ * Canonical identifier used to label the Conductor execution context.
+ */
+const VAULT_CONDUCTOR = 'vault-conductor';
+
+var withCoreAbstainController_1;
+/**
+ * Core abstain controller responsible for participating in controller vote resolution.
+ * This controller observes incoming controller messages and emits a neutral vote without modifying pipeline flow.
+ *
+ * --RelatedStart--
+ * ControllerMessageShape
+ * ControllerVote
+ * ControllerVotes
+ * --RelatedEnd--
+ */
+let withCoreAbstainController = class withCoreAbstainController {
+    static { withCoreAbstainController_1 = this; }
+    controllerCtx;
+    /**
+     * Static controller type identifier used by the orchestrator.
+     */
+    static type;
+    /**
+     * Static controller key assigned by the decorator.
+     */
+    static key;
+    /**
+     * Indicates whether this controller is critical.
+     */
+    static critical;
+    /**
+     * Controller type identifier used for pipeline classification.
+     */
+    type = withCoreAbstainController_1.type;
+    /**
+     * Indicates whether this controller instance is critical.
+     */
+    critical = withCoreAbstainController_1.critical;
+    /**
+     * Unique controller key identifying this instance.
+     */
+    key;
+    #isInitialized = false;
+    #initializationFailed = false;
+    /**
+     * Creates a new core conductor controller instance.
+     *
+     * @param key Unique controller identifier supplied by the factory.
+     * @param controllerCtx Controller context supplying execution metadata.
+     */
+    constructor(key, controllerCtx) {
+        this.controllerCtx = controllerCtx;
+        this.key = key;
+    }
+    /**
+     * Handles an incoming controller message and emits a controller vote.
+     *
+     * @param msg Controller message supplied by the orchestrator.
+     * @returns Observable emitting a controller vote or no value.
+     */
+    handleMessage(msg) {
+        vaultDebug(`${this.key} handleMessage received "${msg.type}" for trace "${msg.traceId}".`);
+        switch (msg.type) {
+            case ControllerMessageTypes.Attempt: {
+                const { ctx } = msg;
+                if (this.#initializationFailed) {
+                    return of(ControllerVotes.Abort);
+                }
+                if (ctx.operation === OperationTypes.Initialize) {
+                    return of(ControllerVotes.Abstain);
+                }
+                return of(this.#isInitialized ? ControllerVotes.Abstain : ControllerVotes.Deny);
+            }
+            case ControllerMessageTypes.Finalize: {
+                this.#isInitialized = true;
+                return of();
+            }
+            case ControllerMessageTypes.Success: {
+                this.#isInitialized = true;
+                return of();
+            }
+            case ControllerMessageTypes.Failure: {
+                if (msg.ctx.operation === OperationTypes.Initialize) {
+                    this.#initializationFailed = true;
+                }
+                return of();
+            }
+            default: {
+                return of(ControllerVotes.Abstain);
+            }
+        }
+    }
+    /**
+     * Lifecycle hook invoked when the controller instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy noop`);
+    }
+    /**
+     * Lifecycle hook invoked when the controller instance is reset.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset noop`);
+    }
+};
+withCoreAbstainController = withCoreAbstainController_1 = __decorate([
+    VaultController({
+        type: ControllerTypes.CoreAbstain,
+        key: defineControllerKey('Policy', 'CoreAbstain'),
+        critical: false
+    })
+], withCoreAbstainController);
+
+var withCoreErrorController_1;
+let withCoreErrorController = class withCoreErrorController {
+    static { withCoreErrorController_1 = this; }
+    controllerCtx;
+    /**
+     * Static controller type identifier used by the orchestrator.
+     */
+    static type;
+    /**
+     * Static controller key assigned by the decorator.
+     */
+    static key;
+    /**
+     * Indicates whether this controller is critical.
+     */
+    static critical;
+    /**
+     * Controller type identifier used for pipeline classification.
+     */
+    type = withCoreErrorController_1.type;
+    /**
+     * Indicates whether this controller instance is critical.
+     */
+    critical = withCoreErrorController_1.critical;
+    /**
+     * Unique controller key identifying this instance.
+     */
+    key;
+    ctx;
+    /**
+     * Creates a new core conductor controller instance.
+     *
+     * @param key Unique controller identifier supplied by the factory.
+     * @param controllerCtx Controller context supplying execution metadata.
+     */
+    constructor(key, controllerCtx) {
+        this.controllerCtx = controllerCtx;
+        this.key = key;
+        this.ctx = controllerCtx;
+    }
+    /**
+     * Handles an incoming controller message and emits a controller vote.
+     *
+     * @param msg Controller message supplied by the orchestrator.
+     * @returns Observable emitting a controller vote or no value.
+     */
+    handleMessage(msg) {
+        vaultDebug(`${this.key} handleMessage received "${msg.type}" for trace "${msg.traceId}".`);
+        switch (msg.type) {
+            case ControllerMessageTypes.Failure: {
+                vaultDebug(`${this.key} ABORT — default failure handler for trace "${msg.traceId}"`);
+                this.ctx.requestAbort(msg.traceId);
+                return of();
+            }
+            default: {
+                return of(ControllerVotes.Abstain);
+            }
+        }
+    }
+    /**
+     * Lifecycle hook invoked when the controller instance is destroyed.
+     */
+    destroy() {
+        vaultWarn(`${this.key} - destroy noop`);
+    }
+    /**
+     * Lifecycle hook invoked when the controller instance is reset.
+     */
+    reset() {
+        vaultWarn(`${this.key} - reset noop`);
+    }
+};
+withCoreErrorController = withCoreErrorController_1 = __decorate([
+    VaultController({
+        type: ControllerTypes.Error,
+        key: defineControllerKey('Policy', 'CoreError'),
+        critical: false
+    })
+], withCoreErrorController);
+
+const LicenseEventTypes = {
+    RequireLicense: 'requireLicense',
+    ValidateLicense: 'validateLicense',
+    LicenseStatus: 'licenseStatus',
+    DescribeFeature: 'describe-feature',
+    DescribeBehaviors: 'describe-behaviors',
+    DescribeControllers: 'describe-controllers'
+};
+
+//eslint-disable-next-line
+let singleton = null;
+function InitializeLicensingService(events$, validation$) {
+    if (singleton)
+        return;
+    singleton = new LicensingServiceInstance(events$, validation$);
+}
+function LicensingService() {
+    if (!singleton) {
+        throw new Error('[vault] LicensingService not initialized.');
+    }
+    return singleton;
+}
+class LicensingServiceInstance {
+    events$;
+    validation$;
+    constructor(events$, validation$) {
+        this.events$ = events$;
+        this.validation$ = validation$;
+    }
+    describeFeature(event) {
+        event.type = LicenseEventTypes.DescribeFeature;
+        this.events$.next(event);
+    }
+    describeBehaviors(event) {
+        event.type = LicenseEventTypes.DescribeBehaviors;
+        this.events$.next(event);
+    }
+    describeControllers(event) {
+        event.type = LicenseEventTypes.DescribeControllers;
+        this.events$.next(event);
+    }
+    requestLicense(featureCellKey, key) {
+        if (!key) {
+            throw new Error('[vault] Cannot register controller license without a key.');
+        }
+        const licenseToken = this.#generateLicenseToken();
+        this.events$.next({
+            featureCellKey,
+            key,
+            licenseToken,
+            type: LicenseEventTypes.RequireLicense
+        });
+        return licenseToken;
+    }
+    validateLicense(featureCellKey, key, licenseToken, valid) {
+        this.events$.next({
+            featureCellKey,
+            key,
+            licenseToken,
+            type: LicenseEventTypes.ValidateLicense,
+            valid
+        });
+    }
+    #generateLicenseToken() {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        const randomPart = (length) => Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+        return `${randomPart(5)}-${randomPart(5)}`;
+    }
+    getLicenseValidation$() {
+        return this.validation$;
+    }
+}
+const resetLicensingServiceForTests = () => {
+    if (!DevMode.active)
+        return;
+    singleton = null;
+};
+
+var withCoreLicenseController_1;
+let withCoreLicenseController = class withCoreLicenseController {
+    static { withCoreLicenseController_1 = this; }
+    controllerCtx;
+    static type;
+    static key;
+    static critical;
+    type = withCoreLicenseController_1.type;
+    critical = withCoreLicenseController_1.critical;
+    key;
+    #licenseApproved = null;
+    #sub;
+    constructor(key, controllerCtx) {
+        this.controllerCtx = controllerCtx;
+        this.key = key;
+        const featureCellKey = controllerCtx.featureCellKey;
+        this.#sub = LicensingService()
+            .getLicenseValidation$()
+            .pipe(filter((licenseEvent) => licenseEvent.featureCellKey === featureCellKey))
+            .subscribe((event) => {
+            this.#licenseApproved = event.approved;
+            this.#sub?.unsubscribe();
+            const traceId = `${featureCellKey}::license`;
+            if (event.approved) {
+                controllerCtx?.licenseApproved?.(traceId);
+            }
+            else {
+                controllerCtx?.licenseDenied?.(traceId);
+            }
+        });
+    }
+    handleMessage(msg) {
+        vaultDebug(`${this.key} received "${msg.type}" for trace "${msg.traceId}".`);
+        switch (msg.type) {
+            case ControllerMessageTypes.Attempt: {
+                if (this.#licenseApproved) {
+                    return of(ControllerVotes.Abstain);
+                }
+                else if (this.#licenseApproved === null) {
+                    return of(ControllerVotes.Deny);
+                }
+                // abort
+                return of(ControllerVotes.Abort);
+            }
+            default:
+                return of();
+        }
+    }
+    destroy() {
+        this.#sub?.unsubscribe();
+        vaultWarn(`${this.key} - destroy unsubscribe`);
+    }
+    reset() {
+        vaultWarn(`${this.key} - reset noop`);
+    }
+};
+withCoreLicenseController = withCoreLicenseController_1 = __decorate([
+    VaultController({
+        type: ControllerTypes.License,
+        key: defineControllerKey('Policy', 'CoreLicense'),
+        critical: true
+    })
+], withCoreLicenseController);
+
+/**
+ * Pure decision engine responsible for aggregating controller votes.
+ *
+ * This class evaluates controller responses deterministically by normalizing
+ * votes, applying priority rules, and producing a single decision outcome
+ * without maintaining internal state or execution history.
+ */
+class Arbitrator {
+    /**
+     * Evaluates an ATTEMPT message across all provided controllers.
+     *
+     * Each controller vote is normalized and aggregated using deterministic
+     * priority rules to produce exactly one decision outcome.
+     *
+     * @param controllers - The set of controllers participating in arbitration.
+     * @param msg - The ATTEMPT message being evaluated.
+     * @returns An observable emitting a single controller decision.
+     */
+    evaluateAttempt(controllers, msg) {
+        // No controllers → treat as unanimous abstain → arbitrate
+        if (controllers.length === 0) {
+            return of(this.arbitrate(msg.traceId, [ControllerVotes.Abstain]));
+        }
+        try {
+            const votes$ = controllers.map((controller) => controller.handleMessage(msg).pipe(map((v) => v ?? ControllerVotes.Abstain), catchError((err) => {
+                vaultWarn('[vault:arbitrator] controller threw during attempt:', err);
+                return of(ControllerVotes.Deny);
+            })));
+            return forkJoin(votes$).pipe(map((votes) => this.arbitrate(msg.traceId, votes)));
+        }
+        catch {
+            return of(this.arbitrate(msg.traceId, [ControllerVotes.Deny]));
+        }
+    }
+    /**
+     * Notifies controllers of non-attempt lifecycle messages.
+     *
+     * These messages are forwarded to controllers for observation only and
+     * do not participate in arbitration or decision-making.
+     *
+     * @param controllers - The controllers to notify.
+     * @param msg - The lifecycle message being dispatched.
+     * @returns An observable that completes when all notifications finish.
+     */
+    notify(controllers, msg) {
+        if (controllers.length === 0) {
+            return of(void 0);
+        }
+        try {
+            const streams$ = controllers.map((controller) => controller.handleMessage(msg).pipe(map(() => void 0), catchError((err) => {
+                vaultWarn('[vault:arbitrator] controller threw during notify:', err);
+                return of(void 0);
+            })));
+            return forkJoin(streams$).pipe(map(() => void 0));
+        }
+        catch {
+            return of(void 0);
+        }
+    }
+    /**
+     * Applies priority rules to a set of controller votes.
+     *
+     * Votes are evaluated in descending priority order to determine the
+     * final controller decision for a given trace.
+     *
+     * @param traceId - The trace identifier associated with the decision.
+     * @param votes - The normalized controller votes.
+     * @returns The resolved controller decision.
+     */
+    arbitrate(traceId, votes) {
+        const hasAbort = votes.includes(ControllerVotes.Abort);
+        if (hasAbort) {
+            return { traceId, outcome: DecisionOutcomeTypes.Abort };
+        }
+        const hasDeny = votes.includes(ControllerVotes.Deny);
+        if (hasDeny) {
+            return { traceId, outcome: DecisionOutcomeTypes.Deny };
+        }
+        const allAbstain = votes.every((v) => v === ControllerVotes.Abstain);
+        if (allAbstain) {
+            return { traceId, outcome: DecisionOutcomeTypes.Abstain };
+        }
+        vaultError(`Unknown controller vote detected`, { traceId, votes });
+        return { traceId, outcome: DecisionOutcomeTypes.Deny };
+    }
+}
+
+// --- AI Model File Path ---
+// projects > engine > src > lib > types > monitor > vault-monitor-event-category.type.ts
+const VaultMonitorEventCategoryType = {
+    Boundary: 'boundary',
+    State: 'state',
+    Error: 'error'
+};
+
+// --- AI Model File Path ---
+// projects > engine > src > lib > types > monitor > vault-monitor-field-rule.type.ts
+const FieldRuleTypes = {
+    Never: 'never',
+    Optional: 'optional',
+    Required: 'required'
+};
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > monitor > event-policy > vault-monitor-category-field-policy.constant.ts
+// Updated: 2026-03-06 16:29
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const CATEGORY_FIELD_POLICY_CONSTANT = {
+    [VaultMonitorEventCategoryType.Boundary]: {
+        state: FieldRuleTypes.Never,
+        payload: FieldRuleTypes.Optional,
+        error: FieldRuleTypes.Never
+    },
+    [VaultMonitorEventCategoryType.State]: {
+        state: FieldRuleTypes.Required,
+        payload: FieldRuleTypes.Optional,
+        error: FieldRuleTypes.Never
+    },
+    [VaultMonitorEventCategoryType.Error]: {
+        state: FieldRuleTypes.Required,
+        payload: FieldRuleTypes.Optional,
+        error: FieldRuleTypes.Required
+    }
+};
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > monitor > event-policy > vault-monitor-event-policy.constant.ts
+// Updated: 2026-03-06 16:30
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const EVENT_POLICY_CONSTANT = {
+    // ─────────────────────────────────────────────
+    // STATE
+    // ─────────────────────────────────────────────
+    'stage:end:core-state': { category: VaultMonitorEventCategoryType.State },
+    'stage:end:core-emit-state': { category: VaultMonitorEventCategoryType.State },
+    'lifecycle:end:merge': { category: VaultMonitorEventCategoryType.State },
+    'lifecycle:end:replace': { category: VaultMonitorEventCategoryType.State },
+    'stage:end:compute-merge': { category: VaultMonitorEventCategoryType.State },
+    'stage:end:reducer': { category: VaultMonitorEventCategoryType.State },
+    'stage:end:resolve': { category: VaultMonitorEventCategoryType.State },
+    // ─────────────────────────────────────────────
+    // ERROR
+    // ─────────────────────────────────────────────
+    'lifecycle:notification:failure': { category: VaultMonitorEventCategoryType.Error },
+    'lifecycle:notification:runtime-error': { category: VaultMonitorEventCategoryType.Error },
+    'lifecycle:notification:warn': { category: VaultMonitorEventCategoryType.Error },
+    'lifecycle:notification:fatal': { category: VaultMonitorEventCategoryType.Error },
+    // ─────────────────────────────────────────────
+    // BOUNDARY
+    // ─────────────────────────────────────────────
+    'conductor:start:abort': { category: VaultMonitorEventCategoryType.Boundary },
+    'conductor:start:deny': { category: VaultMonitorEventCategoryType.Boundary },
+    'conductor:start:revote': { category: VaultMonitorEventCategoryType.Boundary },
+    'controller:end:vote': { category: VaultMonitorEventCategoryType.Boundary },
+    // Conductor
+    'conductor:start:license-approved': { category: VaultMonitorEventCategoryType.Boundary },
+    'conductor:start:license-attempt': { category: VaultMonitorEventCategoryType.Boundary },
+    // Controller
+    'controller:end:attempt': { category: VaultMonitorEventCategoryType.Boundary },
+    'controller:notification:finalize': { category: VaultMonitorEventCategoryType.Boundary },
+    'controller:notification:success': { category: VaultMonitorEventCategoryType.Boundary },
+    'controller:restart:restart-controller-attempt': {
+        category: VaultMonitorEventCategoryType.Boundary
+    },
+    'controller:start:attempt': { category: VaultMonitorEventCategoryType.Boundary },
+    'controller:start:vote': { category: VaultMonitorEventCategoryType.Boundary },
+    // Lifecycle (end)
+    'lifecycle:end:initialized': { category: VaultMonitorEventCategoryType.Boundary },
+    // Lifecycle (start)
+    'lifecycle:start:core-callback-error': {
+        category: VaultMonitorEventCategoryType.Boundary
+    },
+    'lifecycle:start:core-error': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:start:core-state': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:start:global-error': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:start:initialized': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:start:merge': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:start:replace': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:start:error-transform': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:end:error-transform': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:end:core-callback-error': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:end:core-error': { category: VaultMonitorEventCategoryType.Boundary },
+    'lifecycle:end:global-error': { category: VaultMonitorEventCategoryType.Boundary },
+    // Stage (end)
+    'stage:end:after-tap': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:end:before-tap': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:end:encrypt': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:end:filter': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:end:load-persist': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:end:operator': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:end:persist': { category: VaultMonitorEventCategoryType.Boundary },
+    // Stage (start)
+    'stage:start:after-tap': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:before-tap': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:compute-merge': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:encrypt': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:filter': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:load-persist': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:operator': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:persist': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:reducer': { category: VaultMonitorEventCategoryType.Boundary },
+    'stage:start:resolve': { category: VaultMonitorEventCategoryType.Boundary }
+};
+
+/**
+ * Holds the singleton VaultMonitorSharedState instance.
+ */
+let instance$2 = null;
+/**
+ * Returns the global VaultMonitorSharedState singleton instance.
+ * This function ensures a single shared state instance is created and reused across the runtime.
+ *
+ * --RelatedStart--
+ * VaultMonitorSharedStateInstance
+ * --RelatedEnd--
+ *
+ * @returns The global VaultMonitorSharedState instance.
+ */
+function VaultMonitorSharedState() {
+    if (!instance$2) {
+        instance$2 = new VaultMonitorSharedStateInstance();
+    }
+    return instance$2;
+}
+class VaultMonitorSharedStateInstance {
+    /**
+     * Optional global insight definition that overrides per-cell insight
+     * configuration for all monitor instances. When set, all monitors use
+     * this definition when determining which event fields to emit.
+     */
+    globalInsightOverride = null;
+    /**
+     * Registry of FeatureCell insight configurations keyed by cell ID.
+     *
+     * Each entry indicates whether insight is enabled and contains the
+     * resolved list of {@link InsightConfig} values associated with
+     * that FeatureCell.
+     */
+    cellRegistry = new Map();
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > monitor > vault-monitor.helper.ts
+// Updated: 2026-03-06 16:27
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+/**
+ * Abstract helper base class used by both `VaultMonitor` and
+ * `VaultQueueMonitor`.
+ *
+ * This class centralizes access to shared monitor state and DevMode
+ * utilities. All mutable state is delegated to `VaultMonitorSharedState`,
+ * ensuring that every monitor instance operates on the same global registry
+ * and global insight override.
+ *
+ * No pipeline behavior is implemented directly here; this class provides
+ * shared accessors, helpers, and common metadata required by monitor
+ * implementations.
+ */
+class VaultMonitorHelper {
+    /**
+     * Shared global monitor state. All cell registry information and
+     * global insight overrides are pulled from this injected source.
+     */
+    shared = VaultMonitorSharedState();
+    /**
+     * Behavior key used for DevTools/Telemetry classification in
+     * Vault diagnostics. Identifies monitor-related behavior for
+     * analytics, devtools, and inspector utilities.
+     */
+    key = defineBehaviorKey('DevTools', 'Telemetry');
+    /**
+     * Retrieves the globally-applied insight override, if any.
+     *
+     * @returns The active global `InsightDefinition`, or `null` if
+     *          no override is applied.
+     */
+    get globalInsightOverride() {
+        return this.shared.globalInsightOverride;
+    }
+    /**
+     * Applies a global insight override. This value is shared across all
+     * monitors, allowing system-wide inspection behavior injection.
+     *
+     * @param def - The insight metadata to set as the global override.
+     */
+    set globalInsightOverride(def) {
+        this.shared.globalInsightOverride = def;
+    }
+    /**
+     * Provides access to the shared FeatureCell registry. This registry
+     * tracks monitor metadata about every registered cell, including
+     * whether it provides insights and the definitions associated with it.
+     *
+     * @returns The shared cell registry map.
+     */
+    get cellRegistry() {
+        return this.shared.cellRegistry;
+    }
+    /**
+     * Registers a FeatureCell into the shared monitor registry.
+     * Each entry stores insight awareness and any provided definitions.
+     *
+     * @param cellKey - The unique FeatureCell identifier.
+     * @param insight - Optional `InsightDefinition` describing cell-level
+     *                  insight capabilities.
+     */
+    registerCell(cellKey, insight) {
+        const hasInsight = !!insight;
+        this.cellRegistry.set(cellKey, {
+            hasInsight,
+            insights: hasInsight ? [insight] : []
+        });
+    }
+    /**
+     * Applies a global insight override shared across all monitors.
+     * When set, this overrides cell-specific insight metadata for
+     * system-wide inspection behavior.
+     *
+     * @param definition - The global insight definition to activate.
+     */
+    activateGlobalInsights(definition) {
+        this.globalInsightOverride = definition;
+    }
+    isChromeDevTools(cell) {
+        return cell === DEVTOOLS_LOGGING_KEY_CONSTANT || cell === DEVTOOLS_AGGREGATE_KEY_CONSTANT;
+    }
+    applyPolicy(event, insight) {
+        const category = EVENT_POLICY_CONSTANT[event.name]?.category ?? VaultMonitorEventCategoryType.Boundary;
+        const policy = CATEGORY_FIELD_POLICY_CONSTANT[category];
+        const allowState = !!insight?.wantsState;
+        const allowPayload = !!insight?.wantsPayload;
+        const allowErrors = !!insight?.wantsErrors;
+        if (!event.source) {
+            delete event.source;
+        }
+        // STATE
+        if (!allowState || policy.state === FieldRuleTypes.Never) {
+            delete event.state;
+        }
+        // PAYLOAD
+        if (!allowPayload ||
+            policy.payload === FieldRuleTypes.Never ||
+            (policy.payload === FieldRuleTypes.Optional && event.payload === undefined)) {
+            delete event.payload;
+        }
+        // ERROR
+        if (!allowErrors || policy.error === FieldRuleTypes.Never) {
+            delete event.error;
+        }
+        else if (policy.error === FieldRuleTypes.Required) {
+            // Optional payload allowed on Error category
+            if (!allowPayload || event.payload === undefined) {
+                delete event.payload;
+            }
+        }
+        return event;
+    }
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > monitor > vault-monitor.service.ts
+// Updated: 2026-03-03 09:10
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+/**
+ * Holds the singleton VaultMonitor instance.
+ */
+let instance$1 = null;
+/**
+ * Returns the global VaultMonitor singleton instance.
+ * This function ensures a single monitor instance is created and reused across the runtime.
+ *
+ * --RelatedStart--
+ * VaultMonitorContract
+ * --RelatedEnd--
+ *
+ * @returns The global VaultMonitor instance.
+ */
+function VaultMonitor() {
+    if (!instance$1) {
+        instance$1 = new VaultMonitorInstance();
+    }
+    return instance$1;
+}
+/**
+ * Implements the VaultMonitorContract using shared helper functionality.
+ * This class provides the concrete singleton implementation backing the VaultMonitor entry point.
+ *
+ * --RelatedStart--
+ * VaultMonitorContract
+ * --RelatedEnd--
+ */
+class VaultMonitorInstance extends VaultMonitorHelper {
+    /**
+     * Event bus used to emit structured pipeline events to DevTools.
+     * This bus is consumed by the ngSDuX Chrome extension and internal
+     * development utilities.
+     */
+    #eventBus = EventBus();
+    /**
+     * Creates a new VaultMonitor instance and exposes it globally for
+     * DevTools integration. The monitor is attached to `window.sdux`
+     * so that browser extensions can observe all emitted events.
+     */
+    constructor() {
+        super();
+        // This is for the chrome plugin
+        window.sdux ??= {};
+        window.sdux.vaultMonitorInstance = this;
+    }
+    /**
+     * Maps a BehaviorContext into a StateSnapshot suitable for DevTools.
+     * This ensures each pipeline event includes a normalized representation
+     * of loading, value, error, and hasValue.
+     *
+     * @typeParam T - State value type.
+     * @param ctx - Immutable behavior context provided by the orchestrator.
+     * @returns A standardized StateSnapshot.
+     */
+    #toSnapshot(ctx) {
+        // const src: any = ctx.incoming ?? ctx.state ?? {};
+        const src = ctx?.snapshot ?? ctx?.state ?? {};
+        return {
+            isLoading: src.isLoading ?? false,
+            value: src.value ?? undefined,
+            error: src.error ?? null,
+            hasValue: src.hasValue ?? !!src.value
+        };
+    }
+    /** Emits a startAfterTap event. */
+    startAfterTap(cell, behaviorKey, ctx) {
+        const name = 'after-tap';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endAfterTap event with optional payload. */
+    endAfterTap(cell, behaviorKey, ctx, payload) {
+        const name = 'after-tap';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startBeforeTap event. */
+    startBeforeTap(cell, behaviorKey, ctx) {
+        const name = 'before-tap';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endBeforeTap event with optional payload. */
+    endBeforeTap(cell, behaviorKey, ctx, payload) {
+        const name = 'before-tap';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startClearPersist event. */
+    startClearPersist(cell, behaviorKey, ctx) {
+        const name = 'clear-persist';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endClearPersist event. */
+    endClearPersist(cell, behaviorKey, ctx) {
+        const name = 'clear-persist';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startComputeMerge event. */
+    startComputeMerge(cell, behaviorKey, ctx) {
+        const name = 'compute-merge';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endComputeMerge event. */
+    endComputeMerge(cell, behaviorKey, ctx) {
+        const name = 'compute-merge';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a notifyConductorDeny event. */
+    notifyConductorDeny(cell, behaviorKey, ctx) {
+        const name = 'deny';
+        this.#emitEventV2ConductorNotification({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a conductorCrashed event. */
+    conductorCrashed(cell, behaviorKey, ctx, error) {
+        const errorMessage = createVaultError(error, cell);
+        const name = 'fatal';
+        vaultError(cell, behaviorKey, errorMessage);
+        this.#emitEventV2LifecycleNotification({
+            cell,
+            behaviorKey,
+            name,
+            ctx,
+            payload: {
+                message: 'This has proven to be untested code in unit tests. So you win some type of prize. Please create a github issues and share your amazing gift to bring down a systm.'
+            },
+            error: errorMessage
+        });
+    }
+    /** Emits a conductorRevote event. */
+    conductorRevote(cell, behaviorKey, ctx) {
+        const name = 'revote';
+        this.#emitEventV2LifecycleNotification({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a conductorAbort event. */
+    conductorAbort(cell, behaviorKey, ctx) {
+        const name = 'abort';
+        this.#emitEventV2LifecycleNotification({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a conductorAttempt event. */
+    conductorLicenseAttempt(cell, featureCellKey) {
+        const name = 'license-attempt';
+        this.#emitEventV2LifecycleNotification({ cell, behaviorKey: featureCellKey, name, ctx: {} });
+    }
+    /** Emits a conductorApproved event. */
+    conductorLicenseApproved(cell, featureCellKey) {
+        const name = 'license-approved';
+        this.#emitEventV2LifecycleNotification({ cell, behaviorKey: featureCellKey, name, ctx: {} });
+    }
+    /** Emits a conductorDenied event. */
+    conductorLicenseDenied(cell, featureCellKey) {
+        const name = 'license-denied';
+        this.#emitEventV2LifecycleNotification({ cell, behaviorKey: featureCellKey, name, ctx: {} });
+    }
+    /** Emits a startControllerAttempt event. */
+    startControllerAttempt(cell, behaviorKey, ctx) {
+        const name = 'attempt';
+        this.#emitEventV2ControllerStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a endControllerAttempt event. */
+    endControllerAttempt(cell, behaviorKey, ctx, payload) {
+        const name = 'attempt';
+        this.#emitEventV2ControllerEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a restartControllerAttempt event. */
+    restartControllerAttempt(cell, behaviorKey, ctx, payload) {
+        const name = 'restart-attempt';
+        this.#emitEventV2ControllerNotification({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a controllerFailure event. */
+    controllerFailure(behaviorKey, ctx, error) {
+        const errorMessage = createVaultError(error, behaviorKey);
+        const name = 'failure';
+        this.#emitEventV2LifecycleNotification({ cell: ctx.featureCellKey, behaviorKey, name, ctx, error: errorMessage });
+    }
+    /** Emits a controllerFinalize event. */
+    controllerFinalize(behaviorKey, ctx) {
+        const name = 'finalize';
+        this.#emitEventV2LifecycleNotification({ cell: ctx.featureCellKey, behaviorKey, name, ctx });
+    }
+    /** Emits a controllerSuccess event. */
+    controllerSuccess(behaviorKey, ctx) {
+        const name = 'success';
+        this.#emitEventV2LifecycleNotification({ cell: ctx.featureCellKey, behaviorKey, name, ctx });
+    }
+    /** Emits a startControllerVote event. */
+    startControllerVote(cell, behaviorKey, ctx) {
+        const name = 'vote';
+        this.#emitEventV2ControllerStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a endControllerVote event. */
+    endControllerVote(cell, behaviorKey, ctx, payload) {
+        const name = 'vote';
+        this.#emitEventV2ControllerEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startCallbackError event. */
+    startCoreCallbackError(cell, behaviorKey, ctx) {
+        const name = 'core-callback-error';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endCoreCallbackError event. */
+    endCoreCallbackError(cell, behaviorKey, ctx) {
+        const name = 'core-callback-error';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startStatEmit event. */
+    startCoreEmitState(cell, behaviorKey, ctx) {
+        const name = 'core-emit-state';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endCoreEmitState event. */
+    endCoreEmitState(cell, behaviorKey, ctx) {
+        const name = 'core-emit-state';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startError event. */
+    startCoreError(cell, behaviorKey, ctx) {
+        const name = 'core-error';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endCoreError event. */
+    endCoreError(cell, behaviorKey, ctx) {
+        const name = 'core-error';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startState event. */
+    startCoreState(cell, behaviorKey, ctx) {
+        const name = 'core-state';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endCoreState event. */
+    endCoreState(cell, behaviorKey, ctx) {
+        const name = 'core-state';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startDecrypt event. */
+    startDecrypt(cell, behaviorKey, ctx) {
+        const name = 'decrypt';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endDecrypt event with optional payload. */
+    endDecrypt(cell, behaviorKey, ctx, payload) {
+        const name = 'decrypt';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startDestroy event. */
+    startDestroy(cell, behaviorKey, ctx) {
+        const name = 'destroy';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endDestroy event. */
+    endDestroy(cell, behaviorKey, ctx, payload) {
+        const name = 'destroy';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startEncrypt event. */
+    startEncrypt(cell, behaviorKey, ctx) {
+        const name = 'encrypt';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endEncrypt event. */
+    endEncrypt(cell, behaviorKey, ctx) {
+        const name = 'encrypt';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /**
+     * Emits an error event. Errors are logged and sent to DevTools
+     * depending on configured insight preferences.
+     *
+     * @param error - Raw error thrown by pipeline stage.
+     */
+    runtimeError(cell, behaviorKey, ctx, error) {
+        const errorMessage = createVaultError(error, cell);
+        vaultError(cell, behaviorKey, errorMessage);
+        const name = 'runtime-error';
+        this.#emitEventV2LifecycleNotification({ cell, behaviorKey, name, ctx, error: errorMessage });
+    }
+    /** Emits a startError event. */
+    startErrorTransform(cell, behaviorKey, ctx) {
+        const name = 'error-transform';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endError event. */
+    endErrorTransform(cell, behaviorKey, ctx, payload) {
+        const name = 'error-transform';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startFilter event. */
+    startFilter(cell, behaviorKey, ctx) {
+        const name = 'filter';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endFilter event. */
+    endFilter(cell, behaviorKey, ctx) {
+        const name = 'filter';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startGlobalError event. */
+    startGlobalError(cell, behaviorKey, ctx) {
+        const name = 'global-error';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endGlobalError event. */
+    endGlobalError(cell, behaviorKey, ctx) {
+        const name = 'global-error';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a ingressSubscribed event. */
+    ingressSubscribed(cell, behaviorKey, ctx, source) {
+        const name = 'ingress-subscribed';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx, source });
+    }
+    /** Emits an ingressCompleted event. */
+    ingressCompleted(cell, behaviorKey, ctx, source) {
+        const name = 'ingress-completed';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx, source });
+    }
+    /** Emits a startInitialized event. */
+    startInitialized(cell, behaviorKey, ctx) {
+        const name = 'initialized';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endInitialized event. */
+    endInitialized(cell, behaviorKey, ctx) {
+        const name = 'initialized';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startInterceptor event. */
+    startInterceptor(cell, behaviorKey, ctx) {
+        const name = 'interceptor';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endInterceptor event with optional payload. */
+    endInterceptor(cell, behaviorKey, ctx, payload) {
+        const name = 'interceptor';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startLoadPersist event. */
+    startLoadPersist(cell, behaviorKey, ctx) {
+        const name = 'load-persist';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endLoadPersist event with optional payload. */
+    endLoadPersist(cell, behaviorKey, ctx, payload) {
+        const name = 'load-persist';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startMerge event for DevTools inspection. */
+    startMerge(cell, behaviorKey, ctx) {
+        const name = 'merge';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endMerge event with an optional payload. */
+    endMerge(cell, behaviorKey, ctx, payload) {
+        const name = 'merge';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startOperator event. */
+    startOperator(cell, behaviorKey, ctx) {
+        this.#emitEventV2StageStart({
+            cell,
+            behaviorKey,
+            name: 'operator',
+            ctx
+        });
+    }
+    /** Emits an endOperator event with optional payload. */
+    endOperator(cell, behaviorKey, ctx, payload) {
+        this.#emitEventV2StageEnd({
+            cell,
+            behaviorKey,
+            name: 'operator',
+            ctx,
+            payload
+        });
+    }
+    /** Emits a startPersist event. */
+    startPersist(cell, behaviorKey, ctx) {
+        const name = 'persist';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endPersist event. */
+    endPersist(cell, behaviorKey, ctx) {
+        const name = 'persist';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startReducer event. */
+    startReducer(cell, behaviorKey, ctx) {
+        this.#emitEventV2StageStart({
+            cell,
+            behaviorKey,
+            name: 'reducer',
+            ctx
+        });
+    }
+    /** Emits an endReducer event. */
+    endReducer(cell, behaviorKey, ctx) {
+        this.#emitEventV2StageEnd({
+            cell,
+            behaviorKey,
+            name: 'reducer',
+            ctx
+        });
+    }
+    /** Emits a startReplace event for DevTools inspection. */
+    startReplace(cell, behaviorKey, ctx) {
+        const name = 'replace';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endReplace event with an optional payload. */
+    endReplace(cell, behaviorKey, ctx, payload) {
+        const name = 'replace';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startReset event. */
+    startReset(cell, behaviorKey, ctx) {
+        const name = 'reset';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endReset event. */
+    endReset(cell, behaviorKey, ctx, payload) {
+        const name = 'reset';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx, payload });
+    }
+    /** Emits a startResolve event. */
+    startResolve(cell, behaviorKey, ctx) {
+        const name = 'resolve';
+        this.#emitEventV2StageStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endResolve event. */
+    endResolve(cell, behaviorKey, ctx) {
+        const name = 'resolve';
+        this.#emitEventV2StageEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startSetInitialValue event. */
+    startSetInitialValue(cell, behaviorKey, ctx) {
+        const name = 'set-initial-value';
+        this.#emitEventV2LifecycleStart({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits an endSetInitialValue event. */
+    endSetInitialValue(cell, behaviorKey, ctx) {
+        const name = 'set-initial-value';
+        this.#emitEventV2LifecycleEnd({ cell, behaviorKey, name, ctx });
+    }
+    /** Emits a startStepwise event. */
+    startStepwise(cell, behaviorKey, ctx) {
+        const name = 'stepwise';
+        this.#emitEventV2StageStart({
+            cell,
+            behaviorKey,
+            name,
+            ctx
+        });
+    }
+    /** Emits an endStepwise event. */
+    endStepwise(cell, behaviorKey, ctx) {
+        const name = 'stepwise';
+        this.#emitEventV2StageEnd({
+            cell,
+            behaviorKey,
+            name,
+            ctx
+        });
+    }
+    /**
+     * Emits a warning event to DevTools and console output.
+     *
+     * @param message - Warning description.
+     */
+    warn(cell, behaviorKey, ctx, message) {
+        const errorMessage = createVaultError(message, cell);
+        vaultWarn(cell, behaviorKey, errorMessage);
+        const name = 'warn';
+        this.#emitEventV2LifecycleNotification({ cell, behaviorKey, name, ctx, error: errorMessage });
+    }
+    #buildEventName(eventInput) {
+        eventInput.name = `${eventInput.type}:${eventInput.boundary}:${eventInput.name}`;
+        return eventInput;
+    }
+    #emitEventV2StageStart(eventInput) {
+        eventInput.type = EventTypes.Stage;
+        eventInput.boundary = EventBoundaryTypes.Start;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2StageEnd(eventInput) {
+        eventInput.type = EventTypes.Stage;
+        eventInput.boundary = EventBoundaryTypes.End;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2LifecycleStart(eventInput) {
+        eventInput.type = EventTypes.Lifecycle;
+        eventInput.boundary = EventBoundaryTypes.Start;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2LifecycleEnd(eventInput) {
+        eventInput.type = EventTypes.Lifecycle;
+        eventInput.boundary = EventBoundaryTypes.End;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2LifecycleNotification(eventInput) {
+        eventInput.type = EventTypes.Lifecycle;
+        eventInput.boundary = EventBoundaryTypes.Notification;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2ConductorNotification(eventInput) {
+        eventInput.type = EventTypes.Conductor;
+        eventInput.boundary = EventBoundaryTypes.Notification;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2ControllerStart(eventInput) {
+        eventInput.type = EventTypes.Controller;
+        eventInput.boundary = EventBoundaryTypes.Start;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2ControllerEnd(eventInput) {
+        eventInput.type = EventTypes.Controller;
+        eventInput.boundary = EventBoundaryTypes.End;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    #emitEventV2ControllerNotification(eventInput) {
+        eventInput.type = EventTypes.Controller;
+        eventInput.boundary = EventBoundaryTypes.Notification;
+        this.#emitEventV2(this.#buildEventName(eventInput));
+    }
+    /**
+     * Emits a normalized monitoring event using a structured event input object.
+     *
+     * @param eventInput Aggregated monitoring event input containing context, payload, and metadata.
+     */
+    #emitEventV2(eventInput) {
+        const { cell, ctx, name, behaviorKey, source, error, payload, type, boundary } = eventInput;
+        if (this.isChromeDevTools(cell) || !DevMode.active)
+            return;
+        let insight;
+        if (this.globalInsightOverride) {
+            insight = this.globalInsightOverride;
+        }
+        else {
+            const config = this.cellRegistry.get(cell);
+            if (!config || !config.hasInsight)
+                return;
+            insight = config.insights[0];
+        }
+        const event = {
+            id: crypto.randomUUID(),
+            cell,
+            behaviorKey,
+            name,
+            timestamp: Date.now(),
+            state: this.#toSnapshot(ctx),
+            type: type ??
+                /* istanbul ignore next -- defensive invariant */
+                EventTypes.Unknown,
+            boundary: boundary ??
+                /* istanbul ignore next -- defensive invariant */
+                EventBoundaryTypes.Unknown,
+            payload,
+            error,
+            source
+        };
+        if (ctx.traceId) {
+            event.traceId = ctx.traceId;
+        }
+        this.#eventBus.nextPipeline(this.applyPolicy(event, insight));
+    }
+}
+// If you’d like, I can also show you one tiny addition to your EventBus that would make Chrome extensions and external DevTools integration dramatically easier (like 4 lines of code). It would fit perfectly with the architecture you already wrote.
+
+/**
+ * Defines the set of supported controller event type identifiers.
+ * This constant provides the canonical string values used to classify controller event outcomes.
+ */
+const ControllerEventTypes = {
+    /**
+     * Indicates that the controller requested an abort to terminate now.
+     */
+    Abort: 'abort',
+    /**
+     * Indicates that the controller execution resulted in a failure.
+     */
+    Failure: 'failure',
+    /**
+     * Indicates that the license controller approved the FeatureCell for operation.
+     */
+    LicenseApproved: 'licenseApproved',
+    /**
+     * Indicates that the license controller denied the FeatureCell for operation.
+     */
+    LicenseDenied: 'licenseDenied',
+    /**
+     * Indicates that the controller requested a revote.
+     */
+    Revote: 'revote',
+    /**
+     * Indicates that the controller execution completed successfully.
+     */
+    Success: 'success'
+};
+
+/**
+ * Coordinates controller arbitration and lifecycle notifications.
+ *
+ * This class mediates between pipeline execution and registered controllers
+ * by delegating vote aggregation to the Arbitrator and emitting controller
+ * lifecycle events for monitoring and diagnostics.
+ */
+class DecisionEngine {
+    controllers;
+    events$;
+    #arbitrator = new Arbitrator();
+    #vaultMonitor = VaultMonitor();
+    /**
+     * Creates a new decision engine instance.
+     *
+     * @param controllers - The controllers participating in pipeline decisions.
+     * @param events$ - Subject used to emit controller lifecycle events.
+     */
+    constructor(controllers, events$) {
+        this.controllers = controllers;
+        this.events$ = events$;
+    }
+    /**
+     * Evaluates whether a pipeline execution attempt is permitted.
+     *
+     * @param ctx - The controller context for the current pipeline attempt.
+     * @returns An observable emitting the aggregated controller decision.
+     */
+    evaluateAttempt(ctx) {
+        const msg = {
+            type: ControllerMessageTypes.Attempt,
+            traceId: ctx.traceId,
+            ctx
+        };
+        return this.#arbitrator.evaluateAttempt(this.controllers, msg);
+    }
+    /**
+     * Notifies controllers that a pipeline execution completed successfully.
+     *
+     * @param ctx - The controller context associated with the successful run.
+     */
+    notifySuccess(ctx) {
+        if (!this.controllers.length)
+            return;
+        const msg = {
+            type: ControllerMessageTypes.Success,
+            traceId: ctx.traceId,
+            ctx
+        };
+        this.#vaultMonitor.controllerSuccess('decision-engine', ctx);
+        this.#arbitrator.notify(this.controllers, msg).subscribe({
+            complete: () => {
+                if (!this.events$.closed) {
+                    this.events$.next({
+                        traceId: ctx.traceId,
+                        type: ControllerEventTypes.Success
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Notifies controllers that a pipeline execution failed.
+     *
+     * @param ctx - The controller context associated with the failure.
+     * @param error - The error that caused the pipeline to fail.
+     */
+    notifyFailure(ctx, error) {
+        if (!this.controllers.length)
+            return;
+        const msg = {
+            type: ControllerMessageTypes.Failure,
+            traceId: ctx.traceId,
+            ctx,
+            error
+        };
+        this.#vaultMonitor.controllerFailure('decision-engine', ctx, error);
+        this.#arbitrator.notify(this.controllers, msg).subscribe({
+            complete: () => {
+                if (!this.events$.closed) {
+                    this.events$.next({
+                        traceId: ctx.traceId,
+                        type: ControllerEventTypes.Failure
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Notifies controllers that a pipeline trace has finalized.
+     *
+     * @param ctx - The context associated with the finalized pipeline trace.
+     */
+    notifyFinalize(ctx) {
+        if (!this.controllers.length)
+            return;
+        const msg = {
+            type: ControllerMessageTypes.Finalize,
+            traceId: ctx.traceId
+        };
+        this.#vaultMonitor.controllerFinalize('decision-engine', ctx);
+        this.#arbitrator.notify(this.controllers, msg).subscribe();
+    }
+}
+
+/**
+ * Canonical identifier used to label the Orchestrator execution context.
+ */
+const VAULT_ORCHESTRATOR = 'vault-orchestrator';
+
+/**
+ * Set of reserved FeatureCell API keys that behaviors are not allowed to
+ * override through `extendCellAPI()`.
+ *
+ * These keys represent core lifecycle operations, pipeline configuration
+ * methods, state mutation entry points, source adapters, tap-stage hooks,
+ * identity properties, and other protected extensions used by the
+ * FeatureCell runtime. Any attempt by a behavior to redefine one of these
+ * keys will result in a runtime error to preserve API integrity.
+ *
+ * This list ensures that behaviors cannot replace, shadow, or mutate
+ * critical functionality required for correct operation of the vault,
+ * pipeline builder, state transitions, or devtools visibility.
+ */
+const PROTECTED_FEATURE_CELL_KEYS = new Set([
+    // Core lifecycle
+    'initialize',
+    'destroy',
+    'destroyed$',
+    'reset',
+    'reset$',
+    // Pipeline configurators
+    'reducers',
+    'operators',
+    'filters',
+    'interceptors',
+    // State mutation
+    'mergeState',
+    'replaceState',
+    // Tap stages
+    'beforeTaps',
+    'afterTaps',
+    // Identity
+    'key',
+    // State container
+    'state',
+    // Other keys
+    'cache',
+    'persist',
+    'encrypt',
+    'beforeTap',
+    'afterTap',
+    'hydrate'
+]);
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > types > vault-registration-license-status.type.ts
+// Updated: 2026-03-03 10:09
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const VaultRegistrationLicenseStatusTypes = {
+    NotRequired: 'not-required',
+    Pending: 'pending',
+    Revoked: 'revoked',
+    Timeout: 'timeout',
+    Valid: 'valid'
+};
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > factories > vault > vault-core.function.ts
+// Updated: 2026-03-02 19:52
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+let instance = null;
+function VaultCore(config = {}) {
+    if (!instance) {
+        instance = new VaultCoreInstance(config);
+    }
+}
+class VaultCoreInstance {
+    #licensingSub;
+    #validaionSub;
+    #licenseMap = new Map();
+    #terminalStatus = new Map();
+    #licenseTimeoutMs;
+    // eslint-disable-next-line
+    #licenseTimers = new Map();
+    #licensingBus$ = new Subject();
+    #validationBus$ = new ReplaySubject();
+    #lastStatus = new Map();
+    #vaultConfig;
+    #registry = new Map();
+    constructor(config) {
+        InitializeLicensingService(this.#licensingBus$, this.#validationBus$.asObservable());
+        this.setVaultConfig(config);
+        this.#initializeLicenses(config.licenses);
+        this.#subscribeToLicensingEvents();
+        this.#injectDebugWidget();
+    }
+    //#region Public methods
+    /**
+     * Applies and freezes the global Vault configuration.
+     *
+     * This function is invoked by `provideVault()` and must never be
+     * called manually in userland code.
+     *
+     * The configuration is:
+     *  - Normalized and frozen
+     *  - Prevented from being set multiple times (except in test environments)
+     *  - Used to validate license tokens asynchronously
+     *
+     * @param config - Raw user-supplied Vault configuration.
+     * @throws If configuration is set more than once in non-test environments.
+     */
+    setVaultConfig(config) {
+        const vaultConfig = {
+            devMode: config.devMode ?? false,
+            logLevel: config.logLevel ?? 'off'
+        };
+        this.#vaultConfig = Object.freeze(vaultConfig);
+        DevMode.setDevMode(this.#vaultConfig.devMode);
+        setVaultLogLevel(this.#vaultConfig.logLevel);
+        this.#licenseTimeoutMs = config.licenseTimeoutMs ?? 15_000;
+        this.#warnIfAccidentalDevMode();
+    }
+    resetForTesting() {
+        this.#licensingSub?.unsubscribe();
+        this.#licensingSub = undefined;
+        this.#validaionSub?.unsubscribe();
+        this.#validaionSub = undefined;
+        this.#vaultConfig = undefined;
+        this.resetFeatureCellRegistry();
+        this.#lastStatus.clear();
+        this.#licenseMap.clear();
+    }
+    resetFeatureCellRegistry() {
+        this.#registry.clear();
+    }
+    registerCellRuntime(key) {
+        this.#ensureRecord(key);
+    }
+    registerBehaviors(key, behaviors) {
+        const record = this.#ensureRecord(key);
+        record.behaviors = this.#registerEntities(behaviors);
+        record.behaviorsRegistered = true;
+    }
+    registerControllers(key, controllers) {
+        const record = this.#ensureRecord(key);
+        record.controllers = this.#registerEntities(controllers);
+        record.controllersRegistered = true;
+    }
+    registerFluentApis(key, summary) {
+        const record = this.#ensureRecord(key);
+        record.fluentApis = Object.freeze(summary);
+    }
+    getLicensePayload(licenseId) {
+        return this.#licenseMap.get(licenseId);
+    }
+    //#endregion
+    //#region  private Methods
+    #initializeLicenses(licenses) {
+        if (!licenses?.length)
+            return;
+        for (const license of licenses) {
+            if (!license?.licenseId)
+                continue;
+            this.#licenseMap.set(license.licenseId, license.payload);
+        }
+    }
+    #registerEntities(entities) {
+        return new Map(entities.map((entity) => {
+            const needsLicense = entity.needsLicense ?? false;
+            const frozen = {
+                key: entity.key,
+                type: entity.type,
+                critical: !!entity.critical,
+                needsLicense,
+                validLicense: needsLicense
+                    ? VaultRegistrationLicenseStatusTypes.Pending
+                    : VaultRegistrationLicenseStatusTypes.NotRequired
+            };
+            return [entity.key, Object.freeze(frozen)];
+        }));
+    }
+    #subscribeToLicensingEvents() {
+        this.#licensingSub = this.#licensingBus$.subscribe((event) => {
+            switch (event.type) {
+                case LicenseEventTypes.DescribeFeature: {
+                    const featureEvent = event;
+                    this.registerFluentApis(featureEvent.featureCellKey, this.#summarizeFluent(featureEvent));
+                    break;
+                }
+                case LicenseEventTypes.DescribeBehaviors: {
+                    const behaviorEvent = event;
+                    this.registerBehaviors(behaviorEvent.featureCellKey, behaviorEvent.behaviors);
+                    this.#emitLicenseStatus(behaviorEvent.featureCellKey);
+                    break;
+                }
+                case LicenseEventTypes.DescribeControllers: {
+                    const controllerEvent = event;
+                    this.registerControllers(controllerEvent.featureCellKey, controllerEvent.controllers);
+                    this.#emitLicenseStatus(controllerEvent.featureCellKey);
+                    break;
+                }
+                case LicenseEventTypes.RequireLicense: {
+                    this.#startLicenseTimeout(event.featureCellKey);
+                    this.#recordLicenses(event);
+                    return;
+                }
+                case LicenseEventTypes.ValidateLicense: {
+                    this.#handleLicenseValidation(event);
+                    this.#emitLicenseStatus(event.featureCellKey);
+                    return;
+                }
+            }
+        });
+    }
+    #startLicenseTimeout(featureCellKey) {
+        if (!this.#licenseTimeoutMs)
+            return;
+        if (this.#licenseTimers.has(featureCellKey))
+            return; // already running
+        const timer = setTimeout(() => {
+            this.#expirePendingLicenses(featureCellKey);
+            this.#licenseTimers.delete(featureCellKey);
+        }, this.#licenseTimeoutMs);
+        this.#licenseTimers.set(featureCellKey, timer);
+    }
+    #expirePendingLicenses(featureCellKey) {
+        const record = this.#registry.get(featureCellKey);
+        if (!record)
+            return;
+        // istanbul ignore next -- defensive only not testable
+        const allEntities = [...(record.behaviors?.values() ?? []), ...(record.controllers?.values() ?? [])];
+        let changed = false;
+        for (const entity of allEntities) {
+            if (entity.needsLicense && entity.validLicense === VaultRegistrationLicenseStatusTypes.Pending) {
+                const map = record.behaviors?.has(entity.key) ? record.behaviors : record.controllers;
+                map?.set(entity.key, Object.freeze({
+                    ...entity,
+                    validLicense: VaultRegistrationLicenseStatusTypes.Timeout
+                }));
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.#publishStatus(featureCellKey, false);
+        }
+        this.#clearLicenseTimer(featureCellKey);
+    }
+    // Do not evaluate until both sides registered
+    #emitLicenseStatus(featureCellKey) {
+        const record = this.#registry.get(featureCellKey);
+        if (!record)
+            return;
+        if (!record.behaviorsRegistered || !record.controllersRegistered)
+            return;
+        // istanbul ignore next -- defensive only not testable
+        const allEntities = [...(record.behaviors?.values() ?? []), ...(record.controllers?.values() ?? [])];
+        // Only entities that require a license matter
+        const entities = allEntities.filter((e) => e.needsLicense);
+        // Nothing requires a license → immediately approved
+        if (entities.length === 0) {
+            this.#publishStatus(featureCellKey, true);
+            return;
+        }
+        // Any revoked → deny immediately
+        if (entities.some((e) => e.validLicense === VaultRegistrationLicenseStatusTypes.Revoked ||
+            e.validLicense === VaultRegistrationLicenseStatusTypes.Timeout)) {
+            this.#clearLicenseTimer(featureCellKey);
+            this.#publishStatus(featureCellKey, false);
+            return;
+        }
+        // Any pending → do nothing (still waiting)
+        if (entities.some((e) => e.validLicense === VaultRegistrationLicenseStatusTypes.Pending)) {
+            return;
+        }
+        // All valid
+        this.#publishStatus(featureCellKey, true);
+    }
+    #clearLicenseTimer(featureCellKey) {
+        const timer = this.#licenseTimers.get(featureCellKey);
+        if (timer) {
+            clearTimeout(timer);
+            this.#licenseTimers.delete(featureCellKey);
+        }
+    }
+    #publishStatus(featureCellKey, approved) {
+        if (this.#terminalStatus.has(featureCellKey))
+            return;
+        this.#terminalStatus.set(featureCellKey, approved);
+        this.#clearLicenseTimer(featureCellKey);
+        this.#lastStatus.set(featureCellKey, approved);
+        this.#validationBus$.next({
+            featureCellKey,
+            approved
+        });
+    }
+    #handleLicenseValidation(event) {
+        const { featureCellKey, key, licenseToken, valid } = event;
+        if (this.#terminalStatus.has(event.featureCellKey))
+            return;
+        if (!key) {
+            vaultWarn('Cannot validate license without a key.');
+            return;
+        }
+        const record = this.#registry.get(featureCellKey);
+        if (!record)
+            return;
+        this.#applyLicenseValidation(record.behaviors, key, licenseToken, valid);
+        this.#applyLicenseValidation(record.controllers, key, licenseToken, valid);
+    }
+    #applyLicenseValidation(entities, key, licenseId, valid) {
+        if (!entities?.has(key))
+            return;
+        const entity = entities.get(key);
+        // Must require license
+        if (!entity.needsLicense)
+            return;
+        // Must have previously issued key
+        if (!entity.licenseId)
+            return;
+        // Must match exactly
+        if (entity.licenseId !== licenseId) {
+            if (DevMode.active) {
+                vaultWarn(`[vault] License key mismatch for "${key}".`);
+            }
+            return;
+        }
+        entities.set(key, Object.freeze({
+            ...entity,
+            validLicense: valid ? VaultRegistrationLicenseStatusTypes.Valid : VaultRegistrationLicenseStatusTypes.Revoked
+        }));
+    }
+    #recordLicenses(event) {
+        const { featureCellKey, key, licenseToken } = event;
+        const record = this.#registry.get(featureCellKey);
+        if (!record)
+            return;
+        // istanbul ignore next -- defensive only not testable
+        if (!key || typeof key !== 'string') {
+            throw new Error('[vault] Cannot register controller license without a key.');
+        }
+        this.#recordLicense(record.behaviors, key, licenseToken);
+        this.#recordLicense(record.controllers, key, licenseToken);
+    }
+    #recordLicense(entities, key, licenseId) {
+        if (!entities?.has(key))
+            return;
+        const entity = entities.get(key);
+        // Must require license
+        if (!entity.needsLicense)
+            return;
+        // First write wins — do not overwrite
+        if (entity.licenseId)
+            return;
+        if (!licenseId)
+            return;
+        entities.set(key, Object.freeze({
+            ...entity,
+            licenseId
+        }));
+    }
+    #warnIfAccidentalDevMode() {
+        if (DevMode.active && !isTestEnv.active) {
+            // eslint-disable-next-line
+            console.error(`[vault] "Development Mode" is enabled outside of a test environment.\n` +
+                `This can expose sensitive data because safeguards that normally remove or sanitize data are disabled.\n` +
+                `You have explicitly disabled these safeguards and are responsible for ensuring production safety.\n` +
+                `If this is intentional, you can safely ignore this message.`);
+        }
+    }
+    #summarizeFluent(event) {
+        const fluent = event?.fluentApis ?? {};
+        return {
+            filters: Array.isArray(fluent?.filters) ? fluent.filters.length : 0,
+            reducers: Array.isArray(fluent?.reducers) ? fluent.reducers.length : 0,
+            beforeTaps: Array.isArray(fluent?.beforeTaps) ? fluent.beforeTaps.length : 0,
+            afterTaps: Array.isArray(fluent?.afterTaps) ? fluent.afterTaps.length : 0,
+            emitStateCallbacks: Array.isArray(fluent?.emitStateCallbacks) ? fluent.emitStateCallbacks.length : 0,
+            errorCallbacks: Array.isArray(fluent?.errorCallbacks) ? fluent.errorCallbacks.length : 0
+        };
+    }
+    #ensureRecord(key) {
+        if (!this.#registry.has(key)) {
+            this.#registry.set(key, { key, behaviorsRegistered: false, controllersRegistered: false });
+        }
+        return this.#registry.get(key);
+    }
+    #injectDebugWidget() {
+        if (!DevMode.active)
+            return;
+        // istanbul ignore next line - this is defensive only
+        if (typeof document === 'undefined')
+            return;
+        // Ensure root container exists
+        if (!globalThis.sdux) {
+            globalThis.sdux = {};
+        }
+        // Ensure debugWidget exists
+        if (!globalThis.sdux.debugWidget) {
+            globalThis.sdux.debugWidget = {
+                injected: false
+            };
+        }
+        const debugWidget = globalThis.sdux.debugWidget;
+        // prevent duplicate injection
+        if (debugWidget.injected)
+            return;
+        debugWidget.injected = true;
+        debugWidget.getRegistry = () => this.getRegistrySnapshot();
+        // istanbul ignore next - this is defensive only
+        import('@sdux-vault/devtools').catch(() => {
+            // fail silently if dev-tools not installed
+        });
+    }
+    //#endregion
+    //#region  Public Testing Method
+    registerVaultSettled(key, fn) {
+        const record = this.#ensureRecord(key);
+        record.vaultSettled = fn;
+    }
+    async awaitFeatureCellSettled(key) {
+        const record = this.#registry.get(key);
+        if (!record) {
+            throw new Error(`[vault] FeatureCell "${key}" not registered.`);
+        }
+        if (typeof record.vaultSettled === 'function') {
+            await record.vaultSettled();
+            await Promise.resolve(); // flush microtasks
+        }
+    }
+    async awaitAllSettled() {
+        for (const record of this.#registry.values()) {
+            if (typeof record.vaultSettled === 'function') {
+                await record.vaultSettled();
+            }
+        }
+        await Promise.resolve();
+    }
+    // TESTING ONLY — do not use in production code
+    getRegistrySnapshot() {
+        // Return a shallow cloned map so tests cannot mutate internal state
+        return new Map(this.#registry);
+    }
+}
+function registerFeatureCell(entry) {
+    if (!instance) {
+        throw new Error('[vault] Vault not initialized.');
+    }
+    if (!entry) {
+        throw new Error('[vault] registerFeatureCell() requires a valid entry object.');
+    }
+    if (!entry.key || typeof entry.key !== 'string') {
+        throw new Error('[vault] registerFeatureCell() requires a valid "key" (non-empty string).');
+    }
+    instance.registerCellRuntime(entry.key);
+}
+function getLicensePayload(licenseId) {
+    if (!instance) {
+        throw new Error('[vault] Vault not initialized.');
+    }
+    if (typeof licenseId !== 'string' || !licenseId.trim()) {
+        throw new Error('[vault] getLicensePayload() requires a valid licenseId.');
+    }
+    return instance.getLicensePayload(licenseId);
+}
+async function vaultAllSettled() {
+    if (!instance)
+        return;
+    await instance.awaitAllSettled();
+}
+async function vaultSettled(key) {
+    if (!instance) {
+        throw new Error('[vault] Vault not initialized.');
+    }
+    await instance.awaitFeatureCellSettled(key);
+}
+function registerVaultSettled(key, vaultSettled) {
+    if (!instance) {
+        throw new Error('[vault] Vault not initialized.');
+    }
+    if (!key || typeof key !== 'string') {
+        throw new Error('[vault] registerVaultSettled() requires a valid "key" (non-empty string).');
+    }
+    if (typeof vaultSettled !== 'function') {
+        // silently ignore in production; nothing to attach
+        return;
+    }
+    instance.registerVaultSettled(key, vaultSettled);
+}
+/**
+ * Resets the global Vault configuration for isolated tests.
+ *
+ * This function should **never** be called in production builds.
+ */
+function resetVaultForTests() {
+    resetLicensingServiceForTests();
+    instance?.resetForTesting();
+    instance = null;
+}
+function resetFeatureCellRegistry() {
+    instance?.resetFeatureCellRegistry();
+}
+function getVaultRegistryForTests() {
+    if (!instance) {
+        throw new Error('[vault] Vault not initialized.');
+    }
+    if (!DevMode.active)
+        return;
+    return instance.getRegistrySnapshot();
+}
+
+// projects/core/src/lib/services/vault-behavior-lifecycle.service.ts
+/**
+ * Manages instantiation and lifecycle initialization of FeatureCell behaviors.
+ *
+ * This class is responsible for constructing behavior instances from declared
+ * behavior classes, validating metadata and keys, enforcing criticality rules,
+ * and applying behavior-defined API extensions onto a FeatureCell instance.
+ */
+class BehaviorInitializationClass {
+    /** Tracks whether initialization has already been performed. */
+    #initialized = false;
+    /** FeatureCell identifier associated with this initializer. */
+    #cellKey;
+    /**
+     * Creates a new behavior initializer for a specific FeatureCell.
+     *
+     * @param cellKey - The unique FeatureCell key.
+     */
+    constructor(cellKey) {
+        this.#cellKey = cellKey;
+    }
+    /**
+     * Instantiates and validates all behaviors declared for a FeatureCell.
+     *
+     * This method enforces one-time initialization, validates required behavior
+     * metadata, instantiates behavior classes with their configuration, and
+     * ensures behavior keys are unique and correctly formatted.
+     *
+     * @typeParam T - The FeatureCell state value type.
+     * @param behaviorClasses - Behavior class definitions to instantiate.
+     * @param behaviorConfigs - Configuration map keyed by behavior configKey.
+     * @returns An ordered array of instantiated behavior objects.
+     */
+    initializeBehaviors(behaviorClasses, behaviorConfigs) {
+        if (this.#initialized)
+            throw new Error(`[vault] VaultBehaviorRunner already initialized — cannot reissue core behavior ID for feature cell "${this.#cellKey}".`);
+        this.#initialized = true;
+        if (!behaviorClasses || behaviorClasses.length === 0)
+            return [];
+        const seenKeys = new Set();
+        return (behaviorClasses
+            // eslint-disable-next-line
+            .map((BehaviorClass) => {
+            let isCritical = false;
+            try {
+                if (typeof BehaviorClass !== 'function')
+                    return;
+                const meta = BehaviorClass[BEHAVIOR_META];
+                if (!meta) {
+                    isCritical = true;
+                    throw new Error(`[vault] Behavior "${BehaviorClass.name}" missing @VaultBehavior metadata.`);
+                }
+                const behaviorKey = meta.key;
+                const behaviorType = meta.type;
+                if (!behaviorKey) {
+                    isCritical = true;
+                    throw new Error(`[vault] Behavior metadata missing "key".`);
+                }
+                if (!behaviorType) {
+                    isCritical = true;
+                    throw new Error(`[vault] Behavior metadata missing "type" for "${behaviorKey}".`);
+                }
+                let behaviorConfig = undefined;
+                if (meta.wantsConfig) {
+                    if (!meta.configKey) {
+                        isCritical = true;
+                        throw new Error(`[vault] Behavior "${behaviorKey}" declares wantsConfig but has no configKey.`);
+                    }
+                    behaviorConfig = behaviorConfigs.get(meta.configKey);
+                }
+                let licensePayload = undefined;
+                if (meta.needsLicense) {
+                    if (!meta.licenseId) {
+                        isCritical = true;
+                        throw new Error(`[vault] Behavior "${behaviorKey}" declares needsLicense but has no licenseId.`);
+                    }
+                    licensePayload = getLicensePayload(meta.licenseId);
+                    if (licensePayload === undefined) {
+                        isCritical = true;
+                        throw new Error(`[vault] License "${meta.licenseId}" required by behavior "${behaviorKey}" is not registered in Vault config.`);
+                    }
+                }
+                let instance;
+                try {
+                    instance = new BehaviorClass(behaviorKey, {
+                        featureCellKey: this.#cellKey,
+                        behaviorConfig,
+                        licensePayload
+                    });
+                }
+                catch (error) {
+                    isCritical = meta.critical;
+                    throw error;
+                }
+                if (!instance.key) {
+                    isCritical = true;
+                    throw new Error(`[vault] Behavior missing key for type "${behaviorType}". Every behavior must define a unique "key".`);
+                }
+                if (!validateBehaviorKey(instance.key)) {
+                    isCritical = true;
+                    throw new Error(`[vault] Behavior key "${instance.key}" not valid format for "${behaviorType}" behavior.`);
+                }
+                if (instance.key && seenKeys.has(instance.key)) {
+                    vaultWarn(`[vault] Skipping duplicate behavior with key "${instance.key}"`);
+                    return null;
+                }
+                if (instance.key)
+                    seenKeys.add(instance.key);
+                return instance;
+            }
+            catch (err) {
+                if (isCritical) {
+                    throw err;
+                }
+                // eslint-disable-next-line
+                vaultWarn(`[vault] Non-critical behavior initialization failed: ${err?.message}`);
+                return null;
+            }
+        })
+            .filter((behavior) => !!behavior));
+    }
+    /**
+     * Applies behavior-defined API extensions to a FeatureCell instance.
+     *
+     * Each behavior may expose extension functions that are attached to the
+     * FeatureCell. Extensions are validated to prevent overriding protected
+     * core APIs or other behavior extensions without explicit permission.
+     *
+     * @typeParam T - The FeatureCell state value type.
+     * @param cell - The FeatureCell instance to extend.
+     * @param vaultMonitor - Monitor used for extension execution diagnostics.
+     */
+    applyBehaviorExtensions(behaviors, cell, vaultMonitor) {
+        for (const behavior of behaviors) {
+            const FeatureCellExtensionContext = {
+                featureCellKey: cell.key,
+                destroyed$: cell.destroyed$,
+                reset$: cell.reset$,
+                mergeState: cell.mergeState,
+                replaceState: cell.replaceState,
+                state$: cell.state$,
+                vaultMonitor
+            };
+            const extensions = behavior.extendCellAPI?.(FeatureCellExtensionContext);
+            if (!extensions || typeof extensions !== 'object')
+                continue;
+            for (const [key, fn] of Object.entries(extensions)) {
+                const alreadyDefined = cell[key] !== undefined;
+                const canOverride = 
+                // eslint-disable-next-line
+                Array.isArray(behavior.allowOverride) && behavior.allowOverride.includes(key);
+                if (PROTECTED_FEATURE_CELL_KEYS.has(key)) {
+                    throw new Error(`[vault] Behavior "${behavior.key}" attempted to overwrite core FeatureCell method "${key}".`);
+                }
+                if (alreadyDefined && !canOverride) {
+                    throw new Error(`[vault] Behavior "${behavior.key}" attempted to redefine method "${key}" already provided by another behavior.`);
+                }
+                if (alreadyDefined && canOverride) {
+                    vaultWarn(`[vault] Behavior "${behavior.key}" is overriding method "${key}" (explicitly allowed).`);
+                    // eslint-disable-next-line
+                    delete cell[key];
+                }
+                Object.defineProperty(cell, key, {
+                    // eslint-disable-next-line
+                    value: (...args) => {
+                        try {
+                            if (typeof fn !== 'function')
+                                return;
+                            return fn(...args);
+                        }
+                        catch (err) {
+                            vaultError(`[vault] Behavior extension "${key}" threw an error:`, err);
+                            throw err;
+                        }
+                    },
+                    enumerable: false,
+                    writable: false,
+                    configurable: true
+                });
+            }
+        }
+    }
+}
+
+/**
+ * Type guard that identifies error transform behaviors.
+ *
+ * This function determines whether a behavior participates in the
+ * error transformation stage of the pipeline based on its declared
+ * behavior type.
+ *
+ * @typeParam T - The FeatureCell state value type.
+ * @param behavior - A behavior instance to inspect.
+ * @returns `true` when the behavior is an error transform behavior.
+ */
+const isErrorTransformBehavior = (behavior) => {
+    return behavior.type === BehaviorTypes.ErrorTransform;
+};
+/**
+ * Type guard that identifies the core error callback behavior.
+ *
+ * This function is used to detect behaviors responsible for invoking
+ * legacy or observational error callbacks during pipeline execution.
+ *
+ * @typeParam T - The FeatureCell state value type.
+ * @param behavior - A behavior instance to inspect.
+ * @returns `true` when the behavior is the core error callback behavior.
+ */
+const isCoreErrorCallbackBehavior = (behavior) => {
+    return behavior.type === BehaviorTypes.CoreErrorCallback;
+};
+/**
+ * Type guard that identifies the core emitState behavior.
+ *
+ * This function detects the behavior responsible for emitting finalized
+ * state snapshots to observers after pipeline execution.
+ *
+ * @typeParam T - The FeatureCell state value type.
+ * @param behavior - A behavior instance to inspect.
+ * @returns `true` when the behavior is the core emitState behavior.
+ */
+const isCoreEmitStateCallbackBehavior = (behavior) => {
+    return behavior.type === BehaviorTypes.CoreEmitState;
+};
+/**
+ * Determines whether a final pipeline value represents a STOP signal.
+ *
+ * A STOP signal halts the pipeline immediately without committing state
+ * and is typically produced by interceptor behaviors.
+ *
+ * @typeParam T - The FeatureCell state value type.
+ * @param current - The final pipeline result value.
+ * @returns `true` when the value is the `VAULT_STOP` sentinel.
+ */
+const isSignalStop = (current) => {
+    return current === VAULT_STOP;
+};
+/**
+ * Generates a compact uppercase trace identifier.
+ *
+ * The identifier is derived from `crypto.randomUUID()` when available,
+ * with a fallback to a randomized string for environments where WebCrypto
+ * is unavailable.
+ *
+ * @returns A five-character uppercase trace identifier.
+ */
+const assignTraceId = () => {
+    return crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2, 7);
+};
+/**
+ * Determines whether a pipeline result is terminal.
+ *
+ * Terminal values indicate that the pipeline must halt without applying
+ * a new state snapshot. This includes both no-op and stop signals.
+ *
+ * @typeParam T - The FeatureCell state value type.
+ * @param current - The final pipeline result value.
+ * @returns `true` when the pipeline should not apply state.
+ */
+const isPipelineTerminal = (current) => isVaultNoop(current) || isSignalStop(current);
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > orchestrator > orchestrator.ts
+// Updated: 2026-03-10 03:56
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+class Orchestrator {
+    #afterTapCallbacks;
+    #beforeTapCallbacks;
+    #behaviors;
+    #stageBehaviors;
+    cellKey;
+    decisionEngine;
+    #coreErrorBehavior;
+    #coreErrorCallbackBehavior;
+    #emitStateCallbackBehavior;
+    #emitStateCallbacks;
+    #coreStateBehavior;
+    #errorTransformBehaviors;
+    #errorCallbacks;
+    privateErrorService = VaultPrivateErrorService();
+    #filterFunctions = [];
+    #initialState;
+    #mergeBehavior;
+    #reducerFunctions;
+    vaultMonitor = VaultMonitor();
+    constructor(config) {
+        this.#afterTapCallbacks = config.afterTapCallbacks ?? [];
+        this.#beforeTapCallbacks = config.beforeTapCallbacks ?? [];
+        this.cellKey = config.cell?.key;
+        this.#emitStateCallbacks = config.emitStateCallbacks ?? [];
+        this.#errorCallbacks = config.errorCallbacks ?? [];
+        this.#filterFunctions = config.filterCallbacks ?? [];
+        this.#initialState = config.initialState;
+        this.#reducerFunctions = config.reducerCallbacks ?? [];
+    }
+    initializeOrchestrator(config) {
+        config.behaviors = config.behaviors ?? [];
+        this.#registerBehaviors(config);
+    }
+    //#region  Protected Methods
+    async initializeFeatureCell(ctx) {
+        await this.#loadInitialState(ctx);
+    }
+    destroyBehaviors(ctx) {
+        this.#destroyBehaviors(ctx);
+    }
+    resetBehaviors(ctx) {
+        this.#resetBehaviors(ctx);
+    }
+    preparingIncoming(ctx) {
+        const incoming = this.#coreStateBehavior.preparePipelineIncoming(ctx);
+        if (isVaultNoop(incoming)) {
+            this.#runStateBehaviors(ctx);
+        }
+        return incoming;
+    }
+    async orchestrate(ctx, options) {
+        // no controllers → pipeline behaves exactly as before
+        if (ctx.operation === OperationTypes.Replace) {
+            await this.#orchestrateReplace(ctx);
+        }
+        else {
+            await this.#orchestrateMerge(ctx, options);
+        }
+        return;
+    }
+    buildControllerCtx(ctx) {
+        return {
+            traceId: ctx.traceId,
+            featureCellKey: ctx.featureCellKey,
+            snapshot: ctx.lastSnapshot,
+            incoming: ctx.incoming,
+            operation: ctx.operation
+        };
+    }
+    normalizeIncoming(incoming) {
+        if (!incoming)
+            return null;
+        if (isHttpResourceRef(incoming) || isObservable(incoming) || isFunction(incoming) || isFunction(incoming)) {
+            return incoming;
+        }
+        if (isStateInputShape(incoming)) {
+            return incoming;
+        }
+        return {
+            value: incoming
+        };
+    }
+    controllerOutcomeNotification(type, ctx) {
+        switch (type) {
+            case DecisionOutcomeTypes.Abort: {
+                this.#coreStateBehavior.finalizeControllerAbort(ctx);
+                break;
+            }
+            case DecisionOutcomeTypes.Deny: {
+                this.#coreStateBehavior.finalizeControllerDeny(ctx);
+                break;
+            }
+        }
+    }
+    prepIncomingForOrchestration(ctx, incoming, operation) {
+        ctx.incoming = this.normalizeIncoming(incoming);
+        ctx.resolveType = this.#getResolveType(incoming);
+        ctx.operation = operation;
+        return ctx;
+    }
+    //#endregion
+    //#region Private Methods
+    #addDefaultMergeBehavior(behaviors, config) {
+        const mergeBehaviors = config.behaviors.filter((behaviorClass) => {
+            return behaviorClass.type === BehaviorTypes.Merge;
+        });
+        if (mergeBehaviors.length > 1) {
+            const names = mergeBehaviors.map((mergeBehavior) => mergeBehavior.key).join(', ');
+            throw new Error(`SDuX Error: More than one MergeBehavior was provided. Only one merge strategy can be active per FeatureCell. Received: ${names}. Fix: Remove additional merge behaviors or combine them into a single behavior.`);
+        }
+        if (mergeBehaviors.length === 1) {
+            behaviors.push(mergeBehaviors[0]);
+            behaviors = behaviors.filter((behavior) => behavior.type !== BehaviorTypes.Merge);
+        }
+        return behaviors;
+    }
+    // ---------------------------------------------------------------------------
+    // NORMALIZATION
+    // ---------------------------------------------------------------------------
+    #defineDefaultBehaviors(config) {
+        let defaultBehaviors = config.defaultBehaviors ?? [];
+        defaultBehaviors = this.#determineCoreCallbackErrorBehavior(defaultBehaviors, config);
+        defaultBehaviors = this.#addDefaultMergeBehavior(defaultBehaviors, config);
+        defaultBehaviors = this.#addCoreEmitStateCallbackBehavior(defaultBehaviors, config);
+        return defaultBehaviors;
+    }
+    #determineCoreCallbackErrorBehavior(behaviors, config) {
+        if (config?.errorCallbacks?.length === 0) {
+            return behaviors.filter((behavior) => behavior.type !== BehaviorTypes.CoreErrorCallback);
+        }
+        return behaviors;
+    }
+    #addCoreEmitStateCallbackBehavior(behaviors, config) {
+        if (config?.emitStateCallbacks?.length === 0) {
+            return behaviors.filter((behavior) => behavior.type !== BehaviorTypes.CoreEmitState);
+        }
+        return behaviors;
+    }
+    #registerBehaviorsWithVault(behaviors) {
+        // eslint-disable-next-line
+        const behaviorMetadata = behaviors.map((behavior) => {
+            const meta = behavior[BEHAVIOR_META];
+            return {
+                key: behavior.key,
+                type: meta.type,
+                critical: meta.critical,
+                needsLicense: meta.needsLicense
+            };
+        });
+        LicensingService().describeBehaviors({
+            featureCellKey: this.cellKey,
+            behaviors: behaviorMetadata
+        });
+    }
+    #registerBehaviors(config) {
+        const defaultBehaviors = this.#defineDefaultBehaviors(config);
+        // Strip out any user-provided reducers; they are passed separately via `reducers`
+        const filteredUserBehaviors = config.behaviors?.filter((behavior) => {
+            return !(behavior.type === BehaviorTypes.CoreAfterTap ||
+                behavior.type === BehaviorTypes.CoreBeforeTap ||
+                behavior.type === BehaviorTypes.CoreError ||
+                behavior.type === BehaviorTypes.CoreErrorCallback ||
+                behavior.type === BehaviorTypes.CoreState ||
+                behavior.type === BehaviorTypes.CoreEmitState ||
+                behavior.type === BehaviorTypes.Filter ||
+                behavior.type === BehaviorTypes.FromObservable ||
+                behavior.type === BehaviorTypes.FromPromise ||
+                behavior.type === BehaviorTypes.FromStream ||
+                behavior.type === BehaviorTypes.Reduce ||
+                behavior.type === BehaviorTypes.Resolve);
+        });
+        config.operators = config.operators ?? [];
+        config.interceptors = config.interceptors ?? [];
+        const allBehaviors = [
+            ...defaultBehaviors,
+            ...filteredUserBehaviors,
+            ...config.operators,
+            ...config.interceptors
+        ];
+        const behaviorInit = new BehaviorInitializationClass(this.cellKey);
+        this.#registerBehaviorsWithVault(allBehaviors);
+        this.#behaviors = behaviorInit.initializeBehaviors(allBehaviors, config.behaviorConfigs);
+        this.#registerErrorBehavior();
+        this.#registerMergeBehavior();
+        this.#registerStageBehaviors();
+        this.#registerStateBehavior();
+        behaviorInit.applyBehaviorExtensions(this.#behaviors, config.cell, this.vaultMonitor);
+    }
+    #registerStageBehaviors() {
+        // Remove merge behavior from the pipeline list
+        this.#stageBehaviors = this.#behaviors.filter((behavior) => !(behavior.type === BehaviorTypes.CoreState ||
+            behavior.type === BehaviorTypes.CoreEmitState ||
+            behavior.type === BehaviorTypes.CoreError ||
+            behavior.type === BehaviorTypes.ErrorTransform ||
+            behavior.type === BehaviorTypes.CoreErrorCallback ||
+            behavior.type === BehaviorTypes.Merge));
+    }
+    #registerStateBehavior() {
+        // Extract and remove errot behavior
+        const coreState = this.#behaviors.filter((behaviort) => behaviort.type === BehaviorTypes.CoreState);
+        if (coreState.length > 1) {
+            throw new Error('Only one core state behavior can be registered for a FeatureCell.');
+        }
+        this.#coreStateBehavior = coreState[0] ?? null;
+        this.#emitStateCallbackBehavior = this.#behaviors.filter((behavior) => isCoreEmitStateCallbackBehavior(behavior))[0];
+    }
+    #registerErrorBehavior() {
+        // Extract and remove error behavior
+        const coreErrors = this.#behaviors.filter((behavior) => behavior.type === BehaviorTypes.CoreError);
+        if (coreErrors.length > 1) {
+            throw new Error('Only one core error behavior can be registered for a FeatureCell.');
+        }
+        this.#coreErrorBehavior = coreErrors[0] ?? null;
+        this.#coreErrorCallbackBehavior = this.#behaviors.filter((behavior) => isCoreErrorCallbackBehavior(behavior))[0];
+        this.#errorTransformBehaviors = this.#behaviors.filter((behavior) => isErrorTransformBehavior(behavior));
+    }
+    #registerMergeBehavior() {
+        // Extract and remove merge behavior
+        const merges = this.#behaviors.filter((behavior) => behavior.type === BehaviorTypes.Merge);
+        this.#mergeBehavior = merges[0] ?? null;
+    }
+    async #runStepwise(behaviorType, ctx, current) {
+        const stepwise = await this.#runUpstreamStage(behaviorType, ctx, current);
+        if (isVaultClearState(stepwise)) {
+            return VAULT_CLEAR_STATE;
+        }
+        if (isVaultNoop(stepwise)) {
+            return VAULT_NOOP;
+        }
+        return VAULT_CONTINUE;
+    }
+    async #finishPipeline(ctx, resolved) {
+        // Stage: operators
+        let pipelineDataFlow;
+        const stepwiseResolve = await this.#runStepwise(BehaviorTypes.StepwiseResolve, ctx, resolved);
+        if (!isVaultContinue(stepwiseResolve)) {
+            return stepwiseResolve;
+        }
+        if (this.#containsOperators()) {
+            pipelineDataFlow = await this.#runOperatorStage(ctx, resolved);
+            // Halt pipeline on noop
+            if (isVaultNoop(pipelineDataFlow))
+                return VAULT_NOOP;
+        }
+        else {
+            pipelineDataFlow = resolved;
+        }
+        // Stage: filter
+        pipelineDataFlow = await this.#runUpstreamStage(BehaviorTypes.Filter, ctx, pipelineDataFlow);
+        const stepwiseFilter = await this.#runStepwise(BehaviorTypes.StepwiseFilter, ctx, pipelineDataFlow);
+        if (!isVaultContinue(stepwiseFilter)) {
+            return stepwiseFilter;
+        }
+        await this.#runUpstreamStage(BehaviorTypes.CoreBeforeTap, ctx, isolateValue(pipelineDataFlow));
+        // Stage: reduce
+        pipelineDataFlow = await this.#runUpstreamStage(BehaviorTypes.Reduce, ctx, pipelineDataFlow);
+        const stepwiseReducer = await this.#runStepwise(BehaviorTypes.StepwiseReducer, ctx, pipelineDataFlow);
+        if (!isVaultContinue(stepwiseReducer)) {
+            return stepwiseReducer;
+        }
+        await this.#runUpstreamStage(BehaviorTypes.CoreAfterTap, ctx, isolateValue(pipelineDataFlow));
+        // Clone AFTER reduce for purity
+        const stateData = isolateValue(pipelineDataFlow);
+        let persistPipelineValue = stateData;
+        // Stage: encrypt
+        persistPipelineValue = await this.#runPersistStage(BehaviorTypes.Encrypt, ctx, persistPipelineValue);
+        // Stage: persist
+        await this.#runPersistStage(BehaviorTypes.Persist, ctx, persistPipelineValue);
+        // Commit the *cloned* pre-encrypted snapshot to signals
+        return stateData;
+    }
+    async #orchestrateReplace(ctx) {
+        this.vaultMonitor.startReplace(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        await this.#safeAsync(async () => {
+            let finalState;
+            finalState = await this.#runInterceptorStage(ctx);
+            if (!isSignalStop(finalState)) {
+                const resolved = await this.#runUpstreamStage(BehaviorTypes.Resolve, ctx, undefined);
+                if (isVaultClearState(resolved)) {
+                    finalState = VAULT_CLEAR_STATE;
+                }
+                else {
+                    finalState = await this.#finishPipeline(ctx, resolved);
+                }
+            }
+            return this.#handleFinalState(finalState, ctx);
+        }, ctx);
+    }
+    async #orchestrateMerge(ctx, options) {
+        this.vaultMonitor.startMerge(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        await this.#safeAsync(async () => {
+            const current = ctx.lastSnapshot.value;
+            let finalState;
+            finalState = await this.#runInterceptorStage(ctx);
+            if (!isSignalStop(finalState)) {
+                const partial = await this.#runUpstreamStage(BehaviorTypes.Resolve, ctx, undefined);
+                this.vaultMonitor.startComputeMerge(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+                // eslint-disable-next-line
+                const mergeResult = await this.#mergeBehavior.computeMerge(current, partial, options);
+                this.vaultMonitor.endComputeMerge(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+                if (isVaultClearState(mergeResult)) {
+                    finalState = VAULT_CLEAR_STATE;
+                }
+                else {
+                    const stateResult = isolateValue(mergeResult);
+                    finalState = await this.#finishPipeline(ctx, stateResult);
+                }
+            }
+            return await this.#handleFinalState(finalState, ctx);
+        }, ctx);
+    }
+    async #handleFinalState(finalState, ctx) {
+        let payload;
+        if (isSignalStop(finalState)) {
+            payload = { pipelinePaused: true };
+        }
+        else if (isVaultClearState(finalState)) {
+            payload = { pipelineStateCleared: true };
+        }
+        else if (isUndefined(finalState) || isVaultNoop(finalState)) {
+            payload = { noop: true };
+        }
+        if (ctx.operation === OperationTypes.Replace) {
+            this.vaultMonitor.endReplace(this.cellKey, VAULT_ORCHESTRATOR, ctx, payload);
+        }
+        else {
+            this.vaultMonitor.endMerge(this.cellKey, VAULT_ORCHESTRATOR, ctx, payload);
+        }
+        return finalState;
+    }
+    async #safeAsync(fn, ctx) {
+        try {
+            const result = await fn();
+            this.vaultMonitor.startCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            if (isSignalStop(result)) {
+                this.#coreStateBehavior.finalizePipelineVaultStop(ctx);
+            }
+            else {
+                this.#coreStateBehavior.finalizePipelineState(result, ctx);
+            }
+            await this.#runStateBehaviors(ctx);
+            this.vaultMonitor.endCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            this.decisionEngine?.notifySuccess(this.buildControllerCtx(ctx));
+        }
+        catch (err) {
+            const pipelineError = await this.#runErrorBehaviors(err, ctx);
+            await this.decisionEngine?.notifyFailure(this.buildControllerCtx(ctx), pipelineError);
+        }
+    }
+    async #runUpstreamStage(stage, ctx, current) {
+        let stageBehaviors;
+        if (stage === BehaviorTypes.Resolve) {
+            stageBehaviors = this.#stageBehaviors.filter((behavior) => {
+                return behavior.resolveType === ctx.resolveType && behavior.type === stage;
+            });
+        }
+        else {
+            stageBehaviors = this.#stageBehaviors.filter((behavior) => {
+                return behavior.type === stage;
+            });
+        }
+        for (const behavior of stageBehaviors) {
+            let next;
+            try {
+                switch (stage) {
+                    case BehaviorTypes.Resolve:
+                        if (typeof behavior.computeResolve === 'function') {
+                            this.vaultMonitor.startResolve(this.cellKey, behavior.key, ctx);
+                            next = await behavior.computeResolve(ctx);
+                            this.vaultMonitor.endResolve(this.cellKey, behavior.key, ctx);
+                        }
+                        break;
+                    case BehaviorTypes.StepwiseResolve:
+                    case BehaviorTypes.StepwiseFilter:
+                    case BehaviorTypes.StepwiseReducer:
+                        if (typeof behavior.evaluateStepwise === 'function') {
+                            this.vaultMonitor.startStepwise(this.cellKey, behavior.key, ctx);
+                            next = await behavior.evaluateStepwise(isolateValue(ctx.lastSnapshot.value), isolateValue(current), ctx.featureCellKey);
+                            this.vaultMonitor.endStepwise(this.cellKey, behavior.key, ctx);
+                        }
+                        break;
+                    case BehaviorTypes.Filter:
+                        if (typeof behavior.applyFilter === 'function') {
+                            for (const filter of this.#filterFunctions) {
+                                this.vaultMonitor.startFilter(this.cellKey, behavior.key, ctx);
+                                const nextValue = await behavior.applyFilter(current, filter);
+                                this.vaultMonitor.endFilter(this.cellKey, behavior.key, ctx);
+                                if (isDefined(nextValue)) {
+                                    current = nextValue;
+                                }
+                            }
+                        }
+                        break;
+                    case BehaviorTypes.CoreBeforeTap:
+                        if (typeof behavior.applyBeforeTap === 'function') {
+                            for (const beforeTap of this.#beforeTapCallbacks) {
+                                this.vaultMonitor.startBeforeTap(this.cellKey, behavior.key, ctx);
+                                await behavior.applyBeforeTap(current, beforeTap);
+                                this.vaultMonitor.endBeforeTap(this.cellKey, behavior.key, ctx);
+                            }
+                        }
+                        break;
+                    case BehaviorTypes.Reduce:
+                        if (typeof behavior.applyReducer === 'function') {
+                            if (isUndefined(current) && this.#reducerFunctions.length > 0) {
+                                throw new Error(`[vault] Reducer stage received undefined state in FeatureCell "${this.cellKey}", but reducers are registered.`);
+                            }
+                            for (const reducer of this.#reducerFunctions) {
+                                this.vaultMonitor.startReducer(this.cellKey, behavior.key, ctx);
+                                const nextValue = await behavior.applyReducer(current, reducer);
+                                this.vaultMonitor.endReducer(this.cellKey, behavior.key, ctx);
+                                if (isDefined(nextValue)) {
+                                    current = nextValue;
+                                }
+                            }
+                        }
+                        break;
+                    case BehaviorTypes.CoreAfterTap:
+                        if (typeof behavior.applyAfterTap === 'function') {
+                            for (const afterTap of this.#afterTapCallbacks) {
+                                this.vaultMonitor.startAfterTap(this.cellKey, behavior.key, ctx);
+                                await behavior.applyAfterTap(current, afterTap);
+                                this.vaultMonitor.endAfterTap(this.cellKey, behavior.key, ctx);
+                            }
+                        }
+                        break;
+                }
+            }
+            catch (err) {
+                this.vaultMonitor.runtimeError(this.cellKey, behavior.key, ctx, err);
+                throw err;
+            }
+            if (isDefined(next))
+                current = next;
+        }
+        return current;
+    }
+    async #runInterceptorStage(ctx) {
+        const interceptorBehaviors = this.#stageBehaviors.filter((behavior) => behavior.type === BehaviorTypes.Interceptor);
+        for (const behavior of interceptorBehaviors) {
+            try {
+                this.vaultMonitor.startInterceptor(this.cellKey, behavior.key, ctx);
+                const nextIncoming = await behavior.applyInterceptor(ctx);
+                if (isSignalStop(nextIncoming)) {
+                    this.vaultMonitor.endInterceptor(this.cellKey, behavior.key, ctx, { pipelinePaused: true });
+                    return VAULT_STOP;
+                }
+                this.vaultMonitor.endInterceptor(this.cellKey, behavior.key, ctx);
+            }
+            catch (err) {
+                this.vaultMonitor.runtimeError(this.cellKey, behavior.key, ctx, err);
+                throw err;
+            }
+        }
+        return;
+    }
+    #containsOperators() {
+        const operatorBehaviors = this.#stageBehaviors.filter((behavior) => behavior.type === BehaviorTypes.Operator);
+        return operatorBehaviors.length > 0;
+    }
+    async #runOperatorStage(ctx, current) {
+        const operatorBehaviors = this.#stageBehaviors.filter((behavior) => behavior.type === BehaviorTypes.Operator);
+        for (const behavior of operatorBehaviors) {
+            try {
+                this.vaultMonitor.startOperator(this.cellKey, behavior.key, ctx);
+                const next = await behavior.applyOperator(current);
+                if (isUndefined(next)) {
+                    // short-circuit pipeline — operator decided to block this write
+                    this.vaultMonitor.endOperator(this.cellKey, behavior.key, ctx, { noop: true });
+                    return undefined;
+                }
+                current = next;
+                this.vaultMonitor.endOperator(this.cellKey, behavior.key, ctx);
+            }
+            catch (err) {
+                this.vaultMonitor.runtimeError(this.cellKey, behavior.key, ctx, err);
+                throw err;
+            }
+        }
+        return current;
+    }
+    async #runPersistStage(stage, ctx, current) {
+        let stageBehaviors;
+        stageBehaviors = this.#stageBehaviors.filter((behavior) => behavior.type === stage);
+        for (const behavior of stageBehaviors) {
+            try {
+                switch (stage) {
+                    case BehaviorTypes.Encrypt:
+                        if (typeof behavior.encryptState === 'function') {
+                            this.vaultMonitor.startEncrypt(this.cellKey, behavior.key, ctx);
+                            current = await behavior.encryptState(ctx, current);
+                            this.vaultMonitor.endEncrypt(this.cellKey, behavior.key, ctx);
+                        }
+                        break;
+                    case BehaviorTypes.Persist:
+                        if (typeof behavior.persistState === 'function') {
+                            this.vaultMonitor.startPersist(this.cellKey, behavior.key, ctx);
+                            await behavior.persistState(current);
+                            this.vaultMonitor.endPersist(this.cellKey, behavior.key, ctx);
+                        }
+                        break;
+                }
+            }
+            catch (err) {
+                this.vaultMonitor.runtimeError(this.cellKey, behavior.key, ctx, err);
+                throw err;
+            }
+        }
+        return current;
+    }
+    #destroyBehaviors(ctx) {
+        for (const behavior of this.#behaviors) {
+            this.vaultMonitor.startDestroy(this.cellKey, behavior.key, ctx);
+            try {
+                behavior.destroy?.(ctx);
+                this.vaultMonitor.endDestroy(this.cellKey, behavior.key, ctx);
+            }
+            catch (err) {
+                vaultError(`${behavior.key} destroy() failed`, err);
+                this.vaultMonitor.endDestroy(this.cellKey, behavior.key, ctx, { destroyFailed: true });
+            }
+        }
+    }
+    #resetBehaviors(ctx) {
+        for (const behavior of this.#behaviors) {
+            this.vaultMonitor.startReset(this.cellKey, behavior.key, ctx);
+            try {
+                behavior.reset?.(ctx);
+                this.vaultMonitor.endReset(this.cellKey, behavior.key, ctx);
+            }
+            catch (err) {
+                vaultError(`${behavior.key} reset() failed`, err);
+                this.vaultMonitor.endReset(this.cellKey, behavior.key, ctx, { resetFailed: true });
+            }
+        }
+    }
+    async #runStateBehaviors(ctx) {
+        if (this.#emitStateCallbacks?.length > 0) {
+            const lastSnapshotClone = isolateValue(ctx.lastSnapshot);
+            this.vaultMonitor.startCoreEmitState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            for (const callback of this.#emitStateCallbacks) {
+                await this.#emitStateCallbackBehavior.emitState(lastSnapshotClone, callback);
+            }
+            this.vaultMonitor.endCoreEmitState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        }
+    }
+    /**
+     * Runs the error behaviors in sequence.
+     *
+     * - Starts from a normalized ResourceError produced by resourceError().
+     * - Each behavior gets (rawError, currentResourceError, ctx).
+     * - If a behavior returns:
+     *    • ResourceError → becomes the next currentResourceError
+     *    • VAULT_NOOP    → previous ResourceError is kept
+     *
+     * Returns void
+     */
+    async #runErrorBehaviors(rawError, ctx) {
+        let current;
+        /**
+         * The order is
+         *
+         * Core Error
+         * Transforms
+         * State
+         * Callbacks
+         * Global Error Service
+         */
+        // ---- Core error normalization (trusted) ----
+        try {
+            this.vaultMonitor.startCoreError(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            current = await this.#coreErrorBehavior.handleError(rawError, ctx.featureCellKey);
+            vaultDebug(`${this.cellKey} #runErrorBehaviors starting with base ResourceError: ${JSON.stringify(current)}`);
+        }
+        catch (err) {
+            vaultError('[vault] Core error normalization failed', err);
+            current = createVaultError(rawError, ctx.featureCellKey);
+        }
+        finally {
+            this.vaultMonitor.endCoreError(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        }
+        // ---- Error behaviors (untrusted, isolated) ----
+        for (const behavior of this.#errorTransformBehaviors) {
+            try {
+                this.vaultMonitor.startErrorTransform(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+                const result = await behavior.transformError(isolateValue(rawError), isolateValue(current), isolateValue(ctx.lastSnapshot));
+                if (!isVaultNoop(result) && !isNullish(result)) {
+                    current = result;
+                }
+            }
+            catch (err) {
+                vaultError(`[vault] ErrorBehavior "${behavior.key}" threw during error handling`, err);
+            }
+            finally {
+                this.vaultMonitor.endErrorTransform(this.cellKey, VAULT_ORCHESTRATOR, ctx, current);
+            }
+        }
+        // ---- Commit error state (trusted, must run) ----
+        try {
+            this.vaultMonitor.startCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            await this.#coreStateBehavior.finalizePipelineError(current, ctx);
+            await this.#runStateBehaviors(ctx);
+        }
+        catch (err) {
+            vaultError('[vault] Failed to finalize error state', err);
+        }
+        finally {
+            this.vaultMonitor.endCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        }
+        try {
+            this.vaultMonitor.startGlobalError(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            await this.privateErrorService.setError(isolateValue(current));
+        }
+        catch (err) {
+            // istanbul ignore next -- defensive only not testable
+            vaultError('[vault] global error service', err);
+        }
+        finally {
+            this.vaultMonitor.endGlobalError(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        }
+        // ---- Error callbacks (untrusted, isolated) ----
+        if (this.#errorCallbacks?.length > 0) {
+            this.vaultMonitor.startCoreCallbackError(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            for (const callback of this.#errorCallbacks) {
+                try {
+                    await this.#coreErrorCallbackBehavior.callbackError(isolateValue(current), isolateValue(ctx.lastSnapshot), callback);
+                }
+                catch (err) {
+                    vaultError('[vault] Error callback threw during error handling', err);
+                }
+            }
+            this.vaultMonitor.endCoreCallbackError(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        }
+        vaultDebug(`${this.cellKey} #runErrorBehaviors completed with final ResourceError: ${JSON.stringify(current)}`);
+        return current;
+    }
+    #getResolveType(incoming) {
+        if (isHttpResourceRef(incoming)) {
+            return ResolveTypes.HttpResource;
+        }
+        else if (isObservable(incoming)) {
+            return ResolveTypes.Observable;
+        }
+        else if (isFunction(incoming) || isFunction(incoming?.value)) {
+            return ResolveTypes.Promise;
+        }
+        else if (isPromise(incoming) || isPromise(incoming?.value)) {
+            throw new VaultUsagePromiseError();
+        }
+        else {
+            return ResolveTypes.Value;
+        }
+    }
+    async #loadInitialState(ctx) {
+        const incoming = {
+            value: undefined,
+            loading: false,
+            error: null
+        };
+        let value = undefined;
+        if (isFunction(this.#initialState)) {
+            value = this.#initialState;
+        }
+        else {
+            const persistBehaviors = this.#getPersistedBehaviors();
+            if (persistBehaviors.length > 0) {
+                const persistedInitalValue = await this.#loadInitialPersistedState(ctx, persistBehaviors);
+                if (isDefined(persistedInitalValue)) {
+                    vaultDebug('Persisted data loaded from storage');
+                    value = persistedInitalValue;
+                }
+            }
+            else if (!isNullish(this.#initialState)) {
+                this.vaultMonitor.startSetInitialValue(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+                vaultDebug('Initialized data loaded from descriptor.initial');
+                value = this.#initialState;
+                this.vaultMonitor.endSetInitialValue(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            }
+        }
+        incoming.value = value;
+        if (!isNullish(incoming.value)) {
+            await this.orchestrate(this.prepIncomingForOrchestration(ctx, incoming, OperationTypes.Replace));
+        }
+        else {
+            this.decisionEngine?.notifySuccess(this.buildControllerCtx(ctx));
+        }
+    }
+    #getPersistedBehaviors() {
+        return this.#stageBehaviors.filter((behavior) => behavior.type === BehaviorTypes.Persist);
+    }
+    async #loadInitialPersistedState(ctx, persistBehaviors) {
+        let loaded = undefined;
+        for (const behavior of persistBehaviors) {
+            try {
+                this.vaultMonitor.startLoadPersist(this.cellKey, behavior.key, ctx);
+                loaded = await behavior.loadState?.();
+                if (isDefined(loaded)) {
+                    this.vaultMonitor.endLoadPersist(this.cellKey, behavior.key, ctx);
+                    break;
+                }
+                else {
+                    this.vaultMonitor.endLoadPersist(this.cellKey, behavior.key, ctx, { noop: true });
+                }
+                // eslint-disable-next-line
+            }
+            catch (err) {
+                this.vaultMonitor.runtimeError(this.cellKey, behavior.key, ctx, err);
+                vaultWarn(`"[vault] persist.loadState()" for ${behavior.key} failed with ${err.message}`);
+            }
+        }
+        const decryptBehaviors = this.#stageBehaviors.filter((behavior) => {
+            return behavior.type === BehaviorTypes.Encrypt;
+        });
+        if (isDefined(loaded) && decryptBehaviors.length > 0) {
+            for (const behavior of decryptBehaviors) {
+                try {
+                    this.vaultMonitor.startDecrypt(this.cellKey, behavior.key, ctx);
+                    const decrypted = await behavior.decryptState?.(ctx, loaded);
+                    if (isDefined(decrypted)) {
+                        this.vaultMonitor.endDecrypt(this.cellKey, behavior.key, ctx);
+                        loaded = decrypted;
+                    }
+                    else {
+                        this.vaultMonitor.endDecrypt(this.cellKey, behavior.key, ctx, { noop: true });
+                    }
+                    // eslint-disable-next-line
+                }
+                catch (err) {
+                    this.vaultMonitor.runtimeError(this.cellKey, behavior.key, ctx, err);
+                    vaultWarn(`"[vault] encrypt.decryptState()" for ${behavior.key} failed with ${err.message}`);
+                    return undefined;
+                }
+            }
+        }
+        return loaded;
+    }
+}
+
+const ConductorLicenseStatusTypes = {
+    Pending: 'pending',
+    Approved: 'approved',
+    Denied: 'denied'
+};
+
+// projects/core/src/lib/services/vault-controller-lifecycle.service.ts
+/**
+ * Manages instantiation and validation of controllers for a FeatureCell.
+ *
+ * This class is responsible for constructing controller instances from
+ * declared controller classes, validating required metadata, enforcing
+ * uniqueness of controller keys, and wiring controller revote callbacks
+ * into the controller event stream.
+ */
+class ControllerInitializationClass {
+    /** Tracks whether controller initialization has already occurred. */
+    #initialized = false;
+    /** FeatureCell identifier associated with this initializer. */
+    #cellKey;
+    /**
+     * Creates a new initializer for a specific FeatureCell.
+     *
+     * @param cellKey - The unique FeatureCell key.
+     */
+    constructor(cellKey) {
+        this.#cellKey = cellKey;
+    }
+    /**
+     * Instantiates and validates all controllers declared for a FeatureCell.
+     *
+     * This method enforces one-time initialization, validates controller
+     * metadata and key format, ensures uniqueness of controller keys, and
+     * injects a revote callback that emits controller lifecycle events.
+     *
+     * @typeParam T - The FeatureCell state value type.
+     * @param controllerClasses - Controller class definitions to instantiate.
+     * @param events$ - Subject used to emit controller lifecycle events.
+     * @returns An ordered array of instantiated controller objects.
+     */
+    initializeControllers(controllerClasses, events$, controllerConfigs) {
+        if (this.#initialized)
+            throw new Error(`[vault] VaultControllerRunner already initialized — cannot reissue core controller ID for feature cell "${this.#cellKey}".`);
+        this.#initialized = true;
+        if (!controllerClasses || controllerClasses.length === 0)
+            return [];
+        const seenKeys = new Set();
+        return (controllerClasses
+            // eslint-disable-next-line
+            .map((ControllerClass) => {
+            let isCritical = false;
+            try {
+                if (typeof ControllerClass !== 'function')
+                    return;
+                const meta = ControllerClass[CONTROLLER_META];
+                if (!meta) {
+                    isCritical = true;
+                    throw new Error(`[vault] Controller "${ControllerClass.name}" missing @VaultController metadata.`);
+                }
+                const controllerKey = meta.key;
+                const controllerType = meta.type;
+                if (!controllerKey) {
+                    isCritical = true;
+                    throw new Error(`[vault] Controller metadata missing "key".`);
+                }
+                if (!controllerType) {
+                    isCritical = true;
+                    throw new Error(`[vault] Controller metadata missing "type" for "${controllerKey}".`);
+                }
+                let controllerConfig = undefined;
+                if (meta.wantsConfig) {
+                    if (!meta.configKey) {
+                        isCritical = true;
+                        throw new Error(`[vault] Controller "${controllerKey}" declares wantsConfig but has no configKey.`);
+                    }
+                    controllerConfig = controllerConfigs.get(meta.configKey);
+                }
+                let licensePayload = undefined;
+                if (meta.needsLicense) {
+                    if (!meta.licenseId) {
+                        isCritical = true;
+                        throw new Error(`[vault] Controller "${controllerKey}" declares needsLicense but has no licenseId.`);
+                    }
+                    licensePayload = getLicensePayload(meta.licenseId);
+                    if (licensePayload === undefined) {
+                        isCritical = true;
+                        throw new Error(`[vault] License "${meta.licenseId}" required by controller "${controllerKey}" is not registered in Vault config.`);
+                    }
+                }
+                const controllerClassContext = {
+                    featureCellKey: this.#cellKey,
+                    requestRevote: (traceId) => {
+                        events$.next({
+                            traceId,
+                            type: ControllerEventTypes.Revote
+                        });
+                    },
+                    requestAbort: (traceId) => {
+                        events$.next({
+                            traceId,
+                            type: ControllerEventTypes.Abort
+                        });
+                    },
+                    controllerConfig,
+                    licensePayload
+                };
+                if (controllerType === ControllerTypes.License) {
+                    controllerClassContext.licenseDenied = (traceId) => {
+                        events$.next({
+                            traceId,
+                            type: ControllerEventTypes.LicenseDenied
+                        });
+                    };
+                    controllerClassContext.licenseApproved = (traceId) => {
+                        events$.next({
+                            traceId,
+                            type: ControllerEventTypes.LicenseApproved
+                        });
+                    };
+                }
+                const instance = new ControllerClass(controllerKey, controllerClassContext);
+                if (!instance.key) {
+                    isCritical = true;
+                    throw new Error(`[vault] Controller missing key for type "${controllerType}". Every controller must define a unique "key".`);
+                }
+                if (!validateControllerKey(instance.key)) {
+                    isCritical = true;
+                    throw new Error(`[vault] Controller key "${instance.key}" not valid format for "${controllerType}" controller.`);
+                }
+                if (instance.key && seenKeys.has(instance.key)) {
+                    vaultWarn(`[vault] Skipping duplicate controller with key "${instance.key}"`);
+                    return null;
+                }
+                if (instance.key)
+                    seenKeys.add(instance.key);
+                return instance;
+            }
+            catch (err) {
+                if (isCritical) {
+                    throw err;
+                }
+                // eslint-disable-next-line
+                vaultWarn(`[vault] Non-critical controller initialization failed: ${err?.message}`);
+                return null;
+            }
+        })
+            .filter((controller) => !!controller));
+    }
+}
+
+class Conductor extends Orchestrator {
+    #attemptQueue = [];
+    #controllers = [];
+    #events$ = new Subject();
+    #processing = false;
+    #isDenyStateForTesting = false;
+    #conductorLicenseStatus = ConductorLicenseStatusTypes.Pending;
+    #settled$ = new Subject();
+    constructor(config) {
+        super(config);
+        LicensingService().describeFeature({
+            featureCellKey: config.cell.key,
+            fluentApis: {
+                filters: config.filterCallbacks,
+                reducers: config.reducerCallbacks,
+                beforeTaps: config.beforeTapCallbacks,
+                afterTaps: config.afterTapCallbacks,
+                emitStateCallbacks: config.emitStateCallbacks,
+                errorCallbacks: config.errorCallbacks
+            }
+        });
+        if (DevMode.active) {
+            // eslint-disable-next-line
+            this.vaultSettled = this.#conductorSettled.bind(this);
+        }
+        this.#registerControllers(config);
+        this.vaultMonitor.conductorLicenseAttempt(this.cellKey, `${this.cellKey}::license`);
+        this.initializeOrchestrator(config);
+    }
+    initialize(ctx) {
+        const initCtx = this.#buildPipelineCtx(ctx, OperationTypes.Initialize, undefined);
+        this.#enqueueAttempt({
+            behaviorCtx: initCtx,
+            controllerCtx: this.buildControllerCtx(initCtx),
+            options: undefined
+        });
+    }
+    //#region public method
+    conduct(ctx, incoming, operation, options) {
+        const behaviorCtx = this.#buildPipelineCtx(ctx, operation, options);
+        const ensuredIncoming = this.#ensureIncoming(this.prepIncomingForOrchestration(behaviorCtx, incoming, operation));
+        if (isVaultNoop(ensuredIncoming)) {
+            return;
+        }
+        behaviorCtx.incoming = ensuredIncoming;
+        const controllerCtx = this.buildControllerCtx(behaviorCtx);
+        this.#enqueueAttempt({ behaviorCtx, controllerCtx, options });
+    }
+    /**
+     * Resets pipeline + controller state for this FeatureCell.
+     *
+     * FeatureCell should call this from its own reset() method.
+     */
+    reset(ctx) {
+        this.vaultMonitor.startReset(this.cellKey, VAULT_CONDUCTOR, ctx);
+        ctx.traceId = ctx.traceId ?? assignTraceId();
+        this.#resetConductor();
+        this.resetBehaviors(ctx);
+        this.#resetControllers(ctx);
+        // Reset controllers as well.
+        this.vaultMonitor.endReset(this.cellKey, VAULT_CONDUCTOR, ctx);
+    }
+    /**
+     * Destroys pipeline + controller state for this FeatureCell.
+     *
+     * FeatureCell should call this from its own destroy() method.
+     */
+    destroy(ctx) {
+        vaultDebug(`${VAULT_CONDUCTOR} - destroy`);
+        ctx.traceId = ctx.traceId ?? assignTraceId();
+        this.vaultMonitor.startDestroy(this.cellKey, VAULT_CONDUCTOR, ctx);
+        this.#resetConductor();
+        this.destroyBehaviors(ctx);
+        this.#destroyControllers(ctx);
+        // Tear down controllers.
+        this.#events$.complete();
+        this.vaultMonitor.endDestroy(this.cellKey, VAULT_CONDUCTOR, ctx);
+    }
+    //#endregion
+    //#region Private Methods
+    async #processEvent(ctx, options) {
+        if (ctx.operation === OperationTypes.Initialize) {
+            await this.initializeFeatureCell(ctx);
+            return;
+        }
+        if (ctx.operation === OperationTypes.Replace || ctx.operation === OperationTypes.Merge) {
+            await this.orchestrate(ctx, options);
+            return;
+        }
+        this.vaultMonitor.runtimeError(this.cellKey, VAULT_CONDUCTOR, ctx, new Error(`Unknown operation type: "${ctx.operation}"`));
+        this.#completeCurrentAttempt(ctx);
+    }
+    #enqueueMicrotask() {
+        queueMicrotask(() => {
+            this.#denyAttemptCompleted();
+        });
+    }
+    /**
+     * Enqueue an attempt and trigger queue processing if idle.
+     */
+    #enqueueAttempt(pending) {
+        if (this.#conductorLicenseStatus === ConductorLicenseStatusTypes.Pending ||
+            this.#conductorLicenseStatus === ConductorLicenseStatusTypes.Approved) {
+            this.vaultMonitor.startControllerAttempt(this.cellKey, pending.behaviorCtx.traceId, pending.controllerCtx);
+            this.#attemptQueue.push(pending);
+            if (this.#conductorLicenseStatus === ConductorLicenseStatusTypes.Approved) {
+                if (!this.#processing && this.#attemptQueue.length === 1) {
+                    this.#processQueue();
+                }
+                else {
+                    if (this.#isDenyStateForTesting) {
+                        this.#enqueueMicrotask();
+                    }
+                }
+            }
+            else {
+                this.#enqueueMicrotask();
+            }
+        }
+        else {
+            this.#enqueueMicrotask();
+        }
+    }
+    #completeCurrentAttempt(ctx) {
+        const head = this.#attemptQueue[0];
+        /* istanbul ignore next */
+        if (!head || head.finalized)
+            return;
+        head.finalized = true;
+        /**
+         * IMPORTANT: Finalization MUST occur inside a microtask.
+         *
+         * Why?
+         * The conductor processes controller outcomes and orchestrator work
+         * within the same JavaScript turn. If `notifyFinalize()` runs
+         * synchronously here, it can:
+         *
+         *  - Re-enter the pipeline before the current call stack fully drains
+         *  - Trigger controller/orchestrator side effects in the same tick
+         *  - Cause double-finalization or out-of-order queue mutation
+         *  - Break `vaultSettled()` determinism in DevMode
+         *
+         * By deferring to a microtask:
+         *
+         *  1. The current pipeline cycle fully drains.
+         *  2. All synchronous controller emissions complete.
+         *  3. The attempt is finalized in a clean turn boundary.
+         *  4. Queue mutation (shift) happens atomically with finalize.
+         *  5. `#processQueue()` runs only after processing state resets.
+         *
+         * DO NOT:
+         *  - Move `notifyFinalize()` outside this microtask.
+         *  - Split this into multiple microtasks.
+         *  - Make queue mutation synchronous.
+         *
+         * The ordering inside this microtask is intentional:
+         *
+         *   notifyFinalize →
+         *   shift queue →
+         *   reset processing flag →
+         *   signal vault settled →
+         *   process next attempt
+         *
+         * This guarantees:
+         *  - Single active attempt at a time
+         *  - No reentrancy
+         *  - Deterministic queue progression
+         *  - Stable DevMode/test flushing behavior
+         */
+        queueMicrotask(() => {
+            this.decisionEngine.notifyFinalize(ctx);
+            this.#attemptQueue.shift();
+            this.#processing = false;
+            this.#attemptCompleted();
+            this.#processQueue();
+        });
+    }
+    #resetProcessingState(ctx, outcome) {
+        this.vaultMonitor.restartControllerAttempt(this.cellKey, ctx.traceId, ctx, outcome);
+        this.#processing = false;
+    }
+    /**
+     * Central queue processor:
+     *  - ensures only one attempt is processed at a time
+     *  - runs controllers for the active attempt
+     *  - on Allow → runs Orchestrator
+     *  - on Reset/other → calls reset() for that context
+     *  - then continues to the next queued attempt
+     */
+    async #processQueue() {
+        if (this.#processing)
+            return;
+        if (!this.#attemptQueue.length)
+            return;
+        this.#processing = true;
+        const activeAttempt = this.#attemptQueue[0];
+        // istanbul ignore next line - defensive only
+        if (!activeAttempt) {
+            // istanbul ignore next line - defensive only
+            this.#processing = false;
+            // istanbul ignore next line - defensive only
+            return;
+        }
+        try {
+            const outcome = await firstValueFrom(this.#runControllers(activeAttempt));
+            const pending = this.#attemptQueue[0];
+            if (!pending) {
+                this.#processing = false;
+                return;
+            }
+            const { behaviorCtx, options } = pending;
+            let isDeny = false;
+            switch (outcome) {
+                // ───────────────────────────────────────────────
+                // ALLOW → orchestrator will run → outcome will later drive CLEAR
+                // ───────────────────────────────────────────────
+                case DecisionOutcomeTypes.Abstain: {
+                    vaultDebug(`${this.cellKey} DecisionOutcome: "${DecisionOutcomeTypes.Abstain} received. Process Event dispatched.`);
+                    await this.#processEvent(behaviorCtx, options);
+                    break;
+                }
+                // ───────────────────────────────────────────────
+                // FAIL → request is dead → remove + continue
+                // ───────────────────────────────────────────────
+                case DecisionOutcomeTypes.Abort: {
+                    this.controllerOutcomeNotification(DecisionOutcomeTypes.Abort, behaviorCtx);
+                    this.vaultMonitor.endControllerAttempt(this.cellKey, behaviorCtx.traceId, behaviorCtx, {
+                        status: outcome
+                    });
+                    this.#completeCurrentAttempt(behaviorCtx);
+                    break;
+                }
+                // ───────────────────────────────────────────────
+                // DENY → pipeline blocked → keep attempt at head, do NOT shift
+                // ───────────────────────────────────────────────
+                case DecisionOutcomeTypes.Deny: {
+                    // do nothing — wait for external change
+                    this.#denyAttemptCompleted();
+                    isDeny = true;
+                    this.#processing = false;
+                    this.vaultMonitor.notifyConductorDeny(this.cellKey, behaviorCtx.traceId, behaviorCtx);
+                    this.controllerOutcomeNotification(DecisionOutcomeTypes.Deny, behaviorCtx);
+                    break;
+                }
+            }
+            if (isDeny) {
+                this.#isDenyStateForTesting = true;
+            }
+            else {
+                this.#isDenyStateForTesting = false;
+                return this.#processQueue();
+            }
+            // ───────────────────────────────────────────────
+            // ERROR → treat as fail, shift queue, continue
+            // ───────────────────────────────────────────────
+            /*********************************
+             * Catastrophic unreachable state — controller pipeline failed outside arbitrator
+             * on 2025-12-10 I made the decision to leave it though I'm not a fan of untestable
+             * and should be pruned code
+             *********************************/
+        }
+        catch (err) {
+            //istanbul ignore next
+            vaultError('[conductor] Unreachable subscription error', err);
+            //istanbul ignore next
+            this.vaultMonitor.conductorCrashed(this.cellKey, activeAttempt?.controllerCtx.traceId ?? 'unknown', activeAttempt?.controllerCtx ?? { traceId: 'unknown' }, err);
+            // Try to drop the corrupted request to recover
+            //istanbul ignore next
+            this.#attemptQueue.shift();
+            //istanbul ignore next
+            this.#processQueue();
+        }
+    }
+    #registerDecisionEngine() {
+        this.decisionEngine = new DecisionEngine(this.#controllers, this.#events$);
+        this.#events$.subscribe({
+            next: (event) => {
+                if (event.type === ControllerEventTypes.LicenseDenied) {
+                    this.vaultMonitor.conductorLicenseDenied(this.cellKey, event.traceId);
+                    this.#conductorLicenseStatus = ConductorLicenseStatusTypes.Denied;
+                    const error = new Error(`${this.cellKey} Conductor Decision Engine: The FeatureCell received a "License Denied". Pipeline is disabled.`);
+                    vaultDebug(error.message);
+                    this.privateErrorService.setError(createVaultError(error, this.cellKey));
+                    this.#attemptQueue.length = 0;
+                    return;
+                }
+                if (event.type === ControllerEventTypes.LicenseApproved) {
+                    this.vaultMonitor.conductorLicenseApproved(this.cellKey, event.traceId);
+                    this.#conductorLicenseStatus = ConductorLicenseStatusTypes.Approved;
+                    vaultDebug(`${this.cellKey} Conductor Decision Engine: License Approved.`);
+                    this.#processQueue();
+                    return;
+                }
+                const head = this.#attemptQueue[0];
+                if (!head)
+                    return;
+                // Defensive guard: with serialized pipeline execution,
+                // controller events cannot arrive out of order.
+                // This is retained as a safety net against future regressions.
+                /* istanbul ignore next */
+                if (head.controllerCtx.traceId !== event.traceId) {
+                    vaultDebug(`The head ctx is not the same as the event. ${head.controllerCtx.traceId} != ${event.traceId}`);
+                    return;
+                }
+                // For both Success and Fail, this request is DONE from the queue’s POV
+                switch (event.type) {
+                    case ControllerEventTypes.Success: {
+                        this.vaultMonitor.endControllerAttempt(this.cellKey, head.behaviorCtx.traceId, head.controllerCtx, {
+                            status: 'success'
+                        });
+                        this.#completeCurrentAttempt(head.controllerCtx);
+                        break;
+                    }
+                    case ControllerEventTypes.Failure: {
+                        this.vaultMonitor.endControllerAttempt(this.cellKey, head.behaviorCtx.traceId, head.controllerCtx, {
+                            status: 'failure'
+                        });
+                        this.#resetProcessingState(head.behaviorCtx, event.type);
+                        break;
+                    }
+                    case ControllerEventTypes.Abort: {
+                        this.vaultMonitor.conductorAbort(this.cellKey, event.traceId, head.controllerCtx);
+                        vaultDebug(`${this.cellKey} Conductor Decision Engine: Abort request received for Behavior TraceId: ${head.controllerCtx.traceId}.`);
+                        this.#completeCurrentAttempt(head.controllerCtx);
+                        break;
+                    }
+                    case ControllerEventTypes.Revote: {
+                        vaultDebug(`${this.cellKey} Conductor Decision Engine: Revote request received for Behavior TraceId: ${head.controllerCtx.traceId}.`);
+                        this.vaultMonitor.conductorRevote(this.cellKey, event.traceId, head.controllerCtx);
+                        this.#processing = false;
+                        vaultDebug(`${this.cellKey} Conductor Decision Engine: processQueue event dispatched for Behavior TraceId: ${head.controllerCtx.traceId}.`);
+                        this.#processQueue();
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    #buildPipelineCtx(ctx, operation, options) {
+        const traceId = assignTraceId();
+        return {
+            // shared, live references (DO NOT CLONE)
+            destroyed$: ctx.destroyed$,
+            reset$: ctx.reset$,
+            state$: ctx.state$,
+            featureCellKey: ctx.featureCellKey,
+            state: ctx.state,
+            lastSnapshot: ctx.lastSnapshot,
+            options: options != null ? isolateValue(options) : options,
+            // per-attempt immutable values
+            traceId,
+            operation,
+            resolveType: undefined,
+            incoming: undefined
+        };
+    }
+    #ensureIncoming(ctx) {
+        const incoming = this.preparingIncoming(ctx);
+        if (isVaultNoop(incoming)) {
+            this.vaultMonitor.startCoreState(this.cellKey, VAULT_CONDUCTOR, ctx);
+            this.reset(ctx);
+            this.vaultMonitor.endCoreState(this.cellKey, VAULT_CONDUCTOR, ctx);
+        }
+        return incoming;
+    }
+    #resetConductor() {
+        this.#attemptQueue.length = 0;
+        this.#processing = false;
+    }
+    #destroyControllers(ctx) {
+        for (const controller of this.#controllers) {
+            this.vaultMonitor.startDestroy(this.cellKey, controller.key, ctx);
+            try {
+                controller.destroy?.();
+                this.vaultMonitor.endDestroy(this.cellKey, controller.key, ctx);
+            }
+            catch (err) {
+                vaultError(`${controller.key} destroy() failed`, err);
+                this.vaultMonitor.endDestroy(this.cellKey, controller.key, ctx, { destroyFailed: true });
+            }
+        }
+    }
+    #resetControllers(ctx) {
+        for (const controller of this.#controllers) {
+            this.vaultMonitor.startReset(this.cellKey, controller.key, ctx);
+            try {
+                controller.reset?.();
+                this.vaultMonitor.endReset(this.cellKey, controller.key, ctx);
+            }
+            catch (err) {
+                vaultError(`${controller.key} reset() failed`, err);
+                this.vaultMonitor.endReset(this.cellKey, controller.key, ctx, { resetFailed: true });
+            }
+        }
+    }
+    #addDefaultErrorController(controllers, config) {
+        const errorControllers = config.controllers.filter((controllerClass) => {
+            return controllerClass.type === ControllerTypes.Error;
+        });
+        if (errorControllers.length > 1) {
+            const names = errorControllers.map((errorController) => errorController.key).join(', ');
+            throw new Error(`SDuX Error: More than one ErrorController was provided. Only one error policy can be active per FeatureCell. Received: ${names}. Fix: Remove additional error controllers or combine them into a single controller.`);
+        }
+        if (errorControllers.length === 1) {
+            controllers.push(errorControllers[0]);
+        }
+        else {
+            controllers.unshift(withCoreErrorController);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // INTERNAL SCHEDULING
+    // ---------------------------------------------------------------------------
+    #registerControllers(config) {
+        config.controllers = config.controllers ?? [];
+        const allControllers = config.controllers.filter(Boolean);
+        this.#addDefaultErrorController(allControllers, config);
+        allControllers.unshift(withCoreLicenseController);
+        allControllers.unshift(withCoreAbstainController);
+        // eslint-disable-next-line
+        const controllerMetadata = allControllers.map((controller) => {
+            const meta = controller[CONTROLLER_META];
+            return {
+                key: controller.key,
+                type: meta.type,
+                critical: meta.critical,
+                needsLicense: meta.needsLicense
+            };
+        });
+        LicensingService().describeControllers({
+            featureCellKey: this.cellKey,
+            controllers: controllerMetadata
+        });
+        const controllerInit = new ControllerInitializationClass(config.cell.key);
+        this.#controllers = controllerInit.initializeControllers(allControllers, this.#events$, config.behaviorConfigs);
+        this.#registerDecisionEngine();
+    }
+    /**
+     * Run controllers for a single pending attempt and normalize their decision.
+     *
+     * Returns:
+     *  - ControllerVotes.Allow
+     *  - ControllerVotes.Reset
+     *
+     * All more detailed opinions (Deny/Retry/Buffer/Abstain) are reduced
+     * at this layer for now.
+     */
+    #runControllers(pending) {
+        this.vaultMonitor.startControllerVote(this.cellKey, pending.controllerCtx.traceId, pending.controllerCtx);
+        return this.decisionEngine.evaluateAttempt(pending.controllerCtx)?.pipe(tap((decision) => {
+            this.vaultMonitor.endControllerVote(this.cellKey, pending.controllerCtx.traceId, pending.controllerCtx, decision);
+        }), map((decision) => decision.outcome));
+    }
+    #denyAttemptCompleted() {
+        if (!DevMode.active)
+            return;
+        this.#settled$.next();
+    }
+    // ADD
+    #attemptCompleted() {
+        if (!DevMode.active || this.#attemptQueue.length > 0)
+            return;
+        queueMicrotask(() => {
+            this.#settled$.next();
+        });
+    }
+    #conductorSettled() {
+        return firstValueFrom(this.#settled$);
+    }
+}
+
+/**
+ * Canonical identifier used to label FeatureCell-related ownership or origin.
+ */
+const VAULT_FEATURE_CELL = 'vault-feature-cell';
+
+/**
+ * Validates a `FeatureCelldescriptorModel` configuration prior to FeatureCell
+ * initialization. This function ensures that the descriptor is structurally
+ * correct and that conflicting behaviors are not registered on the same
+ * FeatureCell instance.
+ *
+ * The validation enforces two primary constraints:
+ *
+ * 1. **Initial State Shape Validation**
+ *    The `initial` value must represent plain unwrapped data (e.g., `{}`, `[]`,
+ *    or primitives). Passing a resource-like object containing fields such as
+ *    `{ loading, data, error }` is not permitted because FeatureCells wrap
+ *    values internally and would otherwise double-encapsulate resource state.
+ *
+ * 2. **Encryption Behavior Exclusivity**
+ *    A FeatureCell may register at most one encryption behavior. Multiple
+ *    encryption behaviors introduce conflicting state guarantees and are
+ *    rejected during validation.
+ *
+ * @typeParam T - The type representing the FeatureCell’s state shape.
+ *
+ * @param descriptor - The declared FeatureCell descriptor, including key and initial state.
+ * @param behaviors - A list of behavior classes registered for this FeatureCell.
+ *
+ * @throws Error if the initial state contains resource-like fields.
+ * @throws Error if more than one encryption behavior is provided.
+ */
+function featureCellValidation(descriptor, behaviors = []) {
+    // Prevent incorrect initialization (e.g., passing a resource object)
+    if (typeof descriptor.initialState === 'object' &&
+        descriptor.initialState !== null &&
+        // eslint-disable-next-line
+        'data' in descriptor.initialState) {
+        throw new Error(`[vault] Invalid FeatureCelldescriptorModel.initial for feature "${descriptor.key}". Expected raw data (e.g., [] or {}), but received an object with resource fields { loading, data, error }. Pass plain data to avoid double-wrapping.`);
+    }
+    const encryptBehaviors = behaviors.filter((behavior) => behavior.type === BehaviorTypes.Encrypt);
+    if (encryptBehaviors.length > 1) {
+        throw new Error(`[vault] FeatureCell cannot register multiple encryption behaviors.`);
+    }
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > factories > feature-cell > feature-cell.builder.ts
+// Updated: 2026-03-02 19:52
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+class FeatureCellBuilder {
+    featureCellConfiguration;
+    defaultBehaviors;
+    behaviors;
+    controllers;
+    #cellCorrupt = false;
+    #conductor;
+    #initialized = false;
+    #vaultMonitor = VaultMonitor();
+    cell;
+    cellKey;
+    ctx;
+    destroyed$ = new Subject();
+    reset$ = new Subject();
+    state$ = new Subject();
+    constructor(
+    // kept for parity with original API, even if not used directly
+    featureCellConfiguration, defaultBehaviors, behaviors, controllers) {
+        this.featureCellConfiguration = featureCellConfiguration;
+        this.defaultBehaviors = defaultBehaviors;
+        this.behaviors = behaviors;
+        this.controllers = controllers;
+        this.cellKey = this.featureCellConfiguration.key;
+        this.ctx = this.#buildCtx();
+    }
+    #buildCtx() {
+        const destroyed$ = this.destroyed$.asObservable();
+        const state$ = this.state$;
+        const reset$ = this.reset$.asObservable();
+        const lastSnapshot = {
+            isLoading: false,
+            value: undefined,
+            error: null,
+            hasValue: false
+        };
+        const ctx = {
+            destroyed$,
+            featureCellKey: this.cellKey,
+            reset$,
+            state$,
+            get state() {
+                const snapshot = this.lastSnapshot;
+                return {
+                    isLoading: snapshot.isLoading,
+                    value: snapshot.value,
+                    error: snapshot.error,
+                    hasValue: snapshot.hasValue
+                };
+            }
+        };
+        // 🔒 CRITICAL: Lock the reference forever
+        Object.defineProperty(ctx, 'lastSnapshot', {
+            value: lastSnapshot,
+            writable: false, // ❗ cannot reassign
+            configurable: false, // ❗ cannot redefine
+            enumerable: true
+        });
+        return ctx;
+    }
+    // ---------------------------------------------------------------------------
+    // INTERNAL LIFECYCLE
+    // ---------------------------------------------------------------------------
+    reset() {
+        this.#vaultMonitor.startReset(this.cellKey, VAULT_FEATURE_CELL, this.ctx);
+        vaultWarn(`${VAULT_FEATURE_CELL}: reset`);
+        this.#ensureInitialized();
+        this.reset$.next();
+        this.#conductor?.reset(this.ctx);
+        this.#vaultMonitor.endReset(this.cellKey, VAULT_FEATURE_CELL, this.ctx);
+    }
+    destroy() {
+        this.#vaultMonitor.startDestroy(this.cellKey, VAULT_FEATURE_CELL, this.ctx);
+        vaultWarn(`${VAULT_FEATURE_CELL}: destroy`);
+        this.reset$.next();
+        this.reset$.complete();
+        this.#conductor?.destroy(this.ctx);
+        this.destroyed$.next();
+        this.destroyed$.complete();
+        this.state$.complete();
+        this.#vaultMonitor.endDestroy(this.cellKey, VAULT_FEATURE_CELL, this.ctx);
+    }
+    #ensureInitialized() {
+        if (this.#cellCorrupt) {
+            const errorMessage = `[vault] FeatureCell "${this.featureCellConfiguration.key}" encountered a critical initialization failure and is now in a corrupted state. Further use is blocked.`;
+            this.#vaultMonitor.runtimeError(this.cellKey, VAULT_FEATURE_CELL, this.ctx, errorMessage);
+            throw new Error(errorMessage);
+        }
+        if (!this.#initialized) {
+            const errorMessage = `[vault] FeatureCell "${this.featureCellConfiguration.key}" has not been initialized. You must call cell.initialize() before using state methods.`;
+            this.#vaultMonitor.runtimeError(this.cellKey, VAULT_FEATURE_CELL, this.ctx, errorMessage);
+            throw new Error(errorMessage);
+        }
+    }
+    #initialize(ctx) {
+        if (this.#initialized) {
+            const errorMessage = `[vault] FeatureCell "${this.featureCellConfiguration.key}" already initialized.`;
+            this.#vaultMonitor.runtimeError(this.cellKey, VAULT_FEATURE_CELL, this.ctx, errorMessage);
+            throw new Error(errorMessage);
+        }
+        try {
+            // Register cell + start lifecycle event
+            this.#vaultMonitor.registerCell(this.cellKey, this.featureCellConfiguration.insights);
+            this.#vaultMonitor.startInitialized(this.cellKey, VAULT_FEATURE_CELL, this.ctx);
+            featureCellValidation(this.featureCellConfiguration, this.behaviors);
+            // This must proceed the orchestrator instantiation
+            this.#initialized = true;
+            // Orchestrator needs the concrete cell API
+            this.#conductor = new Conductor({
+                afterTapCallbacks: ctx.afterTapCallbacks,
+                beforeTapCallbacks: ctx.beforeTapCallbacks,
+                behaviors: this.behaviors,
+                behaviorConfigs: ctx.behaviorConfigs,
+                cell: this.cell,
+                defaultBehaviors: this.defaultBehaviors,
+                controllers: this.controllers,
+                emitStateCallbacks: ctx.emitStateCallbacks,
+                errorCallbacks: ctx.errorCallbacks,
+                filterCallbacks: ctx.filterFunctions,
+                initialState: ctx.hydrate || this.featureCellConfiguration.initialState,
+                interceptors: ctx.interceptors,
+                operators: ctx.operators,
+                reducerCallbacks: ctx.reducerFunctions
+            });
+            this.#conductor.initialize(this.ctx);
+            if (DevMode.active) {
+                Object.defineProperty(this.cell, 'vaultSettled', {
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                    // eslint-disable-next-line
+                    value: () => this.#conductor.vaultSettled()
+                });
+                // eslint-disable-next-line
+                registerVaultSettled(this.cellKey, this.#conductor.vaultSettled.bind(this.#conductor));
+            }
+            this.#vaultMonitor.endInitialized(this.cellKey, VAULT_FEATURE_CELL, this.ctx);
+        }
+        catch (err) {
+            this.#cellCorrupt = true;
+            this.#vaultMonitor.runtimeError(this.cellKey, VAULT_FEATURE_CELL, this.ctx, err);
+            throw err;
+        }
+    }
+    #handleCorruptionError(message) {
+        this.#cellCorrupt = true;
+        this.#vaultMonitor.runtimeError(this.cellKey, VAULT_FEATURE_CELL, this.ctx, message);
+        throw new Error(message);
+    }
+    setup() {
+        const afterTapCallbacks = [];
+        const beforeTapCallbacks = [];
+        const errorCallbacks = [];
+        const filterFunctions = [];
+        let hydrate;
+        const interceptors = [];
+        const operators = [];
+        const reducerFunctions = [];
+        const emitStateCallbacks = [];
+        const behaviorConfigs = new Map();
+        const builder = {
+            behaviorConfigs,
+            afterTaps: (incomingAfterTaps) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "afterTaps" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingAfterTaps)) {
+                    afterTapCallbacks.push(...incomingAfterTaps);
+                }
+                return builder;
+            },
+            beforeTaps: (incomingBeforeTaps) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "beforeTaps" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingBeforeTaps)) {
+                    beforeTapCallbacks.push(...incomingBeforeTaps);
+                }
+                return builder;
+            },
+            emitStates: (incomingEmitStates) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "emitStates" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingEmitStates)) {
+                    emitStateCallbacks.push(...incomingEmitStates);
+                }
+                return builder;
+            },
+            errors: (incomingErrors) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "errors" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingErrors)) {
+                    errorCallbacks.push(...incomingErrors);
+                }
+                return builder;
+            },
+            filters: (incomingFilters) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "filters" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingFilters)) {
+                    filterFunctions.push(...incomingFilters);
+                }
+                return builder;
+            },
+            hydrate: (incoming) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "hydrate" after initialize(). Configuration must be done before initialization.');
+                }
+                hydrate = incoming;
+                return builder;
+            },
+            initialize: () => {
+                this.#initialize({
+                    afterTapCallbacks,
+                    beforeTapCallbacks,
+                    behaviorConfigs,
+                    emitStateCallbacks,
+                    errorCallbacks,
+                    filterFunctions,
+                    hydrate,
+                    interceptors,
+                    operators,
+                    reducerFunctions
+                });
+            },
+            interceptors: (incomingInterceptors) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "interceptors" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingInterceptors)) {
+                    interceptors.push(...incomingInterceptors);
+                }
+                return builder;
+            },
+            operators: (incomingOperators) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "operators" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingOperators)) {
+                    operators.push(...incomingOperators);
+                }
+                return builder;
+            },
+            reducers: (incomingReducers) => {
+                if (this.#initialized) {
+                    this.#handleCorruptionError('Cannot call "reducers" after initialize(). Configuration must be done before initialization.');
+                }
+                if (Array.isArray(incomingReducers)) {
+                    reducerFunctions.push(...incomingReducers);
+                }
+                return builder;
+            }
+        };
+        return builder;
+    }
+    // ---------------------------------------------------------------------------
+    // STATE OPERATIONS
+    // ---------------------------------------------------------------------------
+    mergeState(incoming, options) {
+        this.#ensureInitialized();
+        return this.#conductor.conduct(this.ctx, incoming, OperationTypes.Merge, options);
+    }
+    replaceState(incoming, options) {
+        this.#ensureInitialized();
+        return this.#conductor.conduct(this.ctx, incoming, OperationTypes.Replace, options);
+    }
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: projects > engine > src > lib > factories > feature-cell > feature-cell.class.ts
+// Updated: 2026-03-02 19:52
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+class FeatureCellClass extends FeatureCellBuilder {
+    constructor(descriptor, defaultBehaviors, behaviors, controllers) {
+        super(descriptor, defaultBehaviors, behaviors, controllers);
+    }
+    build() {
+        const builder = this.setup();
+        const ctx = this.ctx;
+        const cell = {
+            afterTaps: builder.afterTaps,
+            beforeTaps: builder.beforeTaps,
+            destroy: this.destroy.bind(this),
+            destroyed$: this.destroyed$.asObservable(),
+            errors: builder.errors,
+            filters: builder.filters,
+            hydrate: builder.hydrate,
+            initialize: builder.initialize,
+            interceptors: builder.interceptors,
+            key: this.cellKey,
+            mergeState: this.mergeState.bind(this),
+            operators: builder.operators,
+            reducers: builder.reducers,
+            emitStates: builder.emitStates,
+            replaceState: this.replaceState.bind(this),
+            reset$: this.reset$.asObservable(),
+            reset: this.reset.bind(this),
+            state$: this.state$.asObservable(),
+            get state() {
+                return {
+                    isLoading: ctx.lastSnapshot.isLoading,
+                    value: ctx.lastSnapshot.value,
+                    error: ctx.lastSnapshot.error,
+                    hasValue: ctx.lastSnapshot.hasValue
+                };
+            }
+        };
+        // Keep a reference for orchestrator creation
+        this.cell = cell;
+        this.behaviors.forEach((behavior) => {
+            behavior?.installFluentApi?.(this.cell, builder.behaviorConfigs);
+        });
+        this.controllers.forEach((controller) => {
+            controller?.installFluentApi?.(this.cell, builder.behaviorConfigs);
+        });
+        Object.defineProperty(cell, 'ctx', {
+            value: this.ctx,
+            enumerable: false,
+            writable: false
+        });
+        Object.defineProperty(cell, 'key', {
+            value: this.featureCellConfiguration.key,
+            enumerable: false,
+            writable: false
+        });
+        return cell;
+    }
+}
+
+class LicensingAbstract {
+    static needsLicense;
+    static key;
+    #licenseToken;
+    #featureCellKey;
+    #key;
+    #licenseService;
+    constructor(ctx) {
+        const ctor = this.constructor;
+        if (typeof ctor.key !== 'string' || !ctor.key.trim()) {
+            throw new VaultLicenseError(`LicensingClass requires a static "key". Did you forget @VaultBehavior?`);
+        }
+        this.#licenseService = LicensingService();
+        this.#key = ctor.key;
+        this.#featureCellKey = ctx.featureCellKey;
+        if (ctor.needsLicense) {
+            this.#requestLicense();
+        }
+    }
+    #requestLicense() {
+        this.#licenseToken = this.#licenseService.requestLicense(this.#featureCellKey, this.#key);
+    }
+    validateLicense(valid) {
+        if (!this.#licenseToken) {
+            throw new VaultLicenseError(`validateLicense() called but no license was requested for "${this.#featureCellKey}" and "${this.#key}".`);
+        }
+        this.#licenseService.validateLicense(this.#featureCellKey, this.#key, this.#licenseToken, valid);
+    }
+}
+
+/**
+ * The feature cell tokens map
+ */
+const featureCellTokens = new Map();
+/**
+ * Tracks whether a FeatureCell token has already been retrieved
+ */
+const featureCellTokenRequested = new Map();
+/**
+ * Internal token resolution mechanism used by both createFeatureCellToken()
+ * and getFeatureCellToken().
+ *
+ * Enforces:
+ * - unique FeatureCell keys
+ * - single retrieval per key (unless dev mode)
+ */
+function internalFeatureCellToken(key, isCreate) {
+    // ──────────────────────────────────────────────
+    // CREATE MODE
+    // ──────────────────────────────────────────────
+    if (isCreate) {
+        if (featureCellTokens.has(key)) {
+            if (!DevMode.active) {
+                const existing = featureCellTokens.get(key);
+                throw new Error(`[vault] Duplicate FeatureCell key detected: "${key}". ` +
+                    `Each FeatureCell must have a unique key. Existing token: "${existing?.key}"`);
+            }
+            return featureCellTokens.get(key);
+        }
+        const token = {
+            key
+        };
+        // const token: FeatureCellToken = { key };
+        featureCellTokens.set(key, token);
+        return token;
+    }
+    // ──────────────────────────────────────────────
+    // RETRIEVE MODE
+    // ──────────────────────────────────────────────
+    if (!featureCellTokens.has(key)) {
+        throw new Error(`[vault] FeatureCell token not found for key "${key}". You must call provideFeatureCell() before retrieving this FeatureCell.`);
+    }
+    if (featureCellTokenRequested.has(key)) {
+        if (!DevMode.active) {
+            throw new Error(`[vault] FeatureCell "${key}" can only be owned by a single consumer.`);
+        }
+        return featureCellTokens.get(key);
+    }
+    featureCellTokenRequested.set(key, true);
+    return featureCellTokens.get(key);
+}
+/**
+ * Creates a FeatureCell token for the specified key.
+ */
+function createFeatureCellToken(key) {
+    return internalFeatureCellToken(key, true);
+}
+/**
+ * Retrieves the FeatureCell token associated with a key.
+ */
+function getFeatureCellToken(key) {
+    return internalFeatureCellToken(key, false);
+}
+/**
+ * Clears FeatureCell token state for test isolation.
+ *
+ * This must be called explicitly by test utilities.
+ * No framework assumptions are made.
+ */
+function resetFeatureCellToken() {
+    // DevMode already gates unsafe behavior
+    if (!DevMode.active)
+        return;
+    featureCellTokens.clear();
+    featureCellTokenRequested.clear();
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: lib > public-api.ts
+// Updated: 2026-03-30 15:42
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+/*
+ * This is for version support in dev mode and tracking in the devtools
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Conductor, FeatureCellClass, LicensingAbstract, VaultCore, createFeatureCellToken, getFeatureCellToken, getLicensePayload, getVaultRegistryForTests, isPipelineTerminal, registerFeatureCell, registerVaultSettled, resetFeatureCellRegistry, resetVaultForTests, vaultAllSettled, vaultSettled };
+//# sourceMappingURL=sdux-vault-engine.mjs.map