@sdux-vault/engine 0.1.3 → 0.3.0

package/fesm2022/sdux-vault-engine.mjs

@@ -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.1.3';
+const SDUX_VERSION = '0.3.0';
 registerVersion(SDUX_PACKAGE, SDUX_VERSION);
 
 /**
@@ -1486,6 +1486,87 @@ const VaultRegistrationLicenseStatusTypes = {
     Valid: 'valid'
 };
 
+/**
+ * Set of all known behavior and controller keys shipped with the core,
+ * addon, and engine packages. Keys in this set are always permitted
+ * during behavior and controller initialization regardless of license
+ * status.
+ *
+ * Any key not present in this set is treated as a custom extension and
+ * requires a valid Vault license to be registered.
+ *
+ * Entries follow the canonical key format produced by
+ * `defineBehaviorKey()` and `defineControllerKey()`:
+ *
+ * `SDUX::Behavior::<Domain>::<Name>`
+ * `SDUX::Controller::<Domain>::<Name>`
+ */
+const KNOWN_VAULT_KEYS = new Set([
+    // ---------------------------------------------------------------------------
+    // Core Behaviors (libs/core)
+    // ---------------------------------------------------------------------------
+    'SDUX::Behavior::Core::Error',
+    'SDUX::Behavior::Core::ErrorCallback',
+    'SDUX::Behavior::Core::Filter',
+    'SDUX::Behavior::Core::Reducer',
+    'SDUX::Behavior::Core::BeforeTap',
+    'SDUX::Behavior::Core::AfterTap',
+    'SDUX::Behavior::Core::EmitState',
+    'SDUX::Behavior::Core::State',
+    'SDUX::Behavior::Core::Value',
+    'SDUX::Behavior::Core::Observable',
+    'SDUX::Behavior::Core::Promise',
+    'SDUX::Behavior::Core::FromStream',
+    'SDUX::Behavior::Core::FromPromise',
+    'SDUX::Behavior::Core::FromObservable',
+    'SDUX::Behavior::Core::ObjectMerge',
+    'SDUX::Behavior::Core::ArrayMerge',
+    // ---------------------------------------------------------------------------
+    // Addon Behaviors (libs/addons)
+    // ---------------------------------------------------------------------------
+    'SDUX::Behavior::Persist::SessionStorage',
+    'SDUX::Behavior::Persist::LocalStorage',
+    'SDUX::Behavior::Persist::CookieStorage',
+    'SDUX::Behavior::Encrypt::Aes256',
+    'SDUX::Behavior::Policy::StepwiseFilter',
+    'SDUX::Behavior::Policy::StepwiseReducer',
+    'SDUX::Behavior::Policy::StepwiseResolve',
+    'SDUX::Behavior::Addon::DistinctUntilChanged',
+    'SDUX::Behavior::Interceptor::GlobalErrorPause',
+    'SDUX::Behavior::Merge::ArrayAppend',
+    'SDUX::Behavior::Merge::ArrayPush',
+    'SDUX::Behavior::Merge::Deep',
+    'SDUX::Behavior::Core::Query',
+    'SDUX::Behavior::Core::Lookup',
+    'SDUX::Behavior::Cache::State',
+    // ---------------------------------------------------------------------------
+    // Engine Behaviors (vault-engine)
+    // ---------------------------------------------------------------------------
+    'SDUX::Behavior::Core::License',
+    // ---------------------------------------------------------------------------
+    // Engine Controllers (vault-engine)
+    // ---------------------------------------------------------------------------
+    'SDUX::Controller::Policy::CoreAbstain',
+    'SDUX::Controller::Policy::CoreError',
+    'SDUX::Controller::Policy::CoreLicense',
+    // ---------------------------------------------------------------------------
+    // Addon Controllers (libs/addons)
+    // ---------------------------------------------------------------------------
+    'SDUX::Controller::Policy::ReplayGlobalError',
+    'SDUX::Controller::Policy::Stepwise',
+    'SDUX::Controller::Policy::MaxFailures',
+    'SDUX::Controller::Policy::Delay',
+    'SDUX::Controller::Policy::Throttle'
+]);
+
+/**
+ * Canonical license identifier for the SDuX Vault engine license.
+ *
+ * This value must match the `licenseId` field in the `VaultLicensingShape`
+ * payload supplied via `provideVault({ licenses: [...] })`.
+ */
+const VAULT_LICENSE_ID = 'sdux-vault';
+
 // --- AI Model File Path (DO NOT DELETE) ---
 // FilePath: projects > engine > src > lib > factories > vault > vault-core.function.ts
 // Updated: 2026-03-02 19:52
