@naylence/runtime 0.3.3 → 0.3.5-test.0

package/dist/esm/src/naylence/fame/node/upstream-session-manager.js

@@ -0,0 +1,690 @@
+import { ConnectorFactory } from '../connector/connector-factory.js';
+import { TaskSpawner } from '../util/task-spawner.js';
+import { AsyncEvent } from '../util/async-event.js';
+import { getLogger } from '../util/logging.js';
+import { DeliveryOriginType, FameFabric, generateId, } from '@naylence/core';
+import { FameConnectError, FameMessageTooLarge, FameTransportClose, } from '../errors/errors.js';
+import { TaskCancelledError } from '../util/task-types.js';
+import { FameResponseType } from '@naylence/core';
+const logger = getLogger('naylence.fame.node.upstream_session_manager');
+function isPlainRecord(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (Object.prototype.toString.call(value) !== '[object Object]') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
+function pickOption(record, ...keys) {
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(record, key)) {
+            const value = record[key];
+            if (value !== undefined) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+function coerceStringArray(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const filtered = value.filter((entry) => typeof entry === 'string');
+    return [...filtered];
+}
+function resolveOriginType(value, label) {
+    if (value === undefined || value === null) {
+        throw new Error(`UpstreamSessionManager requires a ${label} option`);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return value;
+}
+function ensureCallback(value, label) {
+    if (typeof value !== 'function') {
+        throw new Error(`UpstreamSessionManager requires a ${label} callback`);
+    }
+    return value;
+}
+function normalizeOptions(options) {
+    if (!isPlainRecord(options)) {
+        throw new Error('UpstreamSessionManager options must be an object');
+    }
+    const record = options;
+    const node = pickOption(record, 'node');
+    if (!node) {
+        throw new Error('UpstreamSessionManager requires a node option');
+    }
+    const attachClient = pickOption(record, 'attachClient', 'attach_client');
+    if (!attachClient) {
+        throw new Error('UpstreamSessionManager requires an attachClient option');
+    }
+    const requestedLogicalsValue = pickOption(record, 'requestedLogicals', 'requested_logicals');
+    const requestedLogicals = coerceStringArray(requestedLogicalsValue) ?? [];
+    const outboundOriginType = resolveOriginType(pickOption(record, 'outboundOriginType', 'outbound_origin_type'), 'outboundOriginType');
+    const inboundOriginType = resolveOriginType(pickOption(record, 'inboundOriginType', 'inbound_origin_type'), 'inboundOriginType');
+    const inboundHandler = pickOption(record, 'inboundHandler', 'inbound_handler');
+    const validatedInboundHandler = ensureCallback(inboundHandler, 'inboundHandler');
+    const onWelcome = pickOption(record, 'onWelcome', 'on_welcome');
+    const validatedOnWelcome = ensureCallback(onWelcome, 'onWelcome');
+    const onAttach = pickOption(record, 'onAttach', 'on_attach');
+    const validatedOnAttach = ensureCallback(onAttach, 'onAttach');
+    const onEpochChangeValue = pickOption(record, 'onEpochChange', 'on_epoch_change');
+    const onEpochChange = typeof onEpochChangeValue === 'function' ? onEpochChangeValue : undefined;
+    const admissionClient = pickOption(record, 'admissionClient', 'admission_client');
+    return {
+        node,
+        attachClient,
+        requestedLogicals,
+        outboundOriginType,
+        inboundOriginType,
+        inboundHandler: validatedInboundHandler,
+        onWelcome: validatedOnWelcome,
+        onAttach: validatedOnAttach,
+        onEpochChange,
+        admissionClient: admissionClient ?? undefined,
+    };
+}
+export class UpstreamSessionManager extends TaskSpawner {
+    constructor(optionsInput) {
+        super();
+        this.readyEvent = new AsyncEvent();
+        this.stopEvent = new AsyncEvent();
+        this.queueEvent = new AsyncEvent();
+        this.currentStopSubtasks = null;
+        this.messageQueue = [];
+        this.fsmTask = null;
+        this.connector = null;
+        this.targetSystemId = null;
+        this.lastHeartbeatAckTime = null;
+        this.lastSeenEpoch = null;
+        this.hadSuccessfulAttach = false;
+        this.connectEpoch = 0;
+        const options = normalizeOptions(optionsInput);
+        this.node = options.node;
+        this.attachClient = options.attachClient;
+        this.requestedLogicals = [...options.requestedLogicals];
+        this.outboundOriginType = options.outboundOriginType;
+        this.inboundOriginType = options.inboundOriginType;
+        this.onWelcome = options.onWelcome;
+        this.onAttach = options.onAttach;
+        this.onEpochChange = options.onEpochChange;
+        this.admissionClient =
+            options.admissionClient ?? options.node.admissionClient;
+        this.wrappedHandler = this.makeHeartbeatEnabledHandler(options.inboundHandler);
+        logger.debug('created_upstream_session_manager', {
+            target_system_id: this.targetSystemId,
+        });
+    }
+    get systemId() {
+        return this.targetSystemId;
+    }
+    async start(options = {}) {
+        const { waitUntilReady = true } = options;
+        if (this.fsmTask) {
+            return;
+        }
+        this.stopEvent.clear();
+        this.readyEvent.clear();
+        const taskName = `upstream-fsm-${this.connectEpoch}`;
+        this.fsmTask = this.spawn(() => this.fsmLoop(), { name: taskName });
+        if (!waitUntilReady) {
+            return;
+        }
+        const readyPromise = this.readyEvent.wait();
+        await Promise.race([readyPromise, this.fsmTask.promise]);
+        if (!this.readyEvent.isSet()) {
+            if (this.fsmTask) {
+                await this.fsmTask.promise;
+            }
+            throw new FameConnectError('Upstream session manager failed to attach');
+        }
+        logger.debug('upstream_session_manager_started');
+    }
+    getActiveConnector() {
+        return this.connector;
+    }
+    async stop() {
+        logger.debug('upstream_session_manager_stopping');
+        this.stopEvent.set();
+        this.currentStopSubtasks?.set();
+        if (this.fsmTask) {
+            this.fsmTask.cancel();
+            try {
+                await this.fsmTask.promise;
+            }
+            catch (error) {
+                if (!(error instanceof TaskCancelledError)) {
+                    logger.debug('fsm_task_stopped_with_error', {
+                        error: error.message,
+                    });
+                }
+            }
+            this.fsmTask = null;
+        }
+        if (this.connector) {
+            await this.connector.stop().catch((error) => {
+                logger.debug('connector_stop_error', {
+                    error: error.message,
+                });
+            });
+            this.connector = null;
+        }
+        logger.debug('upstream_session_manager_stopped');
+    }
+    async send(envelope) {
+        if (this.messageQueue.length >= UpstreamSessionManager.TX_QUEUE_MAX) {
+            throw new Error('Upstream message queue is full');
+        }
+        this.messageQueue.push(envelope);
+        this.queueEvent.set();
+    }
+    isReady() {
+        return this.readyEvent.isSet();
+    }
+    async awaitReady(timeoutMs) {
+        if (this.isReady()) {
+            return;
+        }
+        const readyPromise = this.readyEvent.wait();
+        if (timeoutMs === undefined) {
+            await readyPromise;
+            return;
+        }
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new FameConnectError('Timed out waiting for upstream ready')), timeoutMs);
+        });
+        await Promise.race([readyPromise, timeoutPromise]);
+    }
+    async fsmLoop() {
+        let delay = UpstreamSessionManager.BACKOFF_INITIAL;
+        while (!this.stopEvent.isSet()) {
+            try {
+                await this.connectCycle();
+                delay = UpstreamSessionManager.BACKOFF_INITIAL;
+            }
+            catch (error) {
+                if (error instanceof TaskCancelledError) {
+                    throw error;
+                }
+                if (error instanceof FameTransportClose ||
+                    error instanceof FameConnectError) {
+                    logger.warning('upstream_link_closed', {
+                        error: error.message,
+                        will_retry: true,
+                    });
+                    if (!this.hadSuccessfulAttach && error instanceof FameConnectError) {
+                        throw error;
+                    }
+                }
+                else {
+                    logger.warning('upstream_link_closed', {
+                        error: error.message,
+                        will_retry: true,
+                        exc_info: true,
+                    });
+                    if (!this.hadSuccessfulAttach) {
+                        throw error;
+                    }
+                }
+                delay = await this.applyBackoff(delay);
+            }
+        }
+    }
+    async applyBackoff(delay) {
+        const jitter = Math.random() * delay;
+        await this.sleepWithStop(delay + jitter);
+        return Math.min(delay * 2, UpstreamSessionManager.BACKOFF_CAP);
+    }
+    async sleepWithStop(delaySeconds) {
+        if (delaySeconds <= 0) {
+            return;
+        }
+        let timeout;
+        const sleepPromise = new Promise((resolve) => {
+            timeout = setTimeout(() => {
+                timeout = undefined;
+                resolve();
+            }, delaySeconds * 1000);
+        });
+        await Promise.race([sleepPromise, this.stopEvent.wait()]);
+        if (timeout !== undefined) {
+            clearTimeout(timeout);
+        }
+    }
+    getNodeAttachGrant(connectionGrants) {
+        if (!connectionGrants) {
+            return null;
+        }
+        for (const grant of connectionGrants) {
+            if (grant?.purpose === 'node.attach') {
+                return grant;
+            }
+        }
+        return null;
+    }
+    waitEvent(event, signal) {
+        return signal ? event.wait({ signal }) : event.wait();
+    }
+    async connectCycle() {
+        if (!this.admissionClient) {
+            throw new FameConnectError('Admission client is required to attach upstream');
+        }
+        this.connectEpoch += 1;
+        const welcome = await this.admissionClient.hello(this.node.id, generateId(), this.requestedLogicals);
+        const connectionGrants = welcome.frame.connectionGrants;
+        if (!connectionGrants?.length) {
+            throw new Error('Welcome frame missing connection grants');
+        }
+        const grant = this.getNodeAttachGrant(connectionGrants);
+        if (!grant) {
+            throw new Error('Welcome frame missing node attach grant');
+        }
+        const cryptoProvider = this.node.cryptoProvider; //getCryptoProvider();
+        if (welcome.frame.assignedPath && cryptoProvider?.prepareForAttach) {
+            cryptoProvider.prepareForAttach(welcome.frame.systemId, welcome.frame.assignedPath, welcome.frame.acceptedLogicals ?? []);
+        }
+        await this.onWelcome(welcome.frame);
+        const connector = await ConnectorFactory.createConnector(grant, {
+            systemId: welcome.frame.systemId,
+        });
+        await connector.start(this.wrappedHandler);
+        this.connector = connector;
+        const callbackGrants = this.node.gatherSupportedCallbackGrants();
+        const attachInfo = await this.attachClient.attach(this.node, this.outboundOriginType, connector, welcome.frame, this.wrappedHandler, this.getKeys() ?? undefined, callbackGrants);
+        this.targetSystemId = attachInfo.targetSystemId ?? null;
+        await this.onAttach(attachInfo, connector);
+        // Close the admission client immediately after attach completes
+        // This releases HTTP keep-alive connections (Node.js fetch/undici requires explicit cleanup)
+        if (this.admissionClient) {
+            await this.admissionClient.close();
+        }
+        const epoch = attachInfo.routingEpoch;
+        if (epoch && epoch !== this.lastSeenEpoch) {
+            this.lastSeenEpoch = epoch;
+            if (this.onEpochChange) {
+                this.spawn(() => this.onEpochChange(epoch), {
+                    name: `epoch-change-${epoch}`,
+                });
+            }
+            else {
+                logger.warning('parent_epoch_changed', { epoch });
+            }
+        }
+        if (!this.readyEvent.isSet()) {
+            this.readyEvent.set();
+        }
+        if (this.messageQueue.length > 0) {
+            logger.debug('flushing_buffered_frames', {
+                queue_size: this.messageQueue.length,
+            });
+            this.queueEvent.set();
+        }
+        const stopSubtasks = new AsyncEvent();
+        this.currentStopSubtasks = stopSubtasks;
+        const heartbeatTask = this.spawn((signal) => this.heartbeatLoop(connector, stopSubtasks, signal), {
+            name: `upstream-heartbeat-${this.connectEpoch}`,
+        });
+        const messagePumpTask = this.spawn((signal) => this.messagePumpLoop(connector, stopSubtasks, signal), {
+            name: `message-pump-${this.connectEpoch}`,
+        });
+        const expiryGuardTask = this.spawn((signal) => this.expiryGuard(connector, welcome, attachInfo, stopSubtasks, signal), {
+            name: `expiry-guard-${this.connectEpoch}`,
+        });
+        if (this.hadSuccessfulAttach) {
+            logger.debug('reconnected_to_upstream', {
+                attach_expires_at: attachInfo.attachExpiresAt?.toISOString?.() ?? null,
+            });
+        }
+        else {
+            logger.debug('connected_to_upstream', {
+                attach_expires_at: attachInfo.attachExpiresAt?.toISOString?.() ?? null,
+            });
+        }
+        this.hadSuccessfulAttach = true;
+        const tasks = [heartbeatTask, messagePumpTask, expiryGuardTask];
+        let failure = null;
+        try {
+            await this.waitForFailureOrStop(tasks, stopSubtasks);
+        }
+        catch (error) {
+            failure = error;
+        }
+        finally {
+            stopSubtasks.set();
+            this.currentStopSubtasks = null;
+            await Promise.allSettled(tasks.map((task) => task.promise));
+            if (this.connector) {
+                await this.connector.stop().catch(() => undefined);
+                this.connector = null;
+            }
+        }
+        if (failure) {
+            throw failure;
+        }
+    }
+    getKeys() {
+        const securityManager = this.node.securityManager;
+        if (!securityManager || !securityManager.supportsOverlaySecurity) {
+            return null;
+        }
+        const shareable = securityManager.getShareableKeys();
+        if (Array.isArray(shareable)) {
+            return shareable.length ? shareable : null;
+        }
+        if (shareable && typeof shareable === 'object') {
+            return [shareable];
+        }
+        const provider = this.node.cryptoProvider;
+        if (!provider) {
+            return null;
+        }
+        const keys = [];
+        const nodeJwk = provider.nodeJwk?.();
+        if (nodeJwk) {
+            keys.push(nodeJwk);
+        }
+        const jwks = provider.getJwks?.();
+        if (jwks?.keys) {
+            for (const jwk of jwks.keys) {
+                if (nodeJwk &&
+                    jwk?.kid === nodeJwk.kid &&
+                    jwk?.use !== 'enc') {
+                    continue;
+                }
+                keys.push(jwk);
+            }
+        }
+        return keys.length ? keys : null;
+    }
+    async waitForFailureOrStop(tasks, stopEvt) {
+        const stopPromise = stopEvt.wait().then(() => ({ type: 'stop' }));
+        const wrappedTasks = tasks.map((task) => task.promise
+            .then(() => ({ type: 'task', error: null }))
+            .catch((error) => ({ type: 'task', error: error })));
+        const result = await Promise.race([stopPromise, ...wrappedTasks]);
+        if (result.type === 'stop') {
+            tasks.forEach((task) => task.cancel());
+            return;
+        }
+        if (result.error && !(result.error instanceof TaskCancelledError)) {
+            throw result.error;
+        }
+    }
+    async heartbeatLoop(connector, stopEvt, signal) {
+        logger.debug('starting_heartbeat_loop');
+        const intervalMs = UpstreamSessionManager.HEARTBEAT_INTERVAL * 1000;
+        const graceMs = intervalMs * UpstreamSessionManager.HEARTBEAT_GRACE;
+        this.lastHeartbeatAckTime = Date.now();
+        while (!stopEvt.isSet() && !signal?.aborted) {
+            let timer;
+            try {
+                await Promise.race([
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => {
+                            timer = undefined;
+                            resolve();
+                        }, intervalMs);
+                    }),
+                    this.waitEvent(stopEvt, signal),
+                ]);
+            }
+            catch (error) {
+                if (error instanceof TaskCancelledError) {
+                    throw error;
+                }
+            }
+            finally {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+            }
+            if (stopEvt.isSet() || signal?.aborted) {
+                break;
+            }
+            const envelope = await this.makeHeartbeatEnvelope();
+            logger.debug('sending_heartbeat', {
+                hb_corr_id: envelope.corrId,
+                hb_env_id: envelope.id,
+            });
+            const context = {
+                originType: DeliveryOriginType.LOCAL,
+                expectedResponseType: FameResponseType.NONE,
+            };
+            try {
+                await this.node.dispatchEnvelopeEvent('onForwardUpstream', this.node, envelope, context);
+                await connector.send(envelope);
+                await this.node.dispatchEnvelopeEvent('onForwardUpstreamComplete', this.node, envelope, undefined, undefined, context);
+            }
+            catch (error) {
+                await this.node
+                    .dispatchEnvelopeEvent('onForwardUpstreamComplete', this.node, envelope, error, undefined, context)
+                    .catch(() => undefined);
+                throw error;
+            }
+            await this.node.dispatchEvent('onHeartbeatSent', this.node, envelope);
+            if (this.lastHeartbeatAckTime !== null &&
+                Date.now() - this.lastHeartbeatAckTime > graceMs) {
+                throw new FameConnectError('missed heartbeat acknowledgement');
+            }
+        }
+        logger.debug('completed_heartbeat_loop');
+    }
+    async messagePumpLoop(connector, stopEvt, signal) {
+        while (!stopEvt.isSet() && !signal?.aborted) {
+            let envelope = null;
+            try {
+                envelope = await this.takeMessage(stopEvt, signal);
+            }
+            catch (error) {
+                if (error instanceof TaskCancelledError) {
+                    return;
+                }
+                throw error;
+            }
+            if (!envelope) {
+                continue;
+            }
+            try {
+                await connector.send(envelope);
+            }
+            catch (error) {
+                if (error instanceof FameMessageTooLarge) {
+                    logger.error('failed_to_send_message', { error: error.message });
+                    await this.handleMessageTooLarge(envelope, error.message);
+                }
+                else if (error instanceof FameTransportClose) {
+                    this.requeueFront(envelope);
+                    throw error;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    requeueFront(envelope) {
+        this.messageQueue.unshift(envelope);
+        this.queueEvent.set();
+    }
+    async takeMessage(stopEvt, signal) {
+        while (true) {
+            if (this.messageQueue.length > 0) {
+                const envelope = this.messageQueue.shift();
+                if (this.messageQueue.length === 0) {
+                    this.queueEvent.clear();
+                }
+                return envelope;
+            }
+            if (stopEvt.isSet() || signal?.aborted) {
+                return null;
+            }
+            await Promise.race([
+                this.waitEvent(this.queueEvent, signal),
+                this.waitEvent(stopEvt, signal),
+            ]);
+            if (stopEvt.isSet() || signal?.aborted) {
+                return null;
+            }
+        }
+    }
+    async handleMessageTooLarge(envelope, reason) {
+        const corrId = envelope.corrId;
+        const replyTo = envelope.replyTo;
+        if (!corrId || !replyTo) {
+            return;
+        }
+        try {
+            const fabric = FameFabric.current();
+            const nack = {
+                type: 'DeliveryAck',
+                ok: false,
+                refId: envelope.id,
+                code: 'MESSAGE_TOO_LARGE',
+                reason,
+            };
+            const target = replyTo;
+            const ackEnvelope = this.node.envelopeFactory.createEnvelope({
+                to: target,
+                frame: nack,
+                corrId,
+            });
+            await fabric.send(ackEnvelope);
+        }
+        catch (error) {
+            logger.warning('failed_to_send_nack', {
+                error: error.message,
+            });
+        }
+    }
+    async expiryGuard(connector, welcome, info, stopEvt, signal) {
+        const timestamps = [];
+        if (welcome.frame.expiresAt) {
+            timestamps.push(new Date(welcome.frame.expiresAt));
+        }
+        if (info.attachExpiresAt) {
+            timestamps.push(info.attachExpiresAt);
+        }
+        if (!timestamps.length) {
+            logger.debug('no_ttl_expiry_configured');
+            await this.waitEvent(stopEvt, signal);
+            return;
+        }
+        const earliest = timestamps.reduce((min, current) => current < min ? current : min);
+        const now = new Date();
+        let delaySeconds = (earliest.getTime() - now.getTime()) / 1000 -
+            UpstreamSessionManager.JWT_REFRESH_SAFETY;
+        delaySeconds = Math.max(delaySeconds, UpstreamSessionManager.JWT_REFRESH_SAFETY);
+        logger.debug('ttl_expiry_guard_started', {
+            welcome_expires_at: welcome.frame.expiresAt ?? null,
+            attach_expires_at: info.attachExpiresAt?.toISOString?.() ?? null,
+            earliest_expiry: earliest.toISOString(),
+            delay_seconds: delaySeconds,
+            refresh_safety_seconds: UpstreamSessionManager.JWT_REFRESH_SAFETY,
+        });
+        if (delaySeconds > 0) {
+            let timer;
+            try {
+                await Promise.race([
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => {
+                            timer = undefined;
+                            resolve();
+                        }, delaySeconds * 1000);
+                        timer?.unref?.();
+                    }),
+                    this.waitEvent(stopEvt, signal),
+                ]);
+            }
+            finally {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+            }
+        }
+        if (!stopEvt.isSet()) {
+            logger.debug('ttl_expiry_triggered_reconnect', {
+                expires_at: earliest.toISOString(),
+                current_time: new Date().toISOString(),
+                seconds_before_expiry: UpstreamSessionManager.JWT_REFRESH_SAFETY,
+            });
+            await connector.stop();
+        }
+    }
+    async makeHeartbeatEnvelope() {
+        const envelope = this.node.envelopeFactory.createEnvelope({
+            frame: { type: 'NodeHeartbeat' },
+            corrId: generateId(),
+        });
+        return envelope;
+    }
+    makeHeartbeatEnabledHandler(downstream) {
+        return async (env, context) => {
+            const authorizationContext = this.connector?.authorizationContext;
+            if (!context) {
+                context = {
+                    originType: this.inboundOriginType,
+                    fromConnector: this.connector ?? undefined,
+                    fromSystemId: this.targetSystemId ?? undefined,
+                    security: {
+                        authorization: authorizationContext,
+                    },
+                    expectedResponseType: FameResponseType.NONE,
+                };
+            }
+            else {
+                context.originType = this.inboundOriginType;
+                context.fromConnector = this.connector ?? undefined;
+                context.fromSystemId = this.targetSystemId ?? undefined;
+                if (!context.security) {
+                    context.security = {};
+                }
+                if (!context.security.authorization) {
+                    context.security.authorization = authorizationContext;
+                }
+                if (context.expectedResponseType === undefined) {
+                    context.expectedResponseType = FameResponseType.NONE;
+                }
+            }
+            await this.node.dispatchEnvelopeEvent('onEnvelopeReceived', this.node, env, context);
+            if (env.frame.type === 'NodeHeartbeatAck') {
+                logger.debug('received_heartbeat_ack', {
+                    hb_ack_env_id: env.id,
+                    hb_ack_corr_id: env.corrId,
+                    hb_routing_epoch: env.frame.routingEpoch,
+                });
+                await this.node.dispatchEvent('onHeartbeatReceived', this.node, env);
+                this.lastHeartbeatAckTime = Date.now();
+                const epoch = env.frame.routingEpoch;
+                if (epoch && epoch !== this.lastSeenEpoch) {
+                    this.lastSeenEpoch = epoch;
+                    if (this.onEpochChange) {
+                        await this.onEpochChange(epoch);
+                    }
+                    else {
+                        logger.warning('parent_epoch_changed', { epoch });
+                    }
+                }
+                return;
+            }
+            if (env.frame.type === 'NodeAttachAck') {
+                return;
+            }
+            return await downstream(env, context);
+        };
+    }
+}
+UpstreamSessionManager.HEARTBEAT_INTERVAL = 15; // seconds
+UpstreamSessionManager.HEARTBEAT_GRACE = 2.0;
+UpstreamSessionManager.JWT_REFRESH_SAFETY = 60; // seconds
+UpstreamSessionManager.TX_QUEUE_MAX = 512;
+UpstreamSessionManager.BACKOFF_INITIAL = 1; // seconds
+UpstreamSessionManager.BACKOFF_CAP = 30; // seconds
+//# sourceMappingURL=upstream-session-manager.js.map