@sdux-vault/engine 0.0.9 → 0.1.0

package/fesm2022/sdux-vault-engine.mjs

@@ -1,4 +1,4 @@
-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 { 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, isolateValue, isVaultClearState, VAULT_CLEAR_STATE, VAULT_NOOP, VAULT_CONTINUE, isVaultContinue, 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';
@@ -11,7 +11,7 @@ import { EventBus } from '@sdux-vault/devtools';
 //	 cmd+alt+j (see .vscode/keybindings.json)
 // --- END AI MODEL FILE PATH ---
 const SDUX_PACKAGE = '@sdux-vault/engine';
-const SDUX_VERSION = '0.0.9';
+const SDUX_VERSION = '0.1.0';
 registerVersion(SDUX_PACKAGE, SDUX_VERSION);
 
 /**
@@ -2194,8 +2194,8 @@ const assignTraceId = () => {
 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
+// FilePath: lib > src > orchestrator > orchestrator.ts
+// Updated: 2026-04-07 16:30
 //	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
 //	 cmd+alt+j (see .vscode/keybindings.json)
 // --- END AI MODEL FILE PATH ---
@@ -2243,13 +2243,6 @@ class Orchestrator {
     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) {
@@ -2276,7 +2269,7 @@ class Orchestrator {
             return incoming;
         }
         if (isStateInputShape(incoming)) {
-            return incoming;
+            return isolateValue(incoming);
         }
         return {
             value: incoming
@@ -2294,14 +2287,31 @@ class Orchestrator {
             }
         }
     }
-    prepIncomingForOrchestration(ctx, incoming, operation) {
+    prepareIncoming(ctx, incoming, operation) {
+        ctx = this.#prepIncomingForOrchestration(ctx, incoming, operation);
+        const normalizedIncoming = this.#coreStateBehavior.preparePipelineIncoming(ctx);
+        if (isVaultNoop(normalizedIncoming)) {
+            this.vaultMonitor.startCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            this.#runStateBehaviors(ctx);
+            this.vaultMonitor.endCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+        }
+        if (isVaultClearState(normalizedIncoming)) {
+            this.vaultMonitor.startCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            this.#resetBehaviors(ctx);
+            this.#runStateBehaviors(ctx);
+            this.vaultMonitor.endCoreState(this.cellKey, VAULT_ORCHESTRATOR, ctx);
+            return;
+        }
+        return normalizedIncoming;
+    }
+    //#endregion
+    //#region Private Methods
+    #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;
@@ -2491,14 +2501,15 @@ class Orchestrator {
     async #orchestrateMerge(ctx, options) {
         this.vaultMonitor.startMerge(this.cellKey, VAULT_ORCHESTRATOR, ctx);
         await this.#safeAsync(async () => {
-            const current = ctx.lastSnapshot.value;
+            const safeCurrent = isolateValue(ctx.lastSnapshot.value);
             let finalState;
             finalState = await this.#runInterceptorStage(ctx);
             if (!isSignalStop(finalState)) {
                 const partial = await this.#runUpstreamStage(BehaviorTypes.Resolve, ctx, undefined);
+                const safePartial = isolateValue(partial);
                 this.vaultMonitor.startComputeMerge(this.cellKey, VAULT_ORCHESTRATOR, ctx);
                 // eslint-disable-next-line
-                const mergeResult = await this.#mergeBehavior.computeMerge(current, partial, options);
+                const mergeResult = await this.#mergeBehavior.computeMerge(safeCurrent, safePartial, options);
                 this.vaultMonitor.endComputeMerge(this.cellKey, VAULT_ORCHESTRATOR, ctx);
                 if (isVaultClearState(mergeResult)) {
                     finalState = VAULT_CLEAR_STATE;
@@ -2569,6 +2580,8 @@ class Orchestrator {
                         if (typeof behavior.computeResolve === 'function') {
                             this.vaultMonitor.startResolve(this.cellKey, behavior.key, ctx);
                             next = await behavior.computeResolve(ctx);
+                            if (isDefined(next))
+                                current = isolateValue(next);
                             this.vaultMonitor.endResolve(this.cellKey, behavior.key, ctx);
                         }
                         break;
@@ -2577,7 +2590,9 @@ class Orchestrator {
                     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);
+                            const safeCurrent = isolateValue(ctx.lastSnapshot.value);
+                            const safeCandidate = isolateValue(current);
+                            next = await behavior.evaluateStepwise(safeCurrent, safeCandidate, ctx.featureCellKey);
                             this.vaultMonitor.endStepwise(this.cellKey, behavior.key, ctx);
                         }
                         break;
@@ -2585,10 +2600,11 @@ class Orchestrator {
                         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);
+                                const safeCurrent = isolateValue(current);
+                                const nextValue = await behavior.applyFilter(safeCurrent, filter);
                                 this.vaultMonitor.endFilter(this.cellKey, behavior.key, ctx);
                                 if (isDefined(nextValue)) {
-                                    current = nextValue;
+                                    current = isolateValue(nextValue);
                                 }
                             }
                         }
@@ -2597,7 +2613,8 @@ class Orchestrator {
                         if (typeof behavior.applyBeforeTap === 'function') {
                             for (const beforeTap of this.#beforeTapCallbacks) {
                                 this.vaultMonitor.startBeforeTap(this.cellKey, behavior.key, ctx);
-                                await behavior.applyBeforeTap(current, beforeTap);
+                                const safeCurrent = isolateValue(current);
+                                await behavior.applyBeforeTap(safeCurrent, beforeTap);
                                 this.vaultMonitor.endBeforeTap(this.cellKey, behavior.key, ctx);
                             }
                         }
@@ -2609,10 +2626,11 @@ class Orchestrator {
                             }
                             for (const reducer of this.#reducerFunctions) {
                                 this.vaultMonitor.startReducer(this.cellKey, behavior.key, ctx);
-                                const nextValue = await behavior.applyReducer(current, reducer);
+                                const safeCurrent = isolateValue(current);
+                                const nextValue = await behavior.applyReducer(safeCurrent, reducer);
                                 this.vaultMonitor.endReducer(this.cellKey, behavior.key, ctx);
                                 if (isDefined(nextValue)) {
-                                    current = nextValue;
+                                    current = isolateValue(nextValue);
                                 }
                             }
                         }
@@ -2621,7 +2639,8 @@ class Orchestrator {
                         if (typeof behavior.applyAfterTap === 'function') {
                             for (const afterTap of this.#afterTapCallbacks) {
                                 this.vaultMonitor.startAfterTap(this.cellKey, behavior.key, ctx);
-                                await behavior.applyAfterTap(current, afterTap);
+                                const safeCurrent = isolateValue(current);
+                                await behavior.applyAfterTap(safeCurrent, afterTap);
                                 this.vaultMonitor.endAfterTap(this.cellKey, behavior.key, ctx);
                             }
                         }
@@ -2633,7 +2652,7 @@ class Orchestrator {
                 throw err;
             }
             if (isDefined(next))
-                current = next;
+                current = isolateValue(next);
         }
         return current;
     }
@@ -2642,6 +2661,7 @@ class Orchestrator {
         for (const behavior of interceptorBehaviors) {
             try {
                 this.vaultMonitor.startInterceptor(this.cellKey, behavior.key, ctx);
+                ctx.incoming = isolateValue(ctx.incoming);
                 const nextIncoming = await behavior.applyInterceptor(ctx);
                 if (isSignalStop(nextIncoming)) {
                     this.vaultMonitor.endInterceptor(this.cellKey, behavior.key, ctx, { pipelinePaused: true });
@@ -2665,13 +2685,14 @@ class Orchestrator {
         for (const behavior of operatorBehaviors) {
             try {
                 this.vaultMonitor.startOperator(this.cellKey, behavior.key, ctx);
-                const next = await behavior.applyOperator(current);
+                const safeCurrent = isolateValue(current);
+                const next = await behavior.applyOperator(safeCurrent);
                 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;
+                current = isolateValue(next);
                 this.vaultMonitor.endOperator(this.cellKey, behavior.key, ctx);
             }
             catch (err) {
@@ -2690,14 +2711,19 @@ class Orchestrator {
                     case BehaviorTypes.Encrypt:
                         if (typeof behavior.encryptState === 'function') {
                             this.vaultMonitor.startEncrypt(this.cellKey, behavior.key, ctx);
-                            current = await behavior.encryptState(ctx, current);
+                            const safeCurrent = isolateValue(current);
+                            const nextValue = await behavior.encryptState(ctx, safeCurrent);
                             this.vaultMonitor.endEncrypt(this.cellKey, behavior.key, ctx);
+                            if (isDefined(nextValue)) {
+                                current = isolateValue(nextValue);
+                            }
                         }
                         break;
                     case BehaviorTypes.Persist:
                         if (typeof behavior.persistState === 'function') {
                             this.vaultMonitor.startPersist(this.cellKey, behavior.key, ctx);
-                            await behavior.persistState(current);
+                            const safeCurrent = isolateValue(current);
+                            await behavior.persistState(safeCurrent);
                             this.vaultMonitor.endPersist(this.cellKey, behavior.key, ctx);
                         }
                         break;
@@ -2881,7 +2907,7 @@ class Orchestrator {
         }
         incoming.value = value;
         if (!isNullish(incoming.value)) {
-            await this.orchestrate(this.prepIncomingForOrchestration(ctx, incoming, OperationTypes.Replace));
+            await this.orchestrate(this.#prepIncomingForOrchestration(ctx, incoming, OperationTypes.Replace));
         }
         else {
             this.decisionEngine?.notifySuccess(this.buildControllerCtx(ctx));
@@ -2920,7 +2946,7 @@ class Orchestrator {
                     const decrypted = await behavior.decryptState?.(ctx, loaded);
                     if (isDefined(decrypted)) {
                         this.vaultMonitor.endDecrypt(this.cellKey, behavior.key, ctx);
-                        loaded = decrypted;
+                        loaded = isolateValue(decrypted);
                     }
                     else {
                         this.vaultMonitor.endDecrypt(this.cellKey, behavior.key, ctx, { noop: true });
@@ -3088,6 +3114,12 @@ class ControllerInitializationClass {
     }
 }
 
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: lib > src > conductor > conductor.ts
+// Updated: 2026-04-07 16:29
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
 class Conductor extends Orchestrator {
     #attemptQueue = [];
     #controllers = [];
@@ -3128,11 +3160,11 @@ class Conductor extends Orchestrator {
     //#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)) {
+        const preparedIncoming = this.prepareIncoming(behaviorCtx, incoming, operation);
+        if (isVaultNoop(preparedIncoming) || isVaultClearState(preparedIncoming)) {
             return;
         }
-        behaviorCtx.incoming = ensuredIncoming;
+        behaviorCtx.incoming = preparedIncoming;
         const controllerCtx = this.buildControllerCtx(behaviorCtx);
         this.#enqueueAttempt({ behaviorCtx, controllerCtx, options });
     }
@@ -3444,15 +3476,6 @@ class Conductor extends Orchestrator {
             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;