@naylence/runtime 0.3.5-test.931 → 0.3.5-test.934

package/dist/node/node.mjs

@@ -2115,6 +2115,10 @@ class BaseAsyncConnector extends TaskSpawner {
      * Stop the connector gracefully
      */
     async stop() {
+        logger$1f.debug('stopping_connector', {
+            current_state: this._state,
+            connector_id: this._connectorFlowId,
+        });
         if (!ConnectorStateUtils.canStop(this._state)) {
             logger$1f.debug('connector_stop_already_stopped', {
                 current_state: this._state,
@@ -2127,6 +2131,10 @@ class BaseAsyncConnector extends TaskSpawner {
         if (this._lastError) {
             throw this._lastError;
         }
+        logger$1f.debug('connector_stopped', {
+            current_state: this._state,
+            connector_id: this._connectorFlowId,
+        });
     }
     /**
      * Close the connector with optional code and reason
@@ -2457,8 +2465,21 @@ class BaseAsyncConnector extends TaskSpawner {
      */
     async _shutdown(code, reason, gracePeriod, exc) {
         if (this._closed) {
+            logger$1f.debug('shutdown_already_closed', {
+                connector_id: this._connectorFlowId,
+                current_state: this._state,
+            });
             return;
         }
+        logger$1f.info('connector_shutdown_starting', {
+            connector_id: this._connectorFlowId,
+            connector_type: this.constructor.name,
+            code,
+            reason,
+            current_state: this._state,
+            has_error: !!exc,
+            timestamp: new Date().toISOString(),
+        });
         this._closed = true;
         this._closeCode = code;
         this._closeReason = reason;
@@ -2480,16 +2501,39 @@ class BaseAsyncConnector extends TaskSpawner {
             this._sendPromiseResolve = undefined;
         }
         // Close transport
+        logger$1f.info('connector_closing_transport', {
+            connector_id: this._connectorFlowId,
+            connector_type: this.constructor.name,
+            timestamp: new Date().toISOString(),
+        });
         await this._transportClose(code, reason);
+        logger$1f.info('connector_transport_closed', {
+            connector_id: this._connectorFlowId,
+            connector_type: this.constructor.name,
+            timestamp: new Date().toISOString(),
+        });
         // Shutdown spawned tasks
+        logger$1f.info('connector_shutting_down_tasks', {
+            connector_id: this._connectorFlowId,
+            connector_type: this.constructor.name,
+            grace_period_ms: effectiveGracePeriod * 1000,
+            join_timeout_ms: this._shutdownJoinTimeout,
+            timestamp: new Date().toISOString(),
+        });
         try {
             await this.shutdownTasks({
                 gracePeriod: effectiveGracePeriod * 1000, // Convert to milliseconds
                 joinTimeout: this._shutdownJoinTimeout,
             });
+            logger$1f.info('connector_tasks_shutdown_complete', {
+                connector_id: this._connectorFlowId,
+                connector_type: this.constructor.name,
+                timestamp: new Date().toISOString(),
+            });
         }
         catch (error) {
             logger$1f.warning('task_shutdown_error', {
+                connector_id: this._connectorFlowId,
                 error: error instanceof Error ? error.message : String(error),
             });
         }
@@ -2501,6 +2545,12 @@ class BaseAsyncConnector extends TaskSpawner {
         if (this._closeResolver) {
             this._closeResolver();
         }
+        logger$1f.info('connector_shutdown_complete', {
+            connector_id: this._connectorFlowId,
+            connector_type: this.constructor.name,
+            final_state: this._state,
+            timestamp: new Date().toISOString(),
+        });
     }
     /**
      * Close the underlying transport
@@ -5385,12 +5435,12 @@ for (const [name, config] of Object.entries(SQLITE_PROFILES)) {
 }
 
 // This file is auto-generated during build - do not edit manually
-// Generated from package.json version: 0.3.5-test.931
+// Generated from package.json version: 0.3.5-test.934
 /**
  * The package version, injected at build time.
  * @internal
  */
-const VERSION = '0.3.5-test.931';
+const VERSION = '0.3.5-test.934';
 
 /**
  * Fame errors module - Fame protocol specific error classes
@@ -11430,6 +11480,7 @@ let BroadcastChannelConnector$2 = class BroadcastChannelConnector extends BaseAs
         this.ackDedupTtlMs = 30000;
         this.ackDedupMaxEntries = 4096;
         this.textDecoder = new TextDecoder();
+        this.visibilityChangeListenerRegistered = false;
         this.channelName =
             typeof config.channelName === 'string' && config.channelName.trim().length > 0
                 ? config.channelName.trim()
@@ -11442,12 +11493,22 @@ let BroadcastChannelConnector$2 = class BroadcastChannelConnector extends BaseAs
         this.inbox = new BoundedAsyncQueue(preferredCapacity);
         this.connectorId = BroadcastChannelConnector.generateConnectorId();
         this.channel = new BroadcastChannel(this.channelName);
-        logger$10.debug('broadcast_channel_connector_initialized', {
+        logger$10.info('broadcast_channel_connector_created', {
             channel: this.channelName,
             connector_id: this.connectorId,
             inbox_capacity: preferredCapacity,
+            timestamp: new Date().toISOString(),
         });
         this.onMsg = (event) => {
+            // Guard: Don't process if listener was unregistered
+            if (!this.listenerRegistered) {
+                logger$10.warning('broadcast_channel_message_after_unregister', {
+                    channel: this.channelName,
+                    connector_id: this.connectorId,
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
             const message = event.data;
             logger$10.debug('broadcast_channel_raw_event', {
                 channel: this.channelName,
@@ -11510,6 +11571,26 @@ let BroadcastChannelConnector$2 = class BroadcastChannelConnector extends BaseAs
         };
         this.channel.addEventListener('message', this.onMsg);
         this.listenerRegistered = true;
+        // Setup visibility change monitoring
+        this.visibilityChangeHandler = () => {
+            const isHidden = document.hidden;
+            logger$10.info('broadcast_channel_visibility_changed', {
+                channel: this.channelName,
+                connector_id: this.connectorId,
+                visibility: isHidden ? 'hidden' : 'visible',
+                timestamp: new Date().toISOString(),
+            });
+        };
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', this.visibilityChangeHandler);
+            this.visibilityChangeListenerRegistered = true;
+            // Log initial state
+            logger$10.info('broadcast_channel_initial_visibility', {
+                channel: this.channelName,
+                connector_id: this.connectorId,
+                visibility: document.hidden ? 'hidden' : 'visible',
+            });
+        }
     }
     async pushToReceive(rawOrEnvelope) {
         const item = this._normalizeInboxItem(rawOrEnvelope);
@@ -11554,11 +11635,44 @@ let BroadcastChannelConnector$2 = class BroadcastChannelConnector extends BaseAs
         return await this.inbox.dequeue();
     }
     async _transportClose(code, reason) {
+        logger$10.info('broadcast_channel_transport_closing', {
+            channel: this.channelName,
+            connector_id: this.connectorId,
+            code,
+            reason,
+            listener_registered: this.listenerRegistered,
+            timestamp: new Date().toISOString(),
+        });
         if (this.listenerRegistered) {
+            logger$10.info('broadcast_channel_removing_listener', {
+                channel: this.channelName,
+                connector_id: this.connectorId,
+                timestamp: new Date().toISOString(),
+            });
             this.channel.removeEventListener('message', this.onMsg);
             this.listenerRegistered = false;
+            logger$10.info('broadcast_channel_listener_removed', {
+                channel: this.channelName,
+                connector_id: this.connectorId,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        if (this.visibilityChangeListenerRegistered && this.visibilityChangeHandler && typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
+            this.visibilityChangeListenerRegistered = false;
+            this.visibilityChangeHandler = undefined;
         }
+        logger$10.info('broadcast_channel_closing', {
+            channel: this.channelName,
+            connector_id: this.connectorId,
+            timestamp: new Date().toISOString(),
+        });
         this.channel.close();
+        logger$10.info('broadcast_channel_closed', {
+            channel: this.channelName,
+            connector_id: this.connectorId,
+            timestamp: new Date().toISOString(),
+        });
         const closeCode = typeof code === 'number' ? code : 1000;
         const closeReason = typeof reason === 'string' && reason.length > 0 ? reason : 'closed';
         const shutdownError = new FameTransportClose(closeReason, closeCode);
@@ -12161,7 +12275,22 @@ class UpstreamSessionManager extends TaskSpawner {
             this.currentStopSubtasks = null;
             await Promise.allSettled(tasks.map((task) => task.promise));
             if (this.connector) {
-                await this.connector.stop().catch(() => undefined);
+                logger$$.info('upstream_stopping_old_connector', {
+                    connect_epoch: this.connectEpoch,
+                    target_system_id: this.targetSystemId,
+                    timestamp: new Date().toISOString(),
+                });
+                await this.connector.stop().catch((err) => {
+                    logger$$.warning('upstream_connector_stop_error', {
+                        connect_epoch: this.connectEpoch,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
+                logger$$.info('upstream_old_connector_stopped', {
+                    connect_epoch: this.connectEpoch,
+                    target_system_id: this.targetSystemId,
+                    timestamp: new Date().toISOString(),
+                });
                 this.connector = null;
             }
         }
@@ -14175,10 +14304,10 @@ class TraceEmitterFactory extends AbstractResourceFactory {
         return traceEmitter;
     }
 }
-// Ensure default factories are registered lazily to avoid circular ESM initialization issues
-void Promise.resolve().then(function () { return noopTraceEmitterFactory; });
-void Promise.resolve().then(function () { return openTelemetryTraceEmitterFactory; });
-void Promise.resolve().then(function () { return traceEmitterProfileFactory; });
+// // Ensure default factories are registered lazily to avoid circular ESM initialization issues
+// void import('./noop-trace-emitter-factory.js');
+// void import('./open-telemetry-trace-emitter-factory.js');
+// void import('./trace-emitter-profile-factory.js');
 
 const BINDING_STORE_NAMESPACE = '__binding_store';
 const logger$X = getLogger('naylence.fame.node.factory_commons');
@@ -34180,839 +34309,217 @@ async function main() {
     process.on('SIGTERM', () => shutdown('SIGTERM'));
 }
 
-const telemetryLogger = getLogger('naylence.fame.telemetry.base_trace_emitter');
-function logTelemetryFailure(event, error, context = {}) {
-    telemetryLogger.warning(event, {
-        ...context,
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error && error.stack ? error.stack : undefined,
-    });
-}
-function buildEnvelopeAttributes(envelope) {
-    return {
-        'env.id': envelope.id,
-        'env.trace_id': envelope.traceId,
-        'env.corr_id': envelope.corrId,
-        'env.flow_id': envelope.flowId,
-        'env.seq_id': envelope.seqId,
-        'env.to': envelope.to ?? null,
-        'env.priority': envelope.priority ?? null,
-        'env.sid': envelope.sid ?? null,
-        'env.reply_to': envelope.replyTo ?? null,
-        'env.ts': envelope.ts?.toISOString?.() ?? null,
-        'env.frame_type': envelope.frame
-            ? (envelope.frame.type ?? null)
-            : null,
-        'env.is_signed': Boolean(envelope.sec?.sig),
-        'env.sign_kid': envelope.sec?.sig?.kid ?? null,
-        'env.is_encrypted': Boolean(envelope.sec?.enc),
-        'env.enc_kid': envelope.sec?.enc?.kid ?? null,
-    };
+/**
+ * Base abstraction for message delivery policies.
+ */
+class DeliveryPolicy {
+    constructor(options = {}) {
+        this.senderPolicy = options.senderRetryPolicy;
+        this.receiverPolicy = options.receiverRetryPolicy;
+    }
+    /**
+     * Determine if the policy requires an acknowledgement for the envelope.
+     */
+    isAckRequired(_envelope) {
+        return false;
+    }
+    get senderRetryPolicy() {
+        return this.senderPolicy;
+    }
+    get receiverRetryPolicy() {
+        return this.receiverPolicy;
+    }
 }
-function filterAttributes(attributes) {
-    const filtered = {};
-    for (const [key, value] of Object.entries(attributes)) {
-        if (value !== undefined && value !== null) {
-            filtered[key] = value;
+
+/**
+ * Message delivery policy that ensures envelopes are delivered at least once.
+ */
+class AtLeastOnceDeliveryPolicy extends DeliveryPolicy {
+    constructor(options = {}) {
+        super(options);
+    }
+    isAckRequired(envelope) {
+        const frame = envelope?.frame;
+        const frameType = typeof frame?.type === 'string' ? frame.type : null;
+        if (!frameType) {
+            return false;
         }
+        return frameType === 'Data' || frameType === 'DataFrame';
     }
-    return filtered;
 }
-function extractContextValue(context, keys) {
-    if (!context) {
-        return undefined;
+
+/**
+ * Configuration and helper for retry backoff behaviour.
+ */
+class RetryPolicy {
+    constructor(options = {}) {
+        this.maxRetries = Math.max(0, Math.trunc(options.maxRetries ?? 0));
+        this.baseDelayMs = Math.max(0, Math.trunc(options.baseDelayMs ?? 200));
+        this.maxDelayMs = Math.max(this.baseDelayMs, Math.trunc(options.maxDelayMs ?? 10000));
+        this.jitterMs = Math.max(0, Math.trunc(options.jitterMs ?? 50));
+        this.backoffFactor = Math.max(0, options.backoffFactor ?? 2.0);
     }
-    const source = context;
-    for (const key of keys) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-            const value = source[key];
-            if (value !== undefined) {
-                return value;
-            }
-        }
+    /**
+     * Calculate the next retry delay based on attempt number (0-indexed).
+     */
+    nextDelayMs(attempt) {
+        const normalizedAttempt = Number.isFinite(attempt)
+            ? Math.max(0, Math.trunc(attempt))
+            : 0;
+        const base = normalizedAttempt <= 0
+            ? this.baseDelayMs
+            : Math.round(this.baseDelayMs * this.backoffFactor ** normalizedAttempt);
+        const jitter = this.jitterMs > 0
+            ? Math.round((Math.random() * 2 - 1) * this.jitterMs)
+            : 0;
+        const withJitter = base + jitter;
+        return Math.min(this.maxDelayMs, Math.max(0, withJitter));
     }
-    return undefined;
 }
-class BaseTraceEmitter extends BaseNodeEventListener {
+
+const LEGACY_POLICY_KEYS = {
+    senderRetryPolicy: ['sender_retry_policy', 'sender_retryPolicy'],
+    receiverRetryPolicy: ['receiver_retry_policy', 'receiver_retryPolicy'],
+};
+class AtLeastOnceDeliveryPolicyFactory extends DeliveryPolicyFactory {
     constructor() {
         super(...arguments);
-        this.node = null;
-        this.inflight = new Map();
-        this.priority = 10000;
+        this.type = 'AtLeastOnceDeliveryPolicy';
+        this.isDefault = true;
     }
-    getSpanKey(envelope, operationKey) {
-        return `${envelope.id}:${operationKey}`;
+    async create(config) {
+        const normalized = normalizeAtLeastOnceConfig(config);
+        const options = {
+            ...(normalized.senderRetryPolicy
+                ? { senderRetryPolicy: normalized.senderRetryPolicy }
+                : {}),
+            ...(normalized.receiverRetryPolicy
+                ? { receiverRetryPolicy: normalized.receiverRetryPolicy }
+                : {}),
+        };
+        return new AtLeastOnceDeliveryPolicy(options);
     }
-    startEnvelopeOperationSpan(node, operationName, envelope, operationKey, additionalAttributes = null) {
-        try {
-            const key = this.getSpanKey(envelope, operationKey);
-            const previous = this.inflight.get(key);
-            if (previous) {
-                this.inflight.delete(key);
-                try {
-                    previous.scope.exit();
-                }
-                catch (cleanupError) {
-                    logTelemetryFailure('trace_span_scope_exit_failed', cleanupError, {
-                        operation: operationName,
-                        span_key: key,
-                    });
-                }
-            }
-            const attributes = buildEnvelopeAttributes(envelope);
-            if (additionalAttributes) {
-                for (const [attrKey, attrValue] of Object.entries(additionalAttributes)) {
-                    attributes[attrKey] = attrValue;
-                }
-            }
-            const effectiveNode = node ?? this.node;
-            if (effectiveNode) {
-                attributes['node.id'] = effectiveNode.id;
-                attributes['node.sid'] = effectiveNode.sid ?? null;
-            }
-            const scope = this.startSpan(operationName, {
-                attributes: filterAttributes(attributes),
-            });
-            const span = scope.enter();
-            this.inflight.set(key, { scope, span });
-        }
-        catch (error) {
-            logTelemetryFailure('trace_span_start_failed', error, {
-                operation: operationName,
-                envelope_id: envelope.id,
-            });
-        }
-        return envelope;
+}
+function normalizeAtLeastOnceConfig(config) {
+    if (!config) {
+        return {};
     }
-    completeEnvelopeOperationSpan(node, operationName, envelope, operationKey, _result = null, error = null, additionalAttributes = null) {
-        try {
-            const key = this.getSpanKey(envelope, operationKey);
-            let active = this.inflight.get(key);
-            if (!active) {
-                const attributes = buildEnvelopeAttributes(envelope);
-                if (additionalAttributes) {
-                    for (const [attrKey, attrValue] of Object.entries(additionalAttributes)) {
-                        attributes[attrKey] = attrValue;
-                    }
-                }
-                const effectiveNode = node ?? this.node;
-                if (effectiveNode) {
-                    attributes['node.id'] = effectiveNode.id;
-                    attributes['node.sid'] = effectiveNode.sid ?? null;
-                }
-                const scope = this.startSpan(operationName, {
-                    attributes: filterAttributes(attributes),
-                });
-                const span = scope.enter();
-                active = { scope, span };
-            }
-            else {
-                this.inflight.delete(key);
-            }
-            if (error !== null && error !== undefined) {
-                try {
-                    active.span.recordException(error);
-                }
-                catch (recordError) {
-                    logTelemetryFailure('trace_span_record_exception_failed', recordError, {
-                        operation: operationName,
-                        envelope_id: envelope.id,
-                    });
-                }
-                try {
-                    const description = error instanceof Error ? error.message : String(error);
-                    active.span.setStatusError(description);
-                }
-                catch (statusError) {
-                    logTelemetryFailure('trace_span_set_status_failed', statusError, {
-                        operation: operationName,
-                        envelope_id: envelope.id,
-                    });
-                }
-            }
-            try {
-                active.scope.exit();
-            }
-            catch (exitError) {
-                logTelemetryFailure('trace_span_scope_exit_failed', exitError, {
-                    operation: operationName,
-                    envelope_id: envelope.id,
-                });
-            }
-        }
-        catch (error) {
-            logTelemetryFailure('trace_span_complete_failed', error, {
-                operation: operationName,
-                envelope_id: envelope.id,
-            });
-        }
-        return envelope;
+    const candidate = config;
+    const senderPolicyInput = getRetryPolicyInput(candidate, 'senderRetryPolicy');
+    const receiverPolicyInput = getRetryPolicyInput(candidate, 'receiverRetryPolicy');
+    return {
+        senderRetryPolicy: resolveRetryPolicy(senderPolicyInput),
+        receiverRetryPolicy: resolveRetryPolicy(receiverPolicyInput),
+    };
+}
+function getRetryPolicyInput(candidate, key) {
+    const camelKey = key;
+    const primary = candidate[camelKey];
+    if (primary !== undefined) {
+        return primary;
     }
-    async onEnvelopeReceived(node, envelope, context) {
-        try {
-            const attributes = buildEnvelopeAttributes(envelope);
-            attributes['node.id'] = node.id;
-            attributes['node.sid'] = node.sid ?? null;
-            const fromNodeId = extractContextValue(context, [
-                'fromSystemId',
-                'from_system_id',
-                'fromNodeId',
-                'from_node_id',
-            ]);
-            if (fromNodeId !== undefined && fromNodeId !== null) {
-                attributes['from.node_id'] = String(fromNodeId);
-            }
-            const originType = extractContextValue(context, [
-                'originType',
-                'origin_type',
-            ]);
-            if (originType !== undefined && originType !== null) {
-                attributes['from.origin_type'] = String(originType);
-            }
-            const scope = this.startSpan('env.received', {
-                attributes: filterAttributes(attributes),
-            });
-            scope.enter();
-            scope.exit();
-        }
-        catch (error) {
-            logTelemetryFailure('trace_span_received_failed', error, {
-                envelope_id: envelope.id,
-            });
+    const legacyKeys = LEGACY_POLICY_KEYS[key] ?? [];
+    for (const legacyKey of legacyKeys) {
+        const value = candidate[legacyKey];
+        if (value !== undefined) {
+            candidate[camelKey] = value;
+            return value;
         }
-        return envelope;
-    }
-    async onForwardToRoute(node, nextSegment, envelope, _context) {
-        return this.startEnvelopeOperationSpan(node, 'env.fwd_to_route', envelope, nextSegment, {
-            'route.segment': nextSegment,
-        });
-    }
-    async onForwardToRouteComplete(node, nextSegment, envelope, result, error, _context) {
-        return this.completeEnvelopeOperationSpan(node, 'env.fwd_to_route', envelope, nextSegment, result, error, {
-            'route.segment': nextSegment,
-        });
-    }
-    async onForwardUpstream(node, envelope, _context) {
-        return this.startEnvelopeOperationSpan(node, 'env.fwd_upstream', envelope, 'upstream', {
-            direction: 'upstream',
-        });
     }
-    async onForwardUpstreamComplete(node, envelope, result, error, _context) {
-        return this.completeEnvelopeOperationSpan(node, 'env.fwd_upstream', envelope, 'upstream', result, error, {
-            direction: 'upstream',
-        });
-    }
-    async onForwardToPeer(node, peerSegment, envelope, _context) {
-        return this.startEnvelopeOperationSpan(node, 'env.fwd_to_peer', envelope, peerSegment, {
-            'peer.segment': peerSegment,
-        });
-    }
-    async onForwardToPeerComplete(node, peerSegment, envelope, result, error, _context) {
-        return this.completeEnvelopeOperationSpan(node, 'env.fwd_to_peer', envelope, peerSegment, result, error, {
-            'peer.segment': peerSegment,
-        });
-    }
-    async onDeliverLocal(node, address, envelope, _context) {
-        const addressKey = address ? String(address) : 'unknown';
-        return this.startEnvelopeOperationSpan(node, 'env.deliver_local', envelope, addressKey, {
-            'delivery.address': addressKey,
-            'delivery.type': 'local',
-        });
-    }
-    async onDeliverLocalComplete(node, address, envelope, _context) {
-        const addressKey = address ? String(address) : 'unknown';
-        return this.completeEnvelopeOperationSpan(node, 'env.deliver_local', envelope, addressKey, null, null, {
-            'delivery.address': addressKey,
-            'delivery.type': 'local',
-        });
+    return undefined;
+}
+function resolveRetryPolicy(input) {
+    if (!input) {
+        return undefined;
     }
-    async onNodeInitialized(node) {
-        this.node = node;
+    if (input instanceof RetryPolicy) {
+        return input;
     }
-    async onNodeStopped(_node) {
-        try {
-            if (typeof this.flush === 'function') {
-                await this.flush();
+    const record = input;
+    const options = {
+        ...(withOption(record, ['maxRetries', 'max_retries']) ?? {}),
+        ...(withOption(record, ['baseDelayMs', 'base_delay_ms']) ?? {}),
+        ...(withOption(record, ['maxDelayMs', 'max_delay_ms']) ?? {}),
+        ...(withOption(record, ['jitterMs', 'jitter_ms']) ?? {}),
+        ...(withOption(record, ['backoffFactor', 'backoff_factor']) ?? {}),
+    };
+    return new RetryPolicy(options);
+}
+function extractNumber(source, keys) {
+    for (const key of keys) {
+        if (key in source) {
+            const value = source[key];
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                return value;
             }
-            if (typeof this.shutdown === 'function') {
-                await this.shutdown();
+            if (typeof value === 'string' && value.trim().length > 0) {
+                const parsed = Number(value);
+                if (!Number.isNaN(parsed)) {
+                    return parsed;
+                }
             }
         }
-        catch (error) {
-            logTelemetryFailure('trace_span_shutdown_failed', error);
-        }
-    }
-    async flush() {
-        // Default implementation: no-op
     }
-    async shutdown() {
-        // Default implementation: no-op
+    return undefined;
+}
+function withOption(source, keys) {
+    const value = extractNumber(source, keys);
+    if (value === undefined) {
+        return undefined;
     }
+    const camelKey = keys[0];
+    return {
+        [camelKey]: value,
+    };
 }
+const FACTORY_META$R = {
+    base: DELIVERY_POLICY_FACTORY_BASE_TYPE,
+    key: 'AtLeastOnceDeliveryPolicy',
+};
 
-class NoopTraceSpan {
-    setAttribute() { }
-    recordException() { }
-    setStatusError() { }
-}
-class NoopTraceSpanScope {
-    constructor(span) {
-        this.span = span;
-    }
-    enter() {
-        return this.span;
+var atLeastOnceDeliveryPolicyFactory = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AtLeastOnceDeliveryPolicyFactory: AtLeastOnceDeliveryPolicyFactory,
+    FACTORY_META: FACTORY_META$R,
+    default: AtLeastOnceDeliveryPolicyFactory
+});
+
+/**
+ * Message delivery policy that ensures envelopes are delivered at most once.
+ */
+class AtMostOnceDeliveryPolicy extends DeliveryPolicy {
+    constructor() {
+        super();
     }
-    exit() { }
-}
-class NoopTraceEmitter extends BaseTraceEmitter {
-    startSpan(_name, _options) {
-        void _options;
-        return new NoopTraceSpanScope(new NoopTraceSpan());
+    isAckRequired(_envelope) {
+        return false;
     }
 }
 
-const FACTORY_META$R = {
-    base: TRACE_EMITTER_FACTORY_BASE_TYPE,
-    key: 'NoopTraceEmitter',
-};
-class NoopTraceEmitterFactory extends TraceEmitterFactory {
+class AtMostOnceDeliveryPolicyFactory extends DeliveryPolicyFactory {
     constructor() {
         super(...arguments);
-        this.type = 'NoopTraceEmitter';
-        this.isDefault = true;
-        this.priority = 100;
+        this.type = 'AtMostOnceDeliveryPolicy';
     }
-    async create() {
-        return new NoopTraceEmitter();
+    async create(_config) {
+        return new AtMostOnceDeliveryPolicy();
     }
 }
+registerDeliveryPolicyFactory('AtMostOnceDeliveryPolicy', AtMostOnceDeliveryPolicyFactory);
+registerDeliveryPolicyFactory('AtMostOnceMessageDeliveryPolicy', AtMostOnceDeliveryPolicyFactory);
+const FACTORY_META$Q = {
+    base: DELIVERY_POLICY_FACTORY_BASE_TYPE,
+    key: 'AtMostOnceDeliveryPolicy',
+};
 
-var noopTraceEmitterFactory = /*#__PURE__*/Object.freeze({
+var atMostOnceDeliveryPolicyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$R,
-    NoopTraceEmitterFactory: NoopTraceEmitterFactory,
-    default: NoopTraceEmitterFactory
+    AtMostOnceDeliveryPolicyFactory: AtMostOnceDeliveryPolicyFactory,
+    FACTORY_META: FACTORY_META$Q,
+    default: AtMostOnceDeliveryPolicyFactory
 });
 
-let openTelemetryTraceEmitterModulePromise = null;
-let otelApiModulePromise = null;
-let otelSetupModulePromise = null;
-const logger$h = getLogger('naylence.fame.telemetry.open_telemetry_trace_emitter_factory');
-const MISSING_OTEL_HELP_MESSAGE = 'Missing optional OpenTelemetry dependency. Install @opentelemetry/api (and related packages) to enable trace emission.';
-function getOpenTelemetryTraceEmitterModule() {
-    if (!openTelemetryTraceEmitterModulePromise) {
-        openTelemetryTraceEmitterModulePromise = safeImport(() => Promise.resolve().then(function () { return openTelemetryTraceEmitter; }), '@opentelemetry/api', {
-            helpMessage: MISSING_OTEL_HELP_MESSAGE,
-        });
-    }
-    return openTelemetryTraceEmitterModulePromise;
-}
-function getOtelApiModule() {
-    if (!otelApiModulePromise) {
-        otelApiModulePromise = safeImport(() => import('@opentelemetry/api'), '@opentelemetry/api', {
-            helpMessage: MISSING_OTEL_HELP_MESSAGE,
-        });
-    }
-    return otelApiModulePromise;
-}
-function getOtelSetupModule() {
-    if (!otelSetupModulePromise) {
-        otelSetupModulePromise = safeImport(() => Promise.resolve().then(function () { return otelSetup; }), '@opentelemetry/api', {
-            helpMessage: MISSING_OTEL_HELP_MESSAGE,
-        });
-    }
-    return otelSetupModulePromise;
-}
-const FACTORY_META$Q = {
-    base: TRACE_EMITTER_FACTORY_BASE_TYPE,
-    key: 'OpenTelemetryTraceEmitter',
-};
-class OpenTelemetryTraceEmitterFactory extends TraceEmitterFactory {
-    constructor() {
-        super(...arguments);
-        this.type = 'OpenTelemetryTraceEmitter';
-    }
-    async create(config, ...factoryArgs) {
-        const options = (factoryArgs[0] ??
-            {});
-        const normalized = normalizeConfig$n(config);
-        const mergedHeaders = {
-            ...normalized.headers,
-            ...(options.headers ?? {}),
-        };
-        let authStrategy = null;
-        if (normalized.auth) {
-            authStrategy =
-                await AuthInjectionStrategyFactory.createAuthInjectionStrategy(normalized.auth);
-            try {
-                await authStrategy.apply(mergedHeaders);
-                logger$h.info('trace_emitter_auth_applied', {
-                    service_name: normalized.serviceName,
-                });
-            }
-            catch (error) {
-                try {
-                    await authStrategy.cleanup();
-                }
-                catch {
-                    // Ignore cleanup errors while propagating original failure
-                }
-                throw error;
-            }
-        }
-        let lifecycle = null;
-        try {
-            const { setupOtel } = await getOtelSetupModule();
-            lifecycle = await setupOtel({
-                serviceName: normalized.serviceName,
-                endpoint: normalized.endpoint,
-                environment: normalized.environment,
-                sampler: normalized.sampler,
-                headers: Object.keys(mergedHeaders).length > 0 ? mergedHeaders : undefined,
-            });
-            logger$h.debug('trace_emitter_lifecycle_acquired', {
-                service_name: normalized.serviceName,
-                lifecycle_available: Boolean(lifecycle),
-            });
-        }
-        catch (error) {
-            if (authStrategy) {
-                try {
-                    await authStrategy.cleanup();
-                }
-                catch {
-                    // Ignore cleanup errors while propagating original failure
-                }
-            }
-            throw error;
-        }
-        const [{ OpenTelemetryTraceEmitter }, otelModule] = await Promise.all([
-            getOpenTelemetryTraceEmitterModule(),
-            getOtelApiModule(),
-        ]);
-        const emitterOptions = {
-            serviceName: normalized.serviceName,
-            otelApi: {
-                trace: otelModule.trace,
-                SpanStatusCode: otelModule.SpanStatusCode,
-            },
-        };
-        if (options.tracer) {
-            emitterOptions.tracer = options.tracer;
-        }
-        if (lifecycle) {
-            emitterOptions.lifecycle = lifecycle;
-        }
-        if (authStrategy) {
-            emitterOptions.authStrategy = authStrategy;
-        }
-        try {
-            const emitter = new OpenTelemetryTraceEmitter(emitterOptions);
-            logger$h.debug('trace_emitter_created', {
-                service_name: normalized.serviceName,
-                has_lifecycle: Boolean(lifecycle),
-                has_auth_strategy: Boolean(authStrategy),
-            });
-            return emitter;
-        }
-        catch (error) {
-            if (authStrategy) {
-                try {
-                    await authStrategy.cleanup();
-                }
-                catch {
-                    // Best effort cleanup
-                }
-            }
-            throw error;
-        }
-    }
-}
-function normalizeConfig$n(config) {
-    if (!config) {
-        return {
-            serviceName: 'naylence-service',
-            endpoint: null,
-            environment: null,
-            sampler: null,
-            headers: {},
-            auth: null,
-        };
-    }
-    const candidate = config;
-    const serviceName = extractString(pickFirst$2(candidate, ['serviceName', 'service_name'])) ??
-        'naylence-service';
-    const endpoint = extractString(pickFirst$2(candidate, ['endpoint', 'otlpEndpoint', 'otlp_endpoint'])) ?? null;
-    const environment = extractString(pickFirst$2(candidate, [
-        'environment',
-        'deploymentEnvironment',
-        'deployment_environment',
-    ])) ?? null;
-    const sampler = extractString(pickFirst$2(candidate, ['sampler', 'samplingStrategy', 'sampling_strategy'])) ?? null;
-    const headersFromConfig = extractHeaders$1(pickFirst$2(candidate, ['headers', 'otlpHeaders', 'otlp_headers']));
-    const authConfig = pickFirst$2(candidate, [
-        'auth',
-    ]);
-    return {
-        serviceName,
-        endpoint,
-        environment,
-        sampler,
-        headers: headersFromConfig ?? {},
-        auth: authConfig ?? null,
-    };
-}
-function extractString(value) {
-    if (typeof value === 'string' && value.trim().length > 0) {
-        return value;
-    }
-    return undefined;
-}
-function pickFirst$2(source, keys) {
-    for (const key of keys) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-            const value = source[key];
-            if (value !== undefined) {
-                return value;
-            }
-        }
-    }
-    return undefined;
-}
-function extractHeaders$1(value) {
-    if (!value || typeof value !== 'object') {
-        return null;
-    }
-    const headers = {};
-    for (const [key, raw] of Object.entries(value)) {
-        if (typeof raw === 'string') {
-            headers[key] = raw;
-        }
-    }
-    return Object.keys(headers).length > 0 ? headers : null;
-}
-
-var openTelemetryTraceEmitterFactory = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    FACTORY_META: FACTORY_META$Q,
-    OpenTelemetryTraceEmitterFactory: OpenTelemetryTraceEmitterFactory,
-    default: OpenTelemetryTraceEmitterFactory
-});
-
-const logger$g = getLogger('naylence.fame.telemetry.trace_emitter_profile_factory');
-const PROFILE_NAME_NOOP$1 = 'noop';
-const PROFILE_NAME_OPEN_TELEMETRY = 'open-telemetry';
-const ENV_VAR_TELEMETRY_SERVICE_NAME = 'FAME_TELEMETRY_SERVICE_NAME';
-const NOOP_PROFILE$1 = {
-    type: 'NoopTraceEmitter',
-};
-const OPEN_TELEMETRY_PROFILE = {
-    type: 'OpenTelemetryTraceEmitter',
-    serviceName: Expressions.env(ENV_VAR_TELEMETRY_SERVICE_NAME, 'naylence-service'),
-    headers: {},
-};
-const PROFILE_MAP$3 = {
-    [PROFILE_NAME_NOOP$1]: NOOP_PROFILE$1,
-    [PROFILE_NAME_OPEN_TELEMETRY]: OPEN_TELEMETRY_PROFILE,
-};
-const FACTORY_META$P = {
-    base: TRACE_EMITTER_FACTORY_BASE_TYPE,
-    key: 'TraceEmitterProfile',
-};
-class TraceEmitterProfileFactory extends TraceEmitterFactory {
-    constructor() {
-        super(...arguments);
-        this.type = 'TraceEmitterProfile';
-    }
-    async create(config, ...factoryArgs) {
-        const normalized = normalizeTraceEmitterProfileConfig(config);
-        const profileConfig = resolveProfileConfig$2(normalized.profile);
-        logger$g.debug('enabling_trace_emitter_profile', {
-            profile: normalized.profile,
-        });
-        const traceEmitter = await TraceEmitterFactory.createTraceEmitter(profileConfig, {
-            factoryArgs,
-        });
-        if (!traceEmitter) {
-            throw new Error(`Failed to instantiate trace emitter profile: ${normalized.profile}`);
-        }
-        return traceEmitter;
-    }
-}
-function normalizeTraceEmitterProfileConfig(config) {
-    if (!config) {
-        return { profile: PROFILE_NAME_NOOP$1 };
-    }
-    const candidate = config;
-    const profileValue = resolveProfileName$1(candidate);
-    const canonicalProfile = canonicalizeProfileName(profileValue);
-    candidate.profile = canonicalProfile;
-    return { profile: canonicalProfile };
-}
-function resolveProfileName$1(candidate) {
-    const direct = coerceProfileString$1(candidate.profile);
-    if (direct) {
-        return direct;
-    }
-    const legacyKeys = ['profile_name', 'profileName'];
-    for (const legacyKey of legacyKeys) {
-        const legacyValue = coerceProfileString$1(candidate[legacyKey]);
-        if (legacyValue) {
-            return legacyValue;
-        }
-    }
-    return PROFILE_NAME_NOOP$1;
-}
-function coerceProfileString$1(value) {
-    if (typeof value !== 'string') {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-const PROFILE_ALIASES = {
-    noop: PROFILE_NAME_NOOP$1,
-    'no-op': PROFILE_NAME_NOOP$1,
-    no_op: PROFILE_NAME_NOOP$1,
-    'open-telemetry': PROFILE_NAME_OPEN_TELEMETRY,
-    open_telemetry: PROFILE_NAME_OPEN_TELEMETRY,
-    opentelemetry: PROFILE_NAME_OPEN_TELEMETRY,
-};
-function canonicalizeProfileName(value) {
-    const normalized = value.replace(/[\s_]+/g, '-').toLowerCase();
-    return PROFILE_ALIASES[normalized] ?? normalized;
-}
-function resolveProfileConfig$2(profileName) {
-    const profile = PROFILE_MAP$3[profileName];
-    if (!profile) {
-        throw new Error(`Unknown trace emitter profile: ${profileName}`);
-    }
-    return deepClone$2(profile);
-}
-function deepClone$2(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-
-var traceEmitterProfileFactory = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    FACTORY_META: FACTORY_META$P,
-    PROFILE_NAME_NOOP: PROFILE_NAME_NOOP$1,
-    PROFILE_NAME_OPEN_TELEMETRY: PROFILE_NAME_OPEN_TELEMETRY,
-    TraceEmitterProfileFactory: TraceEmitterProfileFactory,
-    default: TraceEmitterProfileFactory
-});
-
-/**
- * Base abstraction for message delivery policies.
- */
-class DeliveryPolicy {
-    constructor(options = {}) {
-        this.senderPolicy = options.senderRetryPolicy;
-        this.receiverPolicy = options.receiverRetryPolicy;
-    }
-    /**
-     * Determine if the policy requires an acknowledgement for the envelope.
-     */
-    isAckRequired(_envelope) {
-        return false;
-    }
-    get senderRetryPolicy() {
-        return this.senderPolicy;
-    }
-    get receiverRetryPolicy() {
-        return this.receiverPolicy;
-    }
-}
-
-/**
- * Message delivery policy that ensures envelopes are delivered at least once.
- */
-class AtLeastOnceDeliveryPolicy extends DeliveryPolicy {
-    constructor(options = {}) {
-        super(options);
-    }
-    isAckRequired(envelope) {
-        const frame = envelope?.frame;
-        const frameType = typeof frame?.type === 'string' ? frame.type : null;
-        if (!frameType) {
-            return false;
-        }
-        return frameType === 'Data' || frameType === 'DataFrame';
-    }
-}
-
-/**
- * Configuration and helper for retry backoff behaviour.
- */
-class RetryPolicy {
-    constructor(options = {}) {
-        this.maxRetries = Math.max(0, Math.trunc(options.maxRetries ?? 0));
-        this.baseDelayMs = Math.max(0, Math.trunc(options.baseDelayMs ?? 200));
-        this.maxDelayMs = Math.max(this.baseDelayMs, Math.trunc(options.maxDelayMs ?? 10000));
-        this.jitterMs = Math.max(0, Math.trunc(options.jitterMs ?? 50));
-        this.backoffFactor = Math.max(0, options.backoffFactor ?? 2.0);
-    }
-    /**
-     * Calculate the next retry delay based on attempt number (0-indexed).
-     */
-    nextDelayMs(attempt) {
-        const normalizedAttempt = Number.isFinite(attempt)
-            ? Math.max(0, Math.trunc(attempt))
-            : 0;
-        const base = normalizedAttempt <= 0
-            ? this.baseDelayMs
-            : Math.round(this.baseDelayMs * this.backoffFactor ** normalizedAttempt);
-        const jitter = this.jitterMs > 0
-            ? Math.round((Math.random() * 2 - 1) * this.jitterMs)
-            : 0;
-        const withJitter = base + jitter;
-        return Math.min(this.maxDelayMs, Math.max(0, withJitter));
-    }
-}
-
-const LEGACY_POLICY_KEYS = {
-    senderRetryPolicy: ['sender_retry_policy', 'sender_retryPolicy'],
-    receiverRetryPolicy: ['receiver_retry_policy', 'receiver_retryPolicy'],
-};
-class AtLeastOnceDeliveryPolicyFactory extends DeliveryPolicyFactory {
-    constructor() {
-        super(...arguments);
-        this.type = 'AtLeastOnceDeliveryPolicy';
-        this.isDefault = true;
-    }
-    async create(config) {
-        const normalized = normalizeAtLeastOnceConfig(config);
-        const options = {
-            ...(normalized.senderRetryPolicy
-                ? { senderRetryPolicy: normalized.senderRetryPolicy }
-                : {}),
-            ...(normalized.receiverRetryPolicy
-                ? { receiverRetryPolicy: normalized.receiverRetryPolicy }
-                : {}),
-        };
-        return new AtLeastOnceDeliveryPolicy(options);
-    }
-}
-function normalizeAtLeastOnceConfig(config) {
-    if (!config) {
-        return {};
-    }
-    const candidate = config;
-    const senderPolicyInput = getRetryPolicyInput(candidate, 'senderRetryPolicy');
-    const receiverPolicyInput = getRetryPolicyInput(candidate, 'receiverRetryPolicy');
-    return {
-        senderRetryPolicy: resolveRetryPolicy(senderPolicyInput),
-        receiverRetryPolicy: resolveRetryPolicy(receiverPolicyInput),
-    };
-}
-function getRetryPolicyInput(candidate, key) {
-    const camelKey = key;
-    const primary = candidate[camelKey];
-    if (primary !== undefined) {
-        return primary;
-    }
-    const legacyKeys = LEGACY_POLICY_KEYS[key] ?? [];
-    for (const legacyKey of legacyKeys) {
-        const value = candidate[legacyKey];
-        if (value !== undefined) {
-            candidate[camelKey] = value;
-            return value;
-        }
-    }
-    return undefined;
-}
-function resolveRetryPolicy(input) {
-    if (!input) {
-        return undefined;
-    }
-    if (input instanceof RetryPolicy) {
-        return input;
-    }
-    const record = input;
-    const options = {
-        ...(withOption(record, ['maxRetries', 'max_retries']) ?? {}),
-        ...(withOption(record, ['baseDelayMs', 'base_delay_ms']) ?? {}),
-        ...(withOption(record, ['maxDelayMs', 'max_delay_ms']) ?? {}),
-        ...(withOption(record, ['jitterMs', 'jitter_ms']) ?? {}),
-        ...(withOption(record, ['backoffFactor', 'backoff_factor']) ?? {}),
-    };
-    return new RetryPolicy(options);
-}
-function extractNumber(source, keys) {
-    for (const key of keys) {
-        if (key in source) {
-            const value = source[key];
-            if (typeof value === 'number' && Number.isFinite(value)) {
-                return value;
-            }
-            if (typeof value === 'string' && value.trim().length > 0) {
-                const parsed = Number(value);
-                if (!Number.isNaN(parsed)) {
-                    return parsed;
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function withOption(source, keys) {
-    const value = extractNumber(source, keys);
-    if (value === undefined) {
-        return undefined;
-    }
-    const camelKey = keys[0];
-    return {
-        [camelKey]: value,
-    };
-}
-const FACTORY_META$O = {
-    base: DELIVERY_POLICY_FACTORY_BASE_TYPE,
-    key: 'AtLeastOnceDeliveryPolicy',
-};
-
-var atLeastOnceDeliveryPolicyFactory = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AtLeastOnceDeliveryPolicyFactory: AtLeastOnceDeliveryPolicyFactory,
-    FACTORY_META: FACTORY_META$O,
-    default: AtLeastOnceDeliveryPolicyFactory
-});
-
-/**
- * Message delivery policy that ensures envelopes are delivered at most once.
- */
-class AtMostOnceDeliveryPolicy extends DeliveryPolicy {
-    constructor() {
-        super();
-    }
-    isAckRequired(_envelope) {
-        return false;
-    }
-}
-
-class AtMostOnceDeliveryPolicyFactory extends DeliveryPolicyFactory {
-    constructor() {
-        super(...arguments);
-        this.type = 'AtMostOnceDeliveryPolicy';
-    }
-    async create(_config) {
-        return new AtMostOnceDeliveryPolicy();
-    }
-}
-registerDeliveryPolicyFactory('AtMostOnceDeliveryPolicy', AtMostOnceDeliveryPolicyFactory);
-registerDeliveryPolicyFactory('AtMostOnceMessageDeliveryPolicy', AtMostOnceDeliveryPolicyFactory);
-const FACTORY_META$N = {
-    base: DELIVERY_POLICY_FACTORY_BASE_TYPE,
-    key: 'AtMostOnceDeliveryPolicy',
-};
-
-var atMostOnceDeliveryPolicyFactory = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AtMostOnceDeliveryPolicyFactory: AtMostOnceDeliveryPolicyFactory,
-    FACTORY_META: FACTORY_META$N,
-    default: AtMostOnceDeliveryPolicyFactory
-});
-
-const logger$f = getLogger('naylence.fame.delivery.delivery_profile_factory');
+const logger$h = getLogger('naylence.fame.delivery.delivery_profile_factory');
 const PROFILE_NAME_AT_LEAST_ONCE = 'at-least-once';
 const PROFILE_NAME_AT_MOST_ONCE = 'at-most-once';
 const ENV_VAR_FAME_DELIVERY_MAX_RETRIES = 'FAME_DELIVERY_MAX_RETRIES';
@@ -35040,7 +34547,7 @@ const AT_LEAST_ONCE_PROFILE = {
 const AT_MOST_ONCE_PROFILE = {
     type: 'AtMostOnceDeliveryPolicy',
 };
-const PROFILE_MAP$2 = {
+const PROFILE_MAP$3 = {
     [PROFILE_NAME_AT_LEAST_ONCE]: AT_LEAST_ONCE_PROFILE,
     [PROFILE_NAME_AT_MOST_ONCE]: AT_MOST_ONCE_PROFILE,
 };
@@ -35051,8 +34558,8 @@ class DeliveryProfileFactory extends DeliveryPolicyFactory {
     }
     async create(config) {
         const normalized = normalizeDeliveryProfileConfig(config);
-        const profileConfig = resolveProfileConfig$1(normalized.profile);
-        logger$f.debug('enabling_delivery_profile', { profile: normalized.profile });
+        const profileConfig = resolveProfileConfig$2(normalized.profile);
+        logger$h.debug('enabling_delivery_profile', { profile: normalized.profile });
         const policy = await DeliveryPolicyFactory.createDeliveryPolicy(profileConfig);
         if (!policy) {
             throw new Error(`Failed to create delivery policy for profile: ${normalized.profile}`);
@@ -35065,18 +34572,18 @@ function normalizeDeliveryProfileConfig(config) {
         return { profile: PROFILE_NAME_AT_LEAST_ONCE };
     }
     const candidate = config;
-    const profileValue = resolveProfileName(candidate);
+    const profileValue = resolveProfileName$1(candidate);
     candidate.profile = profileValue;
     return { profile: profileValue.toLowerCase() };
 }
-function resolveProfileName(candidate) {
-    const value = coerceProfileString(candidate.profile);
+function resolveProfileName$1(candidate) {
+    const value = coerceProfileString$1(candidate.profile);
     if (value) {
         return value;
     }
     const legacyKeys = ['profile_name', 'profileName'];
     for (const legacyKey of legacyKeys) {
-        const legacyValue = coerceProfileString(candidate[legacyKey]);
+        const legacyValue = coerceProfileString$1(candidate[legacyKey]);
         if (legacyValue) {
             candidate.profile = legacyValue;
             return legacyValue;
@@ -35084,24 +34591,24 @@ function resolveProfileName(candidate) {
     }
     return PROFILE_NAME_AT_LEAST_ONCE;
 }
-function coerceProfileString(value) {
+function coerceProfileString$1(value) {
     if (typeof value !== 'string') {
         return null;
     }
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
-function resolveProfileConfig$1(profileName) {
-    const profile = PROFILE_MAP$2[profileName];
+function resolveProfileConfig$2(profileName) {
+    const profile = PROFILE_MAP$3[profileName];
     if (!profile) {
         throw new Error(`Unknown delivery profile: ${profileName}`);
     }
-    return deepClone$1(profile);
+    return deepClone$2(profile);
 }
-function deepClone$1(value) {
+function deepClone$2(value) {
     return JSON.parse(JSON.stringify(value));
 }
-const FACTORY_META$M = {
+const FACTORY_META$P = {
     base: DELIVERY_POLICY_FACTORY_BASE_TYPE,
     key: 'DeliveryProfile',
 };
@@ -35109,13 +34616,13 @@ const FACTORY_META$M = {
 var deliveryProfileFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DeliveryProfileFactory: DeliveryProfileFactory,
-    FACTORY_META: FACTORY_META$M,
+    FACTORY_META: FACTORY_META$P,
     PROFILE_NAME_AT_LEAST_ONCE: PROFILE_NAME_AT_LEAST_ONCE,
     PROFILE_NAME_AT_MOST_ONCE: PROFILE_NAME_AT_MOST_ONCE,
     default: DeliveryProfileFactory
 });
 
-const logger$e = getLogger('naylence.fame.node.admission.admission_profile_factory');
+const logger$g = getLogger('naylence.fame.node.admission.admission_profile_factory');
 const ENV_VAR_IS_ROOT = 'FAME_ROOT';
 const ENV_VAR_JWT_AUDIENCE = 'FAME_JWT_AUDIENCE';
 const ENV_VAR_ADMISSION_TOKEN_URL = 'FAME_ADMISSION_TOKEN_URL';
@@ -35139,7 +34646,7 @@ const PROFILE_NAME_DIRECT_HTTP = 'direct-http';
 const PROFILE_NAME_DIRECT_INPAGE = 'direct-inpage';
 const PROFILE_NAME_DIRECT_PKCE = 'direct-pkce';
 const PROFILE_NAME_OPEN = 'open';
-const PROFILE_NAME_NOOP = 'noop';
+const PROFILE_NAME_NOOP$1 = 'noop';
 const PROFILE_NAME_NONE = 'none';
 const PROFILE_NAME_DIRECT_INPAGE_ALIAS = 'direct_inpage';
 const PROFILE_NAME_DIRECT_PKCE_ALIAS = 'direct_pkce';
@@ -35319,12 +34826,12 @@ const OPEN_PROFILE = {
         },
     ],
 };
-const NOOP_PROFILE = {
+const NOOP_PROFILE$1 = {
     type: 'NoopAdmissionClient',
     auto_accept_logicals: true,
     autoAcceptLogicals: true,
 };
-const PROFILE_MAP$1 = {
+const PROFILE_MAP$2 = {
     [PROFILE_NAME_WELCOME]: WELCOME_SERVICE_PROFILE,
     [PROFILE_NAME_WELCOME_PKCE]: WELCOME_SERVICE_PKCE_PROFILE,
     [PROFILE_NAME_WELCOME_PKCE_ALIAS]: WELCOME_SERVICE_PKCE_PROFILE,
@@ -35335,10 +34842,10 @@ const PROFILE_MAP$1 = {
     [PROFILE_NAME_DIRECT_INPAGE]: DIRECT_INPAGE_PROFILE,
     [PROFILE_NAME_DIRECT_INPAGE_ALIAS]: DIRECT_INPAGE_PROFILE,
     [PROFILE_NAME_OPEN]: OPEN_PROFILE,
-    [PROFILE_NAME_NOOP]: NOOP_PROFILE,
-    [PROFILE_NAME_NONE]: NOOP_PROFILE,
+    [PROFILE_NAME_NOOP$1]: NOOP_PROFILE$1,
+    [PROFILE_NAME_NONE]: NOOP_PROFILE$1,
 };
-const FACTORY_META$L = {
+const FACTORY_META$O = {
     base: ADMISSION_CLIENT_FACTORY_BASE_TYPE,
     key: 'AdmissionProfile',
 };
@@ -35348,13 +34855,13 @@ class AdmissionProfileFactory extends AdmissionClientFactory {
         this.type = 'AdmissionProfile';
     }
     async create(config) {
-        const normalized = normalizeConfig$m(config);
-        const profileConfig = resolveProfileConfig(normalized.profile);
-        logger$e.debug('enabling_admission_profile', { profile: normalized.profile });
+        const normalized = normalizeConfig$n(config);
+        const profileConfig = resolveProfileConfig$1(normalized.profile);
+        logger$g.debug('enabling_admission_profile', { profile: normalized.profile });
         return AdmissionClientFactory.createAdmissionClient(profileConfig);
     }
 }
-function normalizeConfig$m(config) {
+function normalizeConfig$n(config) {
     if (!config) {
         return { profile: PROFILE_NAME_DIRECT };
     }
@@ -35371,25 +34878,25 @@ function normalizeConfig$m(config) {
     const normalizedProfile = profileValue.trim().toLowerCase();
     return { profile: normalizedProfile };
 }
-function resolveProfileConfig(profileName) {
-    const profile = PROFILE_MAP$1[profileName];
+function resolveProfileConfig$1(profileName) {
+    const profile = PROFILE_MAP$2[profileName];
     if (!profile) {
         throw new Error(`Unknown admission profile: ${profileName}`);
     }
-    return deepClone(profile);
+    return deepClone$1(profile);
 }
-function deepClone(value) {
+function deepClone$1(value) {
     return JSON.parse(JSON.stringify(value));
 }
 
 var admissionProfileFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     AdmissionProfileFactory: AdmissionProfileFactory,
-    FACTORY_META: FACTORY_META$L,
+    FACTORY_META: FACTORY_META$O,
     default: AdmissionProfileFactory
 });
 
-const logger$d = getLogger('naylence.fame.node.admission.direct_admission_client');
+const logger$f = getLogger('naylence.fame.node.admission.direct_admission_client');
 class DirectAdmissionClient {
     constructor(options) {
         this.hasUpstream = true;
@@ -35414,7 +34921,7 @@ class DirectAdmissionClient {
         }
     }
     async hello(systemId, instanceId, requestedLogicals) {
-        logger$d.debug('direct_admission_hello_start', {
+        logger$f.debug('direct_admission_hello_start', {
             providedSystemId: systemId,
             instanceId,
             requestedLogicals,
@@ -35422,7 +34929,7 @@ class DirectAdmissionClient {
         const effectiveSystemId = systemId && systemId.trim().length > 0
             ? systemId
             : await generateIdAsync({ mode: 'fingerprint' }).catch(async () => {
-                logger$d.debug('direct_admission_fingerprint_generation_failed', {
+                logger$f.debug('direct_admission_fingerprint_generation_failed', {
                     reason: 'falling back to random id',
                 });
                 return generateIdAsync({ mode: 'random' });
@@ -35444,7 +34951,7 @@ class DirectAdmissionClient {
         const envelope = createFameEnvelope({
             frame: welcomeFrame,
         });
-        logger$d.debug('direct_admission_hello_success', {
+        logger$f.debug('direct_admission_hello_success', {
             systemId: welcomeFrame.systemId,
             instanceId: welcomeFrame.instanceId,
             acceptedLogicals: welcomeFrame.acceptedLogicals,
@@ -35467,7 +34974,7 @@ function cloneGrant(grant) {
     return JSON.parse(JSON.stringify(grant));
 }
 
-const FACTORY_META$K = {
+const FACTORY_META$N = {
     base: ADMISSION_CLIENT_FACTORY_BASE_TYPE,
     key: 'DirectAdmissionClient',
 };
@@ -35480,7 +34987,7 @@ class DirectAdmissionClientFactory extends AdmissionClientFactory {
         if (!config) {
             throw new Error('DirectAdmissionClient configuration is required');
         }
-        const normalized = normalizeConfig$l(config);
+        const normalized = normalizeConfig$m(config);
         const evaluatedGrants = normalized.connectionGrants.map((grant) => {
             const evaluated = ConnectorFactory.evaluateGrant({
                 ...grant,
@@ -35493,7 +35000,7 @@ class DirectAdmissionClientFactory extends AdmissionClientFactory {
         });
     }
 }
-function normalizeConfig$l(config) {
+function normalizeConfig$m(config) {
     const source = config;
     const connectionGrantsRaw = source.connectionGrants ?? source.connection_grants;
     if (!Array.isArray(connectionGrantsRaw) || connectionGrantsRaw.length === 0) {
@@ -35519,11 +35026,11 @@ function normalizeConfig$l(config) {
 var directAdmissionClientFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DirectAdmissionClientFactory: DirectAdmissionClientFactory,
-    FACTORY_META: FACTORY_META$K,
+    FACTORY_META: FACTORY_META$N,
     default: DirectAdmissionClientFactory
 });
 
-const FACTORY_META$J = {
+const FACTORY_META$M = {
     base: ADMISSION_CLIENT_FACTORY_BASE_TYPE,
     key: 'NoopAdmissionClient',
 };
@@ -35535,11 +35042,11 @@ class NoopAdmissionClientFactory extends AdmissionClientFactory {
         this.priority = 0;
     }
     async create(config, ...factoryArgs) {
-        const resolved = normalizeConfig$k(config, factoryArgs);
+        const resolved = normalizeConfig$l(config, factoryArgs);
         return new NoopAdmissionClient(resolved);
     }
 }
-function normalizeConfig$k(config, factoryArgs) {
+function normalizeConfig$l(config, factoryArgs) {
     const fromArgs = factoryArgs[0] && typeof factoryArgs[0] === 'object'
         ? factoryArgs[0]
         : {};
@@ -35572,7 +35079,7 @@ function normalizeConfig$k(config, factoryArgs) {
 
 var noopAdmissionClientFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$J,
+    FACTORY_META: FACTORY_META$M,
     NoopAdmissionClientFactory: NoopAdmissionClientFactory,
     default: NoopAdmissionClientFactory
 });
@@ -35587,7 +35094,7 @@ class NoAuthInjectionStrategy {
     }
 }
 
-const FACTORY_META$I = {
+const FACTORY_META$L = {
     base: AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE,
     key: 'NoAuth',
 };
@@ -35597,11 +35104,11 @@ class NoAuthInjectionStrategyFactory extends AuthInjectionStrategyFactory {
         this.type = 'NoAuth';
     }
     async create(config) {
-        const preparedConfig = normalizeConfig$j(config);
+        const preparedConfig = normalizeConfig$k(config);
         return new NoAuthInjectionStrategy(preparedConfig);
     }
 }
-function normalizeConfig$j(config) {
+function normalizeConfig$k(config) {
     const defaultConfig = { type: 'NoAuth' };
     if (!config) {
         return defaultConfig;
@@ -35616,12 +35123,12 @@ function normalizeConfig$j(config) {
 
 var noAuthInjectionStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$I,
+    FACTORY_META: FACTORY_META$L,
     NoAuthInjectionStrategyFactory: NoAuthInjectionStrategyFactory,
     default: NoAuthInjectionStrategyFactory
 });
 
-const logger$c = getLogger('naylence.fame.node.admission.welcome_service_client');
+const logger$e = getLogger('naylence.fame.node.admission.welcome_service_client');
 class WelcomeServiceClient {
     constructor(options) {
         this.hasUpstream = options.hasUpstream ?? options.has_upstream ?? false;
@@ -35670,7 +35177,7 @@ class WelcomeServiceClient {
                 'Content-Type': 'application/json',
                 ...authHeaders,
             };
-            logger$c.debug('welcome_service_hello_request', {
+            logger$e.debug('welcome_service_hello_request', {
                 url: this.url,
                 systemId,
                 instanceId,
@@ -35706,7 +35213,7 @@ class WelcomeServiceClient {
                 parsedEnvelope.frame.type !== 'NodeWelcome') {
                 throw new Error(`Unexpected frame type '${parsedEnvelope.frame?.type ?? 'unknown'}'`);
             }
-            logger$c.debug('welcome_service_hello_success', {
+            logger$e.debug('welcome_service_hello_success', {
                 systemId: parsedEnvelope.frame.systemId,
                 targetSystemId: parsedEnvelope.frame.targetSystemId,
                 assignedPath: parsedEnvelope.frame.assignedPath,
@@ -35765,7 +35272,7 @@ function convertKeysToCamelCase(value) {
     return result;
 }
 
-const FACTORY_META$H = {
+const FACTORY_META$K = {
     base: ADMISSION_CLIENT_FACTORY_BASE_TYPE,
     key: 'WelcomeServiceClient',
 };
@@ -35778,7 +35285,7 @@ class WelcomeServiceClientFactory extends AdmissionClientFactory {
         if (!config) {
             throw new Error('WelcomeServiceClient configuration is required');
         }
-        const normalized = normalizeConfig$i(config);
+        const normalized = normalizeConfig$j(config);
         const clientOptions = {
             hasUpstream: !normalized.isRoot,
             url: normalized.url,
@@ -35793,7 +35300,7 @@ class WelcomeServiceClientFactory extends AdmissionClientFactory {
         return new WelcomeServiceClient(clientOptions);
     }
 }
-function normalizeConfig$i(config) {
+function normalizeConfig$j(config) {
     const source = config;
     const urlCandidate = typeof source.url === 'string' ? source.url.trim() : '';
     if (!urlCandidate) {
@@ -35835,7 +35342,7 @@ async function createAuthStrategy(config) {
 
 var welcomeServiceClientFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$H,
+    FACTORY_META: FACTORY_META$K,
     WelcomeServiceClientFactory: WelcomeServiceClientFactory,
     default: WelcomeServiceClientFactory
 });
@@ -35911,7 +35418,7 @@ const staticNodePlacementConfigSchema = z
         .min(1, { message: 'targetPhysicalPath cannot be empty' }),
 })
     .passthrough();
-function normalizeConfig$h(config) {
+function normalizeConfig$i(config) {
     const candidate = {
         ...config,
     };
@@ -35946,14 +35453,14 @@ class StaticNodePlacementStrategyFactory extends NodePlacementStrategyFactory {
         if (!config) {
             throw new Error('StaticNodePlacementStrategy requires configuration');
         }
-        const normalized = normalizeConfig$h(config);
+        const normalized = normalizeConfig$i(config);
         return new StaticNodePlacementStrategy({
             targetSystemId: normalized.targetSystemId,
             targetPhysicalPath: normalized.targetPhysicalPath,
         });
     }
 }
-const FACTORY_META$G = {
+const FACTORY_META$J = {
     base: NODE_PLACEMENT_STRATEGY_FACTORY_BASE_TYPE,
     key: 'StaticNodePlacementStrategy',
 };
@@ -35963,7 +35470,7 @@ registerNodePlacementStrategyFactory('StaticNodePlacementStrategy', StaticNodePl
 
 var staticNodePlacementStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$G,
+    FACTORY_META: FACTORY_META$J,
     StaticNodePlacementStrategyFactory: StaticNodePlacementStrategyFactory,
     default: StaticNodePlacementStrategyFactory
 });
@@ -36122,7 +35629,7 @@ function connectorTypeName(connector) {
     return typeof connector;
 }
 
-const FACTORY_META$F = {
+const FACTORY_META$I = {
     base: AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE,
     key: 'BearerTokenHeaderAuth',
 };
@@ -36132,11 +35639,11 @@ class BearerTokenHeaderAuthInjectionStrategyFactory extends AuthInjectionStrateg
         this.type = 'BearerTokenHeaderAuth';
     }
     async create(config) {
-        const normalized = normalizeConfig$g(config);
+        const normalized = normalizeConfig$h(config);
         return new BearerTokenHeaderAuthInjectionStrategy(normalized);
     }
 }
-function normalizeConfig$g(config) {
+function normalizeConfig$h(config) {
     if (!config) {
         throw new Error('BearerTokenHeaderAuthInjectionStrategy requires configuration');
     }
@@ -36163,7 +35670,7 @@ function normalizeConfig$g(config) {
 var bearerTokenHeaderAuthInjectionStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BearerTokenHeaderAuthInjectionStrategyFactory: BearerTokenHeaderAuthInjectionStrategyFactory,
-    FACTORY_META: FACTORY_META$F,
+    FACTORY_META: FACTORY_META$I,
     default: BearerTokenHeaderAuthInjectionStrategyFactory
 });
 
@@ -36174,7 +35681,7 @@ async function getDefaultAuthorizerModule() {
     }
     return defaultAuthorizerModulePromise;
 }
-function normalizeConfig$f(config) {
+function normalizeConfig$g(config) {
     if (!config) {
         return {};
     }
@@ -36190,7 +35697,7 @@ function normalizeConfig$f(config) {
 function isTokenVerifier(candidate) {
     return Boolean(candidate && typeof candidate.verify === 'function');
 }
-const FACTORY_META$E = {
+const FACTORY_META$H = {
     base: AUTHORIZER_FACTORY_BASE_TYPE,
     key: 'DefaultAuthorizer',
 };
@@ -36202,7 +35709,7 @@ class DefaultAuthorizerFactory extends AuthorizerFactory {
     }
     async create(config, ...factoryArgs) {
         let tokenVerifier = factoryArgs.find(isTokenVerifier);
-        const normalized = normalizeConfig$f(config);
+        const normalized = normalizeConfig$g(config);
         if (!tokenVerifier) {
             if (!normalized.verifier) {
                 throw new Error('DefaultAuthorizer requires a verifier configuration or instance');
@@ -36220,7 +35727,7 @@ class DefaultAuthorizerFactory extends AuthorizerFactory {
 var defaultAuthorizerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DefaultAuthorizerFactory: DefaultAuthorizerFactory,
-    FACTORY_META: FACTORY_META$E,
+    FACTORY_META: FACTORY_META$H,
     default: DefaultAuthorizerFactory
 });
 
@@ -36231,7 +35738,7 @@ function getJwksJwtTokenVerifierModule() {
     }
     return jwksJwtTokenVerifierModulePromise;
 }
-const FACTORY_META$D = {
+const FACTORY_META$G = {
     base: TOKEN_VERIFIER_FACTORY_BASE_TYPE,
     key: 'JWKSJWTTokenVerifier',
 };
@@ -36244,7 +35751,7 @@ class JWKSTokenVerifierFactory extends TokenVerifierFactory {
         if (!config) {
             throw new Error('JWKSJWTTokenVerifier requires configuration');
         }
-        const normalized = normalizeConfig$e(config);
+        const normalized = normalizeConfig$f(config);
         const cacheTtlCandidate = validateCacheTtlSec(normalized.cacheTtlSec);
         const cacheTtlSec = typeof cacheTtlCandidate === 'number'
             ? cacheTtlCandidate
@@ -36258,7 +35765,7 @@ class JWKSTokenVerifierFactory extends TokenVerifierFactory {
         });
     }
 }
-function normalizeConfig$e(config) {
+function normalizeConfig$f(config) {
     const source = config;
     const issuer = typeof source.issuer === 'string' && source.issuer.trim().length > 0
         ? source.issuer
@@ -36293,12 +35800,12 @@ function normalizeConfig$e(config) {
 
 var jwksJwtTokenVerifierFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$D,
+    FACTORY_META: FACTORY_META$G,
     JWKSTokenVerifierFactory: JWKSTokenVerifierFactory,
     default: JWKSTokenVerifierFactory
 });
 
-const FACTORY_META$C = {
+const FACTORY_META$F = {
     base: TOKEN_ISSUER_FACTORY_BASE_TYPE,
     key: 'JWTTokenIssuer',
 };
@@ -36312,7 +35819,7 @@ class JWTTokenIssuerFactory extends TokenIssuerFactory {
         if (!config) {
             throw new Error('JWTTokenIssuerFactory requires configuration');
         }
-        const normalized = normalizeConfig$d(config);
+        const normalized = normalizeConfig$e(config);
         // Extract crypto provider from factory args
         let cryptoProvider1 = null;
         for (const arg of factoryArgs) {
@@ -36369,7 +35876,7 @@ function getJwtTokenIssuerModule() {
     }
     return jwtTokenIssuerModulePromise;
 }
-function normalizeConfig$d(config) {
+function normalizeConfig$e(config) {
     const source = config;
     const issuer = typeof source.issuer === 'string' && source.issuer.trim() !== ''
         ? source.issuer
@@ -36495,12 +36002,12 @@ function getProviderKeyId(provider) {
 
 var jwtTokenIssuerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$C,
+    FACTORY_META: FACTORY_META$F,
     JWTTokenIssuerFactory: JWTTokenIssuerFactory,
     default: JWTTokenIssuerFactory
 });
 
-const FACTORY_META$B = {
+const FACTORY_META$E = {
     base: TOKEN_VERIFIER_FACTORY_BASE_TYPE,
     key: 'JWTTokenVerifier',
 };
@@ -36514,7 +36021,7 @@ class JWTTokenVerifierFactory extends TokenVerifierFactory {
         if (!config) {
             throw new Error('JWTTokenVerifierFactory requires configuration');
         }
-        const normalized = normalizeConfig$c(config);
+        const normalized = normalizeConfig$d(config);
         const cryptoProvider1 = cryptoProvider ?? null;
         let verificationKey;
         if (normalized.hmacSecret !== undefined) {
@@ -36551,7 +36058,7 @@ function getJwtTokenVerifierModule() {
     }
     return jwtTokenVerifierModulePromise;
 }
-function normalizeConfig$c(config) {
+function normalizeConfig$d(config) {
     const source = config;
     const issuer = typeof source.issuer === 'string' && source.issuer.trim() !== ''
         ? source.issuer
@@ -36668,7 +36175,7 @@ function getProviderVerificationKey(provider) {
 
 var jwtTokenVerifierFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$B,
+    FACTORY_META: FACTORY_META$E,
     JWTTokenVerifierFactory: JWTTokenVerifierFactory,
     default: JWTTokenVerifierFactory
 });
@@ -36684,7 +36191,7 @@ class NoneTokenProvider {
     }
 }
 
-const FACTORY_META$A = {
+const FACTORY_META$D = {
     base: TOKEN_PROVIDER_FACTORY_BASE_TYPE,
     key: 'NoneTokenProvider',
 };
@@ -36701,7 +36208,7 @@ class NoneTokenProviderFactory extends TokenProviderFactory {
 
 var noneTokenProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$A,
+    FACTORY_META: FACTORY_META$D,
     NoneTokenProviderFactory: NoneTokenProviderFactory,
     default: NoneTokenProviderFactory
 });
@@ -36753,7 +36260,7 @@ class NoopAuthorizer {
     }
 }
 
-const FACTORY_META$z = {
+const FACTORY_META$C = {
     base: AUTHORIZER_FACTORY_BASE_TYPE,
     key: 'NoopAuthorizer',
 };
@@ -36769,7 +36276,7 @@ class NoopAuthorizerFactory extends AuthorizerFactory {
 
 var noopAuthorizerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$z,
+    FACTORY_META: FACTORY_META$C,
     NoopAuthorizerFactory: NoopAuthorizerFactory,
     default: NoopAuthorizerFactory
 });
@@ -36783,7 +36290,7 @@ class NoopTokenIssuer {
     }
 }
 
-const FACTORY_META$y = {
+const FACTORY_META$B = {
     base: TOKEN_ISSUER_FACTORY_BASE_TYPE,
     key: 'NoopTokenIssuer',
 };
@@ -36799,7 +36306,7 @@ class NoopTokenIssuerFactory extends TokenIssuerFactory {
 
 var noopTokenIssuerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$y,
+    FACTORY_META: FACTORY_META$B,
     NoopTokenIssuerFactory: NoopTokenIssuerFactory,
     default: NoopTokenIssuerFactory
 });
@@ -36821,7 +36328,7 @@ class NoopTokenVerifier {
     }
 }
 
-const FACTORY_META$x = {
+const FACTORY_META$A = {
     base: TOKEN_VERIFIER_FACTORY_BASE_TYPE,
     key: 'NoopTokenVerifier',
 };
@@ -36837,12 +36344,12 @@ class NoopTokenVerifierFactory extends TokenVerifierFactory {
 
 var noopTokenVerifierFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$x,
+    FACTORY_META: FACTORY_META$A,
     NoopTokenVerifierFactory: NoopTokenVerifierFactory,
     default: NoopTokenVerifierFactory
 });
 
-const logger$b = getLogger('naylence.fame.security.auth.oauth2_authorizer_factory');
+const logger$d = getLogger('naylence.fame.security.auth.oauth2_authorizer_factory');
 let oauth2AuthorizerModulePromise = null;
 function getOAuth2AuthorizerModule() {
     if (!oauth2AuthorizerModulePromise) {
@@ -36850,7 +36357,7 @@ function getOAuth2AuthorizerModule() {
     }
     return oauth2AuthorizerModulePromise;
 }
-const FACTORY_META$w = {
+const FACTORY_META$z = {
     base: AUTHORIZER_FACTORY_BASE_TYPE,
     key: 'OAuth2Authorizer',
 };
@@ -36863,18 +36370,18 @@ class OAuth2AuthorizerFactory extends AuthorizerFactory {
         if (!config) {
             throw new Error('OAuth2Authorizer requires configuration');
         }
-        const normalized = normalizeConfig$b(config);
+        const normalized = normalizeConfig$c(config);
         const tokenVerifier = await TokenVerifierFactory.createTokenVerifier(normalized.tokenVerifierConfig);
         let tokenIssuer;
         if (normalized.tokenIssuerConfig) {
             try {
                 tokenIssuer = await TokenIssuerFactory.createTokenIssuer(normalized.tokenIssuerConfig);
-                logger$b.debug('token_issuer_created_for_reverse_auth', {
+                logger$d.debug('token_issuer_created_for_reverse_auth', {
                     issuer_type: normalized.tokenIssuerConfig.type,
                 });
             }
             catch (error) {
-                logger$b.warning('failed_to_create_token_issuer_for_reverse_auth', {
+                logger$d.warning('failed_to_create_token_issuer_for_reverse_auth', {
                     error: error instanceof Error ? error.message : String(error),
                     issuer_config: normalized.tokenIssuerConfig,
                 });
@@ -36898,7 +36405,7 @@ class OAuth2AuthorizerFactory extends AuthorizerFactory {
         return new OAuth2Authorizer(authorizerOptions);
     }
 }
-function normalizeConfig$b(config) {
+function normalizeConfig$c(config) {
     const source = config;
     const issuer = typeof source.issuer === 'string' && source.issuer.trim().length > 0
         ? source.issuer.trim()
@@ -36995,7 +36502,7 @@ function normalizeTokenVerifierConfig({ config, issuer, jwksUrl, algorithm, }) {
 
 var oauth2AuthorizerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$w,
+    FACTORY_META: FACTORY_META$z,
     OAuth2AuthorizerFactory: OAuth2AuthorizerFactory,
     default: OAuth2AuthorizerFactory
 });
@@ -37007,7 +36514,7 @@ async function getOAuth2ClientCredentialsTokenProviderModule() {
     }
     return oauth2ClientCredentialsTokenProviderModulePromise;
 }
-function normalizeConfig$a(config) {
+function normalizeConfig$b(config) {
     if (!config) {
         throw new Error('OAuth2ClientCredentialsTokenProvider requires configuration');
     }
@@ -37035,7 +36542,7 @@ function normalizeConfig$a(config) {
     }
     return normalized;
 }
-const FACTORY_META$v = {
+const FACTORY_META$y = {
     base: TOKEN_PROVIDER_FACTORY_BASE_TYPE,
     key: 'OAuth2ClientCredentialsTokenProvider',
 };
@@ -37045,7 +36552,7 @@ class OAuth2ClientCredentialsTokenProviderFactory extends TokenProviderFactory {
         this.type = 'OAuth2ClientCredentialsTokenProvider';
     }
     async create(config) {
-        const normalized = normalizeConfig$a(config);
+        const normalized = normalizeConfig$b(config);
         const [clientIdProvider, clientSecretProvider] = await Promise.all([
             CredentialProviderFactory.createCredentialProvider(normalized.clientIdConfig),
             CredentialProviderFactory.createCredentialProvider(normalized.clientSecretConfig),
@@ -37066,7 +36573,7 @@ class OAuth2ClientCredentialsTokenProviderFactory extends TokenProviderFactory {
 
 var oauth2ClientCredentialsTokenProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$v,
+    FACTORY_META: FACTORY_META$y,
     OAuth2ClientCredentialsTokenProviderFactory: OAuth2ClientCredentialsTokenProviderFactory,
     default: OAuth2ClientCredentialsTokenProviderFactory
 });
@@ -37099,7 +36606,7 @@ function normalizeScopes$1(value) {
     }
     return [];
 }
-function normalizeConfig$9(config) {
+function normalizeConfig$a(config) {
     if (!config) {
         throw new Error('OAuth2PkceTokenProvider requires configuration');
     }
@@ -37148,7 +36655,7 @@ function normalizeConfig$9(config) {
     }
     return normalized;
 }
-const FACTORY_META$u = {
+const FACTORY_META$x = {
     base: TOKEN_PROVIDER_FACTORY_BASE_TYPE,
     key: 'OAuth2PkceTokenProvider',
 };
@@ -37158,7 +36665,7 @@ class OAuth2PkceTokenProviderFactory extends TokenProviderFactory {
         this.type = 'OAuth2PkceTokenProvider';
     }
     async create(config) {
-        const normalized = normalizeConfig$9(config);
+        const normalized = normalizeConfig$a(config);
         const [usernameProvider, clientSecretProvider] = await Promise.all([
             normalized.usernameConfig
                 ? CredentialProviderFactory.createCredentialProvider(normalized.usernameConfig)
@@ -37203,7 +36710,7 @@ class OAuth2PkceTokenProviderFactory extends TokenProviderFactory {
 
 var oauth2PkceTokenProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$u,
+    FACTORY_META: FACTORY_META$x,
     OAuth2PkceTokenProviderFactory: OAuth2PkceTokenProviderFactory,
     default: OAuth2PkceTokenProviderFactory
 });
@@ -37253,7 +36760,7 @@ class QueryParamAuthInjectionStrategy {
     }
 }
 
-const FACTORY_META$t = {
+const FACTORY_META$w = {
     base: AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE,
     key: 'QueryParamAuth',
 };
@@ -37263,11 +36770,11 @@ class QueryParamAuthInjectionStrategyFactory extends AuthInjectionStrategyFactor
         this.type = 'QueryParamAuth';
     }
     async create(config) {
-        const normalized = normalizeConfig$8(config);
+        const normalized = normalizeConfig$9(config);
         return new QueryParamAuthInjectionStrategy(normalized);
     }
 }
-function normalizeConfig$8(config) {
+function normalizeConfig$9(config) {
     if (!config) {
         throw new Error('QueryParamAuthInjectionStrategy requires configuration');
     }
@@ -37293,7 +36800,7 @@ function normalizeConfig$8(config) {
 
 var queryParamAuthInjectionStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$t,
+    FACTORY_META: FACTORY_META$w,
     QueryParamAuthInjectionStrategyFactory: QueryParamAuthInjectionStrategyFactory,
     default: QueryParamAuthInjectionStrategyFactory
 });
@@ -37305,7 +36812,7 @@ async function getSharedSecretAuthorizerModule() {
     }
     return sharedSecretAuthorizerModulePromise;
 }
-function normalizeConfig$7(config) {
+function normalizeConfig$8(config) {
     if (!config) {
         throw new Error('SharedSecretAuthorizer requires configuration');
     }
@@ -37329,7 +36836,7 @@ function normalizeConfig$7(config) {
         secretConfig: normalizeSecretSource(secretSource),
     };
 }
-const FACTORY_META$s = {
+const FACTORY_META$v = {
     base: AUTHORIZER_FACTORY_BASE_TYPE,
     key: 'SharedSecretAuthorizer',
 };
@@ -37339,7 +36846,7 @@ class SharedSecretAuthorizerFactory extends AuthorizerFactory {
         this.type = 'SharedSecretAuthorizer';
     }
     async create(config) {
-        const normalized = normalizeConfig$7(config);
+        const normalized = normalizeConfig$8(config);
         const credentialProvider = await CredentialProviderFactory.createCredentialProvider(normalized.secretConfig);
         const { SharedSecretAuthorizer } = await getSharedSecretAuthorizerModule();
         return new SharedSecretAuthorizer(credentialProvider);
@@ -37348,7 +36855,7 @@ class SharedSecretAuthorizerFactory extends AuthorizerFactory {
 
 var sharedSecretAuthorizerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$s,
+    FACTORY_META: FACTORY_META$v,
     SharedSecretAuthorizerFactory: SharedSecretAuthorizerFactory,
     default: SharedSecretAuthorizerFactory
 });
@@ -37360,7 +36867,7 @@ async function getSharedSecretTokenProviderModule() {
     }
     return sharedSecretTokenProviderModulePromise;
 }
-function normalizeConfig$6(config) {
+function normalizeConfig$7(config) {
     if (!config) {
         throw new Error('SharedSecretTokenProvider requires configuration');
     }
@@ -37384,7 +36891,7 @@ function normalizeConfig$6(config) {
         secretConfig: normalizeSecretSource(secretSource),
     };
 }
-const FACTORY_META$r = {
+const FACTORY_META$u = {
     base: TOKEN_PROVIDER_FACTORY_BASE_TYPE,
     key: 'SharedSecretTokenProvider',
 };
@@ -37394,7 +36901,7 @@ class SharedSecretTokenProviderFactory extends TokenProviderFactory {
         this.type = 'SharedSecretTokenProvider';
     }
     async create(config) {
-        const normalized = normalizeConfig$6(config);
+        const normalized = normalizeConfig$7(config);
         const credentialProvider = await CredentialProviderFactory.createCredentialProvider(normalized.secretConfig);
         const { SharedSecretTokenProvider } = await getSharedSecretTokenProviderModule();
         return new SharedSecretTokenProvider(credentialProvider);
@@ -37403,7 +36910,7 @@ class SharedSecretTokenProviderFactory extends TokenProviderFactory {
 
 var sharedSecretTokenProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$r,
+    FACTORY_META: FACTORY_META$u,
     SharedSecretTokenProviderFactory: SharedSecretTokenProviderFactory,
     default: SharedSecretTokenProviderFactory
 });
@@ -37415,7 +36922,7 @@ async function getSharedSecretTokenVerifierModule() {
     }
     return sharedSecretTokenVerifierModulePromise;
 }
-function normalizeConfig$5(config) {
+function normalizeConfig$6(config) {
     const candidate = (config ?? {});
     const record = candidate;
     let secretSource = candidate.secret;
@@ -37447,7 +36954,7 @@ function normalizeConfig$5(config) {
     }
     return normalized;
 }
-const FACTORY_META$q = {
+const FACTORY_META$t = {
     base: TOKEN_VERIFIER_FACTORY_BASE_TYPE,
     key: 'SharedSecretTokenVerifier',
 };
@@ -37457,7 +36964,7 @@ class SharedSecretTokenVerifierFactory extends TokenVerifierFactory {
         this.type = 'SharedSecretTokenVerifier';
     }
     async create(config) {
-        const normalized = normalizeConfig$5(config);
+        const normalized = normalizeConfig$6(config);
         const credentialProvider = (await CredentialProviderFactory.createCredentialProvider(normalized.secretConfig));
         const options = {
             credentialProvider,
@@ -37472,7 +36979,7 @@ class SharedSecretTokenVerifierFactory extends TokenVerifierFactory {
 
 var sharedSecretTokenVerifierFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$q,
+    FACTORY_META: FACTORY_META$t,
     SharedSecretTokenVerifierFactory: SharedSecretTokenVerifierFactory,
     default: SharedSecretTokenVerifierFactory
 });
@@ -37562,7 +37069,7 @@ function normalizeOptions$8(input) {
     };
 }
 
-function normalizeConfig$4(config) {
+function normalizeConfig$5(config) {
     if (!config) {
         throw new Error('StaticTokenProvider requires configuration');
     }
@@ -37587,7 +37094,7 @@ function normalizeConfig$4(config) {
     }
     return options;
 }
-const FACTORY_META$p = {
+const FACTORY_META$s = {
     base: TOKEN_PROVIDER_FACTORY_BASE_TYPE,
     key: 'StaticTokenProvider',
 };
@@ -37597,14 +37104,14 @@ class StaticTokenProviderFactory extends TokenProviderFactory {
         this.type = 'StaticTokenProvider';
     }
     async create(config) {
-        const options = normalizeConfig$4(config);
+        const options = normalizeConfig$5(config);
         return new StaticTokenProvider(options);
     }
 }
 
 var staticTokenProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$p,
+    FACTORY_META: FACTORY_META$s,
     StaticTokenProviderFactory: StaticTokenProviderFactory,
     default: StaticTokenProviderFactory
 });
@@ -37655,7 +37162,7 @@ class WebSocketSubprotocolAuthInjectionStrategy {
     }
 }
 
-const FACTORY_META$o = {
+const FACTORY_META$r = {
     base: AUTH_INJECTION_STRATEGY_FACTORY_BASE_TYPE,
     key: 'WebSocketSubprotocolAuth',
 };
@@ -37665,11 +37172,11 @@ class WebSocketSubprotocolAuthInjectionStrategyFactory extends AuthInjectionStra
         this.type = 'WebSocketSubprotocolAuth';
     }
     async create(config) {
-        const normalized = normalizeConfig$3(config);
+        const normalized = normalizeConfig$4(config);
         return new WebSocketSubprotocolAuthInjectionStrategy(normalized);
     }
 }
-function normalizeConfig$3(config) {
+function normalizeConfig$4(config) {
     if (!config) {
         throw new Error('WebSocketSubprotocolAuthInjectionStrategy requires configuration');
     }
@@ -37697,7 +37204,7 @@ function normalizeConfig$3(config) {
 
 var websocketSubprotocolAuthInjectionStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$o,
+    FACTORY_META: FACTORY_META$r,
     WebSocketSubprotocolAuthInjectionStrategyFactory: WebSocketSubprotocolAuthInjectionStrategyFactory,
     default: WebSocketSubprotocolAuthInjectionStrategyFactory
 });
@@ -37745,7 +37252,7 @@ class DevFixedKeyCredentialProviderFactory extends CredentialProviderFactory {
         throw new Error('DevFixedKeyCredentialProvider requires keyHex or keyBase64');
     }
 }
-const FACTORY_META$n = {
+const FACTORY_META$q = {
     base: CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE,
     key: 'DevFixedKeyCredentialProvider',
 };
@@ -37753,7 +37260,7 @@ const FACTORY_META$n = {
 var devFixedKeyCredentialProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DevFixedKeyCredentialProviderFactory: DevFixedKeyCredentialProviderFactory,
-    FACTORY_META: FACTORY_META$n,
+    FACTORY_META: FACTORY_META$q,
     default: DevFixedKeyCredentialProviderFactory,
     normalizeDevFixedConfig: normalizeDevFixedConfig
 });
@@ -37769,14 +37276,14 @@ class NoneCredentialProviderFactory extends CredentialProviderFactory {
         return new NoneCredentialProvider();
     }
 }
-const FACTORY_META$m = {
+const FACTORY_META$p = {
     base: CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE,
     key: 'NoneCredentialProvider',
 };
 
 var noneCredentialProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$m,
+    FACTORY_META: FACTORY_META$p,
     NoneCredentialProviderFactory: NoneCredentialProviderFactory,
     default: NoneCredentialProviderFactory
 });
@@ -37814,20 +37321,20 @@ class SessionKeyCredentialProviderFactory extends CredentialProviderFactory {
         return new SessionKeyCredentialProvider(resolved.length);
     }
 }
-const FACTORY_META$l = {
+const FACTORY_META$o = {
     base: CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE,
     key: 'SessionKeyCredentialProvider',
 };
 
 var sessionKeyCredentialProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$l,
+    FACTORY_META: FACTORY_META$o,
     SessionKeyCredentialProviderFactory: SessionKeyCredentialProviderFactory,
     default: SessionKeyCredentialProviderFactory,
     normalizeSessionKeyConfig: normalizeSessionKeyConfig
 });
 
-const logger$a = getLogger('naylence.fame.security.default_security_manager_factory');
+const logger$c = getLogger('naylence.fame.security.default_security_manager_factory');
 function normalizeDefaultSecurityManagerConfig(config) {
     if (!config) {
         return null;
@@ -37862,7 +37369,7 @@ function normalizeDefaultSecurityManagerConfig(config) {
     ensureAlias('trustStoreProvider', 'trust_store_provider');
     return normalized;
 }
-const FACTORY_META$k = {
+const FACTORY_META$n = {
     base: SECURITY_MANAGER_FACTORY_BASE_TYPE,
     key: 'DefaultSecurityManager',
 };
@@ -37995,7 +37502,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
             return await KeyStoreFactory.createKeyStore(value, createOptions ?? undefined);
         }
         catch (error) {
-            logger$a.error('failed_to_create_key_store_from_config', {
+            logger$c.error('failed_to_create_key_store_from_config', {
                 error: error instanceof Error ? error.message : String(error),
             });
             return null;
@@ -38031,7 +37538,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
                 return null;
             }
             const cryptoProvider = cryptoProviderOverride ?? null;
-            logger$a.debug('auto_create_envelope_signer', {
+            logger$c.debug('auto_create_envelope_signer', {
                 has_crypto_override: Boolean(cryptoProviderOverride),
                 override_constructor: cryptoProviderOverride
                     ? (cryptoProviderOverride.constructor?.name ?? 'unknown')
@@ -38052,7 +37559,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
             });
         }
         catch (error) {
-            logger$a.error('failed_to_auto_create_envelope_signer', {
+            logger$c.error('failed_to_auto_create_envelope_signer', {
                 error: error instanceof Error ? error.message : String(error),
                 exc_info: true,
             });
@@ -38087,7 +37594,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
             });
         }
         catch (error) {
-            logger$a.error('failed_to_auto_create_envelope_verifier', {
+            logger$c.error('failed_to_auto_create_envelope_verifier', {
                 error: error instanceof Error ? error.message : String(error),
                 exc_info: true,
             });
@@ -38099,7 +37606,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
         if (encryptionConfig &&
             DefaultSecurityManagerFactory.isConfigLike(encryptionConfig)) {
             if (!keyManager) {
-                logger$a.warning('encryption_manager_config_requires_key_manager');
+                logger$c.warning('encryption_manager_config_requires_key_manager');
                 return { encryptionManager: null, secureChannelManager };
             }
             const manager = await EncryptionManagerFactory.createEncryptionManager(encryptionConfig, {
@@ -38136,7 +37643,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
             return { encryptionManager: manager, secureChannelManager };
         }
         catch (error) {
-            logger$a.error('failed_to_auto_create_encryption_manager', {
+            logger$c.error('failed_to_auto_create_encryption_manager', {
                 error: error instanceof Error ? error.message : String(error),
                 exc_info: true,
             });
@@ -38179,7 +37686,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
             });
         }
         catch (error) {
-            logger$a.error('failed_to_auto_create_key_manager', {
+            logger$c.error('failed_to_auto_create_key_manager', {
                 error: error instanceof Error ? error.message : String(error),
                 exc_info: true,
             });
@@ -38228,7 +37735,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
             })) ?? null);
         }
         catch (error) {
-            logger$a.error('failed_to_auto_create_authorizer', {
+            logger$c.error('failed_to_auto_create_authorizer', {
                 error: error instanceof Error ? error.message : String(error),
                 exc_info: true,
             });
@@ -38257,7 +37764,7 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
             });
         }
         catch (error) {
-            logger$a.error('failed_to_auto_create_certificate_manager', {
+            logger$c.error('failed_to_auto_create_certificate_manager', {
                 error: error instanceof Error ? error.message : String(error),
                 exc_info: true,
             });
@@ -38328,11 +37835,11 @@ class DefaultSecurityManagerFactory extends SecurityManagerFactory {
 var defaultSecurityManagerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DefaultSecurityManagerFactory: DefaultSecurityManagerFactory,
-    FACTORY_META: FACTORY_META$k,
+    FACTORY_META: FACTORY_META$n,
     default: DefaultSecurityManagerFactory
 });
 
-const FACTORY_META$j = {
+const FACTORY_META$m = {
     base: ENCRYPTION_MANAGER_FACTORY_BASE_TYPE,
     key: 'NoopEncryptionManager',
 };
@@ -38389,7 +37896,7 @@ class NoopEncryptionManagerFactory extends EncryptionManagerFactory {
 
 var noopEncryptionManagerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$j,
+    FACTORY_META: FACTORY_META$m,
     NoopEncryptionManagerFactory: NoopEncryptionManagerFactory,
     default: NoopEncryptionManagerFactory
 });
@@ -38461,7 +37968,7 @@ class NoopSecureChannelManager {
     }
 }
 
-const FACTORY_META$i = {
+const FACTORY_META$l = {
     base: SECURE_CHANNEL_MANAGER_FACTORY_BASE_TYPE,
     key: 'NoopSecureChannelManager',
 };
@@ -38478,12 +37985,12 @@ class NoopSecureChannelManagerFactory extends SecureChannelManagerFactory {
 
 var noopSecureChannelManagerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$i,
+    FACTORY_META: FACTORY_META$l,
     NoopSecureChannelManagerFactory: NoopSecureChannelManagerFactory,
     default: NoopSecureChannelManagerFactory
 });
 
-const FACTORY_META$h = {
+const FACTORY_META$k = {
     base: KEY_MANAGER_FACTORY_BASE_TYPE,
     key: 'DefaultKeyManager',
 };
@@ -38512,11 +38019,11 @@ class DefaultKeyManagerFactory extends KeyManagerFactory {
 var defaultKeyManagerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DefaultKeyManagerFactory: DefaultKeyManagerFactory,
-    FACTORY_META: FACTORY_META$h,
+    FACTORY_META: FACTORY_META$k,
     default: DefaultKeyManagerFactory
 });
 
-const logger$9 = getLogger('naylence.fame.security.keys.in_memory_key_store');
+const logger$b = getLogger('naylence.fame.security.keys.in_memory_key_store');
 class InMemoryKeyStore extends KeyStore {
     constructor(initialKeys = null) {
         super();
@@ -38538,7 +38045,7 @@ class InMemoryKeyStore extends KeyStore {
         }
         catch (error) {
             if (error instanceof JWKValidationError) {
-                logger$9.warning('rejected_invalid_jwk_individual', {
+                logger$b.warning('rejected_invalid_jwk_individual', {
                     kid,
                     error: error.message,
                 });
@@ -38582,7 +38089,7 @@ class InMemoryKeyStore extends KeyStore {
                 }
             }
             if (staleKeys.length > 0) {
-                logger$9.debug('removing_stale_keys_before_adding_new_key', {
+                logger$b.debug('removing_stale_keys_before_adding_new_key', {
                     new_kid: kid,
                     physical_path: physicalPath,
                     base_path: basePath,
@@ -38610,7 +38117,7 @@ class InMemoryKeyStore extends KeyStore {
                 }
                 keysByPath[path].push(existingKid);
             }
-            logger$9.debug('key_lookup_failed', {
+            logger$b.debug('key_lookup_failed', {
                 missing_kid: kid,
                 available_kids: Array.from(this.keys.keys()),
                 keys_by_path: keysByPath,
@@ -38659,7 +38166,7 @@ class InMemoryKeyStore extends KeyStore {
             this.keys.delete(kid);
         }
         if (keysToRemove.length > 0) {
-            logger$9.debug('removed_keys_for_path', {
+            logger$b.debug('removed_keys_for_path', {
                 physical_path: physicalPath,
                 removed_key_ids: keysToRemove,
                 count: keysToRemove.length,
@@ -38670,7 +38177,7 @@ class InMemoryKeyStore extends KeyStore {
     async removeKey(kid) {
         const removed = this.keys.delete(kid);
         if (removed) {
-            logger$9.debug('removed_individual_key', { kid });
+            logger$b.debug('removed_individual_key', { kid });
         }
         return removed;
     }
@@ -38697,7 +38204,7 @@ class InMemoryKeyStore extends KeyStore {
 }
 registerDefaultKeyStoreFactory(() => new InMemoryKeyStore());
 
-const FACTORY_META$g = {
+const FACTORY_META$j = {
     base: KEY_STORE_FACTORY_BASE_TYPE,
     key: 'InMemoryKeyStore',
 };
@@ -38732,12 +38239,12 @@ class InMemoryKeyStoreFactory extends KeyStoreFactory {
 
 var inMemoryKeyStoreFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$g,
+    FACTORY_META: FACTORY_META$j,
     InMemoryKeyStoreFactory: InMemoryKeyStoreFactory,
     default: InMemoryKeyStoreFactory
 });
 
-const FACTORY_META$f = {
+const FACTORY_META$i = {
     base: ATTACHMENT_KEY_VALIDATOR_FACTORY_BASE_TYPE,
     key: 'NoopKeyValidator',
 };
@@ -38755,12 +38262,12 @@ class NoopKeyValidatorFactory extends AttachmentKeyValidatorFactory {
 
 var noopKeyValidatorFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$f,
+    FACTORY_META: FACTORY_META$i,
     NoopKeyValidatorFactory: NoopKeyValidatorFactory,
     default: NoopKeyValidatorFactory
 });
 
-const FACTORY_META$e = {
+const FACTORY_META$h = {
     base: SECURITY_POLICY_FACTORY_BASE_TYPE,
     key: 'DefaultSecurityPolicy',
 };
@@ -38778,7 +38285,7 @@ class DefaultSecurityPolicyFactory extends SecurityPolicyFactory {
      *   - factoryArgs[0]: KeyProvider | null (optional) - Key provider for key lookups
      */
     async create(config, ...factoryArgs) {
-        const prepared = normalizeConfig$2(config);
+        const prepared = normalizeConfig$3(config);
         const options = {};
         // Extract keyProvider from factoryArgs[0] (matches Python's key_provider kwarg)
         const keyProvider = factoryArgs[0];
@@ -38795,7 +38302,7 @@ class DefaultSecurityPolicyFactory extends SecurityPolicyFactory {
         return new DefaultSecurityPolicy(options);
     }
 }
-function normalizeConfig$2(config) {
+function normalizeConfig$3(config) {
     if (!config) {
         return { type: 'DefaultSecurityPolicy' };
     }
@@ -38821,11 +38328,11 @@ function normalizeConfig$2(config) {
 var defaultSecurityPolicyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DefaultSecurityPolicyFactory: DefaultSecurityPolicyFactory,
-    FACTORY_META: FACTORY_META$e,
+    FACTORY_META: FACTORY_META$h,
     default: DefaultSecurityPolicyFactory
 });
 
-const FACTORY_META$d = {
+const FACTORY_META$g = {
     base: SECURITY_POLICY_FACTORY_BASE_TYPE,
     key: 'NoSecurityPolicy',
 };
@@ -38835,11 +38342,11 @@ class NoSecurityPolicyFactory extends SecurityPolicyFactory {
         this.type = 'NoSecurityPolicy';
     }
     async create(config) {
-        void normalizeConfig$1(config);
+        void normalizeConfig$2(config);
         return new NoSecurityPolicy();
     }
 }
-function normalizeConfig$1(config) {
+function normalizeConfig$2(config) {
     if (!config) {
         return { type: 'NoSecurityPolicy' };
     }
@@ -38853,7 +38360,7 @@ function normalizeConfig$1(config) {
 
 var noSecurityPolicyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$d,
+    FACTORY_META: FACTORY_META$g,
     NoSecurityPolicyFactory: NoSecurityPolicyFactory,
     default: NoSecurityPolicyFactory
 });
@@ -38868,7 +38375,7 @@ async function getEdDSAEnvelopeSignerModule() {
     }
     return eddsaEnvelopeSignerModulePromise;
 }
-const FACTORY_META$c = {
+const FACTORY_META$f = {
     base: ENVELOPE_SIGNER_FACTORY_BASE_TYPE,
     key: 'EdDSAEnvelopeSigner',
 };
@@ -38897,7 +38404,7 @@ class EdDSAEnvelopeSignerFactory extends EnvelopeSignerFactory {
 var eddsaEnvelopeSignerFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     EdDSAEnvelopeSignerFactory: EdDSAEnvelopeSignerFactory,
-    FACTORY_META: FACTORY_META$c,
+    FACTORY_META: FACTORY_META$f,
     default: EdDSAEnvelopeSignerFactory
 });
 
@@ -38911,7 +38418,7 @@ async function getEdDSAEnvelopeVerifierModule() {
     }
     return eddsaEnvelopeVerifierModulePromise;
 }
-const FACTORY_META$b = {
+const FACTORY_META$e = {
     base: ENVELOPE_VERIFIER_FACTORY_BASE_TYPE,
     key: 'EdDSAEnvelopeVerifier',
 };
@@ -38937,11 +38444,11 @@ class EdDSAEnvelopeVerifierFactory extends EnvelopeVerifierFactory {
 var eddsaEnvelopeVerifierFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     EdDSAEnvelopeVerifierFactory: EdDSAEnvelopeVerifierFactory,
-    FACTORY_META: FACTORY_META$b,
+    FACTORY_META: FACTORY_META$e,
     default: EdDSAEnvelopeVerifierFactory
 });
 
-const FACTORY_META$a = {
+const FACTORY_META$d = {
     base: TRUST_STORE_PROVIDER_FACTORY_BASE_TYPE,
     key: "NoopTrustStoreProvider",
     isDefault: true,
@@ -38961,12 +38468,12 @@ class NoopTrustStoreProviderFactory extends TrustStoreProviderFactory {
 
 var noopTrustStoreProviderFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$a,
+    FACTORY_META: FACTORY_META$d,
     NoopTrustStoreProviderFactory: NoopTrustStoreProviderFactory,
     default: NoopTrustStoreProviderFactory
 });
 
-const FACTORY_META$9 = {
+const FACTORY_META$c = {
     base: ROUTING_POLICY_FACTORY_BASE,
     key: 'CapabilityAwareRoutingPolicy',
 };
@@ -39032,12 +38539,12 @@ class CapabilityAwareRoutingPolicyFactory extends RoutingPolicyFactory {
 var capabilityAwareRoutingPolicyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     CapabilityAwareRoutingPolicyFactory: CapabilityAwareRoutingPolicyFactory,
-    FACTORY_META: FACTORY_META$9,
+    FACTORY_META: FACTORY_META$c,
     default: CapabilityAwareRoutingPolicyFactory
 });
 
-const logger$8 = getLogger('naylence.fame.sentinel.composite_routing_policy_factory');
-const FACTORY_META$8 = {
+const logger$a = getLogger('naylence.fame.sentinel.composite_routing_policy_factory');
+const FACTORY_META$b = {
     base: ROUTING_POLICY_FACTORY_BASE,
     key: 'CompositeRoutingPolicy',
 };
@@ -39062,13 +38569,13 @@ class CompositeRoutingPolicyFactory extends RoutingPolicyFactory {
                     policies.push(policy);
                 }
                 else {
-                    logger$8.warning('composite_policy_null_child', {
+                    logger$a.warning('composite_policy_null_child', {
                         config: policyConfig,
                     });
                 }
             }
             catch (error) {
-                logger$8.warning('composite_policy_child_error', {
+                logger$a.warning('composite_policy_child_error', {
                     error: error instanceof Error ? error.message : String(error),
                     config: policyConfig,
                 });
@@ -39161,11 +38668,11 @@ function getFirstDefined(record, keys) {
 var compositeRoutingPolicyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     CompositeRoutingPolicyFactory: CompositeRoutingPolicyFactory,
-    FACTORY_META: FACTORY_META$8,
+    FACTORY_META: FACTORY_META$b,
     default: CompositeRoutingPolicyFactory
 });
 
-const FACTORY_META$7 = {
+const FACTORY_META$a = {
     base: ROUTING_POLICY_FACTORY_BASE,
     key: 'HybridPathRoutingPolicy',
 };
@@ -39227,12 +38734,12 @@ class HybridPathRoutingPolicyFactory extends RoutingPolicyFactory {
 
 var hybridPathRoutingPolicyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$7,
+    FACTORY_META: FACTORY_META$a,
     HybridPathRoutingPolicyFactory: HybridPathRoutingPolicyFactory,
     default: HybridPathRoutingPolicyFactory
 });
 
-const FACTORY_META$6 = {
+const FACTORY_META$9 = {
     base: LOAD_BALANCING_STRATEGY_FACTORY_BASE,
     key: 'CompositeLoadBalancingStrategy',
 };
@@ -39291,11 +38798,11 @@ class CompositeLoadBalancingStrategyFactory extends LoadBalancingStrategyFactory
 var compositeLoadBalancingStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     CompositeLoadBalancingStrategyFactory: CompositeLoadBalancingStrategyFactory,
-    FACTORY_META: FACTORY_META$6,
+    FACTORY_META: FACTORY_META$9,
     default: CompositeLoadBalancingStrategyFactory
 });
 
-const FACTORY_META$5 = {
+const FACTORY_META$8 = {
     base: LOAD_BALANCING_STRATEGY_FACTORY_BASE,
     key: 'HRWLoadBalancingStrategy',
 };
@@ -39358,13 +38865,13 @@ async function createDefaultHRWStrategy(config) {
 
 var hrwLoadBalancingStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$5,
+    FACTORY_META: FACTORY_META$8,
     HRWLoadBalancingStrategyFactory: HRWLoadBalancingStrategyFactory,
     createDefaultHRWStrategy: createDefaultHRWStrategy,
     default: HRWLoadBalancingStrategyFactory
 });
 
-const logger$7 = getLogger('naylence.fame.sentinel.load_balancing.load_balancing_profile_factory');
+const logger$9 = getLogger('naylence.fame.sentinel.load_balancing.load_balancing_profile_factory');
 const PROFILE_NAME_RANDOM = 'random';
 const PROFILE_NAME_ROUND_ROBIN = 'round_robin';
 const PROFILE_NAME_HRW = 'hrw';
@@ -39386,7 +38893,7 @@ const STICKY_HRW_PROFILE = {
 const DEVELOPMENT_PROFILE$1 = {
     type: 'RoundRobinLoadBalancingStrategy',
 };
-const FACTORY_META$4 = {
+const FACTORY_META$7 = {
     base: LOAD_BALANCING_STRATEGY_FACTORY_BASE,
     key: 'LoadBalancingProfile',
 };
@@ -39398,7 +38905,7 @@ class LoadBalancingProfileFactory extends LoadBalancingStrategyFactory {
     async create(config, ...factoryArgs) {
         const finalConfig = this.normalizeConfig(config);
         const profileName = finalConfig.profile ?? PROFILE_NAME_DEVELOPMENT$1;
-        logger$7.debug('enabling_load_balancing_profile', { profile: profileName });
+        logger$9.debug('enabling_load_balancing_profile', { profile: profileName });
         const strategyConfig = this.resolveProfile(profileName);
         const strategy = await createResource$1(LOAD_BALANCING_STRATEGY_FACTORY_BASE, strategyConfig, { factoryArgs });
         if (!strategy) {
@@ -39459,7 +38966,7 @@ class LoadBalancingProfileFactory extends LoadBalancingStrategyFactory {
 
 var loadBalancingProfileFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$4,
+    FACTORY_META: FACTORY_META$7,
     LoadBalancingProfileFactory: LoadBalancingProfileFactory,
     PROFILE_NAME_DEVELOPMENT: PROFILE_NAME_DEVELOPMENT$1,
     PROFILE_NAME_HRW: PROFILE_NAME_HRW,
@@ -39486,7 +38993,7 @@ class RandomLoadBalancingStrategy {
     }
 }
 
-const FACTORY_META$3 = {
+const FACTORY_META$6 = {
     base: LOAD_BALANCING_STRATEGY_FACTORY_BASE,
     key: 'RandomLoadBalancingStrategy',
 };
@@ -39502,7 +39009,7 @@ class RandomLoadBalancingStrategyFactory extends LoadBalancingStrategyFactory {
 
 var randomLoadBalancingStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$3,
+    FACTORY_META: FACTORY_META$6,
     RandomLoadBalancingStrategyFactory: RandomLoadBalancingStrategyFactory,
     default: RandomLoadBalancingStrategyFactory
 });
@@ -39522,7 +39029,7 @@ class RoundRobinLoadBalancingStrategy {
     }
 }
 
-const FACTORY_META$2 = {
+const FACTORY_META$5 = {
     base: LOAD_BALANCING_STRATEGY_FACTORY_BASE,
     key: 'RoundRobinLoadBalancingStrategy',
 };
@@ -39538,12 +39045,12 @@ class RoundRobinLoadBalancingStrategyFactory extends LoadBalancingStrategyFactor
 
 var roundRobinLoadBalancingStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$2,
+    FACTORY_META: FACTORY_META$5,
     RoundRobinLoadBalancingStrategyFactory: RoundRobinLoadBalancingStrategyFactory,
     default: RoundRobinLoadBalancingStrategyFactory
 });
 
-const FACTORY_META$1 = {
+const FACTORY_META$4 = {
     base: LOAD_BALANCING_STRATEGY_FACTORY_BASE,
     key: 'StickyLoadBalancingStrategy',
 };
@@ -39584,12 +39091,12 @@ class StickyLoadBalancingStrategyFactory extends LoadBalancingStrategyFactory {
 
 var stickyLoadBalancingStrategyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META$1,
+    FACTORY_META: FACTORY_META$4,
     StickyLoadBalancingStrategyFactory: StickyLoadBalancingStrategyFactory,
     default: StickyLoadBalancingStrategyFactory
 });
 
-const logger$6 = getLogger('naylence.fame.sentinel.routing_profile_factory');
+const logger$8 = getLogger('naylence.fame.sentinel.routing_profile_factory');
 const PROFILE_NAME_DEVELOPMENT = 'development';
 const PROFILE_NAME_PRODUCTION = 'production';
 const PROFILE_NAME_BASIC = 'basic';
@@ -39622,14 +39129,14 @@ const HYBRID_ONLY_PROFILE = {
     type: 'HybridPathRoutingPolicy',
     loadBalancingStrategy: { type: 'HRWLoadBalancingStrategy' },
 };
-const PROFILE_MAP = {
+const PROFILE_MAP$1 = {
     [PROFILE_NAME_DEVELOPMENT]: DEVELOPMENT_PROFILE,
     [PROFILE_NAME_PRODUCTION]: PRODUCTION_PROFILE,
     [PROFILE_NAME_BASIC]: BASIC_PROFILE,
     [PROFILE_NAME_CAPABILITY_AWARE]: CAPABILITY_AWARE_PROFILE,
     [PROFILE_NAME_HYBRID_ONLY]: HYBRID_ONLY_PROFILE,
 };
-const FACTORY_META = {
+const FACTORY_META$3 = {
     base: ROUTING_POLICY_FACTORY_BASE,
     key: 'RoutingProfile',
 };
@@ -39640,7 +39147,7 @@ class RoutingProfileFactory extends RoutingPolicyFactory {
     }
     async create(config, ...kwargs) {
         const normalized = this.normalizeConfig(config);
-        logger$6.debug('enabling_routing_profile', { profile: normalized.profile });
+        logger$8.debug('enabling_routing_profile', { profile: normalized.profile });
         const routingConfig = this.getProfileConfig(normalized.profile);
         const policy = await createResource$1(ROUTING_POLICY_FACTORY_BASE, routingConfig, {
             factoryArgs: kwargs,
@@ -39683,7 +39190,7 @@ class RoutingProfileFactory extends RoutingPolicyFactory {
         return undefined;
     }
     getProfileConfig(profile) {
-        const routingConfig = PROFILE_MAP[profile];
+        const routingConfig = PROFILE_MAP$1[profile];
         if (!routingConfig) {
             throw new Error('Unknown routing profile');
         }
@@ -39693,7 +39200,7 @@ class RoutingProfileFactory extends RoutingPolicyFactory {
 
 var routingProfileFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    FACTORY_META: FACTORY_META,
+    FACTORY_META: FACTORY_META$3,
     PROFILE_NAME_BASIC: PROFILE_NAME_BASIC,
     PROFILE_NAME_CAPABILITY_AWARE: PROFILE_NAME_CAPABILITY_AWARE,
     PROFILE_NAME_DEVELOPMENT: PROFILE_NAME_DEVELOPMENT,
@@ -39703,470 +39210,495 @@ var routingProfileFactory = /*#__PURE__*/Object.freeze({
     default: RoutingProfileFactory
 });
 
-let initialized = false;
-const runtimePlugin = {
-    name: 'naylence:runtime',
-    version: VERSION,
-    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
-});
-
-let currentTraceId = null;
-let currentSpanId = null;
-function getOtelTraceId() {
-    return currentTraceId;
-}
-function getOtelSpanId() {
-    return currentSpanId;
-}
-function setOtelTraceId(traceId) {
-    const previous = currentTraceId;
-    currentTraceId = traceId;
-    return previous;
-}
-function setOtelSpanId(spanId) {
-    const previous = currentSpanId;
-    currentSpanId = spanId;
-    return previous;
-}
-function resetOtelTraceId(previous) {
-    currentTraceId = previous;
+const telemetryLogger = getLogger('naylence.fame.telemetry.base_trace_emitter');
+function logTelemetryFailure(event, error, context = {}) {
+    telemetryLogger.warning(event, {
+        ...context,
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error && error.stack ? error.stack : undefined,
+    });
 }
-function resetOtelSpanId(previous) {
-    currentSpanId = previous;
+function buildEnvelopeAttributes(envelope) {
+    return {
+        'env.id': envelope.id,
+        'env.trace_id': envelope.traceId,
+        'env.corr_id': envelope.corrId,
+        'env.flow_id': envelope.flowId,
+        'env.seq_id': envelope.seqId,
+        'env.to': envelope.to ?? null,
+        'env.priority': envelope.priority ?? null,
+        'env.sid': envelope.sid ?? null,
+        'env.reply_to': envelope.replyTo ?? null,
+        'env.ts': envelope.ts?.toISOString?.() ?? null,
+        'env.frame_type': envelope.frame
+            ? (envelope.frame.type ?? null)
+            : null,
+        'env.is_signed': Boolean(envelope.sec?.sig),
+        'env.sign_kid': envelope.sec?.sig?.kid ?? null,
+        'env.is_encrypted': Boolean(envelope.sec?.enc),
+        'env.enc_kid': envelope.sec?.enc?.kid ?? null,
+    };
 }
-
-class OpenTelemetryTraceSpan {
-    constructor(span, api) {
-        this.span = span;
-        this.api = api;
-    }
-    setAttribute(key, value) {
-        try {
-            this.span.setAttribute(key, normalizeAttributeValue(value));
-        }
-        catch {
-            // Ignore telemetry attribute errors
+function filterAttributes(attributes) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        if (value !== undefined && value !== null) {
+            filtered[key] = value;
         }
     }
-    recordException(error) {
-        try {
-            if (error instanceof Error) {
-                this.span.recordException(error);
-            }
-            else {
-                this.span.recordException(new Error(String(error)));
-            }
-        }
-        catch {
-            // Ignore telemetry recording errors
-        }
+    return filtered;
+}
+function extractContextValue(context, keys) {
+    if (!context) {
+        return undefined;
     }
-    setStatusError(description) {
-        try {
-            const status = {
-                code: this.api.SpanStatusCode.ERROR,
-            };
-            if (description !== undefined) {
-                status.message = description;
+    const source = context;
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const value = source[key];
+            if (value !== undefined) {
+                return value;
             }
-            this.span.setStatus(status);
-        }
-        catch {
-            // Ignore telemetry status errors
         }
     }
+    return undefined;
 }
-class OpenTelemetrySpanScope {
-    constructor(span, api) {
-        this.span = span;
-        this.entered = false;
-        this.wrapper = new OpenTelemetryTraceSpan(span, api);
+class BaseTraceEmitter extends BaseNodeEventListener {
+    constructor() {
+        super(...arguments);
+        this.node = null;
+        this.inflight = new Map();
+        this.priority = 10000;
     }
-    enter() {
-        if (!this.entered) {
-            this.entered = true;
-            const spanContext = this.span.spanContext();
-            this.traceToken = setOtelTraceId(spanContext?.traceId ?? null);
-            this.spanToken = setOtelSpanId(spanContext?.spanId ?? null);
-        }
-        return this.wrapper;
+    getSpanKey(envelope, operationKey) {
+        return `${envelope.id}:${operationKey}`;
     }
-    exit() {
+    startEnvelopeOperationSpan(node, operationName, envelope, operationKey, additionalAttributes = null) {
         try {
-            this.span.end();
-        }
-        catch {
-            // Ignore span termination errors
-        }
-        finally {
-            if (this.traceToken !== undefined) {
-                resetOtelTraceId(this.traceToken);
-                this.traceToken = undefined;
+            const key = this.getSpanKey(envelope, operationKey);
+            const previous = this.inflight.get(key);
+            if (previous) {
+                this.inflight.delete(key);
+                try {
+                    previous.scope.exit();
+                }
+                catch (cleanupError) {
+                    logTelemetryFailure('trace_span_scope_exit_failed', cleanupError, {
+                        operation: operationName,
+                        span_key: key,
+                    });
+                }
             }
-            if (this.spanToken !== undefined) {
-                resetOtelSpanId(this.spanToken);
-                this.spanToken = undefined;
+            const attributes = buildEnvelopeAttributes(envelope);
+            if (additionalAttributes) {
+                for (const [attrKey, attrValue] of Object.entries(additionalAttributes)) {
+                    attributes[attrKey] = attrValue;
+                }
             }
+            const effectiveNode = node ?? this.node;
+            if (effectiveNode) {
+                attributes['node.id'] = effectiveNode.id;
+                attributes['node.sid'] = effectiveNode.sid ?? null;
+            }
+            const scope = this.startSpan(operationName, {
+                attributes: filterAttributes(attributes),
+            });
+            const span = scope.enter();
+            this.inflight.set(key, { scope, span });
         }
-    }
-}
-class OpenTelemetryTraceEmitter extends BaseTraceEmitter {
-    constructor(options) {
-        super();
-        this.shutdownInvoked = false;
-        const normalized = normalizeOpenTelemetryTraceEmitterOptions(options);
-        this.otelApi = normalized.otelApi;
-        this.tracer =
-            normalized.tracer ?? this.otelApi.trace.getTracer(normalized.serviceName);
-        this.lifecycle = normalized.lifecycle ?? null;
-        this.authStrategy = normalized.authStrategy ?? null;
-    }
-    startSpan(name, options) {
-        const attributes = normalizeAttributes(options?.attributes);
-        const spanOptions = {};
-        if (attributes) {
-            spanOptions.attributes = attributes;
-        }
-        if (options?.links) {
-            spanOptions.links = options.links;
-        }
-        const span = this.tracer.startSpan(name, spanOptions);
-        const envelopeTraceId = options?.attributes?.['env.trace_id'];
-        if (typeof envelopeTraceId === 'string') {
-            this.applyEnvelopeTraceId(span, envelopeTraceId);
+        catch (error) {
+            logTelemetryFailure('trace_span_start_failed', error, {
+                operation: operationName,
+                envelope_id: envelope.id,
+            });
         }
-        return new OpenTelemetrySpanScope(span, this.otelApi);
+        return envelope;
     }
-    async flush() {
-        if (this.lifecycle?.forceFlush) {
-            try {
-                await this.lifecycle.forceFlush();
-                return;
+    completeEnvelopeOperationSpan(node, operationName, envelope, operationKey, _result = null, error = null, additionalAttributes = null) {
+        try {
+            const key = this.getSpanKey(envelope, operationKey);
+            let active = this.inflight.get(key);
+            if (!active) {
+                const attributes = buildEnvelopeAttributes(envelope);
+                if (additionalAttributes) {
+                    for (const [attrKey, attrValue] of Object.entries(additionalAttributes)) {
+                        attributes[attrKey] = attrValue;
+                    }
+                }
+                const effectiveNode = node ?? this.node;
+                if (effectiveNode) {
+                    attributes['node.id'] = effectiveNode.id;
+                    attributes['node.sid'] = effectiveNode.sid ?? null;
+                }
+                const scope = this.startSpan(operationName, {
+                    attributes: filterAttributes(attributes),
+                });
+                const span = scope.enter();
+                active = { scope, span };
             }
-            catch {
-                // fall through to global flush fallback
+            else {
+                this.inflight.delete(key);
             }
-        }
-        try {
-            const provider = this.otelApi.trace.getTracerProvider();
-            if (provider && typeof provider.forceFlush === 'function') {
-                await provider.forceFlush();
+            if (error !== null && error !== undefined) {
+                try {
+                    active.span.recordException(error);
+                }
+                catch (recordError) {
+                    logTelemetryFailure('trace_span_record_exception_failed', recordError, {
+                        operation: operationName,
+                        envelope_id: envelope.id,
+                    });
+                }
+                try {
+                    const description = error instanceof Error ? error.message : String(error);
+                    active.span.setStatusError(description);
+                }
+                catch (statusError) {
+                    logTelemetryFailure('trace_span_set_status_failed', statusError, {
+                        operation: operationName,
+                        envelope_id: envelope.id,
+                    });
+                }
             }
-        }
-        catch {
-            // Ignore flush errors
-        }
-    }
-    async shutdown() {
-        if (this.shutdownInvoked) {
-            return;
-        }
-        this.shutdownInvoked = true;
-        const cleanupTasks = [];
-        const strategy = this.authStrategy;
-        if (strategy) {
-            this.authStrategy = null;
-            cleanupTasks.push(strategy.cleanup().catch(() => {
-                // Ignore auth cleanup failures
-            }));
-        }
-        if (this.lifecycle?.shutdown) {
             try {
-                await this.lifecycle.shutdown();
-                this.lifecycle = null;
-                await Promise.all(cleanupTasks);
-                return;
-            }
-            catch {
-                // fall through to global shutdown fallback
-                this.lifecycle = null;
+                active.scope.exit();
             }
-        }
-        try {
-            const provider = this.otelApi.trace.getTracerProvider();
-            if (provider && typeof provider.shutdown === 'function') {
-                await provider.shutdown();
+            catch (exitError) {
+                logTelemetryFailure('trace_span_scope_exit_failed', exitError, {
+                    operation: operationName,
+                    envelope_id: envelope.id,
+                });
             }
         }
-        catch {
-            // Ignore shutdown errors
-        }
-        finally {
-            if (cleanupTasks.length > 0) {
-                await Promise.all(cleanupTasks);
-            }
+        catch (error) {
+            logTelemetryFailure('trace_span_complete_failed', error, {
+                operation: operationName,
+                envelope_id: envelope.id,
+            });
         }
+        return envelope;
     }
-    applyEnvelopeTraceId(span, envelopeTraceId) {
+    async onEnvelopeReceived(node, envelope, context) {
         try {
-            const targetTraceId = this.convertEnvTraceIdToOtel(envelopeTraceId);
-            const internalSpan = span;
-            if (internalSpan?._spanContext) {
-                internalSpan._spanContext.traceId = targetTraceId;
+            const attributes = buildEnvelopeAttributes(envelope);
+            attributes['node.id'] = node.id;
+            attributes['node.sid'] = node.sid ?? null;
+            const fromNodeId = extractContextValue(context, [
+                'fromSystemId',
+                'from_system_id',
+                'fromNodeId',
+                'from_node_id',
+            ]);
+            if (fromNodeId !== undefined && fromNodeId !== null) {
+                attributes['from.node_id'] = String(fromNodeId);
             }
+            const originType = extractContextValue(context, [
+                'originType',
+                'origin_type',
+            ]);
+            if (originType !== undefined && originType !== null) {
+                attributes['from.origin_type'] = String(originType);
+            }
+            const scope = this.startSpan('env.received', {
+                attributes: filterAttributes(attributes),
+            });
+            scope.enter();
+            scope.exit();
         }
-        catch {
-            // Ignore trace-id coercion errors
-        }
-    }
-    convertEnvTraceIdToOtel(envTraceId) {
-        const normalized = envTraceId.slice(0, 16).padEnd(16, '0');
-        let hex = '';
-        for (let i = 0; i < 16; i += 1) {
-            const code = normalized.charCodeAt(i);
-            const byte = Number.isNaN(code) ? 0 : code & 0xff;
-            hex += byte.toString(16).padStart(2, '0');
+        catch (error) {
+            logTelemetryFailure('trace_span_received_failed', error, {
+                envelope_id: envelope.id,
+            });
         }
-        return hex;
+        return envelope;
     }
-}
-function normalizeOpenTelemetryTraceEmitterOptions(input) {
-    const source = (input ?? {});
-    const serviceName = extractNonEmptyString$1(pickFirst$1(source, ['serviceName', 'service_name'])) ?? 'naylence-service';
-    const tracer = pickFirst$1(source, ['tracer']);
-    const otelApi = pickFirst$1(source, [
-        'otelApi',
-        'otel_api',
-    ]);
-    if (!otelApi) {
-        throw new Error('OpenTelemetryTraceEmitter requires OpenTelemetry API bindings. Provide otelApi via options.');
+    async onForwardToRoute(node, nextSegment, envelope, _context) {
+        return this.startEnvelopeOperationSpan(node, 'env.fwd_to_route', envelope, nextSegment, {
+            'route.segment': nextSegment,
+        });
     }
-    const lifecycle = pickFirst$1(source, [
-        'lifecycle',
-        'lifeCycle',
-        'life_cycle',
-    ]) ?? null;
-    const authStrategy = pickFirst$1(source, [
-        'authStrategy',
-        'auth_strategy',
-    ]) ?? null;
-    return {
-        serviceName,
-        tracer,
-        otelApi,
-        lifecycle,
-        authStrategy,
-    };
-}
-function pickFirst$1(source, keys) {
-    for (const key of keys) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-            const value = source[key];
-            if (value !== undefined) {
-                return value;
-            }
-        }
+    async onForwardToRouteComplete(node, nextSegment, envelope, result, error, _context) {
+        return this.completeEnvelopeOperationSpan(node, 'env.fwd_to_route', envelope, nextSegment, result, error, {
+            'route.segment': nextSegment,
+        });
     }
-    return undefined;
-}
-function extractNonEmptyString$1(value) {
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (trimmed.length > 0) {
-            return trimmed;
-        }
+    async onForwardUpstream(node, envelope, _context) {
+        return this.startEnvelopeOperationSpan(node, 'env.fwd_upstream', envelope, 'upstream', {
+            direction: 'upstream',
+        });
     }
-    return undefined;
-}
-function normalizeAttributeValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => String(normalizePrimitiveAttribute(item, true)));
+    async onForwardUpstreamComplete(node, envelope, result, error, _context) {
+        return this.completeEnvelopeOperationSpan(node, 'env.fwd_upstream', envelope, 'upstream', result, error, {
+            direction: 'upstream',
+        });
     }
-    return normalizePrimitiveAttribute(value, false);
-}
-function normalizePrimitiveAttribute(value, forceString) {
-    if (!forceString) {
-        if (typeof value === 'string' ||
-            typeof value === 'number' ||
-            typeof value === 'boolean') {
-            return value;
-        }
-        if (value instanceof Date) {
-            return value.toISOString();
-        }
+    async onForwardToPeer(node, peerSegment, envelope, _context) {
+        return this.startEnvelopeOperationSpan(node, 'env.fwd_to_peer', envelope, peerSegment, {
+            'peer.segment': peerSegment,
+        });
     }
-    if (value instanceof Date) {
-        return value.toISOString();
+    async onForwardToPeerComplete(node, peerSegment, envelope, result, error, _context) {
+        return this.completeEnvelopeOperationSpan(node, 'env.fwd_to_peer', envelope, peerSegment, result, error, {
+            'peer.segment': peerSegment,
+        });
     }
-    if (typeof value === 'boolean') {
-        return value;
+    async onDeliverLocal(node, address, envelope, _context) {
+        const addressKey = address ? String(address) : 'unknown';
+        return this.startEnvelopeOperationSpan(node, 'env.deliver_local', envelope, addressKey, {
+            'delivery.address': addressKey,
+            'delivery.type': 'local',
+        });
     }
-    if (!forceString && typeof value === 'number') {
-        return value;
+    async onDeliverLocalComplete(node, address, envelope, _context) {
+        const addressKey = address ? String(address) : 'unknown';
+        return this.completeEnvelopeOperationSpan(node, 'env.deliver_local', envelope, addressKey, null, null, {
+            'delivery.address': addressKey,
+            'delivery.type': 'local',
+        });
     }
-    return String(value);
-}
-function normalizeAttributes(source) {
-    if (!source) {
-        return undefined;
+    async onNodeInitialized(node) {
+        this.node = node;
     }
-    const entries = [];
-    for (const [key, raw] of Object.entries(source)) {
-        entries.push([key, normalizeAttributeValue(raw)]);
+    async onNodeStopped(_node) {
+        try {
+            if (typeof this.flush === 'function') {
+                await this.flush();
+            }
+            if (typeof this.shutdown === 'function') {
+                await this.shutdown();
+            }
+        }
+        catch (error) {
+            logTelemetryFailure('trace_span_shutdown_failed', error);
+        }
+    }
+    async flush() {
+        // Default implementation: no-op
+    }
+    async shutdown() {
+        // Default implementation: no-op
     }
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
 }
 
-var openTelemetryTraceEmitter = /*#__PURE__*/Object.freeze({
+class NoopTraceSpan {
+    setAttribute() { }
+    recordException() { }
+    setStatusError() { }
+}
+class NoopTraceSpanScope {
+    constructor(span) {
+        this.span = span;
+    }
+    enter() {
+        return this.span;
+    }
+    exit() { }
+}
+class NoopTraceEmitter extends BaseTraceEmitter {
+    startSpan(_name, _options) {
+        void _options;
+        return new NoopTraceSpanScope(new NoopTraceSpan());
+    }
+}
+
+const FACTORY_META$2 = {
+    base: TRACE_EMITTER_FACTORY_BASE_TYPE,
+    key: 'NoopTraceEmitter',
+};
+class NoopTraceEmitterFactory extends TraceEmitterFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'NoopTraceEmitter';
+        this.isDefault = true;
+        this.priority = 100;
+    }
+    async create() {
+        return new NoopTraceEmitter();
+    }
+}
+
+var noopTraceEmitterFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    OpenTelemetryTraceEmitter: OpenTelemetryTraceEmitter
+    FACTORY_META: FACTORY_META$2,
+    NoopTraceEmitterFactory: NoopTraceEmitterFactory,
+    default: NoopTraceEmitterFactory
 });
 
-const logger$5 = getLogger('naylence.fame.telemetry.otel_setup');
-const stringFrom = (...codes) => String.fromCharCode(...codes);
-const OTEL_PREFIX = `${stringFrom(64, 111, 112, 101, 110, 116, 101, 108, 101, 109, 101, 116, 114, 121)}${stringFrom(47)}`;
-const OTEL_API_SPEC = `${OTEL_PREFIX}${stringFrom(97, 112, 105)}`;
-const OTEL_RESOURCES_SPEC = `${OTEL_PREFIX}${stringFrom(114, 101, 115, 111, 117, 114, 99, 101, 115)}`;
-const OTEL_TRACE_NODE_SPEC = `${OTEL_PREFIX}${stringFrom(115, 100, 107, 45, 116, 114, 97, 99, 101, 45, 110, 111, 100, 101)}`;
-const OTEL_TRACE_BASE_SPEC = `${OTEL_PREFIX}${stringFrom(115, 100, 107, 45, 116, 114, 97, 99, 101, 45, 98, 97, 115, 101)}`;
-const OTEL_EXPORTER_HTTP_SPEC = `${OTEL_PREFIX}${stringFrom(101, 120, 112, 111, 114, 116, 101, 114, 45, 116, 114, 97, 99, 101, 45, 111, 116, 108, 112, 45, 104, 116, 116, 112)}`;
-let registeredOtel = null;
-async function setupOtel(options) {
-    const normalized = normalizeSetupOtelOptions(options);
-    try {
-        if (registeredOtel) {
-            logger$5.debug('open_telemetry_reusing_provider', {
-                service_name: normalized.serviceName,
-            });
-            return registeredOtel.control;
-        }
-        const [apiModule, resourcesModule, nodeModule, traceBaseModule] = await Promise.all([
-            import(OTEL_API_SPEC),
-            import(OTEL_RESOURCES_SPEC),
-            import(OTEL_TRACE_NODE_SPEC),
-            import(OTEL_TRACE_BASE_SPEC),
-        ]);
-        const { trace } = apiModule;
-        const { defaultResource, resourceFromAttributes } = resourcesModule;
-        const { NodeTracerProvider } = nodeModule;
-        const { BatchSpanProcessor, ConsoleSpanExporter, ParentBasedSampler, AlwaysOnSampler, AlwaysOffSampler, TraceIdRatioBasedSampler, } = traceBaseModule;
-        const currentProvider = trace.getTracerProvider();
-        if (currentProvider && currentProvider instanceof NodeTracerProvider) {
-            return null;
-        }
-        if (currentProvider &&
-            currentProvider.constructor?.name === 'NodeTracerProvider') {
-            logger$5.debug('open_telemetry_existing_node_provider', {
-                service_name: normalized.serviceName,
-            });
-            return null;
-        }
-        logger$5.debug('open_telemetry_initializing', {
-            service_name: normalized.serviceName,
-            endpoint: normalized.endpoint ?? null,
-            environment: normalized.environment ?? null,
-            sampler: normalized.sampler ?? null,
-            headers_present: Boolean(normalized.headers && Object.keys(normalized.headers).length),
-        });
-        const sampler = resolveSampler(normalized.sampler, {
-            ParentBasedSampler,
-            AlwaysOnSampler,
-            AlwaysOffSampler,
-            TraceIdRatioBasedSampler,
-        });
-        const baseResource = defaultResource();
-        const mergedResource = resourceFromAttributes({
-            'service.name': normalized.serviceName,
-            'service.instance.id': generateInstanceId(),
-            'deployment.environment': normalized.environment ?? 'dev',
+let openTelemetryTraceEmitterModulePromise = null;
+let otelApiModulePromise = null;
+let otelSetupModulePromise = null;
+const logger$7 = getLogger('naylence.fame.telemetry.open_telemetry_trace_emitter_factory');
+const MISSING_OTEL_HELP_MESSAGE = 'Missing optional OpenTelemetry dependency. Install @opentelemetry/api (and related packages) to enable trace emission.';
+function getOpenTelemetryTraceEmitterModule() {
+    if (!openTelemetryTraceEmitterModulePromise) {
+        openTelemetryTraceEmitterModulePromise = safeImport(() => Promise.resolve().then(function () { return openTelemetryTraceEmitter; }), '@opentelemetry/api', {
+            helpMessage: MISSING_OTEL_HELP_MESSAGE,
         });
-        const resource = baseResource.merge(mergedResource);
-        const exporter = await resolveExporter(normalized.endpoint ?? undefined, normalized.headers, ConsoleSpanExporter);
-        const spanProcessor = new BatchSpanProcessor(exporter);
-        const provider = new NodeTracerProvider({
-            resource,
-            sampler,
-            spanProcessors: [spanProcessor],
+    }
+    return openTelemetryTraceEmitterModulePromise;
+}
+function getOtelApiModule() {
+    if (!otelApiModulePromise) {
+        otelApiModulePromise = safeImport(() => import('@opentelemetry/api'), '@opentelemetry/api', {
+            helpMessage: MISSING_OTEL_HELP_MESSAGE,
         });
-        provider.register();
-        logger$5.debug('open_telemetry_initialized', {
-            service_name: normalized.serviceName,
-            exporter: exporter.constructor?.name ?? 'unknown_exporter',
+    }
+    return otelApiModulePromise;
+}
+function getOtelSetupModule() {
+    if (!otelSetupModulePromise) {
+        otelSetupModulePromise = safeImport(() => Promise.resolve().then(function () { return otelSetup; }), '@opentelemetry/api', {
+            helpMessage: MISSING_OTEL_HELP_MESSAGE,
         });
-        const control = {
-            forceFlush: async () => {
+    }
+    return otelSetupModulePromise;
+}
+const FACTORY_META$1 = {
+    base: TRACE_EMITTER_FACTORY_BASE_TYPE,
+    key: 'OpenTelemetryTraceEmitter',
+};
+class OpenTelemetryTraceEmitterFactory extends TraceEmitterFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'OpenTelemetryTraceEmitter';
+    }
+    async create(config, ...factoryArgs) {
+        const options = (factoryArgs[0] ??
+            {});
+        const normalized = normalizeConfig$1(config);
+        const mergedHeaders = {
+            ...normalized.headers,
+            ...(options.headers ?? {}),
+        };
+        let authStrategy = null;
+        if (normalized.auth) {
+            authStrategy =
+                await AuthInjectionStrategyFactory.createAuthInjectionStrategy(normalized.auth);
+            try {
+                await authStrategy.apply(mergedHeaders);
+                logger$7.info('trace_emitter_auth_applied', {
+                    service_name: normalized.serviceName,
+                });
+            }
+            catch (error) {
                 try {
-                    await provider.forceFlush();
+                    await authStrategy.cleanup();
                 }
-                catch (flushError) {
-                    logger$5.warning('open_telemetry_force_flush_failed', {
-                        error: flushError instanceof Error
-                            ? flushError.message
-                            : String(flushError),
-                    });
+                catch {
+                    // Ignore cleanup errors while propagating original failure
                 }
-            },
-            shutdown: async () => {
+                throw error;
+            }
+        }
+        let lifecycle = null;
+        try {
+            const { setupOtel } = await getOtelSetupModule();
+            lifecycle = await setupOtel({
+                serviceName: normalized.serviceName,
+                endpoint: normalized.endpoint,
+                environment: normalized.environment,
+                sampler: normalized.sampler,
+                headers: Object.keys(mergedHeaders).length > 0 ? mergedHeaders : undefined,
+            });
+            logger$7.debug('trace_emitter_lifecycle_acquired', {
+                service_name: normalized.serviceName,
+                lifecycle_available: Boolean(lifecycle),
+            });
+        }
+        catch (error) {
+            if (authStrategy) {
                 try {
-                    await provider.shutdown();
-                }
-                catch (shutdownError) {
-                    logger$5.warning('open_telemetry_shutdown_failed', {
-                        error: shutdownError instanceof Error
-                            ? shutdownError.message
-                            : String(shutdownError),
-                    });
+                    await authStrategy.cleanup();
                 }
-                finally {
-                    registeredOtel = null;
+                catch {
+                    // Ignore cleanup errors while propagating original failure
                 }
+            }
+            throw error;
+        }
+        const [{ OpenTelemetryTraceEmitter }, otelModule] = await Promise.all([
+            getOpenTelemetryTraceEmitterModule(),
+            getOtelApiModule(),
+        ]);
+        const emitterOptions = {
+            serviceName: normalized.serviceName,
+            otelApi: {
+                trace: otelModule.trace,
+                SpanStatusCode: otelModule.SpanStatusCode,
             },
         };
-        registeredOtel = {
-            provider,
-            control,
-        };
-        return control;
-    }
-    catch (error) {
-        logger$5.error('open_telemetry_not_available', {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error && error.stack ? error.stack : undefined,
-        });
-        return null;
+        if (options.tracer) {
+            emitterOptions.tracer = options.tracer;
+        }
+        if (lifecycle) {
+            emitterOptions.lifecycle = lifecycle;
+        }
+        if (authStrategy) {
+            emitterOptions.authStrategy = authStrategy;
+        }
+        try {
+            const emitter = new OpenTelemetryTraceEmitter(emitterOptions);
+            logger$7.debug('trace_emitter_created', {
+                service_name: normalized.serviceName,
+                has_lifecycle: Boolean(lifecycle),
+                has_auth_strategy: Boolean(authStrategy),
+            });
+            return emitter;
+        }
+        catch (error) {
+            if (authStrategy) {
+                try {
+                    await authStrategy.cleanup();
+                }
+                catch {
+                    // Best effort cleanup
+                }
+            }
+            throw error;
+        }
     }
 }
-function normalizeSetupOtelOptions(options) {
-    const source = (options ?? {});
-    const serviceName = extractNonEmptyString(pickFirst(source, ['serviceName', 'service_name'])) ??
+function normalizeConfig$1(config) {
+    if (!config) {
+        return {
+            serviceName: 'naylence-service',
+            endpoint: null,
+            environment: null,
+            sampler: null,
+            headers: {},
+            auth: null,
+        };
+    }
+    const candidate = config;
+    const serviceName = extractString(pickFirst$2(candidate, ['serviceName', 'service_name'])) ??
         'naylence-service';
-    const endpoint = extractNonEmptyString(pickFirst(source, ['endpoint', 'otlpEndpoint', 'otlp_endpoint'])) ?? null;
-    const environment = extractNonEmptyString(pickFirst(source, [
+    const endpoint = extractString(pickFirst$2(candidate, ['endpoint', 'otlpEndpoint', 'otlp_endpoint'])) ?? null;
+    const environment = extractString(pickFirst$2(candidate, [
         'environment',
         'deploymentEnvironment',
         'deployment_environment',
     ])) ?? null;
-    const sampler = extractNonEmptyString(pickFirst(source, ['sampler', 'samplingStrategy', 'sampling_strategy'])) ?? null;
-    const headers = extractHeaders(pickFirst(source, ['headers', 'otlpHeaders', 'otlp_headers']));
+    const sampler = extractString(pickFirst$2(candidate, ['sampler', 'samplingStrategy', 'sampling_strategy'])) ?? null;
+    const headersFromConfig = extractHeaders$1(pickFirst$2(candidate, ['headers', 'otlpHeaders', 'otlp_headers']));
+    const authConfig = pickFirst$2(candidate, [
+        'auth',
+    ]);
     return {
         serviceName,
         endpoint,
         environment,
         sampler,
-        headers: headers ?? undefined,
+        headers: headersFromConfig ?? {},
+        auth: authConfig ?? null,
     };
 }
-function pickFirst(source, keys) {
+function extractString(value) {
+    if (typeof value === 'string' && value.trim().length > 0) {
+        return value;
+    }
+    return undefined;
+}
+function pickFirst$2(source, keys) {
     for (const key of keys) {
         if (Object.prototype.hasOwnProperty.call(source, key)) {
             const value = source[key];
@@ -40177,16 +39709,7 @@ function pickFirst(source, keys) {
     }
     return undefined;
 }
-function extractNonEmptyString(value) {
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (trimmed.length > 0) {
-            return trimmed;
-        }
-    }
-    return undefined;
-}
-function extractHeaders(value) {
+function extractHeaders$1(value) {
     if (!value || typeof value !== 'object') {
         return null;
     }
@@ -40198,76 +39721,145 @@ function extractHeaders(value) {
     }
     return Object.keys(headers).length > 0 ? headers : null;
 }
-function generateInstanceId() {
-    try {
-        if (typeof crypto !== 'undefined' &&
-            typeof crypto.randomUUID === 'function') {
-            return crypto.randomUUID().replace(/-/g, '');
-        }
+
+var openTelemetryTraceEmitterFactory = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FACTORY_META: FACTORY_META$1,
+    OpenTelemetryTraceEmitterFactory: OpenTelemetryTraceEmitterFactory,
+    default: OpenTelemetryTraceEmitterFactory
+});
+
+const logger$6 = getLogger('naylence.fame.telemetry.trace_emitter_profile_factory');
+const PROFILE_NAME_NOOP = 'noop';
+const PROFILE_NAME_OPEN_TELEMETRY = 'open-telemetry';
+const ENV_VAR_TELEMETRY_SERVICE_NAME = 'FAME_TELEMETRY_SERVICE_NAME';
+const NOOP_PROFILE = {
+    type: 'NoopTraceEmitter',
+};
+const OPEN_TELEMETRY_PROFILE = {
+    type: 'OpenTelemetryTraceEmitter',
+    serviceName: Expressions.env(ENV_VAR_TELEMETRY_SERVICE_NAME, 'naylence-service'),
+    headers: {},
+};
+const PROFILE_MAP = {
+    [PROFILE_NAME_NOOP]: NOOP_PROFILE,
+    [PROFILE_NAME_OPEN_TELEMETRY]: OPEN_TELEMETRY_PROFILE,
+};
+const FACTORY_META = {
+    base: TRACE_EMITTER_FACTORY_BASE_TYPE,
+    key: 'TraceEmitterProfile',
+};
+class TraceEmitterProfileFactory extends TraceEmitterFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'TraceEmitterProfile';
     }
-    catch {
-        // Ignore crypto availability errors
+    async create(config, ...factoryArgs) {
+        const normalized = normalizeTraceEmitterProfileConfig(config);
+        const profileConfig = resolveProfileConfig(normalized.profile);
+        logger$6.debug('enabling_trace_emitter_profile', {
+            profile: normalized.profile,
+        });
+        const traceEmitter = await TraceEmitterFactory.createTraceEmitter(profileConfig, {
+            factoryArgs,
+        });
+        if (!traceEmitter) {
+            throw new Error(`Failed to instantiate trace emitter profile: ${normalized.profile}`);
+        }
+        return traceEmitter;
     }
-    const random = Math.random().toString(16).slice(2);
-    return random.padEnd(32, '0').slice(0, 32);
 }
-function resolveSampler(samplerSetting, samplers) {
-    const normalized = (samplerSetting ?? 'parentbased_always_on').toLowerCase();
-    let base;
-    if (normalized === 'always_off') {
-        base = new samplers.AlwaysOffSampler();
+function normalizeTraceEmitterProfileConfig(config) {
+    if (!config) {
+        return { profile: PROFILE_NAME_NOOP };
     }
-    else if (normalized === 'always_on' ||
-        normalized === 'parentbased_always_on') {
-        base = new samplers.AlwaysOnSampler();
+    const candidate = config;
+    const profileValue = resolveProfileName(candidate);
+    const canonicalProfile = canonicalizeProfileName(profileValue);
+    candidate.profile = canonicalProfile;
+    return { profile: canonicalProfile };
+}
+function resolveProfileName(candidate) {
+    const direct = coerceProfileString(candidate.profile);
+    if (direct) {
+        return direct;
     }
-    else if (normalized.startsWith('ratio:')) {
-        const ratioValue = Number.parseFloat(normalized.slice('ratio:'.length));
-        const ratio = Number.isFinite(ratioValue)
-            ? Math.min(Math.max(ratioValue, 0), 1)
-            : 1;
-        base = new samplers.TraceIdRatioBasedSampler(ratio);
+    const legacyKeys = ['profile_name', 'profileName'];
+    for (const legacyKey of legacyKeys) {
+        const legacyValue = coerceProfileString(candidate[legacyKey]);
+        if (legacyValue) {
+            return legacyValue;
+        }
     }
-    else {
-        base = new samplers.AlwaysOnSampler();
+    return PROFILE_NAME_NOOP;
+}
+function coerceProfileString(value) {
+    if (typeof value !== 'string') {
+        return null;
     }
-    return new samplers.ParentBasedSampler({ root: base });
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
 }
-async function resolveExporter(endpoint, headers, ConsoleSpanExporter) {
-    if (endpoint) {
-        try {
-            const exporterModule = await import(OTEL_EXPORTER_HTTP_SPEC);
-            if ('OTLPTraceExporter' in exporterModule) {
-                const { OTLPTraceExporter } = exporterModule;
-                const exporterOptions = {
-                    url: endpoint,
-                };
-                if (headers && Object.keys(headers).length > 0) {
-                    exporterOptions.headers = headers;
-                }
-                logger$5.debug('open_telemetry_using_otlp_http_exporter', {
-                    endpoint,
-                    headers_present: Boolean(headers && Object.keys(headers).length),
-                });
-                return new OTLPTraceExporter(exporterOptions);
-            }
-        }
-        catch (error) {
-            logger$5.error('open_telemetry_exporter_not_available', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
+const PROFILE_ALIASES = {
+    noop: PROFILE_NAME_NOOP,
+    'no-op': PROFILE_NAME_NOOP,
+    no_op: PROFILE_NAME_NOOP,
+    'open-telemetry': PROFILE_NAME_OPEN_TELEMETRY,
+    open_telemetry: PROFILE_NAME_OPEN_TELEMETRY,
+    opentelemetry: PROFILE_NAME_OPEN_TELEMETRY,
+};
+function canonicalizeProfileName(value) {
+    const normalized = value.replace(/[\s_]+/g, '-').toLowerCase();
+    return PROFILE_ALIASES[normalized] ?? normalized;
+}
+function resolveProfileConfig(profileName) {
+    const profile = PROFILE_MAP[profileName];
+    if (!profile) {
+        throw new Error(`Unknown trace emitter profile: ${profileName}`);
     }
-    logger$5.warning('open_telemetry_falling_back_to_console_exporter');
-    return new ConsoleSpanExporter();
+    return deepClone(profile);
+}
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
 }
 
-var otelSetup = /*#__PURE__*/Object.freeze({
+var traceEmitterProfileFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    setupOtel: setupOtel
+    FACTORY_META: FACTORY_META,
+    PROFILE_NAME_NOOP: PROFILE_NAME_NOOP,
+    PROFILE_NAME_OPEN_TELEMETRY: PROFILE_NAME_OPEN_TELEMETRY,
+    TraceEmitterProfileFactory: TraceEmitterProfileFactory,
+    default: TraceEmitterProfileFactory
 });
 
-const logger$4 = getLogger('naylence.fame.security.auth.default_authorizer');
+let initialized = false;
+const runtimePlugin = {
+    name: 'naylence:runtime',
+    version: VERSION,
+    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 logger$5 = getLogger('naylence.fame.security.auth.default_authorizer');
 function decodeCredentials$1(credentials) {
     if (typeof TextDecoder !== 'undefined') {
         return new TextDecoder().decode(credentials);
@@ -40401,7 +39993,7 @@ class DefaultAuthorizer {
             });
         }
         catch (error) {
-            logger$4.warning('token_verification_failed', {
+            logger$5.warning('token_verification_failed', {
                 error: error instanceof Error ? error.message : String(error),
             });
             return undefined;
@@ -40492,7 +40084,7 @@ var defaultAuthorizer = /*#__PURE__*/Object.freeze({
     DefaultAuthorizer: DefaultAuthorizer
 });
 
-const logger$3 = getLogger('naylence.fame.security.auth.jwks_jwt_token_verifier');
+const logger$4 = getLogger('naylence.fame.security.auth.jwks_jwt_token_verifier');
 const DEFAULT_ALGORITHMS = ['RS256', 'ES256', 'EdDSA'];
 function normalizeOptions$5(options) {
     if (!options || typeof options !== 'object') {
@@ -40542,7 +40134,7 @@ class JWKSJWTTokenVerifier {
         this.algorithms = (normalized.algorithms && normalized.algorithms.length > 0
             ? normalized.algorithms
             : Array.from(DEFAULT_ALGORITHMS)).map((alg) => alg.toString().trim());
-        logger$3.debug('jwks_jwt_token_verifier_initialized', {
+        logger$4.debug('jwks_jwt_token_verifier_initialized', {
             issuer: this.issuer,
             jwks_url: this.jwksUrl.toString(),
             cache_ttl_ms: this.cacheTtlMs,
@@ -40564,7 +40156,7 @@ class JWKSJWTTokenVerifier {
             return buildAuthorizationContext$1(payload, protectedHeader?.kid);
         }
         catch (error) {
-            logger$3.warning('jwks_jwt_token_verifier_failed', {
+            logger$4.warning('jwks_jwt_token_verifier_failed', {
                 error: error instanceof Error ? error.message : String(error),
             });
             throw this.normalizeJoseError(error);
@@ -40615,7 +40207,7 @@ var jwksJwtTokenVerifier = /*#__PURE__*/Object.freeze({
     JWKSJWTTokenVerifier: JWKSJWTTokenVerifier
 });
 
-const logger$2 = getLogger('naylence.fame.security.auth.oauth2_authorizer');
+const logger$3 = getLogger('naylence.fame.security.auth.oauth2_authorizer');
 function normalizeOptions$4(raw) {
     const camel = raw;
     const snake = raw;
@@ -40680,12 +40272,12 @@ class OAuth2Authorizer {
     async authenticate(credentials) {
         const token = this.normalizeBearerToken(credentials);
         if (!token) {
-            logger$2.debug('oauth2_authenticate_missing_token');
+            logger$3.debug('oauth2_authenticate_missing_token');
             return undefined;
         }
         try {
             const expectedAudience = this.audience ?? this.node?.physicalPath;
-            logger$2.debug('oauth2_authenticate_start', {
+            logger$3.debug('oauth2_authenticate_start', {
                 expected_audience: expectedAudience,
             });
             const context = expectedAudience !== undefined
@@ -40697,7 +40289,7 @@ class OAuth2Authorizer {
             if (this.requireScope &&
                 this.requiredScopes.size > 0 &&
                 !this.hasRequiredScope(grantedScopes)) {
-                logger$2.warning('oauth2_token_missing_required_scope', {
+                logger$3.warning('oauth2_token_missing_required_scope', {
                     required_scopes: Array.from(this.requiredScopes),
                     token_scopes: Array.from(scopes),
                 });
@@ -40711,13 +40303,13 @@ class OAuth2Authorizer {
                 grantedScopes,
                 authMethod: context.authMethod ?? 'oauth2_jwt',
             });
-            logger$2.debug('oauth2_authenticate_success', {
+            logger$3.debug('oauth2_authenticate_success', {
                 granted_scopes: Array.from(grantedScopes),
             });
             return normalized;
         }
         catch (error) {
-            logger$2.warning('oauth2_token_verification_failed', {
+            logger$3.warning('oauth2_token_verification_failed', {
                 error: error instanceof Error ? error.message : String(error),
             });
             return undefined;
@@ -40759,7 +40351,7 @@ class OAuth2Authorizer {
                 instance_id: node.instanceId ?? null,
                 capabilities: Array.from(this.requiredScopes),
             });
-            logger$2.debug('reverse_authorization_token_generated', {
+            logger$3.debug('reverse_authorization_token_generated', {
                 node_id: node.id,
                 expires_at: expiresAt.toISOString(),
                 capabilities: Array.from(this.requiredScopes),
@@ -40776,7 +40368,7 @@ class OAuth2Authorizer {
             return result;
         }
         catch (error) {
-            logger$2.warning('failed_to_generate_reverse_auth_token', {
+            logger$3.warning('failed_to_generate_reverse_auth_token', {
                 node_id: node.id,
                 error: error instanceof Error ? error.message : String(error),
             });
@@ -40793,7 +40385,7 @@ class OAuth2Authorizer {
         if (this.requireScope &&
             this.requiredScopes.size > 0 &&
             !this.hasRequiredScope(grantedScopes)) {
-            logger$2.warning('oauth2_attach_missing_required_scope', {
+            logger$3.warning('oauth2_attach_missing_required_scope', {
                 required_scopes: Array.from(this.requiredScopes),
                 token_scopes: Array.from(scopes),
             });
@@ -40883,7 +40475,7 @@ var oauth2Authorizer = /*#__PURE__*/Object.freeze({
     OAuth2Authorizer: OAuth2Authorizer
 });
 
-const logger$1 = getLogger('naylence.fame.security.auth.oauth2_client_credentials_token_provider');
+const logger$2 = getLogger('naylence.fame.security.auth.oauth2_client_credentials_token_provider');
 function normalizeOptions$3(raw) {
     const camel = raw;
     const snake = raw;
@@ -40949,7 +40541,7 @@ class OAuth2ClientCredentialsTokenProvider {
     }
     async getToken() {
         if (this.cachedToken && this.isTokenFresh(this.cachedToken)) {
-            logger$1.debug('using_cached_oauth2_token', {
+            logger$2.debug('using_cached_oauth2_token', {
                 token_url: this.options.tokenUrl,
             });
             return { ...this.cachedToken };
@@ -41004,7 +40596,7 @@ class OAuth2ClientCredentialsTokenProvider {
         }
         const expiresInSeconds = this.resolveExpiresIn(payload);
         const expiresAt = Date.now() + expiresInSeconds * 1000;
-        logger$1.debug('oauth2_token_fetched', {
+        logger$2.debug('oauth2_token_fetched', {
             token_url: this.options.tokenUrl,
             scopes: this.options.scopes,
             audience: this.options.audience,
@@ -41039,7 +40631,7 @@ var oauth2ClientCredentialsTokenProvider = /*#__PURE__*/Object.freeze({
     OAuth2ClientCredentialsTokenProvider: OAuth2ClientCredentialsTokenProvider
 });
 
-const logger = getLogger('naylence.fame.security.auth.oauth2_pkce_token_provider');
+const logger$1 = getLogger('naylence.fame.security.auth.oauth2_pkce_token_provider');
 const DEFAULT_SCOPES = [];
 const DEFAULT_CLOCK_SKEW_SECONDS = 30;
 const DEFAULT_CODE_VERIFIER_LENGTH = 48; // bytes before base64url encoding
@@ -41214,7 +40806,7 @@ function readPendingAuthorization(clientId) {
         return parsed;
     }
     catch (error) {
-        logger.debug('pkce_storage_read_failed', {
+        logger$1.debug('pkce_storage_read_failed', {
             error: error instanceof Error ? error.message : String(error),
         });
         return null;
@@ -41233,7 +40825,7 @@ function writePendingAuthorization(clientId, pending) {
         window.sessionStorage.setItem(key, JSON.stringify(pending));
     }
     catch (error) {
-        logger.debug('pkce_storage_write_failed', {
+        logger$1.debug('pkce_storage_write_failed', {
             error: error instanceof Error ? error.message : String(error),
         });
     }
@@ -41279,7 +40871,7 @@ function clearOAuthParamsFromUrl(url) {
         window.history.replaceState(window.history.state, '', finalUrl);
     }
     catch (error) {
-        logger.debug('pkce_replace_state_failed', {
+        logger$1.debug('pkce_replace_state_failed', {
             error: error instanceof Error ? error.message : String(error),
         });
     }
@@ -41320,7 +40912,7 @@ class OAuth2PkceTokenProvider {
             if (persisted) {
                 if (this.isTokenCompatible(persisted.scopes, persisted.audience)) {
                     if (!persisted.expiresAt || this.isTokenFresh(persisted)) {
-                        logger.debug('using_persisted_oauth2_pkce_token', {
+                        logger$1.debug('using_persisted_oauth2_pkce_token', {
                             authorize_url: this.options.authorizeUrl,
                         });
                         const cached = {
@@ -41341,7 +40933,7 @@ class OAuth2PkceTokenProvider {
             }
         }
         if (this.cachedToken && this.isTokenFresh(this.cachedToken)) {
-            logger.debug('using_cached_oauth2_pkce_token', {
+            logger$1.debug('using_cached_oauth2_pkce_token', {
                 authorize_url: this.options.authorizeUrl,
             });
             return { ...this.cachedToken };
@@ -41364,7 +40956,7 @@ class OAuth2PkceTokenProvider {
     async beginBrowserAuthorization() {
         const existing = readPendingAuthorization(this.options.clientId);
         if (existing) {
-            logger.debug('pkce_redirect_in_progress', {
+            logger$1.debug('pkce_redirect_in_progress', {
                 authorize_url: this.options.authorizeUrl,
             });
             this.navigate(existing.authorizeUrl);
@@ -41394,7 +40986,7 @@ class OAuth2PkceTokenProvider {
         };
         writePersistedToken(this.options.clientId, null);
         writePendingAuthorization(this.options.clientId, pending);
-        logger.debug('pkce_redirect_start', {
+        logger$1.debug('pkce_redirect_start', {
             authorize_url: this.options.authorizeUrl,
             redirect_uri: this.options.redirectUri,
         });
@@ -41408,7 +41000,7 @@ class OAuth2PkceTokenProvider {
             window.location.assign(url);
         }
         catch (error) {
-            logger.error('pkce_navigation_failed', {
+            logger$1.error('pkce_navigation_failed', {
                 authorize_url: url,
                 error: error instanceof Error ? error.message : String(error),
             });
@@ -41552,7 +41144,7 @@ class OAuth2PkceTokenProvider {
             value: accessToken,
             expiresAt: Date.now() + expiresInSeconds * 1000,
         };
-        logger.debug('oauth2_pkce_token_fetched', {
+        logger$1.debug('oauth2_pkce_token_fetched', {
             authorize_url: this.options.authorizeUrl,
             token_url: this.options.tokenUrl,
             expires_in: expiresInSeconds,
@@ -41568,7 +41160,7 @@ class OAuth2PkceTokenProvider {
     clearToken() {
         this.cachedToken = undefined;
         writePersistedToken(this.options.clientId, null);
-        logger.debug('oauth2_pkce_token_cleared', {
+        logger$1.debug('oauth2_pkce_token_cleared', {
             authorize_url: this.options.authorizeUrl,
         });
     }
@@ -41965,6 +41557,543 @@ var eddsaEnvelopeVerifier = /*#__PURE__*/Object.freeze({
     EdDSAEnvelopeVerifier: EdDSAEnvelopeVerifier
 });
 
+let currentTraceId = null;
+let currentSpanId = null;
+function getOtelTraceId() {
+    return currentTraceId;
+}
+function getOtelSpanId() {
+    return currentSpanId;
+}
+function setOtelTraceId(traceId) {
+    const previous = currentTraceId;
+    currentTraceId = traceId;
+    return previous;
+}
+function setOtelSpanId(spanId) {
+    const previous = currentSpanId;
+    currentSpanId = spanId;
+    return previous;
+}
+function resetOtelTraceId(previous) {
+    currentTraceId = previous;
+}
+function resetOtelSpanId(previous) {
+    currentSpanId = previous;
+}
+
+class OpenTelemetryTraceSpan {
+    constructor(span, api) {
+        this.span = span;
+        this.api = api;
+    }
+    setAttribute(key, value) {
+        try {
+            this.span.setAttribute(key, normalizeAttributeValue(value));
+        }
+        catch {
+            // Ignore telemetry attribute errors
+        }
+    }
+    recordException(error) {
+        try {
+            if (error instanceof Error) {
+                this.span.recordException(error);
+            }
+            else {
+                this.span.recordException(new Error(String(error)));
+            }
+        }
+        catch {
+            // Ignore telemetry recording errors
+        }
+    }
+    setStatusError(description) {
+        try {
+            const status = {
+                code: this.api.SpanStatusCode.ERROR,
+            };
+            if (description !== undefined) {
+                status.message = description;
+            }
+            this.span.setStatus(status);
+        }
+        catch {
+            // Ignore telemetry status errors
+        }
+    }
+}
+class OpenTelemetrySpanScope {
+    constructor(span, api) {
+        this.span = span;
+        this.entered = false;
+        this.wrapper = new OpenTelemetryTraceSpan(span, api);
+    }
+    enter() {
+        if (!this.entered) {
+            this.entered = true;
+            const spanContext = this.span.spanContext();
+            this.traceToken = setOtelTraceId(spanContext?.traceId ?? null);
+            this.spanToken = setOtelSpanId(spanContext?.spanId ?? null);
+        }
+        return this.wrapper;
+    }
+    exit() {
+        try {
+            this.span.end();
+        }
+        catch {
+            // Ignore span termination errors
+        }
+        finally {
+            if (this.traceToken !== undefined) {
+                resetOtelTraceId(this.traceToken);
+                this.traceToken = undefined;
+            }
+            if (this.spanToken !== undefined) {
+                resetOtelSpanId(this.spanToken);
+                this.spanToken = undefined;
+            }
+        }
+    }
+}
+class OpenTelemetryTraceEmitter extends BaseTraceEmitter {
+    constructor(options) {
+        super();
+        this.shutdownInvoked = false;
+        const normalized = normalizeOpenTelemetryTraceEmitterOptions(options);
+        this.otelApi = normalized.otelApi;
+        this.tracer =
+            normalized.tracer ?? this.otelApi.trace.getTracer(normalized.serviceName);
+        this.lifecycle = normalized.lifecycle ?? null;
+        this.authStrategy = normalized.authStrategy ?? null;
+    }
+    startSpan(name, options) {
+        const attributes = normalizeAttributes(options?.attributes);
+        const spanOptions = {};
+        if (attributes) {
+            spanOptions.attributes = attributes;
+        }
+        if (options?.links) {
+            spanOptions.links = options.links;
+        }
+        const span = this.tracer.startSpan(name, spanOptions);
+        const envelopeTraceId = options?.attributes?.['env.trace_id'];
+        if (typeof envelopeTraceId === 'string') {
+            this.applyEnvelopeTraceId(span, envelopeTraceId);
+        }
+        return new OpenTelemetrySpanScope(span, this.otelApi);
+    }
+    async flush() {
+        if (this.lifecycle?.forceFlush) {
+            try {
+                await this.lifecycle.forceFlush();
+                return;
+            }
+            catch {
+                // fall through to global flush fallback
+            }
+        }
+        try {
+            const provider = this.otelApi.trace.getTracerProvider();
+            if (provider && typeof provider.forceFlush === 'function') {
+                await provider.forceFlush();
+            }
+        }
+        catch {
+            // Ignore flush errors
+        }
+    }
+    async shutdown() {
+        if (this.shutdownInvoked) {
+            return;
+        }
+        this.shutdownInvoked = true;
+        const cleanupTasks = [];
+        const strategy = this.authStrategy;
+        if (strategy) {
+            this.authStrategy = null;
+            cleanupTasks.push(strategy.cleanup().catch(() => {
+                // Ignore auth cleanup failures
+            }));
+        }
+        if (this.lifecycle?.shutdown) {
+            try {
+                await this.lifecycle.shutdown();
+                this.lifecycle = null;
+                await Promise.all(cleanupTasks);
+                return;
+            }
+            catch {
+                // fall through to global shutdown fallback
+                this.lifecycle = null;
+            }
+        }
+        try {
+            const provider = this.otelApi.trace.getTracerProvider();
+            if (provider && typeof provider.shutdown === 'function') {
+                await provider.shutdown();
+            }
+        }
+        catch {
+            // Ignore shutdown errors
+        }
+        finally {
+            if (cleanupTasks.length > 0) {
+                await Promise.all(cleanupTasks);
+            }
+        }
+    }
+    applyEnvelopeTraceId(span, envelopeTraceId) {
+        try {
+            const targetTraceId = this.convertEnvTraceIdToOtel(envelopeTraceId);
+            const internalSpan = span;
+            if (internalSpan?._spanContext) {
+                internalSpan._spanContext.traceId = targetTraceId;
+            }
+        }
+        catch {
+            // Ignore trace-id coercion errors
+        }
+    }
+    convertEnvTraceIdToOtel(envTraceId) {
+        const normalized = envTraceId.slice(0, 16).padEnd(16, '0');
+        let hex = '';
+        for (let i = 0; i < 16; i += 1) {
+            const code = normalized.charCodeAt(i);
+            const byte = Number.isNaN(code) ? 0 : code & 0xff;
+            hex += byte.toString(16).padStart(2, '0');
+        }
+        return hex;
+    }
+}
+function normalizeOpenTelemetryTraceEmitterOptions(input) {
+    const source = (input ?? {});
+    const serviceName = extractNonEmptyString$1(pickFirst$1(source, ['serviceName', 'service_name'])) ?? 'naylence-service';
+    const tracer = pickFirst$1(source, ['tracer']);
+    const otelApi = pickFirst$1(source, [
+        'otelApi',
+        'otel_api',
+    ]);
+    if (!otelApi) {
+        throw new Error('OpenTelemetryTraceEmitter requires OpenTelemetry API bindings. Provide otelApi via options.');
+    }
+    const lifecycle = pickFirst$1(source, [
+        'lifecycle',
+        'lifeCycle',
+        'life_cycle',
+    ]) ?? null;
+    const authStrategy = pickFirst$1(source, [
+        'authStrategy',
+        'auth_strategy',
+    ]) ?? null;
+    return {
+        serviceName,
+        tracer,
+        otelApi,
+        lifecycle,
+        authStrategy,
+    };
+}
+function pickFirst$1(source, keys) {
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const value = source[key];
+            if (value !== undefined) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+function extractNonEmptyString$1(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+    }
+    return undefined;
+}
+function normalizeAttributeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(normalizePrimitiveAttribute(item, true)));
+    }
+    return normalizePrimitiveAttribute(value, false);
+}
+function normalizePrimitiveAttribute(value, forceString) {
+    if (!forceString) {
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean') {
+            return value;
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (!forceString && typeof value === 'number') {
+        return value;
+    }
+    return String(value);
+}
+function normalizeAttributes(source) {
+    if (!source) {
+        return undefined;
+    }
+    const entries = [];
+    for (const [key, raw] of Object.entries(source)) {
+        entries.push([key, normalizeAttributeValue(raw)]);
+    }
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+var openTelemetryTraceEmitter = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    OpenTelemetryTraceEmitter: OpenTelemetryTraceEmitter
+});
+
+const logger = getLogger('naylence.fame.telemetry.otel_setup');
+const stringFrom = (...codes) => String.fromCharCode(...codes);
+const OTEL_PREFIX = `${stringFrom(64, 111, 112, 101, 110, 116, 101, 108, 101, 109, 101, 116, 114, 121)}${stringFrom(47)}`;
+const OTEL_API_SPEC = `${OTEL_PREFIX}${stringFrom(97, 112, 105)}`;
+const OTEL_RESOURCES_SPEC = `${OTEL_PREFIX}${stringFrom(114, 101, 115, 111, 117, 114, 99, 101, 115)}`;
+const OTEL_TRACE_NODE_SPEC = `${OTEL_PREFIX}${stringFrom(115, 100, 107, 45, 116, 114, 97, 99, 101, 45, 110, 111, 100, 101)}`;
+const OTEL_TRACE_BASE_SPEC = `${OTEL_PREFIX}${stringFrom(115, 100, 107, 45, 116, 114, 97, 99, 101, 45, 98, 97, 115, 101)}`;
+const OTEL_EXPORTER_HTTP_SPEC = `${OTEL_PREFIX}${stringFrom(101, 120, 112, 111, 114, 116, 101, 114, 45, 116, 114, 97, 99, 101, 45, 111, 116, 108, 112, 45, 104, 116, 116, 112)}`;
+let registeredOtel = null;
+async function setupOtel(options) {
+    const normalized = normalizeSetupOtelOptions(options);
+    try {
+        if (registeredOtel) {
+            logger.debug('open_telemetry_reusing_provider', {
+                service_name: normalized.serviceName,
+            });
+            return registeredOtel.control;
+        }
+        const [apiModule, resourcesModule, nodeModule, traceBaseModule] = await Promise.all([
+            import(OTEL_API_SPEC),
+            import(OTEL_RESOURCES_SPEC),
+            import(OTEL_TRACE_NODE_SPEC),
+            import(OTEL_TRACE_BASE_SPEC),
+        ]);
+        const { trace } = apiModule;
+        const { defaultResource, resourceFromAttributes } = resourcesModule;
+        const { NodeTracerProvider } = nodeModule;
+        const { BatchSpanProcessor, ConsoleSpanExporter, ParentBasedSampler, AlwaysOnSampler, AlwaysOffSampler, TraceIdRatioBasedSampler, } = traceBaseModule;
+        const currentProvider = trace.getTracerProvider();
+        if (currentProvider && currentProvider instanceof NodeTracerProvider) {
+            return null;
+        }
+        if (currentProvider &&
+            currentProvider.constructor?.name === 'NodeTracerProvider') {
+            logger.debug('open_telemetry_existing_node_provider', {
+                service_name: normalized.serviceName,
+            });
+            return null;
+        }
+        logger.debug('open_telemetry_initializing', {
+            service_name: normalized.serviceName,
+            endpoint: normalized.endpoint ?? null,
+            environment: normalized.environment ?? null,
+            sampler: normalized.sampler ?? null,
+            headers_present: Boolean(normalized.headers && Object.keys(normalized.headers).length),
+        });
+        const sampler = resolveSampler(normalized.sampler, {
+            ParentBasedSampler,
+            AlwaysOnSampler,
+            AlwaysOffSampler,
+            TraceIdRatioBasedSampler,
+        });
+        const baseResource = defaultResource();
+        const mergedResource = resourceFromAttributes({
+            'service.name': normalized.serviceName,
+            'service.instance.id': generateInstanceId(),
+            'deployment.environment': normalized.environment ?? 'dev',
+        });
+        const resource = baseResource.merge(mergedResource);
+        const exporter = await resolveExporter(normalized.endpoint ?? undefined, normalized.headers, ConsoleSpanExporter);
+        const spanProcessor = new BatchSpanProcessor(exporter);
+        const provider = new NodeTracerProvider({
+            resource,
+            sampler,
+            spanProcessors: [spanProcessor],
+        });
+        provider.register();
+        logger.debug('open_telemetry_initialized', {
+            service_name: normalized.serviceName,
+            exporter: exporter.constructor?.name ?? 'unknown_exporter',
+        });
+        const control = {
+            forceFlush: async () => {
+                try {
+                    await provider.forceFlush();
+                }
+                catch (flushError) {
+                    logger.warning('open_telemetry_force_flush_failed', {
+                        error: flushError instanceof Error
+                            ? flushError.message
+                            : String(flushError),
+                    });
+                }
+            },
+            shutdown: async () => {
+                try {
+                    await provider.shutdown();
+                }
+                catch (shutdownError) {
+                    logger.warning('open_telemetry_shutdown_failed', {
+                        error: shutdownError instanceof Error
+                            ? shutdownError.message
+                            : String(shutdownError),
+                    });
+                }
+                finally {
+                    registeredOtel = null;
+                }
+            },
+        };
+        registeredOtel = {
+            provider,
+            control,
+        };
+        return control;
+    }
+    catch (error) {
+        logger.error('open_telemetry_not_available', {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error && error.stack ? error.stack : undefined,
+        });
+        return null;
+    }
+}
+function normalizeSetupOtelOptions(options) {
+    const source = (options ?? {});
+    const serviceName = extractNonEmptyString(pickFirst(source, ['serviceName', 'service_name'])) ??
+        'naylence-service';
+    const endpoint = extractNonEmptyString(pickFirst(source, ['endpoint', 'otlpEndpoint', 'otlp_endpoint'])) ?? null;
+    const environment = extractNonEmptyString(pickFirst(source, [
+        'environment',
+        'deploymentEnvironment',
+        'deployment_environment',
+    ])) ?? null;
+    const sampler = extractNonEmptyString(pickFirst(source, ['sampler', 'samplingStrategy', 'sampling_strategy'])) ?? null;
+    const headers = extractHeaders(pickFirst(source, ['headers', 'otlpHeaders', 'otlp_headers']));
+    return {
+        serviceName,
+        endpoint,
+        environment,
+        sampler,
+        headers: headers ?? undefined,
+    };
+}
+function pickFirst(source, keys) {
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const value = source[key];
+            if (value !== undefined) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+function extractNonEmptyString(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+    }
+    return undefined;
+}
+function extractHeaders(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const headers = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === 'string') {
+            headers[key] = raw;
+        }
+    }
+    return Object.keys(headers).length > 0 ? headers : null;
+}
+function generateInstanceId() {
+    try {
+        if (typeof crypto !== 'undefined' &&
+            typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID().replace(/-/g, '');
+        }
+    }
+    catch {
+        // Ignore crypto availability errors
+    }
+    const random = Math.random().toString(16).slice(2);
+    return random.padEnd(32, '0').slice(0, 32);
+}
+function resolveSampler(samplerSetting, samplers) {
+    const normalized = (samplerSetting ?? 'parentbased_always_on').toLowerCase();
+    let base;
+    if (normalized === 'always_off') {
+        base = new samplers.AlwaysOffSampler();
+    }
+    else if (normalized === 'always_on' ||
+        normalized === 'parentbased_always_on') {
+        base = new samplers.AlwaysOnSampler();
+    }
+    else if (normalized.startsWith('ratio:')) {
+        const ratioValue = Number.parseFloat(normalized.slice('ratio:'.length));
+        const ratio = Number.isFinite(ratioValue)
+            ? Math.min(Math.max(ratioValue, 0), 1)
+            : 1;
+        base = new samplers.TraceIdRatioBasedSampler(ratio);
+    }
+    else {
+        base = new samplers.AlwaysOnSampler();
+    }
+    return new samplers.ParentBasedSampler({ root: base });
+}
+async function resolveExporter(endpoint, headers, ConsoleSpanExporter) {
+    if (endpoint) {
+        try {
+            const exporterModule = await import(OTEL_EXPORTER_HTTP_SPEC);
+            if ('OTLPTraceExporter' in exporterModule) {
+                const { OTLPTraceExporter } = exporterModule;
+                const exporterOptions = {
+                    url: endpoint,
+                };
+                if (headers && Object.keys(headers).length > 0) {
+                    exporterOptions.headers = headers;
+                }
+                logger.debug('open_telemetry_using_otlp_http_exporter', {
+                    endpoint,
+                    headers_present: Boolean(headers && Object.keys(headers).length),
+                });
+                return new OTLPTraceExporter(exporterOptions);
+            }
+        }
+        catch (error) {
+            logger.error('open_telemetry_exporter_not_available', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    logger.warning('open_telemetry_falling_back_to_console_exporter');
+    return new ConsoleSpanExporter();
+}
+
+var otelSetup = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    setupOtel: setupOtel
+});
+
 class WebSocketTransportProvisioner {
     constructor(options) {
         this.url = options.url;