@sdux-vault/engine 0.11.0 → 0.25.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, VaultLicenseError, VaultBehavior, VaultPrivateErrorService, isHttpResourceRef, isFunction, isStateInputShape, isolateValue, isVaultClearState, VAULT_CLEAR_STATE, VAULT_NOOP, VAULT_CONTINUE, isVaultContinue, isUndefined, isDefined, isNullish, ResolveTypes, isPromise, VaultUsagePromiseError, CONTROLLER_META, validateControllerKey } 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, BehaviorTypes, validateBehaviorKey, VAULT_STOP, isVaultNoop, VaultLicenseError, VaultBehavior, VaultPrivateErrorService, isHttpResourceRef, isFunction, isStateInputShape, isolateValue, isVaultClearState, VAULT_CLEAR_STATE, VAULT_NOOP, VAULT_CONTINUE, isVaultContinue, isUndefined, isDefined, isNullish, ResolveTypes, isPromise, VaultUsagePromiseError, CONTROLLER_META, validateControllerKey } 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, initDevtoolsWidget } 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.11.0';
+const SDUX_VERSION = '0.25.0';
 registerVersion(SDUX_PACKAGE, SDUX_VERSION);
 
 /**
@@ -1520,6 +1520,7 @@ const KNOWN_VAULT_KEYS = new Set([
     'SDUX::Behavior::Core::Promise',
     'SDUX::Behavior::Core::Reducer',
     'SDUX::Behavior::Core::State',
+    'SDUX::Behavior::Core::TabSyncState',
     'SDUX::Behavior::Core::Value',
     // ---------------------------------------------------------------------------
     // Addon Behaviors (libs/addons)
@@ -1550,6 +1551,10 @@ const KNOWN_VAULT_KEYS = new Set([
     'SDUX::Controller::Policy::CoreError',
     'SDUX::Controller::Policy::CoreLicense',
     // ---------------------------------------------------------------------------
+    // Core Controllers (libs/core)
+    // ---------------------------------------------------------------------------
+    'SDUX::Controller::Policy::TabSync',
+    // ---------------------------------------------------------------------------
     // Addon Controllers (libs/addons)
     // ---------------------------------------------------------------------------
     'SDUX::Controller::Policy::Delay',
@@ -2063,13 +2068,21 @@ class BehaviorInitializationClass {
     #initialized = false;
     /** FeatureCell identifier associated with this initializer. */
     #cellKey;
+    /** Live reference to the FeatureCell's mutable last-snapshot object. */
+    #lastSnapshot;
+    /** Subject used by the FeatureCell to emit state snapshots. */
+    #state$;
     /**
      * Creates a new behavior initializer for a specific FeatureCell.
      *
      * @param cellKey - The unique FeatureCell key.
+     * @param lastSnapshot - Live reference to the FeatureCell's mutable state snapshot.
+     * @param state$ - Subject used to emit state snapshots.
      */
