@sidub-inc/licensing-client 1.5.1 → 1.5.55

package/dist/index.js

@@ -21,6 +21,29 @@ class LicensingError extends Error {
     }
 }
 
+/**
+ * SEM-03 / Phase 11 D-14: thrown by `LicensingClient.assertLicense` when a
+ * rate-limited feature's assertion evaluates false.
+ *
+ * Distinguishable from transient network errors by type alone:
+ *   `catch (e) { if (e instanceof RateLimitError) { ... } }`
+ *
+ * Matches the .NET `Sidub.Licensing.Client.Exceptions.RateLimitException` shape.
+ * Minimal surface — only `featureKey` and `message`. No retry-after, no counters.
+ */
+class RateLimitError extends Error {
+    /**
+     * Creates a new RateLimitError.
+     * @param featureKey The key of the feature whose rate limit was exceeded.
+     * @param message A human-readable description of the violation.
+     */
+    constructor(featureKey, message) {
+        super(message);
+        this.featureKey = featureKey;
+        this.name = 'RateLimitError';
+    }
+}
+
 /**
  * License classification types defining the licensing model.
  * Matches the .NET LicenseClassificationType enum.
@@ -642,18 +665,136 @@ class SignatureValidator {
 }
 
 /**
- * In-memory authorization cache with TTL-based expiry and pseudo-LRU eviction.
+ * Thin localStorage abstraction for persisting SDK state across page refreshes.
+ * All methods are SSR-safe — they no-op when `window`/`localStorage` is unavailable.
+ *
+ * Used by RateLimitFeatureState and AuthorizationCache for transparent persistence.
+ */
+const isBrowser = typeof window !== 'undefined' && typeof window.localStorage !== 'undefined';
+/**
+ * Serializes and stores a value under the given key.
+ * No-op in SSR/Node environments.
+ */
+function save(key, data) {
+    if (!isBrowser)
+        return;
+    try {
+        window.localStorage.setItem(key, JSON.stringify(data));
+    }
+    catch {
+        // Quota exceeded or security restriction — silently degrade
+    }
+}
+/**
+ * Loads and deserializes a value from the given key.
+ * Returns null if the key is missing, the value cannot be parsed, or in SSR.
+ */
+function load(key) {
+    if (!isBrowser)
+        return null;
+    try {
+        const raw = window.localStorage.getItem(key);
+        if (raw === null)
+            return null;
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Removes a value from localStorage.
+ * No-op in SSR/Node environments.
+ */
+function remove(key) {
+    if (!isBrowser)
+        return;
+    try {
+        window.localStorage.removeItem(key);
+    }
+    catch {
+        // Ignore
+    }
+}
+/**
+ * Returns all localStorage keys that start with the given prefix.
+ * Returns an empty array in SSR/Node environments.
+ */
+function listKeys(prefix) {
+    if (!isBrowser)
+        return [];
+    const keys = [];
+    try {
+        for (let i = 0; i < window.localStorage.length; i++) {
+            const key = window.localStorage.key(i);
+            if (key !== null && key.startsWith(prefix)) {
+                keys.push(key);
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return keys;
+}
+/**
+ * Registers a listener for localStorage changes from OTHER tabs.
+ * Filters events by key prefix and calls the callback with the full key and new value.
+ *
+ * Returns an unsubscribe function that removes the listener.
+ * Returns a no-op in SSR/Node environments.
+ */
+function onStorageChange(prefix, callback) {
+    if (!isBrowser)
+        return () => { };
+    const handler = (event) => {
+        if (event.key !== null && event.key.startsWith(prefix)) {
+            callback(event.key, event.newValue);
+        }
+    };
+    window.addEventListener('storage', handler);
+    return () => window.removeEventListener('storage', handler);
+}
+
+/**
+ * Authorization cache with TTL-based expiry, pseudo-LRU eviction, and localStorage persistence.
  * Cache key format: {licenseId}.{serviceKeyId}
  * One cache instance per LicensingClient — no singletons.
+ *
+ * When a storagePrefix is provided, entries are persisted to localStorage and restored
+ * on construction, surviving page refreshes. Cross-tab sync is available via onSync().
  */
 class AuthorizationCache {
     /**
      * Creates a new authorization cache.
      * @param maxSize The maximum number of entries to store before evicting the oldest. Defaults to 100.
+     * @param storagePrefix Optional localStorage key prefix for persisting entries across page refreshes.
      */
-    constructor(maxSize = 100) {
+    constructor(maxSize = 100, storagePrefix) {
         this.cache = new Map();
+        this.unsubscribe = null;
         this.maxSize = maxSize;
+        this.storagePrefix = storagePrefix ?? null;
+        // Restore persisted entries, filtering out expired ones
+        if (this.storagePrefix) {
+            const keys = listKeys(this.storagePrefix);
+            for (const fullKey of keys) {
+                if (this.cache.size >= this.maxSize)
+                    break;
+                const stored = load(fullKey);
+                if (!stored)
+                    continue;
+                if (Date.now() >= stored.expiresAt) {
+                    remove(fullKey);
+                    continue;
+                }
+                const cacheKey = fullKey.substring(this.storagePrefix.length);
+                const entry = this.deserializeEntry(stored);
+                if (entry) {
+                    this.cache.set(cacheKey, entry);
+                }
+            }
+        }
     }
     /**
      * Gets a cached authorization if it exists and has not expired.
@@ -671,6 +812,9 @@ class AuthorizationCache {
         // Lazy TTL — delete expired entries on access
         if (Date.now() >= entry.expiresAt) {
             this.cache.delete(key);
+            if (this.storagePrefix) {
+                remove(this.storagePrefix + key);
+            }
             return null;
         }
         // Move to end of Map for pseudo-LRU freshness
@@ -701,12 +845,24 @@ class AuthorizationCache {
             const oldestKey = this.cache.keys().next().value;
             if (oldestKey !== undefined) {
                 this.cache.delete(oldestKey);
+                if (this.storagePrefix) {
+                    remove(this.storagePrefix + oldestKey);
+                }
             }
         }
         this.cache.set(key, { authorization, expiresAt });
+        if (this.storagePrefix) {
+            save(this.storagePrefix + key, this.serializeEntry({ authorization, expiresAt }));
+        }
     }
     /** Removes all cached entries */
     clearCache() {
+        if (this.storagePrefix) {
+            const keys = listKeys(this.storagePrefix);
+            for (const fullKey of keys) {
+                remove(fullKey);
+            }
+        }
         this.cache.clear();
     }
     /**
@@ -718,9 +874,96 @@ class AuthorizationCache {
         for (const key of Array.from(this.cache.keys())) {
             if (key.startsWith(prefix)) {
                 this.cache.delete(key);
+                if (this.storagePrefix) {
+                    remove(this.storagePrefix + key);
+                }
             }
         }
     }
+    /**
+     * Registers a cross-tab sync listener. When another tab modifies auth cache entries,
+     * the in-memory cache is updated and the callback is invoked.
+     *
+     * @param callback Invoked after in-memory state is updated from another tab.
+     * @returns An unsubscribe function to remove the listener.
+     */
+    onSync(callback) {
+        if (!this.storagePrefix)
+            return () => { };
+        this.unsubscribe = onStorageChange(this.storagePrefix, (fullKey, newValue) => {
+            const cacheKey = fullKey.substring(this.storagePrefix.length);
+            if (newValue === null) {
+                // Entry was removed in another tab
+                this.cache.delete(cacheKey);
+            }
+            else {
+                try {
+                    const stored = JSON.parse(newValue);
+                    if (Date.now() >= stored.expiresAt) {
+                        this.cache.delete(cacheKey);
+                        return;
+                    }
+                    const entry = this.deserializeEntry(stored);
+                    if (entry) {
+                        // Respect maxSize — evict oldest if needed
+                        if (!this.cache.has(cacheKey) && this.cache.size >= this.maxSize) {
+                            const oldestKey = this.cache.keys().next().value;
+                            if (oldestKey !== undefined) {
+                                this.cache.delete(oldestKey);
+                            }
+                        }
+                        this.cache.set(cacheKey, entry);
+                    }
+                }
+                catch {
+                    // Ignore malformed data
+                }
+            }
+            callback();
+        });
+        return this.unsubscribe;
+    }
+    /**
+     * Removes the cross-tab sync listener if active.
+     */
+    dispose() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+    /**
+     * Serializes a cache entry for localStorage storage.
+     * Converts Date objects to epoch numbers for safe JSON round-tripping.
+     */
+    serializeEntry(entry) {
+        const auth = entry.authorization;
+        return {
+            authorization: {
+                ...auth,
+                issuedAt: auth.issuedAt instanceof Date ? auth.issuedAt.getTime() : auth.issuedAt,
+                expiresAt: auth.expiresAt instanceof Date ? auth.expiresAt.getTime() : auth.expiresAt
+            },
+            expiresAt: entry.expiresAt
+        };
+    }
+    /**
+     * Deserializes a cache entry from localStorage, reconstructing Date objects.
+     */
+    deserializeEntry(stored) {
+        try {
+            const raw = stored.authorization;
+            const authorization = {
+                ...raw,
+                issuedAt: raw.issuedAt ? new Date(raw.issuedAt) : new Date(),
+                expiresAt: raw.expiresAt ? new Date(raw.expiresAt) : undefined
+            };
+            return { authorization, expiresAt: stored.expiresAt };
+        }
+        catch {
+            return null;
+        }
+    }
 }
 
 /**
@@ -729,15 +972,31 @@ class AuthorizationCache {
  *
  * Entries older than sampleSeconds are pruned on every getConsumption() call.
  * Local state is additive/conservative — may over-count (safer than under-counting).
+ *
+ * When a storageKey is provided, metrics are persisted to localStorage and restored
+ * on construction, surviving page refreshes. Cross-tab sync is available via onSync().
  */
 class RateLimitFeatureState {
     /**
      * Creates a new rate limit feature state tracker.
      * @param sampleSeconds The sliding window duration in seconds for rate limit evaluation.
+     * @param storageKey Optional localStorage key for persisting metrics across page refreshes.
      */
-    constructor(sampleSeconds) {
+    constructor(sampleSeconds, storageKey) {
         this.metrics = [];
+        this.unsubscribe = null;
         this.sampleSeconds = sampleSeconds;
+        this.storageKey = storageKey ?? null;
+        // Restore persisted metrics, pruning stale entries
+        if (this.storageKey) {
+            const stored = load(this.storageKey);
+            if (stored && Array.isArray(stored)) {
+                const cutoff = Date.now() - (this.sampleSeconds * 1000);
+                this.metrics = stored.filter(m => m.timestamp >= cutoff);
+                // Persist the pruned list back
+                save(this.storageKey, this.metrics);
+            }
+        }
     }
     /**
      * Records a consumption event with the current timestamp.
@@ -745,6 +1004,9 @@ class RateLimitFeatureState {
      */
     consumeRate(amount) {
         this.metrics.push({ timestamp: Date.now(), amount });
+        if (this.storageKey) {
+            save(this.storageKey, this.metrics);
+        }
     }
     /**
      * Returns total consumption within the sample window, pruning stale entries.
@@ -753,8 +1015,50 @@ class RateLimitFeatureState {
     getConsumption() {
         const cutoff = Date.now() - (this.sampleSeconds * 1000);
         this.metrics = this.metrics.filter(m => m.timestamp >= cutoff);
+        if (this.storageKey) {
+            save(this.storageKey, this.metrics);
+        }
         return this.metrics.reduce((sum, m) => sum + m.amount, 0);
     }
+    /**
+     * Registers a cross-tab sync listener. When another tab modifies the same storageKey,
+     * the in-memory metrics are replaced with the new values and the callback is invoked.
+     *
+     * @param callback Invoked after in-memory state is updated from another tab.
+     * @returns An unsubscribe function to remove the listener.
+     */
+    onSync(callback) {
+        if (!this.storageKey)
+            return () => { };
+        this.unsubscribe = onStorageChange(this.storageKey, (_key, newValue) => {
+            if (newValue === null) {
+                this.metrics = [];
+            }
+            else {
+                try {
+                    const parsed = JSON.parse(newValue);
+                    if (Array.isArray(parsed)) {
+                        const cutoff = Date.now() - (this.sampleSeconds * 1000);
+                        this.metrics = parsed.filter(m => m.timestamp >= cutoff);
+                    }
+                }
+                catch {
+                    // Ignore malformed data
+                }
+            }
+            callback();
+        });
+        return this.unsubscribe;
+    }
+    /**
+     * Removes the cross-tab sync listener if active.
+     */
+    dispose() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
 }
 
 /**
@@ -786,6 +1090,7 @@ class LicensingClient {
     constructor(config) {
         this.featureStates = new Map();
         this.featureMetadata = new Map(); // stateKey -> sampleSeconds
+        this.disposables = [];
         this.contextResolved = false;
         this.contextResolutionPromise = null;
         // Decode credential if provided
@@ -806,11 +1111,64 @@ class LicensingClient {
         this.signatureValidator = new SignatureValidator(cryptoConfig);
         // Determine if signature validation should be performed
         this.validateSignatures = config.validateSignatures ?? (cryptoConfig !== null);
-        // Initialize authorization cache (enabled by default)
+        // Initialize authorization cache (enabled by default) with localStorage persistence
         this.cacheEnabled = config.cacheEnabled !== false;
         this.authorizationCache = this.cacheEnabled
-            ? new AuthorizationCache(config.cacheMaxSize ?? 100)
+            ? new AuthorizationCache(config.cacheMaxSize ?? 100, LicensingClient.AUTH_STORAGE_PREFIX)
             : null;
+        // Register cross-tab sync for authorization cache
+        if (this.authorizationCache) {
+            this.disposables.push(this.authorizationCache.onSync(() => { }));
+        }
+        // Restore featureMetadata from localStorage
+        const storedMetadata = load(LicensingClient.METADATA_STORAGE_KEY);
+        if (storedMetadata && typeof storedMetadata === 'object') {
+            for (const [key, value] of Object.entries(storedMetadata)) {
+                if (typeof value === 'number') {
+                    this.featureMetadata.set(key, value);
+                }
+            }
+        }
+        // Cross-tab sync for featureMetadata
+        this.disposables.push(onStorageChange(LicensingClient.METADATA_STORAGE_KEY, (_key, newValue) => {
+            this.featureMetadata.clear();
+            if (newValue) {
+                try {
+                    const parsed = JSON.parse(newValue);
+                    for (const [k, v] of Object.entries(parsed)) {
+                        if (typeof v === 'number') {
+                            this.featureMetadata.set(k, v);
+                        }
+                    }
+                }
+                catch {
+                    // Ignore malformed data
+                }
+            }
+        }));
+        // Restore persisted featureStates from localStorage
+        this.restoreFeatureStates();
+    }
+    /**
+     * Restores RateLimitFeatureState instances from localStorage for all known features.
+     */
+    restoreFeatureStates() {
+        for (const [stateKey, sampleSeconds] of this.featureMetadata.entries()) {
+            const storageKey = LicensingClient.CONSUMPTION_STORAGE_PREFIX + stateKey;
+            const state = new RateLimitFeatureState(sampleSeconds, storageKey);
+            this.featureStates.set(stateKey, state);
+            this.disposables.push(state.onSync(() => { }));
+        }
+    }
+    /**
+     * Persists the featureMetadata map to localStorage.
+     */
+    persistFeatureMetadata() {
+        const obj = {};
+        for (const [key, value] of this.featureMetadata.entries()) {
+            obj[key] = value;
+        }
+        save(LicensingClient.METADATA_STORAGE_KEY, obj);
     }
     /**
      * Ensures context provider has been resolved before making API calls.
@@ -963,13 +1321,18 @@ class LicensingClient {
                 signatureValidated
             };
             // Cache feature sampleSeconds for auto-creating RateLimitFeatureState in performOperation
+            let metadataChanged = false;
             for (const f of authorization.features) {
                 const rf = f;
                 const ss = rf.sampleSeconds ?? rf.SampleSeconds;
                 if (ss !== undefined && typeof ss === 'number') {
                     this.featureMetadata.set(`${authorization.licenseId}.${f.featureId}`, ss);
+                    metadataChanged = true;
                 }
             }
+            if (metadataChanged) {
+                this.persistFeatureMetadata();
+            }
             // Store in cache
             if (this.cacheEnabled && this.authorizationCache) {
                 this.authorizationCache.set(effectiveLicenseId, this.config.serviceKeyId ?? '', authorization);
@@ -1072,10 +1435,121 @@ class LicensingClient {
      * @param authorization The license authorization to check against.
      * @returns True if the assertion is satisfied, false otherwise.
      */
+    /**
+     * Phase 11 D-01 (LCYC-02): Composes an in-memory LicenseStateView from the current
+     * authorization. Returns null when no license is configured or the authorization cannot
+     * be retrieved.
+     */
+    async getState() {
+        let auth;
+        try {
+            auth = await this.getAuthorization();
+        }
+        catch {
+            return null;
+        }
+        const features = auth.features.map((f) => {
+            const sf = f;
+            const featureKey = String(sf.featureId ?? '');
+            const displayName = String(sf.displayName ?? sf.featureName ?? featureKey);
+            return { featureKey, displayName };
+        });
+        const consumption = [];
+        for (const f of auth.features) {
+            const sf = f;
+            const featureKey = String(sf.featureId ?? '');
+            const rateLimit = sf.rateLimit;
+            const sampleSeconds = sf.sampleSeconds;
+            if (rateLimit === undefined || sampleSeconds === undefined)
+                continue;
+            const licenseId = auth.licenseId;
+            const stateKey = `${licenseId}.${featureKey}`;
+            const localState = this.featureStates.get(stateKey);
+            const currentUsage = localState?.getConsumption() ?? sf.currentConsumption ?? 0;
+            const percentage = rateLimit > 0 ? (currentUsage / rateLimit) * 100 : 0;
+            consumption.push({
+                featureKey,
+                currentUsage,
+                limit: rateLimit,
+                windowSeconds: sampleSeconds,
+                percentage
+            });
+        }
+        return {
+            licenseId: auth.licenseId,
+            features,
+            consumption,
+            expiry: auth.expiresAt ?? null
+        };
+    }
+    /**
+     * Phase 11 D-11 (LCYC-06): Invalidates all cached state and rebuilds internal credential
+     * configuration from a new encodedCredential — without requiring a React component remount.
+     *
+     * Call this from a useEffect keyed on the credential string; the `key={credential}` idiom
+     * is a deprecated fallback.
+     *
+     * @param newConfig A LicensingConfig carrying the updated encodedCredential (all other
+     *   fields are merged; explicit fields on newConfig take precedence).
+     */
+    async refresh(newConfig) {
+        // Decode new credential
+        const newCredential = newConfig.encodedCredential
+            ? decodeCredential(newConfig.encodedCredential)
+            : null;
+        this.credential = newCredential;
+        // Rebuild merged config
+        this.config = {
+            ...newConfig,
+            timeout: newConfig.timeout || 30000,
+            apiKey: newConfig.apiKey || newCredential?.apiAccessKey,
+            licenseId: newConfig.licenseId || newCredential?.licenseId,
+            serviceKeyId: newConfig.serviceKeyId || newCredential?.serviceKeyId,
+            serviceKeyPublicMember: newConfig.serviceKeyPublicMember || newCredential?.serviceKeyPublicMember
+        };
+        // Rebuild crypto + signature validator
+        const cryptoConfig = this.buildCryptoConfig();
+        this.signatureValidator = new SignatureValidator(cryptoConfig);
+        this.validateSignatures = newConfig.validateSignatures ?? (cryptoConfig !== null);
+        // Invalidate authorization cache
+        this.authorizationCache?.clearCache();
+        // Dispose + clear per-feature rate-limit state
+        for (const state of this.featureStates.values()) {
+            state.dispose();
+        }
+        this.featureStates.clear();
+        this.featureMetadata.clear();
+        // Remove persisted state from localStorage
+        remove(LicensingClient.METADATA_STORAGE_KEY);
+        // AUTH_STORAGE_PREFIX keys are managed by the AuthorizationCache; clearCache() handles them.
+        // CONSUMPTION keys are keyed per stateKey — clear all known prefixed entries.
+        if (typeof localStorage !== 'undefined') {
+            const consumptionKeys = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const k = localStorage.key(i);
+                if (k && k.startsWith(LicensingClient.CONSUMPTION_STORAGE_PREFIX)) {
+                    consumptionKeys.push(k);
+                }
+            }
+            for (const k of consumptionKeys) {
+                localStorage.removeItem(k);
+            }
+        }
+        // Reset context resolution so ensureContextResolved() re-runs with new config
+        this.contextResolved = false;
+        this.contextResolutionPromise = null;
+    }
     assertLicense(assertion, authorization) {
         // Auto-inject feature states for RateLimitAssertion
         if (assertion instanceof RateLimitAssertion) {
-            return assertion.isSatisfied(authorization, this.featureStates);
+            const satisfied = assertion.isSatisfied(authorization, this.featureStates);
+            if (!satisfied) {
+                // Phase 11 D-14 / D-16: emit warning unconditionally even when consumer catches
+                const msg = `Rate limit exceeded for feature '${assertion.featureKey}'.`;
+                console.warn(`[Sidub.Licensing] ${msg}`);
+                throw new RateLimitError(assertion.featureKey, msg);
+            }
+            return true;
         }
         return assertion.isSatisfied(authorization);
     }
@@ -1092,6 +1566,21 @@ class LicensingClient {
     invalidateCache(licenseId) {
         this.authorizationCache?.invalidate(licenseId);
     }
+    /**
+     * Releases all resources held by this client instance:
+     * removes cross-tab StorageEvent listeners and disposes cache/state objects.
+     * Call this when the client is no longer needed (e.g., on component unmount).
+     */
+    dispose() {
+        for (const unsub of this.disposables) {
+            unsub();
+        }
+        this.disposables.length = 0;
+        for (const state of this.featureStates.values()) {
+            state.dispose();
+        }
+        this.authorizationCache?.dispose();
+    }
     /**
      * Gets the local feature state for a license+feature combination.
      * @param licenseId The license identifier.
@@ -1165,8 +1654,10 @@ class LicensingClient {
             let state = this.featureStates.get(stateKey);
             if (!state) {
                 const sampleSeconds = this.featureMetadata.get(stateKey) ?? 3600;
-                state = new RateLimitFeatureState(sampleSeconds);
+                const storageKey = LicensingClient.CONSUMPTION_STORAGE_PREFIX + stateKey;
+                state = new RateLimitFeatureState(sampleSeconds, storageKey);
                 this.featureStates.set(stateKey, state);
+                this.disposables.push(state.onSync(() => { }));
             }
             state.consumeRate(operation.quantity ?? 1);
         }
@@ -1441,6 +1932,9 @@ class LicensingClient {
         return { ...this.config };
     }
 }
+LicensingClient.METADATA_STORAGE_KEY = 'sidub.licensing.metadata';
+LicensingClient.CONSUMPTION_STORAGE_PREFIX = 'sidub.licensing.consumption.';
+LicensingClient.AUTH_STORAGE_PREFIX = 'sidub.licensing.auth.';
 
 /**
  * Assertion that checks if a feature with a specific key exists in the authorization.
@@ -1595,7 +2089,9 @@ const LicensingContext = React.createContext(undefined);
  * ```
  */
 const LicensingProvider = ({ config, children }) => {
-    // Create client with memoization - recreate only if config changes
+    // Phase 11 D-11: useMemo no longer depends on encodedCredential.
+    // Client is created once from structural config; credential changes are handled
+    // by the useEffect below via client.refresh() — no remount required.
     const value = React.useMemo(() => {
         const client = new LicensingClient(config);
         return {
@@ -1608,12 +2104,21 @@ const LicensingProvider = ({ config, children }) => {
         config.consumptionServiceUri,
         config.apiKey,
         config.timeout,
-        config.encodedCredential,
         config.serviceKeyId,
         config.serviceKeyPublicMember,
         config.licenseId,
         config.validateSignatures
+        // NOTE: encodedCredential intentionally omitted — changes are handled via refresh() below
     ]);
+    // Phase 11 D-11: when the encoded credential changes, invalidate client state and
+    // rebuild credential config without remounting the component tree.
+    // The `key={credential}` remount idiom is a deprecated fallback.
+    React.useEffect(() => {
+        if (config.encodedCredential !== undefined) {
+            void value.client.refresh(config);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [config.encodedCredential]);
     return (React.createElement(LicensingContext.Provider, { value: value }, children));
 };
 /**
@@ -1763,6 +2268,7 @@ exports.LicensingError = LicensingError;
 exports.LicensingProvider = LicensingProvider;
 exports.NotAssertion = NotAssertion;
 exports.RateLimitAssertion = RateLimitAssertion;
+exports.RateLimitError = RateLimitError;
 exports.RateLimitFeatureState = RateLimitFeatureState;
 exports.ServiceAccessAssertion = ServiceAccessAssertion;
 exports.SignatureValidator = SignatureValidator;
@@ -1774,10 +2280,15 @@ exports.hasFeature = hasFeature;
 exports.hasValidCryptoConfig = hasValidCryptoConfig;
 exports.licensingContextFromEncodedString = licensingContextFromEncodedString;
 exports.licensingContextToEncodedString = licensingContextToEncodedString;
+exports.listKeys = listKeys;
+exports.load = load;
 exports.matchesFeatureKey = matchesFeatureKey;
 exports.normalizeBillingIntervalUnit = normalizeBillingIntervalUnit;
 exports.normalizeLicenseClassificationType = normalizeLicenseClassificationType;
 exports.normalizeServiceAccessLevel = normalizeServiceAccessLevel;
+exports.onStorageChange = onStorageChange;
+exports.remove = remove;
+exports.save = save;
 exports.tryDecodeCredential = tryDecodeCredential;
 exports.useLicensingContext = useLicensingContext;
 exports.useLicensingContextValue = useLicensingContextValue;