@naylence/agent-sdk 0.3.4-test.705 → 0.3.4-test.707

package/dist/browser/index.js

@@ -669,7 +669,7 @@
     const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
     // const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
     const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
-    const date$2 = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
+    const date$3 = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
     function timeSource(args) {
         const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
         const regex = typeof args.precision === "number"
@@ -1435,7 +1435,7 @@
         $ZodStringFormat.init(inst, def);
     });
     const $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def) => {
-        def.pattern ?? (def.pattern = date$2);
+        def.pattern ?? (def.pattern = date$3);
         $ZodStringFormat.init(inst, def);
     });
     const $ZodISOTime = /*@__PURE__*/ $constructor("$ZodISOTime", (inst, def) => {
@@ -2937,6 +2937,13 @@
             ...normalizeParams$1(params),
         });
     }
+    function _coercedDate(Class, params) {
+        return new Class({
+            type: "date",
+            coerce: true,
+            ...normalizeParams$1(params),
+        });
+    }
     function _lt(value, params) {
         return new $ZodCheckLessThan({
             check: "less_than",
@@ -3128,7 +3135,7 @@
         $ZodISODate.init(inst, def);
         ZodStringFormat.init(inst, def);
     });
-    function date$1(params) {
+    function date$2(params) {
         return _isoDate(ZodISODate, params);
     }
     const ZodISOTime = /*@__PURE__*/ $constructor("ZodISOTime", (inst, def) => {
@@ -3338,7 +3345,7 @@
         inst.e164 = (params) => inst.check(_e164(ZodE164, params));
         // iso
         inst.datetime = (params) => inst.check(datetime(params));
-        inst.date = (params) => inst.check(date$1(params));
+        inst.date = (params) => inst.check(date$2(params));
         inst.time = (params) => inst.check(time(params));
         inst.duration = (params) => inst.check(duration(params));
     });
@@ -3524,7 +3531,7 @@
         inst.minDate = c.minimum ? new Date(c.minimum) : null;
         inst.maxDate = c.maximum ? new Date(c.maximum) : null;
     });
-    function date(params) {
+    function date$1(params) {
         return _date(ZodDate, params);
     }
     const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def) => {
@@ -3867,6 +3874,10 @@
         custom: "custom",
     };
 
+    function date(params) {
+        return _coercedDate(ZodDate, params);
+    }
+
     const PARTICIPANT_RE = /^[A-Za-z0-9_-]+$/;
     const SEGMENT_RE = /^[A-Za-z0-9._-]+$/;
     const HOST_SEGMENT_RE = /^[A-Za-z0-9.-]+$/; // Allow dots for host parts
@@ -5974,7 +5985,7 @@
             }
         }
         return value;
-    }, date())
+    }, date$1())
         .describe('UTC timestamp when the envelope was created');
     const FLOW_FLAG_MASK = FlowFlags.SYN | FlowFlags.ACK | FlowFlags.RESET;
     const FlowFlagsSchema = number()
@@ -6271,7 +6282,7 @@
         // Context metadata
         authMethod: string$1().optional()
             .describe('Authentication method used'),
-        expiresAt: date().optional()
+        expiresAt: date$1().optional()
             .describe('When authorization expires'),
     }).transform((data) => {
         // Convert string dates to Date objects if needed
@@ -6532,7 +6543,7 @@
             }
         }
         return value;
-    }, date());
+    }, date$1());
     const TaskStatusSchema = object({
         state: nativeEnum(exports.TaskState),
         message: MessageSchema.nullable().optional(),
@@ -6793,6 +6804,21 @@
     class MissingAPIKeyError extends Error {
     }
 
+    /**
+     * Utilities for hex, bytes, CSPRNG.
+     * @module
+     */
+    /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    /** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+    /**
+     * Converts string to bytes using UTF8 encoding.
+     * Built-in doesn't validate input to be string: we do the check.
+     * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+     */
+    function utf8ToBytes(str) {
+        return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+    }
+
     const ALIAS = Symbol.for('yaml.alias');
     const DOC = Symbol.for('yaml.document');
     const MAP = Symbol.for('yaml.map');
@@ -19249,7 +19275,7 @@
      * limitations under the License.
      */
     // this is autogenerated file, see scripts/version-update.js
-    var VERSION$2 = '1.9.0';
+    var VERSION$3 = '1.9.0';
 
     /*
      * Copyright The OpenTelemetry Authors
@@ -19366,7 +19392,7 @@
      *
      * @param version version of the API requesting an instance of the global API
      */
-    var isCompatible = _makeCompatibilityCheck(VERSION$2);
+    var isCompatible = _makeCompatibilityCheck(VERSION$3);
 
     /*
      * Copyright The OpenTelemetry Authors
@@ -19383,14 +19409,14 @@
      * See the License for the specific language governing permissions and
      * limitations under the License.
      */
-    var major = VERSION$2.split('.')[0];
+    var major = VERSION$3.split('.')[0];
     var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
     var _global = _globalThis$1;
     function registerGlobal(type, instance, diag, allowOverride) {
         var _a;
         if (allowOverride === void 0) { allowOverride = false; }
         var api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
-            version: VERSION$2,
+            version: VERSION$3,
         });
         if (!allowOverride && api[type]) {
             // already registered an API of this type
@@ -19398,14 +19424,14 @@
             diag.error(err.stack || err.message);
             return false;
         }
-        if (api.version !== VERSION$2) {
+        if (api.version !== VERSION$3) {
             // All registered APIs must be of the same version exactly
-            var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION$2);
+            var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION$3);
             diag.error(err.stack || err.message);
             return false;
         }
         api[type] = instance;