-    constructor(cellKey) {
+    constructor(cellKey, lastSnapshot, state$) {
         this.#cellKey = cellKey;
+        this.#lastSnapshot = lastSnapshot;
+        this.#state$ = state$;
     }
     /**
      * Instantiates and validates all behaviors declared for a FeatureCell.
@@ -2140,11 +2153,19 @@ class BehaviorInitializationClass {
                 }
                 let instance;
                 try {
-                    instance = new BehaviorClass(behaviorKey, {
+                    let behaviorContract = {
                         featureCellKey: this.#cellKey,
                         behaviorConfig,
                         licensePayload
-                    });
+                    };
+                    if (meta.type === BehaviorTypes.TabSyncState) {
+                        behaviorContract = {
+                            ...behaviorContract,
+                            lastSnapshot: this.#lastSnapshot,
+                            state$: this.#state$
+                        };
+                    }
+                    instance = new BehaviorClass(behaviorKey, behaviorContract);
                 }
                 catch (error) {
                     isCritical = meta.critical;
@@ -2326,27 +2347,21 @@ const PublicKeys = {
      */
     pro: `
 -----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuXto+eRaFm9pObys/IEI ASwV1wgGvNGJsiyw/9hXsEd9mA76aQI1X9lpkZRKmBFovHdK2unPHFOPQM0k9vJo ieFMNXO9kmHn7UYZV98bDCcDTNURFHQ4SWlcAE/HEiNqcUb9LwotFbON7/mcthM8 QQQ4Lycdv+lm1uozQl8rl+i7FjfQzLaxJMuAkm9jFZK+ta6eoSy/lmXfhDem8RIo dE19aZWfY+LTXP9nn977XFah0z0S0D3NSvMv96gZsXTN2hTbFBl5dgDMAOW9R5OI wT6I+kGwrVqARXq2pTDHnZjqfO3a+rT4Lrb5/L58RjQ0EfA5puZ16EXGEUpOabqI KVT4Z/wv818P8eyat+LtTcy2G0zx/h0Fcz0QANzx3P9K7ezxeqdg4SsjkcNXRWZq PaJUhZHygN/Xuef9zfWwjuKobCBSdyyeXxF5XS0A0Y6NBmdhikyHc/YOY2iYupIt xiUvlHaq97B5wej3XcTmp4kmJUQyeQ8oD5Mj8Dmf69oa7vhI/ANNKWo9s8e7u7UX Dx74Eu3d8JBpACQ+Vvek6ZEGw+D0yCyLF6u/CaCw+cb2cBYAlM7jWZ5kpgsbQcWw YP2nbGV3OofcEspoEU704M4RW4v+nSRYrJbMEIJJ5Wuxk2/RuUgk/9uwgCHAvzXZ cmGomIf9dXZGoNhwT5uW1OECAwEAAQ==
 -----END PUBLIC KEY-----
 `,
     /**
      * the enterprise public key
      */
     enterprise: `
------BEGIN PUBLIC KEY-----
+-----BEGIN PUBLIC KEY----- MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA6k4XHyV4WE6Bd/fizN4Q c3C37LtskNTJ1c3FVxcziygAFd+fotRfbLHctwtJJhuO6+Pv+c1SPjrPeJsWRw4M IN7QHcBQHPbQDW/Erd1XjA0OVNbxs3xLVjtgMuVcd2sKYPp4nJqIyz5WLMde7v1g 1k8knI+ISrym0h4GcjkNSaHK5QKKpK7n3dzOXrjo1P6h1uOVsGAHC/ErVMQNHrAu dKgY+SDVn87oPIrd2pJb5SotI6H8HzODM/CDsF58hk/eK4zApnrtDViVb1j3oNCk hdDOnN98VIgwcHzHYZOhPFM0TFwudpi57Yu/PJJztI7WbsjpxTyX3JPvwVeWJR+Z tt6NEQ5ZaoBghGgHGiuRbhKR5qoznwsMkfb2jUbpbgRTinmtEjFmpIYSnROCixjq W1neupzBDrNi+JfoVsTwiP8SbzxHXWksN0gLMfL235l1LDMS/IrI3RmhcRkhB/Pu vPuc+jhPkwpbXaM9vDkkPWK1dmRYHWo3atYCWoSdK2705woo19oT8Dxm9OXKT+nh HsdOI+k9asBCqe4kQHi3OJ4Raesa6bFWWxKFLeUNKSAt7clJKo7GhrovnHIIAbty gk7ULdwLIlpjwB5mVUBBCts5z9KznHo+pumNoeEA8FGqq374a+jEPOHWjsshA678 RDYeqeRbh2VNcy/OwlqH/MUCAwEAAQ==
 -----END PUBLIC KEY-----
 `,
     /**
      * the development public key
      */
     development: `
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6RDckQGY38NrlPq70YfI
-hIpBFmc9baNLS2HIeyKIU2m+Vvnt3AYcQJlQnzmO4ZLDOUkIP+VxAjaSCaUBeTOx
-KDYXAK8ds0xEur0cRV4Kn26jhLveLZVpfVzhkOjJ6I9ggLeh5JRt7kj3NPgKwnSm
-t5DxLh4JPyLfZdBDtW8tU2tCgCfEs2cArrVo/fg7Dei8FJ8w83PDhsKmX5UazSfj
-MC57gkTZ/cZmKBvVoIhnqaWVXcRRL+wZPArIsO801DRiMAhROyQYyC3EKpGLyUc1
-1VSKqdmQLIUE1pt151EnmStB+VOsMzCLZH4TyU7cd1Afs2Siqu947W2w4Qpm5+Y/
-FwIDAQAB
+-----BEGIN PUBLIC KEY----- MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAsAFRjQalSEZkCDPrdBEf IMQpY7ujGf4pqjuFk86rkZENr7kJ00RjVJxuhcafgygdmxVAhKS+d1WtsSAw6c9m AawI+sSyhAClB+wrwfuCrxt/ZlLbNMiMH5SD1YvoRaHstkLpMGbWnbsLDI+cCpaL hGKk+5LoJLikhf9ipBkGX8VSAT0xTMk06iaYtEV85H9cMWtfx7seyBw2Mps/8S6f Rtp3tLlbNJIyh9+5XjtkTqYNRWJtFW1rv75K9GN9dPVXrEXUGojqeV13G+z2R3Sr QvmhESkyC1DviZBxaYnEhpWoijJQFJUQ1DGRi29ugktYzf36Otw9gyz9jGb5MLNE W+meR2LdnbTBy83QNtaS5lCzNJVo2ohwbD+djblNVegH/Dr0rK4IHEYSgjdxjErY 6xqykJpKJ025CTU4kyI3aaaYB+l2CQMAKVAh2y2rgGyJSJnMDTR44aBIZ8rtTu2r wazjBJ/RiMr0OOkfBqEQPKZ6qzSWtBDebvD0iUyRAP8SXSdDo1DcaJNamLLmjIxr 3KCcwgJt2oLcdZZHKG3WbjqmIdp7tq03O4gajKJHd5GmyLWtHXKqBwaijAx9aNqr qDPWj/Qg/8C9qpSBs7EUod3slV6UhO4yEnb7FdD/O0o8mRMU0rtJ0KQTarpEh2bY MKVsYxByiFeAjUJUWLSqIX8CAwEAAQ==
 -----END PUBLIC KEY-----
 `
 };
