@naylence/runtime 0.3.4 → 0.3.5-test.1

package/dist/esm/src/naylence/fame/sentinel/node-heartbeat-frame-handler.js

@@ -0,0 +1,94 @@
+import { getLogger } from '../util/logging.js';
+const logger = getLogger('naylence.fame.sentinel.node_heartbeat_frame_handler');
+function normalizeOptions(options) {
+    if (!options || typeof options !== 'object') {
+        throw new Error('NodeHeartbeatFrameHandler requires a routingNode option');
+    }
+    const direct = options;
+    if (Object.prototype.hasOwnProperty.call(direct, 'routingNode') &&
+        direct.routingNode !== undefined &&
+        direct.routingNode !== null) {
+        if (typeof direct.routingNode !== 'object') {
+            throw new Error('routingNode must be an object');
+        }
+        return { routingNode: direct.routingNode };
+    }
+    const candidate = options;
+    if (Object.prototype.hasOwnProperty.call(candidate, 'routing_node')) {
+        const routingNode = candidate['routing_node'];
+        if (routingNode === undefined || routingNode === null) {
+            throw new Error('routingNode must be provided');
+        }
+        if (typeof routingNode !== 'object') {
+            throw new Error('routingNode must be an object');
+        }
+        return { routingNode: routingNode };
+    }
+    throw new Error('routingNode must be provided');
+}
+export class NodeHeartbeatFrameHandler {
+    constructor(options) {
+        const normalized = normalizeOptions(options);
+        this.routingNode = normalized.routingNode;
+    }
+    async acceptNodeHeartbeat(envelope, context) {
+        const frame = envelope.frame;
+        if (!frame || frame.type !== 'NodeHeartbeat') {
+            throw new Error(`Invalid envelope frame. Expected: NodeHeartbeatFrame, actual: ${frame?.type ?? 'unknown'}`);
+        }
+        logger.trace('handling_heartbeat', {
+            hb_system_id: frame.systemId ?? 'unknown',
+            hb_env_id: envelope.id ?? 'unknown',
+            hb_corr_id: envelope.corrId ?? 'unknown',
+        });
+        if (!context) {
+            throw new Error('missing FameDeliveryContext');
+        }
+        const connector = context.fromConnector;
+        if (!connector) {
+            throw new Error('Connector in context does not match pending connector');
+        }
+        const ackFrame = {
+            type: 'NodeHeartbeatAck',
+            ok: true,
+            ...(envelope.id ? { refId: envelope.id } : {}),
+            ...(this.routingNode.routingEpoch
+                ? { routingEpoch: this.routingNode.routingEpoch }
+                : {}),
+        };
+        if (frame.address) {
+            ackFrame.address = frame.address;
+        }
+        const ackEnvelope = this.routingNode.envelopeFactory.createEnvelope({
+            frame: ackFrame,
+            ...(envelope.corrId ? { corrId: envelope.corrId } : {}),
+            ...(envelope.traceId ? { traceId: envelope.traceId } : {}),
+        });
+        logger.debug('sending_heartbeat_ack', {
+            hb_ack_env_id: ackEnvelope.id ?? 'unknown',
+            hb_ack_corr_id: ackEnvelope.corrId ?? 'unknown',
+        });
+        await this.sendAndNotify(connector, ackEnvelope, frame.systemId ?? 'unknown', context);
+    }
+    async sendAndNotify(connector, envelope, forwardRoute, context) {
+        let processed = null;
+        try {
+            processed = await this.routingNode.dispatchEnvelopeEvent('onForwardToRoute', this.routingNode, forwardRoute, envelope, context);
+            if (!processed) {
+                throw new Error('Envelope was blocked by onForwardToRoute event');
+            }
+            await connector.send(processed);
+            await this.routingNode
+                .dispatchEnvelopeEvent('onForwardToRouteComplete', this.routingNode, forwardRoute, processed, undefined, undefined, context)
+                .catch(() => undefined);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            await this.routingNode
+                .dispatchEnvelopeEvent('onForwardToRouteComplete', this.routingNode, forwardRoute, processed ?? envelope, undefined, err, context)
+                .catch(() => undefined);
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=node-heartbeat-frame-handler.js.map

package/dist/esm/src/naylence/fame/sentinel/node-heartbeat-frame-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-heartbeat-frame-handler.js","sourceRoot":"","sources":["../../../../../../src/naylence/fame/sentinel/node-heartbeat-frame-handler.ts"],"names":[],"mappings":"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"}

package/dist/esm/src/naylence/fame/sentinel/peer-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-config.js","sourceRoot":"","sources":["../../../../../../src/naylence/fame/sentinel/peer-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,MAAM,gBAAgB,GAAG,CAAC;KACvB,MAAM,CAAC;IACN,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACzD,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CAC7C,CAAC;KACD,WAAW,EAAE,CAAC;AAEjB,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,KAAK,GAAiB,EAAE,CAAC;IAE/B,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;QAC9B,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;YAChD,SAAS;QACX,CAAC;QAED,MAAM,MAAM,GAAG,gBAAgB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,SAAS;QACX,CAAC;QAED,MAAM,EAAE,SAAS,GAAG,IAAI,EAAE,SAAS,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC;QAE3D,KAAK,CAAC,IAAI,CAAC;YACT,SAAS,EAAE,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI;YAC3D,SAAS,EAAE,CAAC,SAAS,IAAI,IAAI,CAGrB;SACT,CAAC,CAAC;IACL,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/esm/src/naylence/fame/sentinel/peer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer.js","sourceRoot":"","sources":["../../../../../../src/naylence/fame/sentinel/peer.ts"],"names":[],"mappings":"AAMA,MAAM,OAAO,IAAI;IAGf,YAAY,OAAoB;QAC9B,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IACjD,CAAC;CACF"}

package/dist/esm/src/naylence/fame/sentinel/route-manager.js

@@ -0,0 +1,543 @@
+import { AuthorizationContextSchema, DeliveryOriginType, FameResponseType, } from '@naylence/core';
+import { ConnectorFactory, createResource, } from '../connector/connector-factory.js';
+import { FameTransportClose } from '../errors/errors.js';
+import { TaskSpawner } from '../util/task-spawner.js';
+import { delay } from '../util/task-utils.js';
+import { getLogger } from '../util/logging.js';
+import { AsyncLock } from '../util/lock.js';
+import { getDefaultRouteStore, normalizeRouteEntry, } from './store/route-store.js';
+const logger = getLogger('naylence.fame.sentinel.route_manager');
+const DEFAULT_CONNECTOR_CLEANUP_DELAY_MS = 200;
+function normalizeRouteManagerOptions(options) {
+    const { route_store, get_id, cleanup_delay_ms, retain_address_bindings_on_disconnect, ...rest } = options;
+    return {
+        ...rest,
+        routeStore: rest.routeStore ?? route_store,
+        getId: rest.getId ?? get_id,
+        cleanupDelayMs: rest.cleanupDelayMs ?? cleanup_delay_ms,
+        retainAddressBindingsOnDisconnect: rest.retainAddressBindingsOnDisconnect ??
+            retain_address_bindings_on_disconnect,
+    };
+}
+function normalizeRouteRemovalOptions(options) {
+    if (!options) {
+        return undefined;
+    }
+    const { delay_ms, capture_stack, retain_addresses, ...rest } = options;
+    return {
+        ...rest,
+        delayMs: rest.delayMs ?? delay_ms,
+        captureStack: rest.captureStack ?? capture_stack,
+        retainAddresses: rest.retainAddresses ?? retain_addresses,
+    };
+}
+export class RouteManager extends TaskSpawner {
+    constructor(options) {
+        super();
+        this.downstreamRoutes = new Map();
+        this._downstream_addresses_routes = new Map();
+        this._downstream_addresses_legacy = new Map();
+        this._peer_routes = new Map();
+        this._peer_addresses_routes = new Map();
+        this._pending_route_metadata = new Map();
+        this._pools = new Map();
+        this._routesLock = new AsyncLock();
+        this.stopController = new AbortController();
+        this.pendingCleanupControllers = new Map();
+        this.flowRoutes = new Map();
+        this._pending_routes = new Map();
+        const normalizedOptions = normalizeRouteManagerOptions(options);
+        this.deliver = normalizedOptions.deliver;
+        this._downstream_route_store =
+            normalizedOptions.routeStore ?? getDefaultRouteStore();
+        this._peer_route_store =
+            normalizedOptions.routeStore ?? getDefaultRouteStore();
+        this.getId = normalizedOptions.getId ?? (() => '');
+        const configuredDelay = normalizedOptions.cleanupDelayMs;
+        this.cleanupDelayMs = Number.isFinite(configuredDelay ?? NaN)
+            ? Math.max(0, Number(configuredDelay))
+            : DEFAULT_CONNECTOR_CLEANUP_DELAY_MS;
+        this.retainAddressBindingsOnDisconnect =
+            normalizedOptions.retainAddressBindingsOnDisconnect ?? true;
+    }
+    get routesLock() {
+        return this._routesLock;
+    }
+    async start() {
+        await this.restoreRoutes();
+        this.spawn(() => this.janitorLoop(), {
+            name: `route-janitor-${this.getId()}`,
+        });
+    }
+    async stop() {
+        this.stopController.abort();
+        await this._routesLock.runExclusive(async () => {
+            for (const connector of this.downstreamRoutes.values()) {
+                await this.safeStop(connector);
+            }
+            for (const connector of this._peer_routes.values()) {
+                await this.safeStop(connector);
+            }
+            this.downstreamRoutes.clear();
+            this._downstream_addresses_routes.clear();
+            this._downstream_addresses_legacy.clear();
+            this._peer_routes.clear();
+            this._peer_addresses_routes.clear();
+        });
+        for (const entry of this._pending_routes.values()) {
+            try {
+                entry.cancelAttachTimeout?.();
+                await this.safeStop(entry.connector);
+            }
+            catch (error) {
+                logger.debug('pending_route_stop_failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        this._pending_routes.clear();
+        this._pending_route_metadata.clear();
+        await this.shutdownTasks({ cancelHanging: true });
+    }
+    getFlowRoute(flowId) {
+        return this.flowRoutes.get(flowId);
+    }
+    trackFlowRoute(flowId, connector) {
+        this.flowRoutes.set(flowId, connector);
+    }
+    clearFlowRoute(flowId) {
+        this.flowRoutes.delete(flowId);
+    }
+    async registerDownstreamRoute(segment, route) {
+        await this._routesLock.runExclusive(async () => {
+            this.cancelPendingCleanup(segment);
+            this.downstreamRoutes.set(segment, route);
+        });
+        logger.debug('registered_downstream_route', { route: segment });
+    }
+    async unregisterDownstreamRoute(segment, options) {
+        const normalizedOptions = normalizeRouteRemovalOptions(options);
+        await this.removeDownstreamRoute(segment, {
+            ...normalizedOptions,
+            reason: normalizedOptions?.reason ?? 'unregisterDownstreamRoute',
+            retainAddresses: normalizedOptions?.retainAddresses ??
+                this.retainAddressBindingsOnDisconnect,
+        });
+    }
+    async registerPeerRoute(segment, route) {
+        await this._routesLock.runExclusive(async () => {
+            this.cancelPendingCleanup(segment);
+            this._peer_routes.set(segment, route);
+        });
+        logger.debug('registered_peer_route', { route: segment });
+    }
+    async unregisterPeerRoute(segment, options) {
+        const normalizedOptions = normalizeRouteRemovalOptions(options);
+        await this.removePeerRoute(segment, {
+            ...normalizedOptions,
+            reason: normalizedOptions?.reason ?? 'unregisterPeerRoute',
+            retainAddresses: normalizedOptions?.retainAddresses ??
+                this.retainAddressBindingsOnDisconnect,
+        });
+    }
+    async restoreRoutes() {
+        const entries = await this._downstream_route_store.list();
+        const now = new Date();
+        const entryTuples = Object.entries(entries);
+        await Promise.all(entryTuples.map(async ([segment, entry]) => {
+            const normalized = this.normalizeEntry(entry);
+            if (!normalized.connectorConfig) {
+                logger.warning('route_restore_missing_config', { segment });
+                return;
+            }
+            if (normalized.attachExpiresAt && normalized.attachExpiresAt < now) {
+                logger.debug('skipping_expired_route', { segment });
+                return;
+            }
+            const authorization = this.parseAuthorization(normalized.metadata);
+            const connectorConfig = normalized.connectorConfig;
+            let backoff = 2000;
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    const connector = await this.createConnector(connectorConfig);
+                    const deliveryContext = this.buildAuthorizedContext({
+                        segment,
+                        connector,
+                        authorization,
+                    });
+                    await connector.start(async (envelope) => {
+                        await this.deliver(envelope, deliveryContext);
+                        return null;
+                    });
+                    await this._routesLock.runExclusive(async () => {
+                        this.downstreamRoutes.set(segment, connector);
+                    });
+                    if (normalized.attachExpiresAt) {
+                        const delayMs = normalized.attachExpiresAt.getTime() - now.getTime();
+                        if (delayMs > 0) {
+                            this.spawn(() => this.expireRouteLater(segment, delayMs), {
+                                name: `expire-restore-${this.getId()}`,
+                            });
+                        }
+                    }
+                    break;
+                }
+                catch (error) {
+                    if (this.isTransientError(error)) {
+                        logger.warning('transient_restore_failure', {
+                            segment,
+                            attempt,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        await delay(backoff, this.stopController.signal).catch(() => undefined);
+                        backoff *= 2;
+                        continue;
+                    }
+                    logger.error('failed_to_restore_route', {
+                        segment,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    break;
+                }
+            }
+        }));
+    }
+    async expireRouteLater(segment, delayMs) {
+        if (delayMs > 0) {
+            try {
+                await delay(delayMs, this.stopController.signal);
+            }
+            catch {
+                return;
+            }
+        }
+        let connector;
+        await this._routesLock.runExclusive(async () => {
+            connector = this.downstreamRoutes.get(segment);
+            this.downstreamRoutes.delete(segment);
+        });
+        if (connector) {
+            await this.safeStop(connector);
+        }
+        await this._downstream_route_store
+            .delete(segment)
+            .catch((error) => {
+            logger.warning('route_expiration_delete_failed', {
+                segment,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+        this.purgeRouteReferences(segment);
+        logger.debug('expired_route', { route: segment });
+    }
+    async removeDownstreamRoute(segment, options) {
+        const normalizedOptions = normalizeRouteRemovalOptions(options);
+        const retainAddresses = normalizedOptions?.retainAddresses ??
+            this.retainAddressBindingsOnDisconnect;
+        await this.removeRoute(segment, this.downstreamRoutes, this._downstream_route_store, {
+            ...normalizedOptions,
+            retainAddresses,
+        });
+    }
+    async removePeerRoute(segment, options) {
+        const normalizedOptions = normalizeRouteRemovalOptions(options);
+        const retainAddresses = normalizedOptions?.retainAddresses ??
+            this.retainAddressBindingsOnDisconnect;
+        await this.removeRoute(segment, this._peer_routes, this._peer_route_store, {
+            ...normalizedOptions,
+            retainAddresses,
+        });
+    }
+    async removeRoute(segment, routes, store, options) {
+        const normalizedOptions = normalizeRouteRemovalOptions(options);
+        const stop = normalizedOptions?.stop ?? true;
+        const delayMs = normalizedOptions?.delayMs ?? this.cleanupDelayMs;
+        const reason = normalizedOptions?.reason ?? 'unspecified';
+        const captureStack = normalizedOptions?.captureStack !== false;
+        const retainAddresses = normalizedOptions?.retainAddresses ?? false;
+        let connector;
+        let existed = false;
+        await this._routesLock.runExclusive(async () => {
+            connector = routes.get(segment);
+            existed = routes.delete(segment);
+        });
+        if (connector && stop) {
+            await this.cleanupConnector(segment, connector, delayMs);
+        }
+        const orphanedDownstream = [];
+        for (const [address, info] of this._downstream_addresses_routes.entries()) {
+            if (info.segment === segment) {
+                orphanedDownstream.push(address);
+            }
+        }
+        const orphanedLegacy = [];
+        for (const [address, info] of this._downstream_addresses_legacy.entries()) {
+            if (info.segment === segment) {
+                orphanedLegacy.push(address);
+            }
+        }
+        const orphanedPeerAddresses = [];
+        for (const [address, mappedSegment,] of this._peer_addresses_routes.entries()) {
+            if (mappedSegment === segment) {
+                orphanedPeerAddresses.push(address);
+            }
+        }
+        if (!retainAddresses) {
+            this.purgeRouteReferences(segment);
+        }
+        await store.delete(segment).catch((error) => {
+            logger.warning('route_delete_failed', {
+                segment,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+        const removalMeta = {
+            segment,
+            reason,
+            stop,
+            delay_ms: delayMs,
+            existed,
+            had_connector: Boolean(connector),
+            orphaned_downstream_addresses: orphanedDownstream,
+            orphaned_legacy_addresses: orphanedLegacy,
+            orphaned_peer_addresses: orphanedPeerAddresses,
+            meta: normalizedOptions?.meta,
+            caller_stack: captureStack ? captureCallerStack() : undefined,
+            retained_addresses: retainAddresses,
+        };
+        logger.debug('removed_route', removalMeta);
+    }
+    purgeRouteReferences(segment) {
+        for (const [address, info] of this._downstream_addresses_routes.entries()) {
+            if (info.segment === segment) {
+                this._downstream_addresses_routes.delete(address);
+            }
+        }
+        for (const [address, info] of this._downstream_addresses_legacy.entries()) {
+            if (info.segment === segment) {
+                this._downstream_addresses_legacy.delete(address);
+            }
+        }
+        for (const [address, mappedSegment,] of this._peer_addresses_routes.entries()) {
+            if (mappedSegment === segment) {
+                this._peer_addresses_routes.delete(address);
+            }
+        }
+        for (const pool of this._pools.values()) {
+            pool.delete(segment);
+        }
+    }
+    cancelPendingCleanup(segment) {
+        const controller = this.pendingCleanupControllers.get(segment);
+        if (!controller) {
+            return;
+        }
+        controller.abort();
+        this.pendingCleanupControllers.delete(segment);
+    }
+    async cleanupConnector(segment, connector, delayMs) {
+        if (!Number.isFinite(delayMs) || delayMs <= 0) {
+            await this.safeStop(connector);
+            return;
+        }
+        this.cancelPendingCleanup(segment);
+        const controller = new AbortController();
+        this.pendingCleanupControllers.set(segment, controller);
+        this.spawn(async (taskSignal) => {
+            const combined = new AbortController();
+            const abortHandler = () => combined.abort();
+            controller.signal.addEventListener('abort', abortHandler);
+            if (taskSignal) {
+                if (taskSignal.aborted) {
+                    combined.abort();
+                }
+                else {
+                    taskSignal.addEventListener('abort', abortHandler);
+                }
+            }
+            try {
+                await delay(delayMs, combined.signal);
+            }
+            catch (error) {
+                if (combined.signal.aborted) {
+                    logger.debug('connector_cleanup_cancelled', { segment });
+                }
+                else {
+                    logger.debug('connector_cleanup_delay_failed', {
+                        segment,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                return;
+            }
+            finally {
+                controller.signal.removeEventListener('abort', abortHandler);
+                taskSignal?.removeEventListener('abort', abortHandler);
+                if (this.pendingCleanupControllers.get(segment) === controller) {
+                    this.pendingCleanupControllers.delete(segment);
+                }
+            }
+            await this.safeStop(connector);
+        }, { name: `route-cleanup-${segment}-${this.getId()}` });
+    }
+    async safeStop(connector) {
+        try {
+            await connector.stop();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger.debug('connector_stop_ignored', { error: error.message });
+            }
+        }
+        for (const [flowId, peer] of this.flowRoutes.entries()) {
+            if (peer === connector) {
+                this.flowRoutes.delete(flowId);
+            }
+        }
+    }
+    async janitorLoop() {
+        const signal = this.stopController.signal;
+        try {
+            while (!signal.aborted) {
+                const now = new Date();
+                await this.scanStoreForExpirations(this._downstream_route_store, now, 'downstream');
+                await this.scanStoreForExpirations(this._peer_route_store, now, 'peer');
+                try {
+                    await delay(1000, signal);
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            logger.error('janitor_loop_error', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            logger.debug('janitor_loop_exited');
+        }
+    }
+    async scanStoreForExpirations(store, now, kind) {
+        const entries = await store.list();
+        const entryTuples = Object.entries(entries);
+        await Promise.all(entryTuples.map(async ([segment, entry]) => {
+            const normalized = this.normalizeEntry(entry);
+            if (!normalized.attachExpiresAt || normalized.attachExpiresAt >= now) {
+                return;
+            }
+            await this._routesLock.runExclusive(async () => {
+                const map = kind === 'downstream' ? this.downstreamRoutes : this._peer_routes;
+                const connector = map.get(segment);
+                if (connector) {
+                    map.delete(segment);
+                    await this.safeStop(connector);
+                }
+            });
+            await store.delete(segment).catch((error) => {
+                logger.warning('route_auto_expire_delete_failed', {
+                    segment,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+            this.purgeRouteReferences(segment);
+            logger.debug('auto_expired_route', { segment });
+        }));
+    }
+    parseAuthorization(metadata) {
+        if (!metadata) {
+            return null;
+        }
+        try {
+            const base = AuthorizationContextSchema.parse(metadata);
+            const record = metadata;
+            const extraFields = {
+                sub: pickString(record.sub ?? record['sub']),
+                aud: pickString(record.aud ?? record['aud']),
+                assignedPath: pickString(record.assignedPath ?? record['assigned_path']),
+                acceptedCapabilities: pickStringArray(record.acceptedCapabilities ?? record['accepted_capabilities']),
+                acceptedLogicals: pickStringArray(record.acceptedLogicals ?? record['accepted_logicals']),
+                instanceId: pickString(record.instanceId ?? record['instance_id']),
+                scopes: pickStringArray(record.scopes),
+                attachExpiresAt: pickDate(record.attachExpiresAt ?? record['attach_expires_at']),
+            };
+            return { ...base, ...extraFields };
+        }
+        catch (error) {
+            logger.error('corrupt_route_metadata', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    buildAuthorizedContext(options) {
+        const security = options.authorization
+            ? { authorization: options.authorization }
+            : undefined;
+        return {
+            fromSystemId: options.segment,
+            fromConnector: options.connector,
+            originType: DeliveryOriginType.DOWNSTREAM,
+            expectedResponseType: FameResponseType.NONE,
+            security,
+        };
+    }
+    normalizeEntry(entry) {
+        return normalizeRouteEntry(entry);
+    }
+    async createConnector(config) {
+        if (ConnectorFactory &&
+            typeof ConnectorFactory.createConnector === 'function') {
+            return await ConnectorFactory.createConnector(config);
+        }
+        return await createResource(config);
+    }
+    isTransientError(error) {
+        if (error instanceof FameTransportClose) {
+            return true;
+        }
+        if (error instanceof Error) {
+            const message = error.message ?? '';
+            return (message.includes('Timeout') ||
+                message.includes('ECONN') ||
+                message.includes('temporary'));
+        }
+        return false;
+    }
+}
+function pickString(value) {
+    return typeof value === 'string' && value.length ? value : undefined;
+}
+function pickStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const strings = value.filter((entry) => typeof entry === 'string');
+    return strings.length ? strings : undefined;
+}
+function pickDate(value) {
+    if (!value && value !== 0) {
+        return undefined;
+    }
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? undefined : value;
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? undefined : date;
+    }
+    return undefined;
+}
+function captureCallerStack(skip = 3, depth = 6) {
+    const stack = new Error('route removal trace').stack;
+    if (!stack) {
+        return undefined;
+    }
+    const frames = stack.split('\n').slice(skip, skip + depth);
+    if (!frames.length) {
+        return undefined;
+    }
+    return frames.map((frame) => frame.trim()).join(' | ');
+}
+//# sourceMappingURL=route-manager.js.map