-        diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION$2 + ".");
+        diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION$3 + ".");
         return true;
     }
     function getGlobal(type) {
@@ -19417,7 +19443,7 @@
         return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
     }
     function unregisterGlobal(type, diag) {
-        diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION$2 + ".");
+        diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION$3 + ".");
         var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
         if (api) {
             delete api[type];
@@ -21564,6 +21590,14 @@
         trace: trace
     });
 
+    // This file is auto-generated during build - do not edit manually
+    // Generated from package.json version: 0.3.5-test.907
+    /**
+     * The package version, injected at build time.
+     * @internal
+     */
+    const VERSION$2 = '0.3.5-test.907';
+
     /**
      * Cross-platform logging utilities for Naylence Fame
      *
@@ -22194,10 +22228,10 @@
      * General utility functions for JSON handling, string manipulation,
      * path normalization, base64 encoding, hashing, and more.
      */
-    const ENV_VAR_SHOW_ENVELOPES = 'FAME_SHOW_ENVELOPES';
+    const ENV_VAR_SHOW_ENVELOPES$1 = 'FAME_SHOW_ENVELOPES';
     function isEnvelopeLoggingEnabled() {
         return (typeof process !== 'undefined' &&
-            process.env?.[ENV_VAR_SHOW_ENVELOPES] === 'true');
+            process.env?.[ENV_VAR_SHOW_ENVELOPES$1] === 'true');
     }
     isEnvelopeLoggingEnabled();
     // Base62 characters: 0–9, a–z, A–Z
@@ -22707,7 +22741,7 @@
     function isArrayBufferView(value) {
         return Boolean(value) && ArrayBuffer.isView(value);
     }
-    function toUint8Array(value) {
+    function toUint8Array$1(value) {
         if (!value) {
             return null;
         }
@@ -22749,7 +22783,7 @@
                 reject(request.error ?? new Error('Failed to read master key from IndexedDB'));
             };
             request.onsuccess = () => {
-                resolve(toUint8Array(request.result));
+                resolve(toUint8Array$1(request.result));
             };
         });
     }
@@ -22768,7 +22802,7 @@
             };
         });
     }
-    function getRandomBytes$2(length) {
+    function getRandomBytes$3(length) {
         if (!globalThis.crypto?.getRandomValues) {
             throw new Error('crypto.getRandomValues is not available in this environment');
         }
@@ -22817,7 +22851,7 @@
                 if (existing) {
                     return existing;
                 }
-                const masterKey = getRandomBytes$2(MASTER_KEY_LENGTH$1);
+                const masterKey = getRandomBytes$3(MASTER_KEY_LENGTH$1);
                 await persistKey(db, this.storeName, this.keyId, masterKey);
                 return masterKey;
             }
@@ -22844,18 +22878,18 @@
             return null;
         }
     }
-    let cachedNodeCrypto$1;
+    let cachedNodeCrypto$2;
     let cachedSubtle;
-    async function loadNodeCrypto$1() {
-        if (cachedNodeCrypto$1 !== undefined) {
-            return cachedNodeCrypto$1;
+    async function loadNodeCrypto$2() {
+        if (cachedNodeCrypto$2 !== undefined) {
+            return cachedNodeCrypto$2;
         }
         try {
-            cachedNodeCrypto$1 = await Promise.resolve().then(function () { return _nodeResolve_empty$1; });
-            return cachedNodeCrypto$1;
+            cachedNodeCrypto$2 = await Promise.resolve().then(function () { return _nodeResolve_empty$1; });
+            return cachedNodeCrypto$2;
         }
         catch {
-            cachedNodeCrypto$1 = null;
+            cachedNodeCrypto$2 = null;
             return null;
         }
     }
@@ -22867,21 +22901,21 @@
             cachedSubtle = globalThis.crypto.subtle;
             return cachedSubtle;
         }
-        const nodeCrypto = await loadNodeCrypto$1();
+        const nodeCrypto = await loadNodeCrypto$2();
         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$1(length) {
+    async function getRandomBytes$2(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$1();
+        const nodeCrypto = await loadNodeCrypto$2();
         if (nodeCrypto) {
             const buffer = nodeCrypto.randomBytes(length);
             return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
@@ -22970,7 +23004,7 @@
             const normalizedKey = normalizeKey(key);
             const keyBuffer = toArrayBuffer$1(normalizedKey);
             const cryptoKey = await subtle.importKey('raw', keyBuffer, { name: 'AES-GCM' }, false, ['encrypt']);
-            const iv = await getRandomBytes$1(GCM_IV_LENGTH$1);
+            const iv = await getRandomBytes$2(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);
@@ -23453,29 +23487,17 @@
         IndexedDBStorageProvider: IndexedDBStorageProvider
     });
 
-    const globalScope$1 = globalThis;
-    const nodeStack = globalScope$1.__naylenceNodeStack__ ?? (globalScope$1.__naylenceNodeStack__ = []);
-    function getCurrentNode() {
-        return nodeStack.length > 0 ? nodeStack[nodeStack.length - 1] : null;
-    }
+    getLogger('naylence.fame.node.binding_manager');
 
-    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);
-        }
-    }
+    getLogger('naylence.fame.node.response_context_manager');
 
-    getLogger('naylence.fame.node.admission.default_node_attach_client');
+    getLogger('naylence.fame.node.streaming_response_handler');
 
-    getLogger('naylence.fame.node.binding_manager');
+    getLogger('naylence.fame.node.channel_polling_manager');
+
+    getLogger('naylence.fame.node.rpc_server_handler');
+
+    getLogger('naylence.fame.node.rpc_client_manager');
 
     var EnvelopeStatus;
     (function (EnvelopeStatus) {
@@ -23512,8 +23534,57 @@
         outbox: MailboxType.OUTBOX,
     });
 
