@naylence/runtime 0.3.4 → 0.3.5-test.0

package/dist/browser/index.js

@@ -4141,16 +4141,15 @@
      * Fallback base64 decoder for environments without Buffer or atob
      */
     function decodeBase64Fallback(str) {
-        // Fallback for environments without Buffer or atob
         const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
         let result = '';
         let i = 0;
-        str = str.replace(/[^A-Za-z0-9+/]/g, '');
-        while (i < str.length) {
-            const encoded1 = chars.indexOf(str.charAt(i++));
-            const encoded2 = chars.indexOf(str.charAt(i++));
-            const encoded3 = chars.indexOf(str.charAt(i++));
-            const encoded4 = chars.indexOf(str.charAt(i++));
+        let sanitized = str.replace(/[^A-Za-z0-9+/]/g, '');
+        while (i < sanitized.length) {
+            const encoded1 = chars.indexOf(sanitized.charAt(i++));
+            const encoded2 = chars.indexOf(sanitized.charAt(i++));
+            const encoded3 = chars.indexOf(sanitized.charAt(i++));
+            const encoded4 = chars.indexOf(sanitized.charAt(i++));
             const bitmap = (encoded1 << 18) | (encoded2 << 12) | (encoded3 << 6) | encoded4;
             result += String.fromCharCode((bitmap >> 16) & 255);
             if (encoded3 !== 64)
@@ -4160,51 +4159,36 @@
         }
         return result;
     }
-    function decodeBase64(str) {
-        if (typeof atob !== 'undefined') {
-            return atob(str);
-        }
-        else if (typeof globalThis !== 'undefined' && globalThis.Buffer) {
-            return globalThis.Buffer.from(str, 'base64').toString('utf8');
-        }
-        else {
-            return decodeBase64Fallback(str);
-        }
+    function createBlacklist(decoder) {
+        return new Set(BLACKLIST_ID_WORDS_B64.map((value) => decoder(value).toLowerCase()));
     }
-    const BLACKLIST_ID_WORDS = new Set(BLACKLIST_ID_WORDS_B64.map(b => decodeBase64(b).toLowerCase()));
-    /**
-     * Convert integer to Base-62 string (no leading zeros)
-     */
     function base62(n) {
         if (n === 0n) {
             return '0';
         }
         const chars = [];
-        while (n > 0n) {
-            const rem = Number(n % 62n);
-            n = n / 62n;
-            const char = ALPHABET[rem];
+        let current = n;
+        while (current > 0n) {
+            const remainder = Number(current % 62n);
+            current = current / 62n;
+            const char = ALPHABET[remainder];
             if (char === undefined) {
-                throw new Error(`Invalid remainder ${rem} for base62 encoding`);
+                throw new Error(`Invalid remainder ${remainder} for base62 encoding`);
             }
             chars.push(char);
         }
         return chars.reverse().join('');
     }
-    /**
-     * Encode digest bytes to Base-62 string of specified length
-     */
     function encodeDigest(digest, length) {
-        // Convert bytes to bigint
-        let n = 0n;
+        let value = 0n;
         for (let i = 0; i < digest.length; i++) {
             const byte = digest[i];
             if (byte === undefined) {
                 throw new Error(`Invalid digest byte at index ${i}`);
             }
-            n = (n << 8n) + BigInt(byte);
+            value = (value << 8n) + BigInt(byte);
         }
-        const base62Value = base62(n);
+        const base62Value = base62(value);
         if (base62Value.length >= length) {
             return base62Value.slice(0, length);
         }
@@ -4226,343 +4210,276 @@
             node: lower,
         };
     }
-    /**
-     * Get canonical representation of command-line arguments
-     * In browser, this will be an empty string
-     */
-    function getCanonicalArgv() {
-        try {
-            if (typeof globalThis !== 'undefined' && globalThis.process?.argv) {
-                const process = globalThis.process;
-                const argv = process.argv.slice(2);
-                const stableArgs = argv
-                    .filter((arg) => arg.startsWith('--') && arg !== '--instance')
-                    .sort();
-                const parts = [];
-                if (stableArgs.length > 0) {
-                    parts.push(`flags:${stableArgs.join(' ')}`);
-                }
-                // Entry script path
-                if (process.argv[1]) {
-                    parts.push(`entry:${process.argv[1]}`);
-                }
-                return parts.join('|');
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-        return 'browser';
-    }
-    /**
-     * Get host and environment fingerprint for deterministic node IDs
-     */
-    async function getDefaultNodeFingerprint(extraMaterial) {
-        let hostFp;
-        // Check for Node.js environment FIRST (before navigator check)
-        // This is critical because Node.js v24+ has a global navigator object
-        if (typeof process !== 'undefined' && process.versions?.node) {
-            try {
-                // Node.js environment - use MAC address or hostname
-                // Try to get os module - works in both CJS and ESM
-                let os;
-                const req = globalThis.require;
-                if (req) {
-                    // CommonJS environment
-                    os = req('os');
+    function materialToBytes(material, encoder) {
+        if (Array.isArray(material)) {
+            const parts = material.map((value, index) => {
+                if (value === undefined || value === null) {
+                    throw new Error(`Invalid material part at index ${index}`);
                 }
-                else {
-                    // ESM environment - use dynamic import
-                    os = await import('os');
-                }
-                if (os) {
-                    const networkInterfaces = os.networkInterfaces();
-                    // Try to find a MAC address
-                    let mac = null;
-                    for (const [, interfaces] of Object.entries(networkInterfaces)) {
-                        for (const iface of interfaces) {
-                            if (iface.mac && iface.mac !== '00:00:00:00:00:00') {
-                                mac = iface.mac;
-                                break;
-                            }
-                        }
-                        if (mac)
-                            break;
-                    }
-                    if (mac) {
-                        // Normalize MAC format to match Python implementation (remove colons)
-                        const normalizedMac = mac.replace(/:/g, '').toLowerCase();
-                        hostFp = `mac:${normalizedMac}`;
-                    }
-                    else {
-                        hostFp = `hn:${os.hostname()}`;
-                    }
+                if (typeof value === 'string') {
+                    return encoder.encode(value);
                 }
-                else {
-                    hostFp = 'unknown';
+                return new Uint8Array(value);
+            });
+            const totalLength = parts.reduce((sum, part) => sum + part.length + 1, 0) - 1;
+            const combined = new Uint8Array(totalLength > 0 ? totalLength : 0);
+            let offset = 0;
+            for (let i = 0; i < parts.length; i++) {
+                if (i > 0) {
+                    combined[offset++] = 124; // '|' separator
                 }
+                const part = parts[i];
+                combined.set(part, offset);
+                offset += part.length;
             }
-            catch (e) {
-                hostFp = 'unknown';
-            }
-        }
-        else if (typeof navigator !== 'undefined' && navigator.userAgent) {
-            // Browser environment - use a hash of user agent
-            hostFp = `ua:${navigator.userAgent}`;
+            return combined;
         }
-        else {
-            hostFp = 'unknown';
+        if (typeof material === 'string') {
+            return encoder.encode(material);
         }
-        // Code + argv part
-        const codeFp = getCanonicalArgv();
-        // Optional extra material
-        let blob;
-        if (extraMaterial) {
-            let salt;
-            if (extraMaterial instanceof Uint8Array) {
-                salt = new TextDecoder().decode(extraMaterial);
-            }
-            else {
-                salt = String(extraMaterial);
+        return new Uint8Array(material);
+    }
+    function candidateContainsBlacklist(candidate, blacklist) {
+        const lowered = candidate.toLowerCase();
+        for (const forbidden of blacklist) {
+            if (lowered.includes(forbidden)) {
+                return true;
             }
-            blob = `${hostFp}|${codeFp}|salt:${salt}`;
-        }
-        else {
-            blob = `${hostFp}|${codeFp}`;
         }
-        return new TextEncoder().encode(blob);
+        return false;
     }
-    /**
-     * Generate cryptographically secure random bytes
-     */
-    function getRandomBytes$2(length) {
-        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
-            // Browser or modern Node.js
-            const bytes = new Uint8Array(length);
-            crypto.getRandomValues(bytes);
-            return bytes;
-        }
-        else {
-            try {
-                const nodeCrypto = globalThis.require?.('crypto');
-                if (nodeCrypto) {
-                    return new Uint8Array(nodeCrypto.randomBytes(length));
+    function generateRandomCandidate(length, getRandomBytes, blacklist) {
+        while (true) {
+            const randomBytes = getRandomBytes(length);
+            let candidate = '';
+            for (let i = 0; i < length; i++) {
+                const byte = randomBytes[i];
+                if (byte === undefined) {
+                    throw new Error(`Invalid random byte at index ${i}`);
                 }
+                candidate += ALPHABET[byte % ALPHABET.length];
             }
-            catch {
-                // Ignore
-            }
-            // Fallback to Math.random (not cryptographically secure)
-            const bytes = new Uint8Array(length);
-            for (let i = 0; i < length; i++) {
-                bytes[i] = Math.floor(Math.random() * 256);
+            if (!candidateContainsBlacklist(candidate, blacklist)) {
+                return candidate;
             }
-            return bytes;
         }
     }
-    /**
-     * Create hash digest
-     */
-    function hash(data, algorithm = 'sha256') {
-        const { node } = normalizeHashAlgorithmNames(algorithm);
-        try {
-            const nodeCrypto = globalThis.require?.('crypto');
-            if (nodeCrypto?.createHash) {
-                const hash = nodeCrypto.createHash(node);
-                hash.update(data);
-                return new Uint8Array(hash.digest());
-            }
-        }
-        catch {
-            // Ignore
+    async function rehashUntilCleanAsync(digest, length, hash, blacklist) {
+        let currentDigest = digest;
+        let candidate = encodeDigest(currentDigest, length);
+        while (candidateContainsBlacklist(candidate, blacklist)) {
+            currentDigest = await hash(currentDigest);
+            candidate = encodeDigest(currentDigest, length);
         }
-        // Fallback - very basic hash (not cryptographically secure)
-        let hash = 0;
+        return candidate;
+    }
+    function fallbackHash(data) {
+        let hashValue = 0;
         for (let i = 0; i < data.length; i++) {
             const byte = data[i];
             if (byte === undefined) {
                 throw new Error(`Invalid data byte at index ${i}`);
             }
-            hash = ((hash << 5) - hash + byte) & 0xffffffff;
+            hashValue = ((hashValue << 5) - hashValue + byte) & 0xffffffff;
         }
         const bytes = new Uint8Array(4);
-        bytes[0] = (hash >>> 24) & 0xff;
-        bytes[1] = (hash >>> 16) & 0xff;
-        bytes[2] = (hash >>> 8) & 0xff;
-        bytes[3] = hash & 0xff;
+        bytes[0] = (hashValue >>> 24) & 0xff;
+        bytes[1] = (hashValue >>> 16) & 0xff;
+        bytes[2] = (hashValue >>> 8) & 0xff;
+        bytes[3] = hashValue & 0xff;
+        return bytes;
+    }
+
+    const textEncoder$1 = ensureEncoder();
+    const textDecoder$1 = ensureDecoder();
+    const STORAGE_SEED_KEY = 'naylence:fame:seed';
+    let cachedBrowserSeed = null;
+    function ensureEncoder() {
+        if (typeof TextEncoder !== 'undefined') {
+            return new TextEncoder();
+        }
+        const util = globalThis.util;
+        if (util?.TextEncoder) {
+            return new util.TextEncoder();
+        }
+        const { TextEncoder: ImportedTextEncoder } = require('util');
+        return new ImportedTextEncoder();
+    }
+    function ensureDecoder() {
+        if (typeof TextDecoder !== 'undefined') {
+            return new TextDecoder();
+        }
+        const util = globalThis.util;
+        if (util?.TextDecoder) {
+            return new util.TextDecoder();
+        }
+        const { TextDecoder: ImportedTextDecoder } = require('util');
+        return new ImportedTextDecoder();
+    }
+    function decodeBase64(str) {
+        if (typeof atob === 'function') {
+            return atob(str);
+        }
+        const bufferLike = globalThis.Buffer;
+        if (bufferLike) {
+            return bufferLike.from(str, 'base64').toString('utf8');
+        }
+        return decodeBase64Fallback(str);
+    }
+    const BLACKLIST_ID_WORDS = createBlacklist(decodeBase64);
+    function getRandomBytes$3(length) {
+        const cryptoRef = globalThis.crypto;
+        if (cryptoRef?.getRandomValues) {
+            const bytes = new Uint8Array(length);
+            cryptoRef.getRandomValues(bytes);
+            return bytes;
+        }
+        const bytes = new Uint8Array(length);
+        for (let i = 0; i < length; i++) {
+            bytes[i] = Math.floor(Math.random() * 256);
+        }
         return bytes;
     }
-    /**
-     * Create hash digest asynchronously (for browser compatibility)
-     */
     async function hashAsync(data, algorithm = 'sha256') {
-        const { subtle, node } = normalizeHashAlgorithmNames(algorithm);
-        if (typeof crypto !== 'undefined' && crypto.subtle) {
+        const { subtle } = normalizeHashAlgorithmNames(algorithm);
+        const cryptoRef = globalThis.crypto;
+        if (cryptoRef?.subtle) {
             try {
-                // Browser environment - create a copy to ensure ArrayBuffer type
                 const buffer = new ArrayBuffer(data.length);
                 const view = new Uint8Array(buffer);
                 view.set(data);
-                const hashBuffer = await crypto.subtle.digest(subtle, buffer);
-                return new Uint8Array(hashBuffer);
+                const digest = await cryptoRef.subtle.digest(subtle, buffer);
+                return new Uint8Array(digest);
             }
             catch {
-                // Fallback if crypto.subtle fails
+                // ignore
             }
         }
-        try {
-            const nodeCrypto = globalThis.require?.('crypto');
-            if (nodeCrypto?.createHash) {
-                const hash = nodeCrypto.createHash(node);
-                hash.update(data);
-                return new Uint8Array(hash.digest());
+        return fallbackHash(data);
+    }
+    function getCanonicalArgv() {
+        return 'browser';
+    }
+    async function getDefaultBrowserFingerprint(extraMaterial) {
+        const hostFingerprint = `seed:${getStableBrowserSeed()}`;
+        const codeFingerprint = getCanonicalArgv();
+        const parts = [`${hostFingerprint}`, `${codeFingerprint}`];
+        if (extraMaterial !== undefined && extraMaterial !== null) {
+            let salt;
+            if (typeof extraMaterial === 'string') {
+                salt = extraMaterial;
             }
+            else if (extraMaterial instanceof Uint8Array) {
+                salt = textDecoder$1.decode(extraMaterial);
+            }
+            else {
+                salt = String(extraMaterial);
+            }
+            parts.push(`salt:${salt}`);
         }
-        catch {
-            // Ignore
-        }
-        // Fallback
-        return hash(data, algorithm);
+        const payload = parts.join('|');
+        return textEncoder$1.encode(payload);
     }
-    /**
-     * Generate ID synchronously (Node.js only for fingerprint mode)
-     */
-    function generateId(options = {}) {
-        const { length = 16, mode = 'random', material, blacklist = BLACKLIST_ID_WORDS, hashAlg = 'sha256' } = options;
-        if (mode !== 'random' && mode !== 'fingerprint') {
-            throw new Error("mode must be 'random' or 'fingerprint'");
+    function getStableBrowserSeed() {
+        if (cachedBrowserSeed) {
+            return cachedBrowserSeed;
         }
-        if (mode === 'random') {
-            while (true) {
-                let candidate = '';
-                const randomBytes = getRandomBytes$2(length);
-                for (let i = 0; i < length; i++) {
-                    const byte = randomBytes[i];
-                    if (byte === undefined) {
-                        throw new Error(`Invalid random byte at index ${i}`);
-                    }
-                    candidate += ALPHABET[byte % ALPHABET.length];
-                }
-                if (!Array.from(blacklist).some(bad => candidate.toLowerCase().includes(bad))) {
-                    return candidate;
-                }
+        const storages = getWritableStorages();
+        for (const storage of storages) {
+            const stored = readSeed(storage);
+            if (stored) {
+                cachedBrowserSeed = stored;
+                return stored;
             }
         }
-        // Fingerprint mode - synchronous version (Node.js only)
-        if (typeof crypto !== 'undefined' && crypto.subtle) {
-            throw new Error('Browser environment requires async ID generation - use generateIdAsync instead');
+        const seed = generateSeed();
+        for (const storage of storages) {
+            if (writeSeed(storage, seed)) {
+                cachedBrowserSeed = seed;
+                return seed;
+            }
         }
-        let materialBytes;
-        if (material === undefined || material === null) {
-            throw new Error('Fingerprint mode requires async operation in browser - use generateIdAsync instead');
+        cachedBrowserSeed = seed;
+        return seed;
+    }
+    function readSeed(storage) {
+        try {
+            return storage.getItem(STORAGE_SEED_KEY);
         }
-        if (Array.isArray(material)) {
-            const parts = material.map(m => {
-                if (typeof m === 'string') {
-                    return new TextEncoder().encode(m);
-                }
-                return new Uint8Array(m);
-            });
-            const totalLength = parts.reduce((sum, part) => sum + part.length + 1, 0) - 1;
-            materialBytes = new Uint8Array(totalLength);
-            let offset = 0;
-            for (let i = 0; i < parts.length; i++) {
-                if (i > 0) {
-                    materialBytes[offset++] = 124; // '|' character
-                }
-                const part = parts[i];
-                if (part === undefined) {
-                    throw new Error(`Invalid part at index ${i}`);
-                }
-                materialBytes.set(part, offset);
-                offset += part.length;
-            }
+        catch {
+            return null;
         }
-        else {
-            if (typeof material === 'string') {
-                materialBytes = new TextEncoder().encode(material);
+    }
+    function writeSeed(storage, seed) {
+        try {
+            storage.setItem(STORAGE_SEED_KEY, seed);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function getWritableStorages() {
+        const storages = [];
+        const storageNames = [
+            'localStorage',
+            'sessionStorage',
+        ];
+        for (const name of storageNames) {
+            const storage = resolveStorage(name);
+            if (storage) {
+                storages.push(storage);
             }
-            else {
-                materialBytes = new Uint8Array(material);
+        }
+        return storages;
+    }
+    function resolveStorage(name) {
+        try {
+            const storage = globalThis[name];
+            if (!storage) {
+                return null;
             }
+            const probeKey = `${STORAGE_SEED_KEY}:probe`;
+            storage.setItem(probeKey, '1');
+            storage.removeItem(probeKey);
+            return storage;
         }
-        let digest = hash(materialBytes, hashAlg);
-        let candidate = encodeDigest(digest, length);
-        // Check blacklist and re-hash if needed
-        while (Array.from(blacklist).some(bad => candidate.toLowerCase().includes(bad))) {
-            digest = hash(digest, hashAlg);
-            candidate = encodeDigest(digest, length);
+        catch {
+            return null;
         }
-        return candidate;
     }
-    /**
-     * Generate ID asynchronously (works in both browser and Node.js)
-     */
+    function generateSeed() {
+        const bytes = getRandomBytes$3(16);
+        return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+    }
+    function generateId(options = {}) {
+        const { length = 16, mode = 'random', blacklist = BLACKLIST_ID_WORDS, } = options;
+        if (mode !== 'random' && mode !== 'fingerprint') {
+            throw new Error("mode must be 'random' or 'fingerprint'");
+        }
+        if (mode === 'random') {
+            return generateRandomCandidate(length, getRandomBytes$3, blacklist);
+        }
+        throw new Error('Browser environment requires async ID generation - use generateIdAsync instead');
+    }
     async function generateIdAsync(options = {}) {
-        const { length = 16, mode = 'random', material, blacklist = BLACKLIST_ID_WORDS, hashAlg = 'sha256' } = options;
+        const { length = 16, mode = 'random', material, blacklist = BLACKLIST_ID_WORDS, hashAlg = 'sha256', } = options;
         if (mode !== 'random' && mode !== 'fingerprint') {
             throw new Error("mode must be 'random' or 'fingerprint'");
         }
         if (mode === 'random') {
-            while (true) {
-                let candidate = '';
-                const randomBytes = getRandomBytes$2(length);
-                for (let i = 0; i < length; i++) {
-                    const byte = randomBytes[i];
-                    if (byte === undefined) {
-                        throw new Error(`Invalid random byte at index ${i}`);
-                    }
-                    candidate += ALPHABET[byte % ALPHABET.length];
-                }
-                if (!Array.from(blacklist).some(bad => candidate.toLowerCase().includes(bad))) {
-                    return candidate;
-                }
-            }
+            return generateRandomCandidate(length, getRandomBytes$3, blacklist);
         }
-        // Fingerprint mode
         let materialBytes;
         if (material === undefined || material === null) {
-            const envSalt = globalThis.process?.env?.FAME_NODE_ID_SALT || '';
-            materialBytes = await getDefaultNodeFingerprint(envSalt);
-        }
-        else if (Array.isArray(material)) {
-            const parts = material.map(m => {
-                if (typeof m === 'string') {
-                    return new TextEncoder().encode(m);
-                }
-                return new Uint8Array(m);
-            });
-            const totalLength = parts.reduce((sum, part) => sum + part.length + 1, 0) - 1;
-            materialBytes = new Uint8Array(totalLength);
-            let offset = 0;
-            for (let i = 0; i < parts.length; i++) {
-                if (i > 0) {
-                    materialBytes[offset++] = 124; // '|' character
-                }
-                const part = parts[i];
-                if (part === undefined) {
-                    throw new Error(`Invalid part at index ${i}`);
-                }
-                materialBytes.set(part, offset);
-                offset += part.length;
-            }
+            const envSalt = globalThis.process?.env?.FAME_NODE_ID_SALT;
+            materialBytes = await getDefaultBrowserFingerprint(envSalt ?? '');
         }
         else {
-            if (typeof material === 'string') {
-                materialBytes = new TextEncoder().encode(material);
-            }
-            else {
-                materialBytes = new Uint8Array(material);
-            }
-        }
-        let digest = await hashAsync(materialBytes, hashAlg);
-        let candidate = encodeDigest(digest, length);
-        // Check blacklist and re-hash if needed
-        while (Array.from(blacklist).some(bad => candidate.toLowerCase().includes(bad))) {
-            digest = await hashAsync(digest, hashAlg);
-            candidate = encodeDigest(digest, length);
+            materialBytes = materialToBytes(material, textEncoder$1);
         }
-        return candidate;
+        const initialDigest = await hashAsync(materialBytes, hashAlg);
+        return rehashUntilCleanAsync(initialDigest, length, (input) => hashAsync(input, hashAlg), blacklist);
     }
 
     /**
@@ -5632,85 +5549,27 @@
         ResourceFactoryRegistry.registerFactory(baseTypeName, resourceTypeName, factoryConstructor, metadata);
     }
 
-    /**
-     * Error thrown when an environment variable is required but not defined.
-     */
-    /**
-     * Expression composition utilities for ResourceConfig.
-     *
-     * Provides helper functions to create expressions in a more readable way
-     * than manually constructing the ${env:VAR:default} syntax.
-     */
-    class Expressions {
-        /**
-         * Create an environment variable expression.
-         *
-         * @param varName The name of the environment variable
-         * @param defaultValue Optional default value if the environment variable is not set
-         * @returns A formatted expression string like ${env:VAR:default}
-         *
-         * @example
-         * ```typescript
-         * Expressions.env("AUTH_ISSUER") // -> "${env:AUTH_ISSUER}"
-         * Expressions.env("AUTH_ISSUER", "https://auth.dev.local") // -> "${env:AUTH_ISSUER:https://auth.dev.local}"
-         * Expressions.env("PORT", "8080") // -> "${env:PORT:8080}"
-         * ```
-         */
-        static env(varName, defaultValue) {
-            if (defaultValue === undefined) {
-                return `\${env:${varName}}`;
-            }
-            else {
-                return `\${env:${varName}:${defaultValue}}`;
-            }
-        }
-        /**
-         * Create a configuration value expression.
-         *
-         * @param key The configuration key (supports dot notation)
-         * @param defaultValue Optional default value if the configuration key is not set
-         * @returns A formatted expression string like ${config:KEY:default}
-         *
-         * @example
-         * ```typescript
-         * Expressions.config("database.host") // -> "${config:database.host}"
-         * Expressions.config("database.port", "5432") // -> "${config:database.port:5432}"
-         * ```
-         */
-        static config(key, defaultValue) {
-            if (defaultValue === undefined) {
-                return `\${config:${key}}`;
-            }
-            else {
-                return `\${config:${key}:${defaultValue}}`;
+    const isNodeEnvironment = typeof process !== 'undefined' && Boolean(process?.versions?.node);
+    let cachedNodeRequire = null;
+    let cachedPathToFileURL = null;
+    function getGlobalDynamicImporter() {
+        try {
+            const candidate = globalThis;
+            const override = candidate?.__naylenceFactoryDynamicImporter;
+            if (typeof override === 'function') {
+                return override;
             }
         }
-        /**
-         * Return a literal string value (no expression).
-         *
-         * This is mainly for consistency when mixing literal and expression values
-         * in configuration objects, making it clear what's an expression vs literal.
-         *
-         * @param value The literal string value
-         * @returns The same string value unchanged
-         *
-         * @example
-         * ```typescript
-         * Expressions.literal("https://api.example.com") // -> "https://api.example.com"
-         * ```
-         */
-        static literal(value) {
-            return value;
+        catch {
+            // Ignore access errors (e.g., globalThis not defined)
         }
+        return null;
     }
-    // Convenience aliases
-    Expressions.environment = Expressions.env;
-    Expressions.setting = Expressions.config;
-
-    const isNodeEnvironment = typeof process !== 'undefined' && Boolean(process?.versions?.node);
-    let cachedNodeRequire = null;
-    let cachedPathToFileURL = null;
     function getDynamicImporter() {
+        const globalImporter = getGlobalDynamicImporter();
+        if (globalImporter) {
+            return globalImporter;
+        }
         return (specifier) => import(specifier);
     }
     function shouldAttemptNodeFallback(error) {
@@ -7787,6 +7646,33 @@
             return false;
         }
     })();
+    function resolveSnapshotValue(snapshot, camelKey, snakeKey) {
+        if (snapshot[camelKey] !== undefined) {
+            return snapshot[camelKey];
+        }
+        if (snapshot[snakeKey] !== undefined) {
+            return snapshot[snakeKey];
+        }
+        return undefined;
+    }
+    function normalizeEnvelopeSnapshot(snapshot) {
+        if (!snapshot) {
+            return {};
+        }
+        const normalized = {};
+        const traceId = resolveSnapshotValue(snapshot, 'traceId', 'trace_id');
+        if (traceId !== undefined) {
+            normalized.trace_id = traceId;
+        }
+        if (snapshot.id !== undefined) {
+            normalized.id = snapshot.id;
+        }
+        const flowId = resolveSnapshotValue(snapshot, 'flowId', 'flow_id');
+        if (flowId !== undefined) {
+            normalized.flow_id = flowId;
+        }
+        return normalized;
+    }
 
     /**
      * Envelope context management for cross-platform environments
@@ -7878,26 +7764,14 @@
      * Context manager function (similar to Python's envelope_context)
      */
     function withEnvelopeContext(envelope, fn) {
-        const context = {};
-        if (envelope.trace_id !== undefined)
-            context.trace_id = envelope.trace_id;
-        if (envelope.id !== undefined)
-            context.id = envelope.id;
-        if (envelope.flow_id !== undefined)
-            context.flow_id = envelope.flow_id;
+        const context = normalizeEnvelopeSnapshot(envelope);
         return envelopeContextManager.runWithContext(context, fn);
     }
     /**
      * Async context manager function
      */
     async function withEnvelopeContextAsync(envelope, fn) {
-        const context = {};
-        if (envelope.trace_id !== undefined)
-            context.trace_id = envelope.trace_id;
-        if (envelope.id !== undefined)
-            context.id = envelope.id;
-        if (envelope.flow_id !== undefined)
-            context.flow_id = envelope.flow_id;
+        const context = normalizeEnvelopeSnapshot(envelope);
         return envelopeContextManager.runWithContextAsync(context, fn);
     }
     /**
@@ -8104,19 +7978,19 @@
     function getConsoleColor(level) {
         switch (level) {
             case exports.LogLevel.TRACE:
-                return 'color: #888';
+                return 'color: #9AA0A6';
             case exports.LogLevel.DEBUG:
-                return 'color: #888';
+                return 'color: #50B5FF';
             case exports.LogLevel.INFO:
-                return 'color: #000';
+                return 'color: #2E7D32; font-weight: 600';
             case exports.LogLevel.WARNING:
-                return 'color: #ff8c00';
+                return 'color: #F9AB00; font-weight: 600';
             case exports.LogLevel.ERROR:
-                return 'color: #ff0000';
+                return 'color: #E53935; font-weight: 600';
             case exports.LogLevel.CRITICAL:
-                return 'color: #ff0000; font-weight: bold';
+                return 'color: #B71C1C; font-weight: 700; text-decoration: underline';
             default:
-                return 'color: #000';
+                return 'color: #37474F';
         }
     }
     // Node.js-specific Pino transport (when available)
@@ -8415,29 +8289,112 @@
      * error handling, cancellation, and graceful shutdown capabilities.
      */
     const logger$4 = getLogger('naylence.fame.util.task_spawner');
-    // Internal task implementation
-    class TaskImpl {
-        constructor(id, name, promise, abortController) {
-            this._state = TaskState.RUNNING;
-            this.id = id;
-            this.name = name || `task-${id}`;
-            this.abortController = abortController;
-            this.startTime = Date.now();
-            // Wrap the promise to track state changes
-            this.promise = promise
-                .then((result) => {
-                this._state = TaskState.COMPLETED;
-                this._result = result;
-                return result;
-            })
-                .catch((error) => {
-                if (error.name === 'AbortError' ||
-                    this.abortController.signal.aborted) {
-                    this._state = TaskState.CANCELLED;
-                    throw new TaskCancelledError(this.name);
+    function firstDefined(source, keys) {
+        for (const key of keys) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+                const value = source[key];
+                if (value !== undefined) {
+                    return value;
                 }
-                else {
-                    this._state = TaskState.FAILED;
+            }
+        }
+        return undefined;
+    }
+    function coerceNumber(value) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed.length === 0) {
+                return undefined;
+            }
+            const parsed = Number(trimmed);
+            if (!Number.isNaN(parsed) && Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+        return undefined;
+    }
+    function coerceBoolean(value) {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const normalized = value.trim().toLowerCase();
+            if (normalized.length === 0) {
+                return undefined;
+            }
+            if (['true', '1', 'yes', 'on'].includes(normalized)) {
+                return true;
+            }
+            if (['false', '0', 'no', 'off'].includes(normalized)) {
+                return false;
+            }
+        }
+        return undefined;
+    }
+    function normalizeTaskSpawnerConfig(config = {}) {
+        const source = config;
+        const maxConcurrent = coerceNumber(firstDefined(source, ['maxConcurrent', 'max_concurrent'])) ??
+            0;
+        const defaultTimeout = coerceNumber(firstDefined(source, ['defaultTimeout', 'default_timeout'])) ??
+            0;
+        const autoCleanup = coerceBoolean(firstDefined(source, ['autoCleanup', 'auto_cleanup'])) ??
+            true;
+        return {
+            maxConcurrent,
+            defaultTimeout,
+            autoCleanup,
+        };
+    }
+    function normalizeSpawnOptions(options = {}) {
+        const source = options;
+        const nameRaw = firstDefined(source, ['name', 'task_name', 'taskName']);
+        const timeoutRaw = firstDefined(source, [
+            'timeout',
+            'task_timeout',
+            'taskTimeout',
+        ]);
+        const name = typeof nameRaw === 'string' ? nameRaw : undefined;
+        const timeout = coerceNumber(timeoutRaw);
+        return { name, timeout };
+    }
+    function normalizeShutdownOptions(options = {}) {
+        const source = options;
+        const gracePeriod = coerceNumber(firstDefined(source, ['gracePeriod', 'grace_period'])) ?? 2000;
+        const cancelHanging = coerceBoolean(firstDefined(source, ['cancelHanging', 'cancel_hanging'])) ??
+            true;
+        const joinTimeout = coerceNumber(firstDefined(source, ['joinTimeout', 'join_timeout'])) ?? 1000;
+        return {
+            gracePeriod,
+            cancelHanging,
+            joinTimeout,
+        };
+    }
+    // Internal task implementation
+    class TaskImpl {
+        constructor(id, name, promise, abortController) {
+            this._state = TaskState.RUNNING;
+            this.id = id;
+            this.name = name || `task-${id}`;
+            this.abortController = abortController;
+            this.startTime = Date.now();
+            // Wrap the promise to track state changes
+            this.promise = promise
+                .then((result) => {
+                this._state = TaskState.COMPLETED;
+                this._result = result;
+                return result;
+            })
+                .catch((error) => {
+                if (error.name === 'AbortError' ||
+                    this.abortController.signal.aborted) {
+                    this._state = TaskState.CANCELLED;
+                    throw new TaskCancelledError(this.name);
+                }
+                else {
+                    this._state = TaskState.FAILED;
                     this._error = error;
                     throw error;
                 }
@@ -8473,17 +8430,13 @@
             this._taskCounter = 0;
             this._lastSpawnerError = null;
             this._suppressCompletionLogging = false;
-            this._config = {
-                maxConcurrent: config.maxConcurrent ?? 0, // 0 = unlimited
-                defaultTimeout: config.defaultTimeout ?? 0, // 0 = no timeout
-                autoCleanup: config.autoCleanup ?? true,
-                ...config,
-            };
+            this._config = normalizeTaskSpawnerConfig(config);
         }
         /**
          * Spawn a new async task with proper error handling and context propagation
          */
         spawn(taskFn, options = {}) {
+            const normalizedOptions = normalizeSpawnOptions(options);
             // Reset logging suppression when new work is spawned. Any lingering
             // completion events from a previous shutdown will remain suppressed
             // until the corresponding tasks finish.
@@ -8494,8 +8447,8 @@
                 throw new Error(`Task limit reached: ${this._config.maxConcurrent} concurrent tasks`);
             }
             const taskId = `task-${++this._taskCounter}`;
-            const taskName = options.name || `unnamed-${taskId}`;
-            const timeout = options.timeout ?? this._config.defaultTimeout;
+            const taskName = normalizedOptions.name || `unnamed-${taskId}`;
+            const timeout = normalizedOptions.timeout ?? this._config.defaultTimeout;
             logger$4.debug('starting_background_task', {
                 task_name: taskName,
                 task_id: taskId,
@@ -8620,9 +8573,7 @@
          * for better shutdown performance and responsiveness.
          */
         async shutdownTasks(options = {}) {
-            const { gracePeriod = 2000, // 2 seconds
-            cancelHanging = true, joinTimeout = 1000, // 1 second
-             } = options;
+            const { gracePeriod, cancelHanging, joinTimeout } = normalizeShutdownOptions(options);
             if (this._tasks.size === 0) {
                 logger$4.debug('shutdown_tasks_no_tasks_to_shutdown');
                 return;
@@ -9655,6 +9606,25 @@
         result = result.replace(/([A-Z])([A-Z][a-z])/g, '$1_$2');
         return result.toLowerCase();
     }
+    /**
+     * Create a shallow copy of an object's top-level properties and add
+     * snake_case aliases for any camelCase keys while also adding camelCase
+     * aliases for snake_case keys when missing. Existing keys always win.
+     */
+    function withLegacySnakeCaseKeys(descriptor) {
+        const augmented = { ...descriptor };
+        for (const [key, value] of Object.entries(descriptor)) {
+            const snakeCaseKey = key.includes('_') ? key : camelToSnakeCase(key);
+            const camelCaseKey = key.includes('_') ? snakeToCamelCase(key) : key;
+            if (snakeCaseKey !== key && !(snakeCaseKey in augmented)) {
+                augmented[snakeCaseKey] = value;
+            }
+            if (camelCaseKey !== key && !(camelCaseKey in augmented)) {
+                augmented[camelCaseKey] = value;
+            }
+        }
+        return augmented;
+    }
     /**
      * Convert snake_case string to CamelCase.
      */
@@ -9697,16 +9667,25 @@
     }
 
     const POOL_WILDCARD_PREFIX = '*.';
-    const DNS_HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.?)+$/;
-    const DNS_LABEL_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
-    function getEnv(name) {
-        if (typeof process === 'undefined') {
+    function readEnvValue(aliases) {
+        const processRef = globalThis?.process;
+        const env = processRef?.env;
+        if (!env) {
             return undefined;
         }
-        return process.env?.[name];
+        for (const alias of aliases) {
+            const value = env[alias];
+            if (typeof value === 'string') {
+                return value;
+            }
+        }
+        return undefined;
     }
+    const DNS_HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.?)+$/;
+    const DNS_LABEL_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
     function getFameRoot() {
-        return getEnv('FAME_ROOT') ?? 'fame.fabric';
+        return (readEnvValue(['FAME_ROOT', 'fame_root', 'fameRoot', 'FameRoot']) ??
+            'fame.fabric');
     }
     function isPoolLogical(logical) {
         return Boolean(logical?.startsWith(POOL_WILDCARD_PREFIX));
@@ -9915,8 +9894,8 @@
             return false;
         }
         catch (error) {
-            if (typeof process !== 'undefined' &&
-                process.env?.NODE_ENV !== 'production') {
+            if (readEnvValue(['NODE_ENV', 'node_env', 'nodeEnv', 'NodeEnv']) !==
+                'production') {
                 // eslint-disable-next-line no-console
                 console.debug('matchesPoolAddress failed', error);
             }
@@ -10089,7 +10068,7 @@
             // track active notifier tasks to prevent spam
             this.activeNotifiers = new Map();
             if (initialWindow <= 0) {
-                throw new Error('initial_window must be > 0');
+                throw new Error('initialWindow must be > 0');
             }
             this.initialWindow = initialWindow;
             this.lowWatermark = Math.floor(initialWindow * lowWatermarkRatio);
@@ -10243,11 +10222,10 @@
     }
 
     /**
-     * in-memory-channel.ts - In-memory ReadWriteChannel implementation
+     * in-memory-channel.ts - In-memory ReadWriteChannel implementation.
      *
-     * TypeScript port of Python's InMemoryReadWriteChannel that uses an internal
-     * queue for message storage and provides async read/write operations with
-     * timeout support.
+     * Maintains an in-memory queue for async read/write operations with optional
+     * size limits and operation timeouts.
      */
     /**
      * In-memory implementation of ReadWriteChannel using a Promise-based queue.
@@ -10259,7 +10237,9 @@
             this._waitingReaders = [];
             this._closed = false;
             this.logger = getLogger('naylence.fame.channel.in_memory.in_memory_channel');
-            this._maxsize = config.maxsize || 0; // 0 = unlimited
+            const legacyMaxSize = config.maxsize;
+            const configuredMaxSize = typeof config.maxSize === 'number' ? config.maxSize : legacyMaxSize;
+            this._maxSize = configuredMaxSize || 0; // 0 = unlimited
             this._defaultTimeoutMs = config.defaultTimeoutMs || 0; // 0 = no timeout
         }
         /**
@@ -10340,12 +10320,12 @@
                 return;
             }
             // No waiting readers, add to queue if there's space
-            if (this._maxsize === 0 || this._queue.length < this._maxsize) {
+            if (this._maxSize === 0 || this._queue.length < this._maxSize) {
                 this._queue.push(message);
                 this.logger.debug('send_enqueued_message', {
                     queue_length: this._queue.length,
                     waiting_readers: this._waitingReaders.length,
-                    max_size: this._maxsize,
+                    max_size: this._maxSize,
                 });
                 return;
             }
@@ -10354,9 +10334,9 @@
             // In a full implementation, we'd want to wait for space to become available
             this.logger.error('send_queue_full', {
                 queue_length: this._queue.length,
-                max_size: this._maxsize,
+                max_size: this._maxSize,
             });
-            throw new Error(`Channel queue is full (maxsize: ${this._maxsize})`);
+            throw new Error(`Channel queue is full (maxSize: ${this._maxSize})`);
         }
         /**
          * Close the channel. All pending reads will be rejected.
@@ -10405,7 +10385,7 @@
          * Check if the queue is full
          */
         get isFull() {
-            return this._maxsize > 0 && this._queue.length >= this._maxsize;
+            return this._maxSize > 0 && this._queue.length >= this._maxSize;
         }
         /**
          * Check if the queue is empty
@@ -10519,8 +10499,16 @@
             this._subscribers = new Set();
             this._running = false;
             this._sink = sink;
-            this._pollTimeoutSec =
-                (config.pollTimeoutMs ?? DEFAULT_POLLING_TIMEOUT_MS) / 1000.0;
+            const legacyPollTimeoutMs = config
+                .poll_timeout_ms;
+            const configuredPollTimeoutMs = typeof config.pollTimeoutMs === 'number'
+                ? config.pollTimeoutMs
+                : legacyPollTimeoutMs;
+            this._pollTimeoutMs =
+                typeof configuredPollTimeoutMs === 'number'
+                    ? configuredPollTimeoutMs
+                    : DEFAULT_POLLING_TIMEOUT_MS;
+            this._pollTimeoutSec = this._pollTimeoutMs / 1000.0;
         }
         /**
          * Start the broker's listen loop
@@ -10677,6 +10665,10 @@
         get subscribers() {
             return new Set(this._subscribers);
         }
+        /** Poll timeout applied to the broker's sink channel in milliseconds */
+        get pollTimeoutMs() {
+            return this._pollTimeoutMs;
+        }
     }
 
     class InMemoryKeyValueStore {
@@ -10727,461 +10719,11 @@
     }
 
     const STORAGE_PROVIDER_FACTORY_BASE_TYPE = 'StorageProviderFactory';
-    class StorageProviderFactory extends AbstractResourceFactory {
-        static async createStorageProvider(config, options = {}) {
-            const instance = config
-                ? await createResource$1(STORAGE_PROVIDER_FACTORY_BASE_TYPE, config, options)
-                : await createDefaultResource(STORAGE_PROVIDER_FACTORY_BASE_TYPE, null, options);
-            if (!instance) {
-                throw new Error('Failed to create storage provider from configuration');
-            }
-            return instance;
-        }
-    }
-    function registerStorageProviderFactory(type, factory) {
-        registerFactory(STORAGE_PROVIDER_FACTORY_BASE_TYPE, type, factory);
-    }
-
-    const inMemoryStorageProviderConfigSchema = object({
-        type: literal('InMemoryStorageProvider')
-            .default('InMemoryStorageProvider'),
-    })
-        .passthrough();
-    class InMemoryStorageProviderFactory extends StorageProviderFactory {
-        constructor() {
-            super(...arguments);
-            this.type = 'InMemoryStorageProvider';
-        }
-        async create(config) {
-            // Validate configuration and ensure correct type information
-            const candidate = config ?? { type: 'InMemoryStorageProvider' };
-            inMemoryStorageProviderConfigSchema.parse({
-                type: candidate.type,
-                ...candidate,
-            });
-            return new InMemoryStorageProvider();
-        }
-    }
-    registerStorageProviderFactory('InMemoryStorageProvider', InMemoryStorageProviderFactory);
-
-    const CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE = 'CredentialProviderFactory';
-    class CredentialProviderFactory extends AbstractResourceFactory {
-        static async createCredentialProvider(config, options = {}) {
-            const instance = config
-                ? await createResource$1(CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE, config, options)
-                : await createDefaultResource(CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE, null, options);
-            if (!instance) {
-                throw new Error('Failed to create credential provider from configuration');
-            }
-            return instance;
-        }
-    }
-
-    function normalizeEnvConfig(config) {
-        if (!config) {
-            return {
-                type: 'EnvCredentialProvider',
-                varName: 'DEFAULT_VAR',
-            };
-        }
-        if ('varName' in config &&
-            typeof config.varName === 'string' &&
-            config.varName.length > 0) {
-            return {
-                type: 'EnvCredentialProvider',
-                varName: config.varName,
-            };
-        }
-        const rawName = config.varName ??
-            config.var_name;
-        if (typeof rawName !== 'string' || rawName.length === 0) {
-            throw new Error('EnvCredentialProvider requires a non-empty "varName"');
-        }
-        return {
-            type: 'EnvCredentialProvider',
-            varName: rawName,
-        };
-    }
-
-    function normalizePromptConfig(config) {
-        if (!config) {
-            return {
-                type: 'PromptCredentialProvider',
-                credentialName: 'credential',
-            };
-        }
-        const credentialName = config.credentialName ??
-            config.credential_name ??
-            'credential';
-        if (typeof credentialName !== 'string' || credentialName.length === 0) {
-            throw new Error('PromptCredentialProvider requires a non-empty "credentialName"');
-        }
-        return {
-            type: 'PromptCredentialProvider',
-            credentialName,
-        };
-    }
-
-    function normalizeSecretStoreConfig(config) {
-        if (!config) {
-            return {
-                type: 'SecretStoreCredentialProvider',
-                secretName: 'default',
-            };
-        }
-        if ('secretName' in config &&
-            typeof config.secretName === 'string' &&
-            config.secretName.length > 0) {
-            return {
-                type: 'SecretStoreCredentialProvider',
-                secretName: config.secretName,
-            };
-        }
-        const rawName = config.secretName ??
-            config.secret_name;
-        if (typeof rawName !== 'string' || rawName.length === 0) {
-            throw new Error('SecretStoreCredentialProvider requires a non-empty "secretName"');
-        }
-        return {
-            type: 'SecretStoreCredentialProvider',
-            secretName: rawName,
-        };
-    }
-
-    function normalizeStaticConfig(config) {
-        if (!config) {
-            return {
-                type: 'StaticCredentialProvider',
-                credentialValue: '',
-            };
-        }
-        if ('credentialValue' in config &&
-            typeof config.credentialValue === 'string') {
-            return {
-                type: 'StaticCredentialProvider',
-                credentialValue: config.credentialValue,
-            };
-        }
-        const rawValue = config.credentialValue ??
-            config.credential_value;
-        if (typeof rawValue !== 'string') {
-            throw new Error('StaticCredentialProvider requires a "credentialValue" string');
-        }
-        return {
-            type: 'StaticCredentialProvider',
-            credentialValue: rawValue,
-        };
-    }
-
-    function isCredentialProviderConfig(value) {
-        return Boolean(value &&
-            typeof value === 'object' &&
-            'type' in value);
-    }
-    class SecretSource {
-        static normalize(value) {
-            if (value === null || value === undefined) {
-                throw new TypeError('Secret source cannot be null or undefined');
-            }
-            if (isCredentialProviderConfig(value)) {
-                switch (value.type) {
-                    case 'EnvCredentialProvider':
-                        return normalizeEnvConfig(value);
-                    case 'SecretStoreCredentialProvider':
-                        return normalizeSecretStoreConfig(value);
-                    case 'StaticCredentialProvider':
-                        return normalizeStaticConfig(value);
-                    case 'PromptCredentialProvider':
-                        return normalizePromptConfig(value);
-                    default:
-                        return { ...value };
-                }
-            }
-            if (typeof value === 'string') {
-                if (value.startsWith('env://')) {
-                    const varName = value.slice('env://'.length);
-                    if (!varName) {
-                        throw new Error("Environment variable name cannot be empty in 'env://' URI");
-                    }
-                    return normalizeEnvConfig({ type: 'EnvCredentialProvider', varName });
-                }
-                if (value.startsWith('secret://')) {
-                    const secretName = value.slice('secret://'.length);
-                    if (!secretName) {
-                        throw new Error("Secret name cannot be empty in 'secret://' URI");
-                    }
-                    return normalizeSecretStoreConfig({
-                        type: 'SecretStoreCredentialProvider',
-                        secretName,
-                    });
-                }
-                return normalizeStaticConfig({
-                    type: 'StaticCredentialProvider',
-                    credentialValue: value,
-                });
-            }
-            if (typeof value === 'object') {
-                const recordValue = value;
-                if (!('type' in recordValue) || typeof recordValue.type !== 'string') {
-                    throw new TypeError("Secret source dict inputs must include a string 'type' field");
-                }
-                switch (recordValue.type) {
-                    case 'EnvCredentialProvider':
-                        return normalizeEnvConfig(recordValue);
-                    case 'SecretStoreCredentialProvider':
-                        return normalizeSecretStoreConfig(recordValue);
-                    case 'StaticCredentialProvider':
-                        return normalizeStaticConfig(recordValue);
-                    case 'PromptCredentialProvider':
-                        return normalizePromptConfig(recordValue);
-                    default:
-                        return { ...recordValue };
-                }
-            }
-            throw new TypeError(`Unsupported secret source type: ${typeof value}. Expected string, dict with 'type' field, or CredentialProviderConfig instance.`);
-        }
-    }
-
-    function isModuleNotFoundError(error) {
-        if (!(error instanceof Error)) {
-            return false;
-        }
-        const message = error.message || '';
-        if (message.includes('Cannot find module') ||
-            message.includes('ERR_MODULE_NOT_FOUND') ||
-            message.includes('MODULE_NOT_FOUND')) {
-            return true;
-        }
-        const code = error.code;
-        if (typeof code === 'string') {
-            return code === 'MODULE_NOT_FOUND' || code === 'ERR_MODULE_NOT_FOUND';
-        }
-        return false;
-    }
-    /**
-     * Wraps a dynamic import loader and enriches "module not found" failures with an actionable error message.
-     */
-    async function safeImport(loader, dependencyNameOrOptions, maybeOptions) {
-        const options = { dependencyName: dependencyNameOrOptions, ...(maybeOptions ?? {}) }
-            ;
-        const dependencyName = options.dependencyName;
-        try {
-            return await loader();
-        }
-        catch (error) {
-            if (isModuleNotFoundError(error)) {
-                const message = options.helpMessage ??
-                    `Missing optional dependency "${dependencyName}". Install it to enable this feature.`;
-                const enrichedError = new Error(message);
-                try {
-                    enrichedError.cause = error;
-                }
-                catch {
-                    // Ignore environments that do not support attaching a cause.
-                }
-                throw enrichedError;
-            }
-            throw error;
-        }
-    }
-
-    const indexedDBConfigSchema = object({
-        type: literal('IndexedDBStorageProvider')
-            .default('IndexedDBStorageProvider'),
-        mode: union([literal('dx'), literal('hardened'), string()])
-            .optional()
-            .default('dx'),
-        dbName: string().min(1).default('naylence'),
-        version: union([number().int().positive(), string()]).default(1),
-        namespacePrefix: string().optional().default('kv'),
-        enableCaching: union([boolean(), string()]).optional(),
-        isEncrypted: union([boolean(), string()]).optional(),
-        masterKey: union([string(), record(string(), unknown()), _null()])
-            .optional()
-            .default(null),
-    })
-        .passthrough();
-    const TRUE_VALUES = new Set(['true', '1', 'yes', 'on']);
-    const FALSE_VALUES = new Set(['false', '0', 'no', 'off', '']);
-    function coerceBoolean(value, fieldName, defaultValue) {
-        if (value === undefined) {
-            return defaultValue;
-        }
-        if (typeof value === 'boolean') {
-            return value;
-        }
-        if (typeof value === 'string') {
-            const normalized = value.trim().toLowerCase();
-            if (TRUE_VALUES.has(normalized)) {
-                return true;
-            }
-            if (FALSE_VALUES.has(normalized)) {
-                return false;
-            }
-        }
-        throw new Error(`Expected a boolean-like value for '${fieldName}' but received '${String(value)}'`);
-    }
-    function normalizeIndexedDBConfig(config) {
-        const candidate = {
-            ...config,
-        };
-        if (candidate.dbName === undefined && typeof candidate.db_name === 'string') {
-            candidate.dbName = candidate.db_name;
-        }
-        if (candidate.namespacePrefix === undefined &&
-            typeof candidate.namespace_prefix === 'string') {
-            candidate.namespacePrefix = candidate.namespace_prefix;
-        }
-        if (candidate.enableCaching === undefined &&
-            candidate.enable_caching !== undefined) {
-            candidate.enableCaching = candidate.enable_caching;
-        }
-        if (candidate.isEncrypted === undefined &&
-            candidate.is_encrypted !== undefined) {
-            candidate.isEncrypted = candidate.is_encrypted;
-        }
-        if (candidate.masterKey === undefined && candidate.master_key !== undefined) {
-            candidate.masterKey = candidate.master_key;
-        }
-        const parsed = indexedDBConfigSchema.parse({
-            ...candidate,
-            type: 'IndexedDBStorageProvider',
-        });
-        const normalizedMode = (typeof parsed.mode === 'string' ? parsed.mode : 'dx').toLowerCase();
-        if (normalizedMode !== 'dx' && normalizedMode !== 'hardened') {
-            throw new Error("mode must be either 'dx' or 'hardened'");
-        }
-        const versionValue = typeof parsed.version === 'string'
-            ? parseInt(parsed.version, 10)
-            : parsed.version;
-        if (!Number.isInteger(versionValue) || versionValue <= 0) {
-            throw new Error('version must be a positive integer');
-        }
-        const enableCaching = coerceBoolean(parsed.enableCaching, 'enableCaching', normalizedMode === 'dx');
-        const isEncrypted = coerceBoolean(parsed.isEncrypted, 'isEncrypted', true);
-        let masterKeyConfig = null;
-        if (parsed.masterKey !== null && parsed.masterKey !== undefined) {
-            masterKeyConfig = SecretSource.normalize(parsed.masterKey);
-        }
-        if (normalizedMode === 'hardened' && !masterKeyConfig) {
-            throw new Error('hardened mode requires a masterKey configuration');
-        }
-        return {
-            type: 'IndexedDBStorageProvider',
-            mode: normalizedMode,
-            dbName: parsed.dbName,
-            version: versionValue,
-            namespacePrefix: parsed.namespacePrefix ?? 'kv',
-            enableCaching,
-            isEncrypted,
-            masterKey: masterKeyConfig,
-        };
-    }
-    class IndexedDBStorageProviderFactory extends StorageProviderFactory {
-        constructor() {
-            super(...arguments);
-            this.type = 'IndexedDBStorageProvider';
-            this.isDefault = true;
-            this.priority = 50;
-        }
-        async create(config) {
-            const normalized = normalizeIndexedDBConfig(config);
-            const { IndexedDBStorageProvider } = await getIndexedDbStorageProviderModule();
-            let masterKeyProvider = null;
-            if (normalized.masterKey) {
-                masterKeyProvider =
-                    await CredentialProviderFactory.createCredentialProvider(normalized.masterKey);
-            }
-            return new IndexedDBStorageProvider({
-                mode: normalized.mode,
-                dbName: normalized.dbName,
-                version: normalized.version,
-                namespacePrefix: normalized.namespacePrefix,
-                enableCaching: normalized.enableCaching,
-                isEncrypted: normalized.isEncrypted,
-                masterKeyProvider,
-            });
-        }
-    }
-    let indexedDbStorageProviderModulePromise = null;
-    function getIndexedDbStorageProviderModule() {
-        if (!indexedDbStorageProviderModulePromise) {
-            indexedDbStorageProviderModulePromise = safeImport(() => Promise.resolve().then(function () { return indexeddbStorageProvider; }), 'IndexedDBStorageProvider', {
-                helpMessage: 'Failed to load the IndexedDB storage provider. Ensure IndexedDB is available or install the required polyfills.',
-            });
-        }
-        return indexedDbStorageProviderModulePromise;
-    }
-    registerStorageProviderFactory('IndexedDBStorageProvider', IndexedDBStorageProviderFactory);
-
-    const ENV_VAR_STORAGE_DB_DIRECTORY = 'FAME_STORAGE_DB_DIRECTORY';
-    const ENV_VAR_STORAGE_MASTER_KEY = 'FAME_STORAGE_MASTER_KEY';
-    const ENV_VAR_STORAGE_ENCRYPTED = 'FAME_STORAGE_ENCRYPTED';
-    const PROFILE_NAME_MEMORY = 'memory';
-    const PROFILE_NAME_SQLITE = 'sqlite';
-    const PROFILE_NAME_ENCRYPTED_SQLITE = 'encrypted-sqlite';
-    const storageProfileSchema = object({
-        type: literal('StorageProfile').default('StorageProfile'),
-        profile: string()
-            .optional()
-            .describe('Storage profile name (memory | sqlite | encrypted-sqlite)'),
-    })
-        .passthrough();
-    const MEMORY_PROFILE_CONFIG = {
-        type: 'InMemoryStorageProvider',
-    };
-    const SQLITE_PROFILE_CONFIG = {
-        type: 'SQLiteStorageProvider',
-        dbDirectory: Expressions.env(ENV_VAR_STORAGE_DB_DIRECTORY, './data/sqlite'),
-        isEncrypted: Expressions.env(ENV_VAR_STORAGE_ENCRYPTED, 'false'),
-        masterKey: Expressions.env(ENV_VAR_STORAGE_MASTER_KEY, ''),
-        isCached: true,
-    };
-    const ENCRYPTED_SQLITE_PROFILE_CONFIG = {
-        type: 'SQLiteStorageProvider',
-        dbDirectory: Expressions.env(ENV_VAR_STORAGE_DB_DIRECTORY, './data/sqlite'),
-        isEncrypted: 'true',
-        masterKey: Expressions.env(ENV_VAR_STORAGE_MASTER_KEY),
-        isCached: true,
-    };
-    const PROFILE_MAP = {
-        [PROFILE_NAME_MEMORY]: MEMORY_PROFILE_CONFIG,
-        [PROFILE_NAME_SQLITE]: SQLITE_PROFILE_CONFIG,
-        [PROFILE_NAME_ENCRYPTED_SQLITE]: ENCRYPTED_SQLITE_PROFILE_CONFIG,
-    };
-    class StorageProfileFactory extends StorageProviderFactory {
-        constructor() {
-            super(...arguments);
-            this.type = 'StorageProfile';
-        }
-        async create(config, options) {
-            const candidate = config ?? { type: 'StorageProfile' };
-            const parsed = storageProfileSchema.parse({
-                ...candidate,
-                type: 'StorageProfile',
-            });
-            const profileName = (parsed.profile ?? PROFILE_NAME_MEMORY).toLowerCase();
-            const profileConfig = PROFILE_MAP[profileName];
-            if (!profileConfig) {
-                throw new Error(`Unknown storage profile '${profileName}'. Supported profiles: ${Object.keys(PROFILE_MAP).join(', ')}`);
-            }
-            const createOptions = {
-                ...options,
-                validate: options?.validate ?? true,
-            };
-            const provider = await createResource$1(STORAGE_PROVIDER_FACTORY_BASE_TYPE, profileConfig, createOptions);
-            if (!provider) {
-                throw new Error(`Failed to create storage provider for profile '${profileName}'`);
-            }
-            return provider;
-        }
-    }
-    registerStorageProviderFactory('StorageProfile', StorageProfileFactory);
 
-    const DEFAULT_DB_NAME$2 = 'naylence-secrets';
-    const DEFAULT_STORE_NAME = 'auto-master-key';
-    const DEFAULT_KEY_ID$1 = 'master';
-    const MASTER_KEY_LENGTH = 32;
+    const DEFAULT_DB_NAME$3 = 'naylence-secrets';
+    const DEFAULT_STORE_NAME$1 = 'auto-master-key';
+    const DEFAULT_KEY_ID$2 = 'master';
+    const MASTER_KEY_LENGTH$1 = 32;
     function isArrayBufferView(value) {
         return Boolean(value) && ArrayBuffer.isView(value);
     }
@@ -11201,7 +10743,7 @@
         }
         return null;
     }
-    async function openDatabase(factory, dbName, storeName) {
+    async function openDatabase$1(factory, dbName, storeName) {
         return new Promise((resolve, reject) => {
             const request = factory.open(dbName, 1);
             request.onerror = () => {
@@ -11246,7 +10788,7 @@
             };
         });
     }
-    function getRandomBytes$1(length) {
+    function getRandomBytes$2(length) {
         if (!globalThis.crypto?.getRandomValues) {
             throw new Error('crypto.getRandomValues is not available in this environment');
         }
@@ -11258,9 +10800,9 @@
         constructor(options = {}) {
             this.cachedKey = null;
             this.inflight = null;
-            this.dbName = options.dbName ?? DEFAULT_DB_NAME$2;
-            this.storeName = options.storeName ?? DEFAULT_STORE_NAME;
-            this.keyId = options.keyId ?? DEFAULT_KEY_ID$1;
+            this.dbName = options.dbName ?? DEFAULT_DB_NAME$3;
+            this.storeName = options.storeName ?? DEFAULT_STORE_NAME$1;
+            this.keyId = options.keyId ?? DEFAULT_KEY_ID$2;
             if (options.idbFactory) {
                 this.idbFactory = options.idbFactory;
             }
@@ -11289,13 +10831,13 @@
             }
         }
         async loadOrCreateKey() {
-            const db = await openDatabase(this.idbFactory, this.dbName, this.storeName);
+            const db = await openDatabase$1(this.idbFactory, this.dbName, this.storeName);
             try {
                 const existing = await readPersistedKey(db, this.storeName, this.keyId);
                 if (existing) {
                     return existing;
                 }
-                const masterKey = getRandomBytes$1(MASTER_KEY_LENGTH);
+                const masterKey = getRandomBytes$2(MASTER_KEY_LENGTH$1);
                 await persistKey(db, this.storeName, this.keyId, masterKey);
                 return masterKey;
             }
@@ -11305,14 +10847,14 @@
         }
     }
 
-    const DEFAULT_KEY_ID = 'default';
+    const DEFAULT_KEY_ID$1 = 'default';
     const DEFAULT_ALGORITHM = 'AES-GCM';
-    const GCM_IV_LENGTH = 12;
-    function isBrowserEnvironment() {
+    const GCM_IV_LENGTH$1 = 12;
+    function isBrowserEnvironment$1() {
         return (typeof indexedDB !== 'undefined' && typeof globalThis.crypto !== 'undefined');
     }
     function tryCreateBrowserAutoKeyCredentialProvider() {
-        if (!isBrowserEnvironment()) {
+        if (!isBrowserEnvironment$1()) {
             return null;
         }
         try {
@@ -11322,18 +10864,18 @@
             return null;
         }
     }
-    let cachedNodeCrypto;
+    let cachedNodeCrypto$1;
     let cachedSubtle;
-    async function loadNodeCrypto() {
-        if (cachedNodeCrypto !== undefined) {
-            return cachedNodeCrypto;
+    async function loadNodeCrypto$1() {
+        if (cachedNodeCrypto$1 !== undefined) {
+            return cachedNodeCrypto$1;
         }
         try {
-            cachedNodeCrypto = await import('node:crypto');
-            return cachedNodeCrypto;
+            cachedNodeCrypto$1 = await import('node:crypto');
+            return cachedNodeCrypto$1;
         }
         catch {
-            cachedNodeCrypto = null;
+            cachedNodeCrypto$1 = null;
             return null;
         }
     }
@@ -11345,21 +10887,21 @@
             cachedSubtle = globalThis.crypto.subtle;
             return cachedSubtle;
         }
-        const nodeCrypto = await loadNodeCrypto();
+        const nodeCrypto = await loadNodeCrypto$1();
         if (nodeCrypto?.webcrypto?.subtle) {
             cachedSubtle = nodeCrypto.webcrypto.subtle;
             return cachedSubtle;
         }
         throw new Error('Web Crypto API is not available in this environment');
     }
-    async function getRandomBytes(length) {
+    async function getRandomBytes$1(length) {
         if (typeof globalThis.crypto !== 'undefined' &&
             typeof globalThis.crypto.getRandomValues === 'function') {
             const buffer = new Uint8Array(length);
             globalThis.crypto.getRandomValues(buffer);
             return buffer;
         }
-        const nodeCrypto = await loadNodeCrypto();
+        const nodeCrypto = await loadNodeCrypto$1();
         if (nodeCrypto) {
             const buffer = nodeCrypto.randomBytes(length);
             return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
@@ -11390,7 +10932,7 @@
             .map((byte) => byte.toString(16).padStart(2, '0'))
             .join('');
     }
-    function toArrayBuffer(view) {
+    function toArrayBuffer$1(view) {
         const slice = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
         return slice;
     }
@@ -11446,11 +10988,11 @@
         async encrypt(plaintext, key) {
             const subtle = await getSubtleCrypto();
             const normalizedKey = normalizeKey(key);
-            const keyBuffer = toArrayBuffer(normalizedKey);
+            const keyBuffer = toArrayBuffer$1(normalizedKey);
             const cryptoKey = await subtle.importKey('raw', keyBuffer, { name: 'AES-GCM' }, false, ['encrypt']);
-            const iv = await getRandomBytes(GCM_IV_LENGTH);
-            const ivBuffer = toArrayBuffer(iv);
-            const ciphertextBuffer = await subtle.encrypt({ name: 'AES-GCM', iv: ivBuffer }, cryptoKey, toArrayBuffer(plaintext));
+            const iv = await getRandomBytes$1(GCM_IV_LENGTH$1);
+            const ivBuffer = toArrayBuffer$1(iv);
+            const ciphertextBuffer = await subtle.encrypt({ name: 'AES-GCM', iv: ivBuffer }, cryptoKey, toArrayBuffer$1(plaintext));
             const ciphertext = new Uint8Array(ciphertextBuffer);
             const result = new Uint8Array(iv.length + ciphertext.length);
             result.set(iv, 0);
@@ -11458,17 +11000,17 @@
             return result;
         }
         async decrypt(ciphertext, key) {
-            if (ciphertext.length <= GCM_IV_LENGTH) {
+            if (ciphertext.length <= GCM_IV_LENGTH$1) {
                 throw new Error('Ciphertext too short to contain IV');
             }
             const subtle = await getSubtleCrypto();
             const normalizedKey = normalizeKey(key);
-            const keyBuffer = toArrayBuffer(normalizedKey);
+            const keyBuffer = toArrayBuffer$1(normalizedKey);
             const cryptoKey = await subtle.importKey('raw', keyBuffer, { name: 'AES-GCM' }, false, ['decrypt']);
-            const iv = ciphertext.slice(0, GCM_IV_LENGTH);
-            const actualCiphertext = ciphertext.slice(GCM_IV_LENGTH);
-            const ivBuffer = toArrayBuffer(iv);
-            const cipherBuffer = toArrayBuffer(actualCiphertext);
+            const iv = ciphertext.slice(0, GCM_IV_LENGTH$1);
+            const actualCiphertext = ciphertext.slice(GCM_IV_LENGTH$1);
+            const ivBuffer = toArrayBuffer$1(iv);
+            const cipherBuffer = toArrayBuffer$1(actualCiphertext);
             const plaintextBuffer = await subtle.decrypt({ name: 'AES-GCM', iv: ivBuffer }, cryptoKey, cipherBuffer);
             return new Uint8Array(plaintextBuffer);
         }
@@ -11487,7 +11029,7 @@
             this.encryptionManager = options.encryptionManager;
             this.modelCtor = options.modelCtor;
             this.cache = options.enableCaching ? new Map() : null;
-            this.keyId = options.keyId ?? DEFAULT_KEY_ID;
+            this.keyId = options.keyId ?? DEFAULT_KEY_ID$1;
             this.algorithm = options.algorithm ?? DEFAULT_ALGORITHM;
         }
         async getRawMasterKey() {
@@ -11684,7 +11226,7 @@
         }
     }
 
-    const DEFAULT_DB_NAME$1 = 'naylence';
+    const DEFAULT_DB_NAME$2 = 'naylence';
     const DEFAULT_DB_VERSION = 1;
     function ensureIndexedDB(factory) {
         if (factory) {
@@ -11713,7 +11255,7 @@
             if (!options?.storeName) {
                 throw new Error('storeName is required');
             }
-            this.dbName = options.dbName ?? DEFAULT_DB_NAME$1;
+            this.dbName = options.dbName ?? DEFAULT_DB_NAME$2;
             this.storeName = options.storeName;
             this.version = options.version ?? DEFAULT_DB_VERSION;
             this.factory = ensureIndexedDB(options.idbFactory);
@@ -11862,7 +11404,7 @@
         }
     }
 
-    const DEFAULT_DB_NAME = 'naylence';
+    const DEFAULT_DB_NAME$1 = 'naylence';
     const DEFAULT_NAMESPACE_PREFIX = 'kv';
     function sanitizeSegment(segment, fallback) {
         const trimmed = segment.trim();
@@ -11898,7 +11440,7 @@
             });
             this.stores = new Map();
             this.mode = mode;
-            this.dbName = options.dbName ?? DEFAULT_DB_NAME;
+            this.dbName = options.dbName ?? DEFAULT_DB_NAME$1;
             this.version = options.version ?? 1;
             this.namespacePrefix = options.namespacePrefix ?? DEFAULT_NAMESPACE_PREFIX;
             this.idbFactory = options.idbFactory ?? undefined;
@@ -11926,10 +11468,54 @@
     }
     IndexedDBStorageProvider.supportedModes = new Set(['dx', 'hardened']);
 
-    var indexeddbStorageProvider = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        IndexedDBStorageProvider: IndexedDBStorageProvider
-    });
+    const nodeStack = [];
+    function getCurrentNode() {
+        return nodeStack.length > 0 ? nodeStack[nodeStack.length - 1] : null;
+    }
+    function getNode() {
+        const current = getCurrentNode();
+        if (!current) {
+            throw new Error('No Fame node is currently bound to the context');
+        }
+        return current;
+    }
+    function pushNode(node) {
+        nodeStack.push(node);
+        let popped = false;
+        return () => {
+            if (popped) {
+                return;
+            }
+            popped = true;
+            const current = nodeStack[nodeStack.length - 1];
+            if (current === node) {
+                nodeStack.pop();
+                return;
+            }
+            const index = nodeStack.lastIndexOf(node);
+            if (index >= 0) {
+                nodeStack.splice(index, 1);
+            }
+        };
+    }
+    async function withNodeContextAsync(node, fn) {
+        const pop = pushNode(node);
+        try {
+            return await fn();
+        }
+        finally {
+            pop();
+        }
+    }
+    function runWithNodeContext(node, fn) {
+        const pop = pushNode(node);
+        try {
+            return fn();
+        }
+        finally {
+            pop();
+        }
+    }
 
     /**
      * NoopFlowController - Flow control stub that provides infinite credits
@@ -11995,7 +11581,9 @@
     const logger$2 = getLogger('naylence.fame.connector.base_async_connector');
     // Environment variables
     const ENV_VAR_FAME_FLOW_CONTROL = 'FAME_FLOW_CONTROL';
-    const FLOW_CONTROL_ENABLED = process.env[ENV_VAR_FAME_FLOW_CONTROL] !== '0';
+    const FLOW_CONTROL_ENABLED = typeof process !== 'undefined' && process?.env
+        ? process.env[ENV_VAR_FAME_FLOW_CONTROL] !== '0'
+        : true;
     const FAME_MAX_MESSAGE_SIZE = 1024 * 256;
     /**
      * Abstract base class for async transport adapters with optional flow control.
@@ -12755,11 +12343,17 @@
      */
     class WebSocketConnector extends BaseAsyncConnector {
         constructor(websocket, config = { type: 'websocket' }) {
+            const normalizedConfig = { ...config };
             // Ensure the connector type is always set for factory compatibility
-            if (!config.type) {
-                config.type = 'websocket';
+            if (!normalizedConfig.type) {
+                normalizedConfig.type = 'websocket';
             }
-            super(config);
+            const legacyAuthContext = config.authorization_context;
+            if (legacyAuthContext !== undefined &&
+                normalizedConfig.authorizationContext === undefined) {
+                normalizedConfig.authorizationContext = legacyAuthContext;
+            }
+            super(normalizedConfig);
             this._authHeader = null;
             this._receiveQueue = [];
             this._receiveWaiters = [];
@@ -13513,7 +13107,8 @@
     function resolveModuleCandidates(spec) {
         const base = spec.startsWith('./') ? `../${spec.slice(2)}` : spec;
         if (base.endsWith('.js')) {
-            return [base.replace(/\.js$/u, '.ts'), base];
+            // Prefer built JS artifacts to avoid browser bundlers fetching missing TS sources.
+            return [base, base.replace(/\.js$/u, '.ts')];
         }
         return [base];
     }
@@ -13525,7 +13120,7 @@
                 let lastError;
                 for (const candidate of candidates) {
                     try {
-                        mod = await import(candidate);
+                        mod = await import(/* @vite-ignore */ candidate);
                         lastError = undefined;
                         break;
                     }
@@ -13570,6 +13165,573 @@
         await registerDefaultFactories(registry);
     }
 
+    let webCryptoAvailable = null;
+    function detectWebCrypto() {
+        if (webCryptoAvailable !== null) {
+            return webCryptoAvailable;
+        }
+        webCryptoAvailable =
+            typeof globalThis.crypto !== 'undefined' &&
+                typeof globalThis.crypto.subtle !== 'undefined';
+        return webCryptoAvailable;
+    }
+    function detectNativeNodeCrypto() {
+        if (typeof globalThis.process === 'undefined' ||
+            typeof globalThis.process.versions?.node !== 'string') {
+            return false;
+        }
+        const moduleId = `node:${'crypto'}`;
+        try {
+            const directRequire = typeof require === 'function'
+                ? require
+                : globalThis.require;
+            if (typeof directRequire === 'function') {
+                const { webcrypto } = directRequire(moduleId);
+                return Boolean(webcrypto?.subtle);
+            }
+            const lazyRequire = Function('return typeof require === "function" ? require : null')();
+            if (typeof lazyRequire === 'function') {
+                const { webcrypto } = lazyRequire(moduleId);
+                return Boolean(webcrypto?.subtle);
+            }
+        }
+        catch {
+            // Ignore resolution errors and fall through to false
+        }
+        return false;
+    }
+    function hasCryptoSupport() {
+        return detectWebCrypto() || detectNativeNodeCrypto();
+    }
+    function requireCryptoSupport() {
+        if (!hasCryptoSupport()) {
+            throw new Error("This functionality requires WebCrypto support. Ensure 'crypto.subtle' is available in your runtime or include a compatible polyfill.");
+        }
+    }
+
+    const DEFAULT_DB_NAME = 'naylence-secrets';
+    const DEFAULT_STORE_NAME = 'wrapped-master-key';
+    const DEFAULT_KEY_ID = 'master';
+    const DEFAULT_ITERATIONS = 200000;
+    const WRAPPED_RECORD_VERSION = 1;
+    const MASTER_KEY_LENGTH = 32;
+    const SALT_LENGTH = 16;
+    const GCM_IV_LENGTH = 12;
+    class InvalidPassphraseError extends Error {
+        constructor(message = 'Unable to decrypt master key with provided passphrase') {
+            super(message);
+            this.name = 'InvalidPassphraseError';
+        }
+    }
+    let cachedNodeCrypto;
+    let cachedCrypto;
+    async function loadNodeCrypto() {
+        if (cachedNodeCrypto !== undefined) {
+            return cachedNodeCrypto;
+        }
+        try {
+            cachedNodeCrypto = await import('node:crypto');
+            return cachedNodeCrypto;
+        }
+        catch {
+            cachedNodeCrypto = null;
+            return null;
+        }
+    }
+    async function getCrypto() {
+        if (cachedCrypto) {
+            return cachedCrypto;
+        }
+        if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.subtle) {
+            const cryptoObject = globalThis.crypto;
+            cachedCrypto = cryptoObject;
+            return cryptoObject;
+        }
+        const nodeCrypto = await loadNodeCrypto();
+        if (nodeCrypto?.webcrypto?.subtle) {
+            const cryptoObject = nodeCrypto.webcrypto;
+            cachedCrypto = cryptoObject;
+            return cryptoObject;
+        }
+        throw new Error('Web Crypto API is not available in this environment');
+    }
+    async function getRandomBytes(length) {
+        const cryptoObject = await getCrypto();
+        if (typeof cryptoObject.getRandomValues === 'function') {
+            const buffer = new Uint8Array(length);
+            cryptoObject.getRandomValues(buffer);
+            return buffer;
+        }
+        const nodeCrypto = await loadNodeCrypto();
+        if (nodeCrypto?.randomBytes) {
+            const buffer = nodeCrypto.randomBytes(length);
+            return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        }
+        throw new Error('Unable to generate secure random bytes in this environment');
+    }
+    function toArrayBuffer(data) {
+        const buffer = new ArrayBuffer(data.byteLength);
+        new Uint8Array(buffer).set(data);
+        return buffer;
+    }
+    function base64Encode(data) {
+        if (typeof btoa === 'function') {
+            let binary = '';
+            for (let i = 0; i < data.length; i++) {
+                binary += String.fromCharCode(data[i]);
+            }
+            return btoa(binary);
+        }
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(data).toString('base64');
+        }
+        throw new Error('Base64 encoding is not available in this environment');
+    }
+    function base64Decode(value) {
+        if (typeof atob === 'function') {
+            const binary = atob(value);
+            const buffer = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                buffer[i] = binary.charCodeAt(i);
+            }
+            return buffer;
+        }
+        if (typeof Buffer !== 'undefined') {
+            return new Uint8Array(Buffer.from(value, 'base64'));
+        }
+        throw new Error('Base64 decoding is not available in this environment');
+    }
+    const UTF8_ENCODER = new TextEncoder();
+    async function deriveKEK(passphrase, salt, iterations) {
+        const cryptoObject = await getCrypto();
+        const subtle = cryptoObject.subtle;
+        const baseKey = await subtle.importKey('raw', UTF8_ENCODER.encode(passphrase), { name: 'PBKDF2' }, false, ['deriveKey']);
+        return subtle.deriveKey({
+            name: 'PBKDF2',
+            salt: toArrayBuffer(salt),
+            iterations,
+            hash: 'SHA-256',
+        }, baseKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+    }
+    async function aesGcmEncrypt(key, data) {
+        const cryptoObject = await getCrypto();
+        const subtle = cryptoObject.subtle;
+        const iv = await getRandomBytes(GCM_IV_LENGTH);
+        const ciphertextBuffer = await subtle.encrypt({ name: 'AES-GCM', iv: toArrayBuffer(iv) }, key, toArrayBuffer(data));
+        return { iv, ciphertext: new Uint8Array(ciphertextBuffer) };
+    }
+    async function aesGcmDecrypt(key, iv, data) {
+        const cryptoObject = await getCrypto();
+        const subtle = cryptoObject.subtle;
+        const plaintextBuffer = await subtle.decrypt({ name: 'AES-GCM', iv: toArrayBuffer(iv) }, key, toArrayBuffer(data));
+        return new Uint8Array(plaintextBuffer);
+    }
+    async function openDatabase(factory, dbName, storeName) {
+        return new Promise((resolve, reject) => {
+            const request = factory.open(dbName, 1);
+            request.onerror = () => {
+                reject(request.error ?? new Error('Failed to open IndexedDB'));
+            };
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains(storeName)) {
+                    db.createObjectStore(storeName);
+                }
+            };
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+        });
+    }
+    async function readWrappedRecord(db, storeName, keyId) {
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(storeName, 'readonly');
+            const store = tx.objectStore(storeName);
+            const request = store.get(keyId);
+            request.onerror = () => {
+                reject(request.error ?? new Error('Failed to read wrapped master key'));
+            };
+            request.onsuccess = () => {
+                resolve(request.result ?? null);
+            };
+        });
+    }
+    async function writeWrappedRecord(db, storeName, keyId, record) {
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(storeName, 'readwrite');
+            const store = tx.objectStore(storeName);
+            const request = store.put(record, keyId);
+            request.onerror = () => {
+                reject(request.error ?? new Error('Failed to persist wrapped master key'));
+            };
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => {
+                reject(tx.error ?? new Error('Failed to persist wrapped master key'));
+            };
+        });
+    }
+    class BrowserWrappedKeyCredentialProvider {
+        constructor(options) {
+            this.cachedKey = null;
+            this.inflight = null;
+            if (!options?.promptPassphrase) {
+                throw new Error('promptPassphrase callback is required');
+            }
+            this.dbName = options.dbName ?? DEFAULT_DB_NAME;
+            this.storeName = options.storeName ?? DEFAULT_STORE_NAME;
+            this.keyId = options.keyId ?? DEFAULT_KEY_ID;
+            this.iterations = options.iterations ?? DEFAULT_ITERATIONS;
+            this.promptPassphrase = options.promptPassphrase;
+            if (options.idbFactory) {
+                this.idbFactory = options.idbFactory;
+            }
+            else if (typeof indexedDB !== 'undefined') {
+                this.idbFactory = indexedDB;
+            }
+            else {
+                throw new Error('IndexedDB is not available in this environment');
+            }
+        }
+        async get() {
+            if (this.cachedKey) {
+                return this.cachedKey;
+            }
+            if (this.inflight) {
+                return this.inflight;
+            }
+            this.inflight = this.loadOrCreateKey();
+            try {
+                const key = await this.inflight;
+                this.cachedKey = key;
+                return key;
+            }
+            finally {
+                this.inflight = null;
+            }
+        }
+        async loadOrCreateKey() {
+            const db = await openDatabase(this.idbFactory, this.dbName, this.storeName);
+            try {
+                const existing = await readWrappedRecord(db, this.storeName, this.keyId);
+                if (!existing) {
+                    return await this.createAndPersistKey(db);
+                }
+                return await this.unwrapExistingKey(existing);
+            }
+            finally {
+                db.close();
+            }
+        }
+        async createAndPersistKey(db) {
+            const passphrase = (await this.promptPassphrase()).trim();
+            if (!passphrase) {
+                throw new Error('Passphrase must not be empty');
+            }
+            const salt = await getRandomBytes(SALT_LENGTH);
+            const kek = await deriveKEK(passphrase, salt, this.iterations);
+            const masterKey = await getRandomBytes(MASTER_KEY_LENGTH);
+            const { iv, ciphertext } = await aesGcmEncrypt(kek, masterKey);
+            const record = {
+                version: WRAPPED_RECORD_VERSION,
+                kdf: {
+                    algo: 'PBKDF2',
+                    hash: 'SHA-256',
+                    iterations: this.iterations,
+                    saltB64: base64Encode(salt),
+                },
+                wrap: {
+                    algo: 'AES-GCM',
+                    ivB64: base64Encode(iv),
+                    ciphertextB64: base64Encode(ciphertext),
+                },
+            };
+            await writeWrappedRecord(db, this.storeName, this.keyId, record);
+            return masterKey;
+        }
+        async unwrapExistingKey(record) {
+            if (record.version !== WRAPPED_RECORD_VERSION) {
+                throw new Error(`Unsupported wrapped key version: ${record.version}`);
+            }
+            if (record.kdf.algo !== 'PBKDF2' || record.kdf.hash !== 'SHA-256') {
+                throw new Error('Unsupported KDF configuration for wrapped master key');
+            }
+            if (record.wrap.algo !== 'AES-GCM') {
+                throw new Error('Unsupported wrapping algorithm for wrapped master key');
+            }
+            const passphrase = (await this.promptPassphrase()).trim();
+            if (!passphrase) {
+                throw new InvalidPassphraseError();
+            }
+            const { saltB64, iterations } = record.kdf;
+            const { ivB64, ciphertextB64 } = record.wrap;
+            const salt = base64Decode(saltB64);
+            const iv = base64Decode(ivB64);
+            const ciphertext = base64Decode(ciphertextB64);
+            try {
+                const kek = await deriveKEK(passphrase, salt, iterations);
+                return await aesGcmDecrypt(kek, iv, ciphertext);
+            }
+            catch (error) {
+                throw new InvalidPassphraseError(error instanceof Error ? error.message : 'Unable to decrypt master key');
+            }
+        }
+    }
+
+    /**
+     * Browser-friendly entry point for Naylence Runtime.
+     *
+     * Exposes utilities, channels, connectors, and cross-platform helpers that
+     * do not rely on Node.js-only dependencies. This file purposefully excludes
+     * modules such as the SQLite storage providers and any prompt utilities that
+     * expect access to the Node.js standard library.
+     */
+    // Re-export everything from naylence-core for protocol primitives
+    const isBrowserEnvironment = typeof window !== 'undefined' && typeof document !== 'undefined';
+    if (isBrowserEnvironment) {
+        const runtimePluginModulePromise = Promise.resolve().then(function () { return plugin; });
+        const globalScope = globalThis;
+        if (typeof globalScope.__naylenceFactoryDynamicImporter !== 'function') {
+            const loader = async (specifier) => {
+                if (specifier === '@naylence/runtime' ||
+                    specifier === '@naylence/runtime/' ||
+                    specifier === '@naylence/runtime/plugin' ||
+                    specifier === '@naylence/runtime/plugin.js' ||
+                    specifier === '@naylence/runtime/dist/esm/plugin.js') {
+                    return runtimePluginModulePromise;
+                }
+                return import(/* @vite-ignore */ specifier);
+            };
+            globalScope.__naylenceFactoryDynamicImporter = loader;
+        }
+    }
+
+    let initialized = false;
+    const runtimePlugin = {
+        name: 'naylence:runtime',
+        async register() {
+            // console.log('[naylence:runtime] register() called, initialized=', initialized);
+            if (initialized) {
+                // console.log('[naylence:runtime] already initialized, skipping');
+                return;
+            }
+            initialized = true;
+            // console.log('[naylence:runtime] registering runtime factories...');
+            // Register factories from manifest
+            await registerRuntimeFactories();
+            // Import modules with side-effect registrations (not in manifest)
+            await Promise.resolve().then(function () { return websocketTransportProvisioner; });
+            // console.log('[naylence:runtime] runtime factories registered');
+        },
+    };
+    const RUNTIME_PLUGIN_SPECIFIER = runtimePlugin.name;
+
+    var plugin = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        RUNTIME_PLUGIN_SPECIFIER: RUNTIME_PLUGIN_SPECIFIER,
+        default: runtimePlugin
+    });
+
+    const GRANT_PURPOSE_NODE_ATTACH = 'node.attach';
+    function isGrant(candidate) {
+        if (!candidate || typeof candidate !== 'object') {
+            return false;
+        }
+        const grant = candidate;
+        return typeof grant.type === 'string' && typeof grant.purpose === 'string';
+    }
+    function assertGrant(candidate, message = 'Invalid grant object') {
+        if (!isGrant(candidate)) {
+            throw new TypeError(message);
+        }
+    }
+
+    const AUTH_INJECTION_STRATEGY_TYPE_ALIASES = {
+        BearerTokenHeaderAuthInjectionStrategy: 'BearerTokenHeaderAuth',
+        BearerTokenHeaderAuthStrategy: 'BearerTokenHeaderAuth',
+        NoAuthInjectionStrategy: 'NoAuth',
+        QueryParamAuthInjectionStrategy: 'QueryParamAuth',
+        QueryParamAuthStrategy: 'QueryParamAuth',
+        WebSocketSubprotocolAuthInjectionStrategy: 'WebSocketSubprotocolAuth',
+        WebSocketSubprotocolAuthStrategy: 'WebSocketSubprotocolAuth',
+    };
+    function canonicalizeAuthConfig(auth) {
+        if (!auth || typeof auth !== 'object' || Array.isArray(auth)) {
+            return undefined;
+        }
+        const typeValue = auth.type;
+        if (typeof typeValue !== 'string') {
+            return auth;
+        }
+        const normalizedType = AUTH_INJECTION_STRATEGY_TYPE_ALIASES[typeValue] ?? typeValue;
+        if (normalizedType === typeValue) {
+            return auth;
+        }
+        return {
+            ...auth,
+            type: normalizedType,
+        };
+    }
+    function assertConnectionGrant(candidate, message = 'Invalid connection grant') {
+        assertGrant(candidate, message);
+    }
+
+    const WEBSOCKET_CONNECTION_GRANT_TYPE = 'WebSocketConnectionGrant';
+    function normalizeWebSocketConnectionGrant(candidate) {
+        const type = typeof candidate.type === 'string'
+            ? candidate.type
+            : WEBSOCKET_CONNECTION_GRANT_TYPE;
+        if (type !== WEBSOCKET_CONNECTION_GRANT_TYPE) {
+            throw new TypeError(`WebSocketConnectionGrant expected type "${WEBSOCKET_CONNECTION_GRANT_TYPE}", received "${type}"`);
+        }
+        const purpose = typeof candidate.purpose === 'string' && candidate.purpose.length > 0
+            ? candidate.purpose
+            : GRANT_PURPOSE_NODE_ATTACH;
+        assertConnectionGrant({ ...candidate, type, purpose }, 'WebSocketConnectionGrant requires a valid base grant');
+        const urlValue = candidate.url;
+        if (urlValue !== undefined &&
+            (typeof urlValue !== 'string' || urlValue.trim().length === 0)) {
+            throw new TypeError('WebSocketConnectionGrant "url" must be a non-empty string when provided');
+        }
+        const base = {
+            type,
+            purpose,
+        };
+        if (typeof urlValue === 'string') {
+            base.url = urlValue;
+        }
+        const authConfig = canonicalizeAuthConfig(candidate.auth);
+        if (authConfig) {
+            base.auth = authConfig;
+        }
+        return base;
+    }
+
+    const TRANSPORT_PROVISIONER_FACTORY_BASE_TYPE = 'TransportProvisionerFactory';
+    class TransportProvisionerFactory extends AbstractResourceFactory {
+        static async createTransportProvisioner(config, options = {}) {
+            if (config) {
+                const provisioner = await createResource$1(TRANSPORT_PROVISIONER_FACTORY_BASE_TYPE, config, options);
+                if (!provisioner) {
+                    throw new Error('Failed to create transport provisioner from configuration');
+                }
+                return provisioner;
+            }
+            let provisioner = null;
+            try {
+                provisioner = await createDefaultResource(TRANSPORT_PROVISIONER_FACTORY_BASE_TYPE, null, options);
+            }
+            catch (error) {
+                const message = 'Failed to create default transport provisioner' +
+                    (error instanceof Error && error.message ? `: ${error.message}` : '');
+                throw new Error(message);
+            }
+            if (!provisioner) {
+                throw new Error('Failed to create default transport provisioner');
+            }
+            return provisioner;
+        }
+    }
+
+    class WebSocketTransportProvisioner {
+        constructor(options) {
+            this.url = options.url;
+            this.ttlSec = options.ttlSec;
+        }
+        async provision(_decision, hello, _fullMetadata, attachToken) {
+            const supportedTransports = hello.supportedTransports;
+            if (Array.isArray(supportedTransports) && supportedTransports.length > 0) {
+                const hasWebSocket = supportedTransports.includes(WebSocketTransportProvisioner.TRANSPORT_TYPE);
+                if (!hasWebSocket) {
+                    throw new Error(`Unsupported transports: ${supportedTransports.join(', ')}`);
+                }
+            }
+            let authConfig;
+            if (attachToken) {
+                const tokenProviderConfig = {
+                    type: 'StaticTokenProvider',
+                    token: attachToken,
+                };
+                authConfig = {
+                    type: 'WebSocketSubprotocolAuth',
+                    tokenProvider: tokenProviderConfig,
+                };
+            }
+            const grant = normalizeWebSocketConnectionGrant({
+                type: WEBSOCKET_CONNECTION_GRANT_TYPE,
+                purpose: GRANT_PURPOSE_NODE_ATTACH,
+                url: this.url,
+                auth: authConfig,
+            });
+            const result = {
+                connectionGrant: grant,
+                cleanupHandle: null,
+            };
+            if (this.ttlSec !== undefined) {
+                result.metadata = {
+                    ...(result.metadata ?? {}),
+                    ttlSec: this.ttlSec,
+                };
+            }
+            return result;
+        }
+        async deprovision(_cleanupHandle) {
+            // No-op for stateless WebSocket transport provisioners
+        }
+    }
+    WebSocketTransportProvisioner.TRANSPORT_TYPE = 'websocket';
+    class WebSocketTransportProvisionerFactory extends TransportProvisionerFactory {
+        constructor() {
+            super(...arguments);
+            this.type = 'WebSocketTransportProvisioner';
+            this.isDefault = true;
+        }
+        async create(config) {
+            const options = normalizeConfig(config);
+            return new WebSocketTransportProvisioner(options);
+        }
+    }
+    function normalizeConfig(config) {
+        if (!config) {
+            throw new Error('WebSocketTransportProvisioner requires configuration');
+        }
+        const candidate = config;
+        const typeValue = typeof candidate.type === 'string' ? candidate.type : undefined;
+        if (typeValue !== 'WebSocketTransportProvisioner') {
+            throw new Error(`WebSocketTransportProvisionerFactory expects type "WebSocketTransportProvisioner", got "${typeValue ?? 'undefined'}"`);
+        }
+        const urlValue = candidate.url;
+        if (typeof urlValue !== 'string' || urlValue.trim().length === 0) {
+            throw new Error('WebSocketTransportProvisioner configuration must include a non-empty "url" string');
+        }
+        const ttlCandidate = (() => {
+            const raw = candidate.ttlSec ?? candidate.ttl_sec ?? candidate.ttlSEC;
+            if (typeof raw === 'number') {
+                return raw;
+            }
+            if (typeof raw === 'string') {
+                const parsed = Number(raw.trim());
+                return Number.isFinite(parsed) ? parsed : undefined;
+            }
+            return undefined;
+        })();
+        const options = {
+            url: urlValue.trim(),
+        };
+        if (typeof ttlCandidate === 'number' && Number.isFinite(ttlCandidate)) {
+            options.ttlSec = ttlCandidate;
+        }
+        return options;
+    }
+    registerFactory(TRANSPORT_PROVISIONER_FACTORY_BASE_TYPE, 'WebSocketTransportProvisioner', WebSocketTransportProvisionerFactory, {
+        isDefault: true,
+    });
+
+    var websocketTransportProvisioner = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        WebSocketTransportProvisioner: WebSocketTransportProvisioner,
+        WebSocketTransportProvisionerFactory: WebSocketTransportProvisionerFactory
+    });
+
     exports.AGENT_CAPABILITY = AGENT_CAPABILITY;
     exports.AddressBindAckFrameSchema = AddressBindAckFrameSchema;
     exports.AddressBindFrameSchema = AddressBindFrameSchema;
@@ -13583,6 +13745,7 @@
     exports.BaseChannel = BaseChannel;
     exports.BaseFameConnector = BaseFameConnector;
     exports.Binding = Binding;
+    exports.BrowserWrappedKeyCredentialProvider = BrowserWrappedKeyCredentialProvider;
     exports.CapabilityAdvertiseAckFrameSchema = CapabilityAdvertiseAckFrameSchema;
     exports.CapabilityAdvertiseFrameSchema = CapabilityAdvertiseFrameSchema;
     exports.CapabilityWithdrawAckFrameSchema = CapabilityWithdrawAckFrameSchema;
@@ -13630,6 +13793,7 @@
     exports.InMemoryStorageProvider = InMemoryStorageProvider;
     exports.IndexedDBKeyValueStore = IndexedDBKeyValueStore;
     exports.IndexedDBStorageProvider = IndexedDBStorageProvider;
+    exports.InvalidPassphraseError = InvalidPassphraseError;
     exports.JSONRPCErrorCodes = JSONRPCErrorCodes;
     exports.JSONRPCErrorSchema = JSONRPCErrorSchema;
     exports.JSONRPCMessageSchema = JSONRPCMessageSchema;
@@ -13714,9 +13878,12 @@
     exports.generateId = generateId;
     exports.generateIdAsync = generateIdAsync;
     exports.getCurrentEnvelope = getCurrentEnvelope;
+    exports.getCurrentNode = getCurrentNode;
     exports.getDefaultFameConfigResolver = getDefaultFameConfigResolver;
     exports.getFameRoot = getFameRoot;
     exports.getLogger = getLogger;
+    exports.getNode = getNode;
+    exports.hasCryptoSupport = hasCryptoSupport;
     exports.hostnameToLogical = hostnameToLogical;
     exports.hostnamesToLogicals = hostnamesToLogicals;
     exports.isConnectorConfig = isConnectorConfig;
@@ -13755,6 +13922,7 @@
     exports.matchesPoolAddress = matchesPoolAddress;
     exports.matchesPoolLogical = matchesPoolLogical;
     exports.maybeAwait = maybeAwait;
+    exports.normalizeEnvelopeSnapshot = normalizeEnvelopeSnapshot;
     exports.normalizeFameConfig = normalizeFameConfig;
     exports.normalizeHandlerResponse = normalizeHandlerResponse;
     exports.normalizePath = normalizePath;
@@ -13768,9 +13936,11 @@
     exports.prettyModel = prettyModel;
     exports.registerDefaultFactories = registerDefaultFactories;
     exports.registerRuntimeFactories = registerRuntimeFactories;
+    exports.requireCryptoSupport = requireCryptoSupport;
     exports.resetFabricStack = resetFabricStack;
     exports.resolveDefaultFameConfig = resolveDefaultFameConfig;
     exports.retryWithBackoff = retryWithBackoff;
+    exports.runWithNodeContext = runWithNodeContext;
     exports.safeColor = safeColor;
     exports.secureDigest = secureDigest;
     exports.serializeEnvelope = serializeEnvelope;
@@ -13800,7 +13970,9 @@
     exports.withEnvelopeContext = withEnvelopeContext;
     exports.withEnvelopeContextAsync = withEnvelopeContextAsync;
     exports.withFabric = withFabric;
+    exports.withLegacySnakeCaseKeys = withLegacySnakeCaseKeys;
     exports.withLock = withLock;
+    exports.withNodeContextAsync = withNodeContextAsync;
     exports.withTimeout = withTimeout;
 
 }));