@@ -2366,6 +2381,12 @@ FwIDAQAB
  *
  * Verification failures return `false` rather than throwing.
  */
+let hasLoggedLicenseDetails = false;
+function resetLicenseDetailsLog() {
+    if (!DevMode.active)
+        return;
+    hasLoggedLicenseDetails = false;
+}
 const VerifyLicenseToken = {
     /**
      * Verifies the supplied signed license token using the public key associated
@@ -2391,6 +2412,11 @@ const VerifyLicenseToken = {
             if (!licenseType) {
                 return false;
             }
+            if (!DevMode.active && licenseType === 'development') {
+                // eslint-disable-next-line
+                console.error('[sdux-vault] Development license token rejected in production environment.');
+                return false;
+            }
             const keyPem = PublicKeys[licenseType];
             if (!keyPem)
                 return false;
@@ -2399,9 +2425,45 @@ const VerifyLicenseToken = {
                 name: 'RSASSA-PKCS1-v1_5',
                 hash: 'SHA-256'
             }, key, signature, new TextEncoder().encode(encodedPayload));
+            if (!hasLoggedLicenseDetails) {
+                hasLoggedLicenseDetails = true;
+                if (verified) {
+                    // eslint-disable-next-line
+                    console.info(`[sdux-vault] License verified — organization: "${payload.organization}", tier: "${payload.licenseType}"`);
+                }
+                else {
+                    // eslint-disable-next-line
+                    console.warn(`[sdux-vault] License signature invalid — organization: "${payload.organization}", tier: "${payload.licenseType}"`);
+                }
+                // eslint-disable-next-line
+                console.info('[sdux-vault] License organization:', payload.organization);
+                // eslint-disable-next-line
+                console.info('[sdux-vault] License domain:', payload.domain);
+                // eslint-disable-next-line
+                console.info('[sdux-vault] License type:', payload.licenseType);
+                // eslint-disable-next-line
+                console.info('[sdux-vault] License issuedAt:', formatLicenseDate(payload.issuedAt));
+                // eslint-disable-next-line
+                console.info('[sdux-vault] License expires:', formatLicenseDate(payload.expires));
+            }
+            if (verified && payload.licenseType === 'enterprise' && typeof payload.expires === 'number') {
+                const msUntilExpiry = payload.expires - Date.now();
+                if (msUntilExpiry < 0) {
+                    // eslint-disable-next-line
+                    console.error(`[sdux-vault] Enterprise license expired — organization: "${payload.organization}", expired: ${formatLicenseDate(payload.expires)}`);
+                    return false;
+                }
+                const fifteenDaysMs = 15 * 24 * 60 * 60 * 1000;
+                if (msUntilExpiry <= fifteenDaysMs) {
+                    // eslint-disable-next-line
+                    console.warn(`[sdux-vault] Enterprise license expiring soon — organization: "${payload.organization}", expires: ${formatLicenseDate(payload.expires)}`);
+                }
+            }
             return verified;
         }
-        catch {
+        catch (error) {
+            // eslint-disable-next-line
+            console.error('[sdux-vault] License token verification failed:', error);
             return false;
         }
     }
@@ -2444,6 +2506,35 @@ function str2ab(str) {
         arr[i] = str.charCodeAt(i);
     return buf;
 }
+/**
+ * Formats a license date value for display. Numeric timestamps are
+ * formatted as locale-aware date strings; string values such as
+ * `'forever'` are returned as-is.
+ *
+ * @param value - A Unix-epoch millisecond timestamp or a string literal.
+ * @returns A human-readable date string.
+ */
+function formatLicenseDate(value) {
+    if (typeof value === 'string')
+        return value;
+    return new Intl.DateTimeFormat('en-US', {
+        month: '2-digit',
+        day: '2-digit',
+        year: 'numeric'
+    }).format(new Date(value));
+}
+
+async function verifyLicensePayload(licensePayload) {
+    try {
+        if (!licensePayload) {
+            return false;
+        }
+        return await VerifyLicenseToken.verify(licensePayload);
+    }
+    catch {
+        return false;
+    }
+}
 
 class LicensingAbstract {
     static needsLicense;
@@ -2455,7 +2546,7 @@ class LicensingAbstract {
     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?`);
+            throw new VaultLicenseError(`LicensingClass requires a static "key". Did you forget @VaultBehavior or @VaultController?`);
         }
         this.#licenseService = LicensingService();
         this.#key = ctor.key;
@@ -2488,21 +2579,7 @@ let withCoreLicenseBehavior = class withCoreLicenseBehavior extends LicensingAbs
         super(behaviorCtx);
         this.behaviorCtx = behaviorCtx;
         this.key = key;
-        this.#performLicenseValidation();
-    }
-    async #performLicenseValidation() {
-        try {
-            const payload = this.behaviorCtx.licensePayload;
-            if (!payload?.token) {
-                this.validateLicense(false);
-                return;
-            }
-            const isValid = await VerifyLicenseToken.verify(payload.token);
-            this.validateLicense(isValid);
-        }
-        catch {
-            this.validateLicense(false);
-        }
+        verifyLicensePayload(this.behaviorCtx.licensePayload).then((valid) => this.validateLicense(valid));
     }
     destroy() {
         vaultWarn(`${this.key} - destroy noop`);
@@ -2720,13 +2797,17 @@ class Orchestrator {
         });
         config.operators = config.operators ?? [];
         config.interceptors = config.interceptors ?? [];
-        const allBehaviors = [
+        let allBehaviors = [
             ...defaultBehaviors,
             ...filteredUserBehaviors,
             ...config.operators,
             ...config.interceptors
         ];
-        const behaviorInit = new BehaviorInitializationClass(this.cellKey);
+        const hasTabSync = allBehaviors.some((behavior) => behavior.type === BehaviorTypes.TabSyncState);
+        if (hasTabSync) {
+            allBehaviors = allBehaviors.filter((behavior) => behavior.type !== BehaviorTypes.CoreState);
+        }
+        const behaviorInit = new BehaviorInitializationClass(this.cellKey, config.lastSnapshot, config.state$);
         this.#registerBehaviorsWithVault(allBehaviors);
         this.#behaviors = behaviorInit.initializeBehaviors(allBehaviors, config.behaviorConfigs);
         this.#registerErrorBehavior();
@@ -2738,6 +2819,7 @@ class Orchestrator {
     #registerStageBehaviors() {
         // Remove merge behavior from the pipeline list
         this.#stageBehaviors = this.#behaviors.filter((behavior) => !(behavior.type === BehaviorTypes.CoreState ||
+            behavior.type === BehaviorTypes.TabSyncState ||
             behavior.type === BehaviorTypes.CoreEmitState ||
             behavior.type === BehaviorTypes.CoreError ||
             behavior.type === BehaviorTypes.ErrorTransform ||
@@ -2745,12 +2827,13 @@ class Orchestrator {
             behavior.type === BehaviorTypes.Merge));
     }
     #registerStateBehavior() {
-        // Extract and remove errot behavior
-        const coreState = this.#behaviors.filter((behaviort) => behaviort.type === BehaviorTypes.CoreState);
-        if (coreState.length > 1) {
+        const tabSyncState = this.#behaviors.filter((behavior) => behavior.type === BehaviorTypes.TabSyncState);
+        const coreState = this.#behaviors.filter((behavior) => behavior.type === BehaviorTypes.CoreState);
+        const stateBehaviors = tabSyncState.length > 0 ? tabSyncState : coreState;
+        if (stateBehaviors.length > 1) {
             throw new Error('Only one core state behavior can be registered for a FeatureCell.');
         }
-        this.#coreStateBehavior = coreState[0] ?? null;
+        this.#coreStateBehavior = stateBehaviors[0] ?? null;
         this.#emitStateCallbackBehavior = this.#behaviors.filter((behavior) => isCoreEmitStateCallbackBehavior(behavior))[0];
     }
     #registerErrorBehavior() {
@@ -3744,6 +3827,8 @@ class Conductor extends Orchestrator {
                     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.`);
+                    // eslint-disable-next-line
+                    console.error(`[vault] ${error.message}`);
                     vaultDebug(error.message);
                     this.privateErrorService.setError(createVaultError(error, this.cellKey));
                     this.#attemptQueue.length = 0;
@@ -4106,8 +4191,10 @@ class FeatureCellBuilder {
                 filterCallbacks: ctx.filterFunctions,
                 initialState: ctx.hydrate || this.featureCellConfiguration.initialState,
                 interceptors: ctx.interceptors,
+                lastSnapshot: this.ctx.lastSnapshot,
                 operators: ctx.operators,
-                reducerCallbacks: ctx.reducerFunctions
+                reducerCallbacks: ctx.reducerFunctions,
+                state$: this.state$
             });
             this.#conductor.initialize(this.ctx);
             if (DevMode.active) {
@@ -4410,5 +4497,5 @@ function resetFeatureCellToken() {
  * Generated bundle index. Do not edit.
  */
 
-export { Conductor, FeatureCellClass, LicensingAbstract, VAULT_LICENSE_ID, VaultCore, VerifyLicenseToken, createFeatureCellToken, getFeatureCellToken, getLicensePayload, getVaultRegistryForTests, hasVaultLicense, isAuthorizedKey, isBypassLicensing, isPipelineTerminal, registerFeatureCell, registerVaultSettled, resetFeatureCellRegistry, resetVaultForTests, vaultAllSettled, vaultSettled };
+export { Conductor, FeatureCellClass, LicensingAbstract, VAULT_LICENSE_ID, VaultCore, VerifyLicenseToken, createFeatureCellToken, getFeatureCellToken, getLicensePayload, getVaultRegistryForTests, hasVaultLicense, isAuthorizedKey, isBypassLicensing, isPipelineTerminal, registerFeatureCell, registerVaultSettled, resetFeatureCellRegistry, resetVaultForTests, vaultAllSettled, vaultSettled, verifyLicensePayload };
 //# sourceMappingURL=sdux-vault-engine.mjs.map