+    getLogger('naylence.fame.node.envelope_listener_manager');
+
     getLogger('naylence.fame.delivery.default_delivery_tracker');
 
+    const globalScope$1 = globalThis;
+    const nodeStack = globalScope$1.__naylenceNodeStack__ ?? (globalScope$1.__naylenceNodeStack__ = []);
+    function getCurrentNode() {
+        return nodeStack.length > 0 ? nodeStack[nodeStack.length - 1] : null;
+    }
+
+    getLogger('naylence.fame.node.root_session_manager');
+
+    /**
+     * Base factory for creating FameConnector instances from either ConnectorConfig or ConnectionGrant.
+     *
+     * Concrete implementations must define supported grant types and provide grant-to-connector
+     * conversion logic.
+     */
+    getLogger('naylence.fame.connector.connector_factory');
+
+    getLogger('naylence.fame.node.upstream_session_manager');
+
+    getLogger('naylence.fame.node.admission.noop_admission_client');
+    getLogger('naylence.fame.node.node');
+
+    const FameNodeModeSchema = union([literal('dev'), literal('prod')])
+        .default('prod');
+    object({
+        type: literal('Node').default('Node'),
+        mode: FameNodeModeSchema,
+        id: string$1().optional().nullable(),
+        directParentUrl: string$1().optional().nullable(),
+        admission: unknown().optional().nullable(),
+        requestedLogicals: array(string$1()).default([]),
+        delivery: unknown().optional().nullable(),
+        envContext: record(string$1(), unknown()).default({}),
+        services: array(unknown()).default([]),
+        hasParent: boolean().default(false),
+        security: unknown().optional().nullable(),
+        listeners: array(record(string$1(), unknown())).default([]),
+        publicUrl: string$1().optional().nullable(),
+        keyStore: unknown().optional().nullable(),
+        storage: unknown().optional().nullable(),
+        attachmentKeyValidator: unknown().optional().nullable(),
+        telemetry: unknown().optional().nullable(),
+        requestedCapabilities: array(string$1()).optional(),
+    })
+        .passthrough();
+
+    getLogger('naylence.fame.node.admission.default_node_attach_client');
+
     const TRACE_EMITTER_FACTORY_BASE_TYPE = 'TraceEmitterFactory';
     class TraceEmitterFactory extends AbstractResourceFactory {
         static async createTraceEmitter(config, options = {}) {
@@ -23553,12 +23624,12 @@
         welcome: unknown().optional(),
     })
         .loose());