@@ -1503,6 +1584,7 @@ class VaultCoreInstance {
     #validaionSub;
     #licenseMap = new Map();
     #terminalStatus = new Map();
+    #bypassLicensing = true;
     #licenseTimeoutMs;
     // eslint-disable-next-line
     #licenseTimers = new Map();
@@ -1541,6 +1623,7 @@ class VaultCoreInstance {
         this.#vaultConfig = Object.freeze(vaultConfig);
         DevMode.setDevMode(this.#vaultConfig.devMode);
         setVaultLogLevel(this.#vaultConfig.logLevel);
+        this.#bypassLicensing = config.devMode ? (config.bypassLicensing ?? true) : false;
         this.#licenseTimeoutMs = config.licenseTimeoutMs ?? 15_000;
         this.#warnIfAccidentalDevMode();
     }
@@ -1577,6 +1660,15 @@ class VaultCoreInstance {
     getLicensePayload(licenseId) {
         return this.#licenseMap.get(licenseId);
     }
+    isBypassLicensing() {
+        return this.#bypassLicensing;
+    }
+    isAuthorizedKey(key) {
+        return KNOWN_VAULT_KEYS.has(key);
+    }
+    hasVaultLicense() {
+        return this.#licenseMap.has(VAULT_LICENSE_ID);
+    }
     //#endregion
     //#region  private Methods
     #initializeLicenses(licenses) {
@@ -1590,7 +1682,13 @@ class VaultCoreInstance {
     }
     #registerEntities(entities) {
         return new Map(entities.map((entity) => {
-            const needsLicense = entity.needsLicense ?? false;
+            let needsLicense;
+            if (this.#bypassLicensing) {
+                needsLicense = false;
+            }
+            else {
+                needsLicense = entity.needsLicense ?? false;
+            }
             const frozen = {
                 key: entity.key,
                 type: entity.type,
@@ -1743,9 +1841,9 @@ class VaultCoreInstance {
             return;
         // Must match exactly
         if (entity.licenseId !== licenseId) {
-            if (DevMode.active) {
-                vaultWarn(`[vault] License key mismatch for "${key}".`);
-            }
+            // if (DevMode.active) {
+            vaultWarn(`[vault] License key mismatch for "${key}".`);
+            //}
             return;
         }
         entities.set(key, Object.freeze({
@@ -1913,10 +2011,22 @@ function getVaultRegistryForTests() {
     if (!instance) {
         throw new Error('[vault] Vault not initialized.');
     }
-    if (!DevMode.active)
-        return;
     return instance.getRegistrySnapshot();
 }
+function isAuthorizedKey(key) {
+    if (!instance)
+        return false;
+    if (instance.isBypassLicensing())
+        return true;
+    return instance.isAuthorizedKey(key);
+}
+function hasVaultLicense() {
+    if (!instance)
+        return false;
+    if (instance.isBypassLicensing())
+        return true;
+    return instance.hasVaultLicense();
+}
 
 // projects/core/src/lib/services/vault-behavior-lifecycle.service.ts
 /**
@@ -1976,6 +2086,12 @@ class BehaviorInitializationClass {
                     isCritical = true;
                     throw new Error(`[vault] Behavior metadata missing "key".`);
                 }
+                if (!hasVaultLicense()) {
+                    if (!isAuthorizedKey(behaviorKey)) {
+                        vaultDebug(`[vault] Unlicensed behavior "${behaviorKey}" skipped during initialization.`);
+                        return;
+                    }
+                }
                 if (!behaviorType) {
                     isCritical = true;
                     throw new Error(`[vault] Behavior metadata missing "type" for "${behaviorKey}".`);
@@ -3015,6 +3131,12 @@ class ControllerInitializationClass {
                     isCritical = true;
                     throw new Error(`[vault] Controller metadata missing "key".`);
                 }
+                if (!hasVaultLicense()) {
+                    if (!isAuthorizedKey(controllerKey)) {
+                        vaultDebug(`[vault] Unlicensed controller "${controllerKey}" skipped during initialization.`);
+                        return;
+                    }
+                }
                 if (!controllerType) {
                     isCritical = true;
                     throw new Error(`[vault] Controller metadata missing "type" for "${controllerKey}".`);
@@ -3507,12 +3629,21 @@ class Conductor extends Orchestrator {
             controllers.unshift(withCoreErrorController);
         }
     }
+    #filterRestrictedControllers(controllers) {
+        return controllers.filter((controller) => {
+            if (controller.type === ControllerTypes.License || controller.type === ControllerTypes.CoreAbstain) {
+                vaultDebug(`${this.cellKey} Conductor: Filtering out controller "${controller.key}" of type "${controller.type}" as it is reserved for internal use.`);
+                return false;
+            }
+            return true;
+        });
+    }
     // ---------------------------------------------------------------------------
     // INTERNAL SCHEDULING
     // ---------------------------------------------------------------------------
     #registerControllers(config) {
         config.controllers = config.controllers ?? [];
-        const allControllers = config.controllers.filter(Boolean);
+        const allControllers = this.#filterRestrictedControllers(config.controllers);
         this.#addDefaultErrorController(allControllers, config);
         allControllers.unshift(withCoreLicenseController);
         allControllers.unshift(withCoreAbstainController);
@@ -4074,5 +4205,5 @@ function resetFeatureCellToken() {
  * Generated bundle index. Do not edit.
  */
 
-export { Conductor, FeatureCellClass, LicensingAbstract, VaultCore, createFeatureCellToken, getFeatureCellToken, getLicensePayload, getVaultRegistryForTests, isPipelineTerminal, registerFeatureCell, registerVaultSettled, resetFeatureCellRegistry, resetVaultForTests, vaultAllSettled, vaultSettled };
+export { Conductor, FeatureCellClass, LicensingAbstract, VAULT_LICENSE_ID, VaultCore, createFeatureCellToken, getFeatureCellToken, getLicensePayload, getVaultRegistryForTests, hasVaultLicense, isAuthorizedKey, isPipelineTerminal, registerFeatureCell, registerVaultSettled, resetFeatureCellRegistry, resetVaultForTests, vaultAllSettled, vaultSettled };
 //# sourceMappingURL=sdux-vault-engine.mjs.map