-    function isPlainObject$1(value) {
+    function isPlainObject$2(value) {
         return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
     }
     function parseJson(content) {
         const parsed = JSON.parse(content);
-        if (!isPlainObject$1(parsed)) {
+        if (!isPlainObject$2(parsed)) {
             throw new Error('Parsed JSON config must be an object');
         }
         return parsed;
@@ -23568,7 +23639,7 @@
         if (parsed == null) {
             return {};
         }
-        if (!isPlainObject$1(parsed)) {
+        if (!isPlainObject$2(parsed)) {
             throw new Error('Parsed YAML config must be an object');
         }
         return parsed;
@@ -23699,164 +23770,284 @@
     if (isNode && !getDefaultFameConfigResolver()) {
         setDefaultFameConfigResolver(async () => loadRawFameConfig());
     }
-    // export function registerNodeLikeFactory(
-    //   type: string,
-    //   factory: new (...args: unknown[]) => NodeLikeFactory
-    // ): void {
-    //   registerFactory(NODE_LIKE_FACTORY_BASE_TYPE, type, factory);
-    // }
-
-    const FameNodeModeSchema = union([literal('dev'), literal('prod')])
-        .default('prod');
-    object({
-        type: literal('Node').default('Node'),
-        mode: FameNodeModeSchema,
-        id: string$1().optional().nullable(),
-        directParentUrl: string$1().optional().nullable(),
-        admission: unknown().optional().nullable(),
-        requestedLogicals: array(string$1()).default([]),
-        delivery: unknown().optional().nullable(),
-        envContext: record(string$1(), unknown()).default({}),
-        services: array(unknown()).default([]),
-        hasParent: boolean().default(false),
-        security: unknown().optional().nullable(),
-        listeners: array(record(string$1(), unknown())).default([]),
-        publicUrl: string$1().optional().nullable(),
-        keyStore: unknown().optional().nullable(),
-        storage: unknown().optional().nullable(),
-        attachmentKeyValidator: unknown().optional().nullable(),
-        telemetry: unknown().optional().nullable(),
-        requestedCapabilities: array(string$1()).optional(),
-    })
-        .passthrough();
-
-    getLogger('naylence.fame.sentinel.load_balancing.composite_load_balancing_strategy');
-
-    getLogger('naylence.fame.sentinel.load_balancing.sticky_load_balancing_strategy');
-
-    getLogger('naylence.fame.node.response_context_manager');
-
-    getLogger('naylence.fame.node.streaming_response_handler');
-
-    getLogger('naylence.fame.node.channel_polling_manager');
-
-    getLogger('naylence.fame.node.rpc_server_handler');
-
-    getLogger('naylence.fame.node.rpc_client_manager');
-
-    getLogger('naylence.fame.node.envelope_listener_manager');
-
-    getLogger('naylence.fame.node.root_session_manager');
 
     /**
-     * Base factory for creating FameConnector instances from either ConnectorConfig or ConnectionGrant.
-     *
-     * Concrete implementations must define supported grant types and provide grant-to-connector
-     * conversion logic.
+     * Node event listener interface for clean, event-driven node lifecycle management.
      */
-    getLogger('naylence.fame.connector.connector_factory');
-
-    getLogger('naylence.fame.node.upstream_session_manager');
-
-    getLogger('naylence.fame.node.admission.noop_admission_client');
-    getLogger('naylence.fame.node.node');
-
-    getLogger('naylence.fame.sentinel.route_manager');
-
-    getLogger('naylence.fame.sentinel.router');
-
-    getLogger('naylence.fame.sentinel.capability_aware_routing_policy');
-
-    getLogger('naylence.fame.sentinel.node_attach_frame_handler');
-    new Set([
-        DeliveryOriginType.DOWNSTREAM,
-        DeliveryOriginType.PEER,
-    ]);
-
-    getLogger('naylence.fame.sentinel.address_bind_frame_handler');
-
-    getLogger('naylence.fame.sentinel.node_heartbeat_frame_handler');
-
-    getLogger('naylence.fame.sentinel.capability_frame_handler');
-
-    getLogger('naylence.fame.sentinel.credit_update_frame_handler');
-
-    getLogger('naylence.fame.sentinel.sentinel');
-
-    object({
-        directUrl: string$1().trim().min(1).optional().nullable(),
-        admission: unknown().optional().nullable(),
-    })
-        .passthrough();
-
-    object({
-        type: literal('Sentinel').default('Sentinel'),
-        routingPolicy: unknown().optional().nullable(),
-        loadBalancing: unknown().optional().nullable(),
-        stickiness: unknown().optional().nullable(),
-        peers: unknown().optional().nullable(),
-        maxAttachTtlSec: number().min(0).optional().nullable(),
-        bindingAckTimeoutMs: number().min(0).optional().nullable(),
-        attachTimeoutSec: number().min(0).optional().nullable(),
-        routeStore: unknown().optional().nullable(),
-    })
-        .passthrough();
-    getLogger('naylence.fame.connector.base_async_connector');
-    // Environment variables
-    const ENV_VAR_FAME_FLOW_CONTROL = 'FAME_FLOW_CONTROL';
-    typeof process !== 'undefined' && process?.env
-        ? process.env[ENV_VAR_FAME_FLOW_CONTROL] !== '0'
-        : true;
-
     /**
-     * WebSocket Connector Implementation
+     * Abstract base class providing default implementations for NodeEventListener.
      *
-     * A transport adapter that works with both Node.js and browser WebSocket APIs.
-     * Supports both native WebSocket clients and server-side WebSocket connections.
+     * This class provides a convenient base for implementing node event listeners
+     * where you only need to override specific lifecycle methods. All methods
+     * have sensible default implementations.
      */
-    getLogger('naylence.fame.connector.websocket_connector');
-
-    const RPC_REGISTRY = Symbol('naylence.rpc.registry');
-    function isPlainObject$2(value) {
-        return Boolean(value &&
-            typeof value === 'object' &&
-            Object.prototype.toString.call(value) === '[object Object]');
-    }
-    function getOrCreateRegistry(ctor) {
-        if (!ctor[RPC_REGISTRY]) {
-            const parentRegistry = ctor.__proto__?.[RPC_REGISTRY];
-            ctor[RPC_REGISTRY] = parentRegistry
-                ? new Map(parentRegistry)
-                : new Map();
+    class BaseNodeEventListener {
+        constructor(priority = 1000) {
+            this.priority = priority;
         }
-        return ctor[RPC_REGISTRY];
-    }
-    function normalizeParams(params) {
-        if (!params || typeof params !== 'object') {
-            return { positional: [], keyword: {} };
+        async onNodeStarted(_node) {
+            // Default implementation does nothing
         }
-        const positional = Array.isArray(params.args) ? [...params.args] : [];
-        const keyword = isPlainObject$2(params.kwargs) ? { ...params.kwargs } : {};
-        if (positional.length === 0 &&
-            Object.keys(keyword).length === 0 &&
-            isPlainObject$2(params)) {
-            return { positional: [], keyword: { ...params } };
+        async onWelcome(_welcomeFrame) {
+            // Default implementation does nothing
         }
-        return { positional, keyword };
-    }
-    class RpcMixin {
-        static get rpcRegistry() {
-            return getOrCreateRegistry(this);
+        async onHeartbeatReceived(_envelope) {
+            // Default implementation does nothing
         }
-        getRpcRegistry() {
-            return this.constructor.rpcRegistry;
+        async onHeartbeatSent(_node, _envelope) {
+            // Default implementation does nothing
         }
-        async handleRpcRequest(method, params) {
-            const registry = this.getRpcRegistry();
-            const entry = registry.get(method);
-            if (!entry) {
-                throw new Error(`Unknown RPC method: ${method}`);
-            }
+        async onNodeInitialized(_node) {
+            // Default implementation does nothing
+        }
+        async onNodeAttachToPeer(_node, _attachInfo, _connector) {
+            // Default implementation does nothing
+        }
+        async onNodeAttachToUpstream(_node, _attachInfo) {
+            // Default implementation does nothing
+        }
+        async onEnvelopeReceived(_node, envelope, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onDeliverLocal(_node, _address, envelope, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onDeliver(_node, envelope, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardUpstream(_node, envelope, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardToRoute(_node, _nextSegment, envelope, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardToPeer(_node, _peerSegment, envelope, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardUpstreamComplete(_node, envelope, _result, _error, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardToRouteComplete(_node, _nextSegment, envelope, _result, _error, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardToPeerComplete(_node, _peerSegment, envelope, _result, _error, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardToPeers(_node, envelope, _peers, _excludePeers, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onForwardToPeersComplete(_node, envelope, _peers, _excludePeers, _result, _error, _context) {
+            // Default implementation passes envelope through unchanged
+            return envelope;
+        }
+        async onChildAttach(_options) {
+            // Default implementation does nothing
+        }
+        async onEpochChange(_node, _epoch) {
+            // Default implementation does nothing
+        }
+        async onNodePreparingToStop(_node) {
+            // Default implementation does nothing
+        }
+        async onNodeStopped(_node) {
+            // Default implementation does nothing
+        }
+    }
+    var EncryptionStatus;
+    (function (EncryptionStatus) {
+        EncryptionStatus["OK"] = "OK";
+        EncryptionStatus["SKIPPED"] = "SKIPPED";
+        EncryptionStatus["QUEUED"] = "QUEUED";
+    })(EncryptionStatus || (EncryptionStatus = {}));
+
+    var CryptoLevel;
+    (function (CryptoLevel) {
+        CryptoLevel["PLAINTEXT"] = "plaintext";
+        CryptoLevel["CHANNEL"] = "channel";
+        CryptoLevel["SEALED"] = "sealed";
+    })(CryptoLevel || (CryptoLevel = {}));
+    ({
+        [CryptoLevel.PLAINTEXT]: 1,
+        [CryptoLevel.CHANNEL]: 2,
+        [CryptoLevel.SEALED]: 3,
+    });
+    var SecurityAction;
+    (function (SecurityAction) {
+        SecurityAction["ALLOW"] = "allow";
+        SecurityAction["REJECT"] = "reject";
+        SecurityAction["NACK"] = "nack";
+    })(SecurityAction || (SecurityAction = {}));
+    var SignaturePolicy;
+    (function (SignaturePolicy) {
+        SignaturePolicy["REQUIRED"] = "required";
+        SignaturePolicy["OPTIONAL"] = "optional";
+        SignaturePolicy["DISABLED"] = "disabled";
+        SignaturePolicy["FORBIDDEN"] = "forbidden";
+    })(SignaturePolicy || (SignaturePolicy = {}));
+    ({
+        plaintextViolationAction: SecurityAction.NACK,
+        channelViolationAction: SecurityAction.NACK,
+        sealedViolationAction: SecurityAction.NACK,
+    });
+    ({
+        minimumResponseLevel: CryptoLevel.CHANNEL});
+    ({
+        defaultLevel: CryptoLevel.CHANNEL});
+    ({
+        signaturePolicy: SignaturePolicy.OPTIONAL,
+        unsignedViolationAction: SecurityAction.ALLOW,
+        invalidSignatureAction: SecurityAction.REJECT,
+        missingKeyAction: SecurityAction.NACK,
+    });
+    ({
+        signingMaterial: SigningMaterial.RAW_KEY});
+    ({
+        minimumCryptoLevel: CryptoLevel.PLAINTEXT});
+
+    getLogger('naylence.fame.node.envelope_security_handler');
+
+    getLogger('naylence.fame.node.secure_channel_frame_handler');
+
+    const FameNodeAuthorizationContextSchema = AuthorizationContextSchema.and(object({
+        sub: string$1().optional(),
+        aud: string$1().optional(),
+        assignedPath: string$1().optional(),
+        acceptedCapabilities: array(string$1()).optional(),
+        acceptedLogicals: array(string$1()).optional(),
+        instanceId: string$1().optional(),
+        scopes: array(string$1()).optional(),
+        attachExpiresAt: date().optional(),
+    }));
+    FameDeliveryContextSchema.extend({
+        security: SecurityContextSchema.extend({
+            authorization: FameNodeAuthorizationContextSchema.optional(),
+        }).optional(),
+    });
+
+    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);
+        }
+    }
+
+    getLogger('naylence.fame.sentinel.load_balancing.composite_load_balancing_strategy');
+
+    getLogger('naylence.fame.sentinel.load_balancing.sticky_load_balancing_strategy');
+
+    getLogger('naylence.fame.sentinel.route_manager');
+
+    getLogger('naylence.fame.sentinel.router');
+
+    getLogger('naylence.fame.sentinel.capability_aware_routing_policy');
+
+    getLogger('naylence.fame.sentinel.node_attach_frame_handler');
+    new Set([
+        DeliveryOriginType.DOWNSTREAM,
+        DeliveryOriginType.PEER,
+    ]);
+
+    getLogger('naylence.fame.sentinel.address_bind_frame_handler');
+
+    getLogger('naylence.fame.sentinel.node_heartbeat_frame_handler');
+
+    getLogger('naylence.fame.sentinel.capability_frame_handler');
+
+    getLogger('naylence.fame.sentinel.credit_update_frame_handler');
+
+    getLogger('naylence.fame.sentinel.sentinel');
+
+    object({
+        directUrl: string$1().trim().min(1).optional().nullable(),
+        admission: unknown().optional().nullable(),
+    })
+        .passthrough();
+
+    object({
+        type: literal('Sentinel').default('Sentinel'),
+        routingPolicy: unknown().optional().nullable(),
+        loadBalancing: unknown().optional().nullable(),
+        stickiness: unknown().optional().nullable(),
+        peers: unknown().optional().nullable(),
+        maxAttachTtlSec: number().min(0).optional().nullable(),
+        bindingAckTimeoutMs: number().min(0).optional().nullable(),
+        attachTimeoutSec: number().min(0).optional().nullable(),
+        routeStore: unknown().optional().nullable(),
+    })
+        .passthrough();
+    getLogger('naylence.fame.connector.base_async_connector');
+    // Environment variables
+    const ENV_VAR_FAME_FLOW_CONTROL = 'FAME_FLOW_CONTROL';
+    typeof process !== 'undefined' && process?.env
+        ? process.env[ENV_VAR_FAME_FLOW_CONTROL] !== '0'
+        : true;
+
+    /**
+     * WebSocket Connector Implementation
+     *
+     * A transport adapter that works with both Node.js and browser WebSocket APIs.
+     * Supports both native WebSocket clients and server-side WebSocket connections.
+     */
+    getLogger('naylence.fame.connector.websocket_connector');
+
+    const RPC_REGISTRY = Symbol('naylence.rpc.registry');
+    function isPlainObject$1(value) {
+        return Boolean(value &&
+            typeof value === 'object' &&
+            Object.prototype.toString.call(value) === '[object Object]');
+    }
+    function getOrCreateRegistry(ctor) {
+        if (!ctor[RPC_REGISTRY]) {
+            const parentRegistry = ctor.__proto__?.[RPC_REGISTRY];
+            ctor[RPC_REGISTRY] = parentRegistry
+                ? new Map(parentRegistry)
+                : new Map();
+        }
+        return ctor[RPC_REGISTRY];
+    }
+    function normalizeParams(params) {
+        if (!params || typeof params !== 'object') {
+            return { positional: [], keyword: {} };
+        }
+        const positional = Array.isArray(params.args) ? [...params.args] : [];
+        const keyword = isPlainObject$1(params.kwargs) ? { ...params.kwargs } : {};
+        if (positional.length === 0 &&
+            Object.keys(keyword).length === 0 &&
+            isPlainObject$1(params)) {
+            return { positional: [], keyword: { ...params } };
+        }
+        return { positional, keyword };
+    }
+    class RpcMixin {
+        static get rpcRegistry() {
+            return getOrCreateRegistry(this);
+        }
+        getRpcRegistry() {
+            return this.constructor.rpcRegistry;
+        }
+        async handleRpcRequest(method, params) {
+            const registry = this.getRpcRegistry();
+            const entry = registry.get(method);
+            if (!entry) {
+                throw new Error(`Unknown RPC method: ${method}`);
+            }
             const handler = this[entry.propertyKey];
             if (typeof handler !== 'function') {
                 throw new TypeError(`RPC handler '${entry.propertyKey}' is not callable`);
@@ -23883,7 +24074,7 @@
             return { stream: false, args };
         }
         const last = args[args.length - 1];
-        if (isPlainObject$2(last) &&
+        if (isPlainObject$1(last) &&
             Object.prototype.hasOwnProperty.call(last, '_stream')) {
             const { _stream, ...rest } = last;
             const cleanedArgs = [...args.slice(0, -1)];
@@ -23893,7 +24084,7 @@
             return { stream: Boolean(_stream), args: cleanedArgs };
         }
         if (args.length === 1 &&
-            isPlainObject$2(args[0]) &&
+            isPlainObject$1(args[0]) &&
             Object.prototype.hasOwnProperty.call(args[0], '_stream')) {
             const { _stream, ...rest } = args[0];
             return {
@@ -23912,7 +24103,7 @@
                     return async (...rawArgs) => {
                         const { stream, args } = extractStreamFlag(rawArgs);
                         let params;
-                        if (args.length === 1 && isPlainObject$2(args[0])) {
+                        if (args.length === 1 && isPlainObject$1(args[0])) {
                             params = args[0];
                         }
                         else {
@@ -24201,23 +24392,198 @@
                     console.warn('[factory-manifest] skipped', spec, '— missing FACTORY_META or default export ctor');
                     return;
                 }
-                registry.registerFactory(meta.base, meta.key, Ctor);
+                registry.registerFactory(meta.base, meta.key, Ctor);
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                console.warn('[factory-manifest] skipped', spec, '-', reason);
+            }
+        }));
+    }
+    /**
+     * Register all default Naylence runtime factories into the supplied registry.
+     *
+     * @param registry Registry implementation to receive the default runtime factories.
+     */
+    async function registerRuntimeFactories(registry = ResourceFactoryRegistry) {
+        await registerDefaultFactories(registry);
+    }
+
+    const AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE = 'AuthInjectionStrategyFactory';
+    class AuthInjectionStrategyFactory extends AbstractResourceFactory {
+        static async createAuthInjectionStrategy(config, options = {}) {
+            if (config) {
+                const strategy = await createResource$1(AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE, config, options);
+                if (!strategy) {
+                    throw new Error('Failed to create auth injection strategy from configuration');
+                }
+                return strategy;
+            }
+            const strategy = await createDefaultResource(AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE, null, options);
+            if (!strategy) {
+                throw new Error('Failed to create default auth injection strategy');
+            }
+            return strategy;
+        }
+    }
+
+    getLogger('naylence.fame.security.keys.default_key_manager');
+
+    getLogger('naylence.fame.security.keys.noop_key_validator');
+
+    getLogger('naylence.fame.security.keys.key_management_handler');
+
+    getLogger('naylence.fame.security.keys.key_store');
+
+    utf8ToBytes('naylence-sealed-envelope');
+
+    getLogger('naylence.fame.security.policy.default_security_policy');
+
+    getLogger('naylence.fame.sentinel.key_correlation_map');
+
+    getLogger('naylence.fame.sentinel.key_frame_handler');
+    getLogger('naylence.fame.security.default_security_manager');
+
+    getLogger('naylence.fame.security.auth.jwt_token_issuer');
+
+    getLogger('naylence.fame.security.auth.jwt_token_verifier');
+
+    getLogger('naylence.fame.security.crypto.providers.default_crypto_provider');
+
+    typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
+    new TextEncoder();
+
+    getLogger('naylence.fame.security.node_security_profile_factory');
+
+    getLogger('naylence.fame.stickiness.simple_load_balancer_stickiness_manager');
+
+    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 reason = error instanceof Error ? error.message : String(error);
-                console.warn('[factory-manifest] skipped', spec, '-', reason);
+                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;
+        }
     }
-    /**
-     * Register all default Naylence runtime factories into the supplied registry.
-     *
-     * @param registry Registry implementation to receive the default runtime factories.
-     */
-    async function registerRuntimeFactories(registry = ResourceFactoryRegistry) {
-        await registerDefaultFactories(registry);
+
+    getLogger('naylence.fame.welcome.default_welcome_service');
+    const ENV_VAR_SHOW_ENVELOPES = 'FAME_SHOW_ENVELOPES';
+    typeof process !== 'undefined' && resolveShowEnvelopesFlag(process.env);
+    function toCamelAlias(snakeKey) {
+        return snakeKey
+            .toLowerCase()
+            .replace(/_([a-z])/g, (_match, char) => char.toUpperCase());
+    }
+    function readEnvValue(env, snakeKey) {
+        if (!env) {
+            return undefined;
+        }
+        if (env[snakeKey] !== undefined) {
+            return env[snakeKey];
+        }
+        const lowerKey = snakeKey.toLowerCase();
+        if (env[lowerKey] !== undefined) {
+            return env[lowerKey];
+        }
+        const camelKey = toCamelAlias(snakeKey);
+        if (env[camelKey] !== undefined) {
+            return env[camelKey];
+        }
+        const pascalKey = camelKey.length > 0
+            ? camelKey[0].toUpperCase() + camelKey.slice(1)
+            : camelKey;
+        if (pascalKey && env[pascalKey] !== undefined) {
+            return env[pascalKey];
+        }
+        return undefined;
     }
-    new TextEncoder();
+    function resolveShowEnvelopesFlag(env) {
+        const candidate = readEnvValue(env, ENV_VAR_SHOW_ENVELOPES);
+        if (typeof candidate !== 'string') {
+            return false;
+        }
+        return candidate.trim().toLowerCase() === 'true';
+    }
+
+    getLogger('naylence.fame.welcome.node_welcome_router');
 
     /**
      * Browser-friendly entry point for Naylence Runtime.
@@ -24266,99 +24632,6 @@
     };
     ensureRuntimePluginLoader();
 
-    /**
-     * Node event listener interface for clean, event-driven node lifecycle management.
-     */
-    /**
-     * Abstract base class providing default implementations for NodeEventListener.
-     *
-     * This class provides a convenient base for implementing node event listeners
-     * where you only need to override specific lifecycle methods. All methods
-     * have sensible default implementations.
-     */
-    class BaseNodeEventListener {
-        constructor(priority = 1000) {
-            this.priority = priority;
-        }
-        async onNodeStarted(_node) {
-            // Default implementation does nothing
-        }
-        async onWelcome(_welcomeFrame) {
-            // Default implementation does nothing
-        }
-        async onHeartbeatReceived(_envelope) {
-            // Default implementation does nothing
-        }
-        async onHeartbeatSent(_node, _envelope) {
-            // Default implementation does nothing
-        }
-        async onNodeInitialized(_node) {
-            // Default implementation does nothing
-        }
-        async onNodeAttachToPeer(_node, _attachInfo, _connector) {
-            // Default implementation does nothing
-        }
-        async onNodeAttachToUpstream(_node, _attachInfo) {
-            // Default implementation does nothing
-        }
-        async onEnvelopeReceived(_node, envelope, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onDeliverLocal(_node, _address, envelope, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onDeliver(_node, envelope, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardUpstream(_node, envelope, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardToRoute(_node, _nextSegment, envelope, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardToPeer(_node, _peerSegment, envelope, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardUpstreamComplete(_node, envelope, _result, _error, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardToRouteComplete(_node, _nextSegment, envelope, _result, _error, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardToPeerComplete(_node, _peerSegment, envelope, _result, _error, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardToPeers(_node, envelope, _peers, _excludePeers, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onForwardToPeersComplete(_node, envelope, _peers, _excludePeers, _result, _error, _context) {
-            // Default implementation passes envelope through unchanged
-            return envelope;
-        }
-        async onChildAttach(_options) {
-            // Default implementation does nothing
-        }
-        async onEpochChange(_node, _epoch) {
-            // Default implementation does nothing
-        }
-        async onNodePreparingToStop(_node) {
-            // Default implementation does nothing
-        }
-        async onNodeStopped(_node) {
-            // Default implementation does nothing
-        }
-    }
-
     const telemetryLogger = getLogger('naylence.fame.telemetry.base_trace_emitter');
     function logTelemetryFailure(event, error, context = {}) {
         telemetryLogger.warning(event, {
@@ -24672,31 +24945,13 @@
         default: NoopTraceEmitterFactory
     });
 
-    const AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE = 'AuthInjectionStrategyFactory';
-    class AuthInjectionStrategyFactory extends AbstractResourceFactory {
-        static async createAuthInjectionStrategy(config, options = {}) {
-            if (config) {
-                const strategy = await createResource$1(AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE, config, options);
-                if (!strategy) {
-                    throw new Error('Failed to create auth injection strategy from configuration');
-                }
-                return strategy;
-            }
-            const strategy = await createDefaultResource(AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE, null, options);
-            if (!strategy) {
-                throw new Error('Failed to create default auth injection strategy');
-            }
-            return strategy;
-        }
-    }
-
-    const logger$5 = getLogger('naylence.fame.telemetry.otel_setup');
+    const logger$2$1 = getLogger('naylence.fame.telemetry.otel_setup');
     let registeredOtel = null;
     async function setupOtel(options) {
         const normalized = normalizeSetupOtelOptions(options);
         try {
             if (registeredOtel) {
-                logger$5.debug('open_telemetry_reusing_provider', {
+                logger$2$1.debug('open_telemetry_reusing_provider', {
                     service_name: normalized.serviceName,
                 });
                 return registeredOtel.control;
@@ -24717,12 +24972,12 @@
             }
             if (currentProvider &&
                 currentProvider.constructor?.name === 'NodeTracerProvider') {
-                logger$5.debug('open_telemetry_existing_node_provider', {
+                logger$2$1.debug('open_telemetry_existing_node_provider', {
                     service_name: normalized.serviceName,
                 });
                 return null;
             }
-            logger$5.debug('open_telemetry_initializing', {
+            logger$2$1.debug('open_telemetry_initializing', {
                 service_name: normalized.serviceName,
                 endpoint: normalized.endpoint ?? null,
                 environment: normalized.environment ?? null,
@@ -24750,7 +25005,7 @@
                 spanProcessors: [spanProcessor],
             });
             provider.register();
-            logger$5.debug('open_telemetry_initialized', {
+            logger$2$1.debug('open_telemetry_initialized', {
                 service_name: normalized.serviceName,
                 exporter: exporter.constructor?.name ?? 'unknown_exporter',
             });
@@ -24760,7 +25015,7 @@
                         await provider.forceFlush();
                     }
                     catch (flushError) {
-                        logger$5.warning('open_telemetry_force_flush_failed', {
+                        logger$2$1.warning('open_telemetry_force_flush_failed', {
                             error: flushError instanceof Error
                                 ? flushError.message
                                 : String(flushError),
@@ -24772,7 +25027,7 @@
                         await provider.shutdown();
                     }
                     catch (shutdownError) {
-                        logger$5.warning('open_telemetry_shutdown_failed', {
+                        logger$2$1.warning('open_telemetry_shutdown_failed', {
                             error: shutdownError instanceof Error
                                 ? shutdownError.message
                                 : String(shutdownError),
@@ -24790,7 +25045,7 @@
             return control;
         }
         catch (error) {
-            logger$5.error('open_telemetry_not_available', {
+            logger$2$1.error('open_telemetry_not_available', {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error && error.stack ? error.stack : undefined,
             });
@@ -24896,7 +25151,7 @@
                     if (headers && Object.keys(headers).length > 0) {
                         exporterOptions.headers = headers;
                     }
-                    logger$5.debug('open_telemetry_using_otlp_http_exporter', {
+                    logger$2$1.debug('open_telemetry_using_otlp_http_exporter', {
                         endpoint,
                         headers_present: Boolean(headers && Object.keys(headers).length),
                     });
@@ -24904,17 +25159,17 @@
                 }
             }
             catch (error) {
-                logger$5.error('open_telemetry_exporter_not_available', {
+                logger$2$1.error('open_telemetry_exporter_not_available', {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
         }
-        logger$5.warning('open_telemetry_falling_back_to_console_exporter');
+        logger$2$1.warning('open_telemetry_falling_back_to_console_exporter');
         return new ConsoleSpanExporter();
     }
 
     let openTelemetryTraceEmitterModulePromise = null;
-    const logger$4 = getLogger('naylence.fame.telemetry.open_telemetry_trace_emitter_factory');
+    const logger$1$1 = getLogger('naylence.fame.telemetry.open_telemetry_trace_emitter_factory');
     function getOpenTelemetryTraceEmitterModule() {
         if (!openTelemetryTraceEmitterModulePromise) {
             openTelemetryTraceEmitterModulePromise = safeImport(() => Promise.resolve().then(function () { return openTelemetryTraceEmitter; }), '@opentelemetry/api', {
@@ -24946,7 +25201,7 @@
                     await AuthInjectionStrategyFactory.createAuthInjectionStrategy(normalized.auth);
                 try {
                     await authStrategy.apply(mergedHeaders);
-                    logger$4.info('trace_emitter_auth_applied', {
+                    logger$1$1.info('trace_emitter_auth_applied', {
                         service_name: normalized.serviceName,
                     });
                 }
@@ -24969,7 +25224,7 @@
                     sampler: normalized.sampler,
                     headers: Object.keys(mergedHeaders).length > 0 ? mergedHeaders : undefined,
                 });
-                logger$4.debug('trace_emitter_lifecycle_acquired', {
+                logger$1$1.debug('trace_emitter_lifecycle_acquired', {
                     service_name: normalized.serviceName,
                     lifecycle_available: Boolean(lifecycle),
                 });
@@ -25000,7 +25255,7 @@
             }
             try {
                 const emitter = new OpenTelemetryTraceEmitter(emitterOptions);
-                logger$4.debug('trace_emitter_created', {
+                logger$1$1.debug('trace_emitter_created', {
                     service_name: normalized.serviceName,
                     has_lifecycle: Boolean(lifecycle),
                     has_auth_strategy: Boolean(authStrategy),
@@ -25194,15 +25449,10 @@
         default: TraceEmitterProfileFactory
     });
 
-    getLogger('naylence.fame.security.auth.jwt_token_issuer');
-
-    getLogger('naylence.fame.security.auth.jwt_token_verifier');
-
-    getLogger('naylence.fame.security.crypto.providers.default_crypto_provider');
-
     let initialized = false;
     const runtimePlugin = {
         name: 'naylence:runtime',
+        version: VERSION$2,
         async register() {
             // console.log('[naylence:runtime] register() called, initialized=', initialized);
             if (initialized) {
@@ -25511,93 +25761,6 @@
         OpenTelemetryTraceEmitter: OpenTelemetryTraceEmitter
     });
 
-    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;