@naylence/runtime 0.3.5-test.908 → 0.3.5-test.910

package/dist/esm/naylence/fame/connector/broadcast-channel-listener.js

@@ -0,0 +1,479 @@
+import { DeliveryOriginType, FameChannelMessage, FameResponseType, deserializeEnvelope, } from '@naylence/core';
+import { ZodError } from 'zod';
+import { TransportListener } from './transport-listener.js';
+import { getLogger } from '../util/logging.js';
+import { GRANT_PURPOSE_NODE_ATTACH } from '../grants/grant.js';
+import { BROADCAST_CHANNEL_CONNECTOR_TYPE, } from './broadcast-channel-connector.js';
+import { GrantSelectionContext, defaultGrantSelectionPolicy, } from './grant-selection-policy.js';
+import { QueueFullError } from '../util/bounded-async-queue.js';
+import { BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE, broadcastChannelGrantToConnectorConfig, } from '../grants/broadcast-channel-connection-grant.js';
+const logger = getLogger('naylence.fame.connector.broadcast_channel_listener');
+const DEFAULT_CHANNEL = 'naylence-fabric';
+const DEFAULT_INBOX_CAPACITY = 2048;
+const RESPONSE_TYPE_MASK = FameResponseType.ACK |
+    FameResponseType.REPLY |
+    FameResponseType.STREAM;
+const isBrowserEnvironment = () => typeof window !== 'undefined' &&
+    typeof BroadcastChannel !== 'undefined' &&
+    typeof MessageEvent !== 'undefined';
+const ensureBrowserEnvironment = () => {
+    if (!isBrowserEnvironment()) {
+        throw new Error('BroadcastChannelListener is browser-only and requires BroadcastChannel support');
+    }
+};
+let _lastBroadcastChannelListenerInstance = null;
+const coercePayload = (raw) => {
+    if (raw instanceof Uint8Array) {
+        return raw;
+    }
+    if (raw instanceof ArrayBuffer) {
+        return new Uint8Array(raw);
+    }
+    if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(raw)) {
+        const view = raw;
+        return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    }
+    if (raw && typeof raw === 'object') {
+        const candidate = raw;
+        if (candidate.constructor?.name === 'Uint8Array') {
+            const view = raw;
+            return new Uint8Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+        }
+    }
+    if (Array.isArray(raw) && raw.every((item) => typeof item === 'number')) {
+        return Uint8Array.from(raw);
+    }
+    return null;
+};
+const isRoutingNodeLike = (node) => typeof node.createOriginConnector === 'function';
+export class BroadcastChannelListener extends TransportListener {
+    constructor(options) {
+        super();
+        this._isRunning = false;
+        this._initialized = false;
+        this._routingNode = null;
+        this._channel = null;
+        this._channelHandler = null;
+        this._senderRegistry = new Map();
+        this._systemToSender = new Map();
+        this._pendingAttachments = new Map();
+        ensureBrowserEnvironment();
+        const channelCandidate = options?.channelName;
+        const inboxCandidate = options?.inboxCapacity;
+        this._channelName =
+            typeof channelCandidate === 'string' && channelCandidate.trim().length > 0
+                ? channelCandidate.trim()
+                : DEFAULT_CHANNEL;
+        const normalizedCapacity = typeof inboxCandidate === 'number' &&
+            Number.isFinite(inboxCandidate) &&
+            inboxCandidate > 0
+            ? Math.floor(inboxCandidate)
+            : DEFAULT_INBOX_CAPACITY;
+        this._inboxCapacity = normalizedCapacity;
+        _lastBroadcastChannelListenerInstance = this;
+    }
+    get channelName() {
+        return this._channelName;
+    }
+    get inboxCapacity() {
+        return this._inboxCapacity;
+    }
+    get isRunning() {
+        return this._isRunning;
+    }
+    get initialized() {
+        return this._initialized;
+    }
+    async onNodeInitialized(node) {
+        ensureBrowserEnvironment();
+        if (this._initialized) {
+            return;
+        }
+        this._routingNode = isRoutingNodeLike(node) ? node : null;
+        this._initialized = true;
+        logger.debug('broadcast_channel_listener_initialized', {
+            channel: this._channelName,
+            inbox_capacity: this._inboxCapacity,
+            routing_capable: Boolean(this._routingNode),
+        });
+    }
+    async onNodeStarted(node) {
+        ensureBrowserEnvironment();
+        if (this._isRunning) {
+            return;
+        }
+        if (!this._routingNode && isRoutingNodeLike(node)) {
+            this._routingNode = node;
+        }
+        if (this._routingNode) {
+            this._registerChannelListener();
+        }
+        else {
+            logger.warning('broadcast_channel_listener_missing_routing_capability');
+        }
+        this._isRunning = true;
+        logger.debug('broadcast_channel_listener_started', {
+            channel: this._channelName,
+        });
+    }
+    async onNodeStopped(_node) {
+        if (!this._isRunning) {
+            return;
+        }
+        this._isRunning = false;
+        this._unregisterChannelListener();
+        this._senderRegistry.clear();
+        this._systemToSender.clear();
+        this._pendingAttachments.clear();
+        logger.debug('broadcast_channel_listener_stopped', {
+            channel: this._channelName,
+        });
+    }
+    getCallbackGrant() {
+        return this.withLegacySnakeCaseKeys({
+            type: BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE,
+            purpose: GRANT_PURPOSE_NODE_ATTACH,
+            channelName: this._channelName,
+            inboxCapacity: this._inboxCapacity,
+        });
+    }
+    asCallbackGrant() {
+        return this.withLegacySnakeCaseKeys({
+            type: BROADCAST_CHANNEL_CONNECTOR_TYPE,
+            connectorType: BROADCAST_CHANNEL_CONNECTOR_TYPE,
+            connectionGrantType: BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE,
+            channelName: this._channelName,
+            inboxCapacity: this._inboxCapacity,
+        });
+    }
+    _registerChannelListener() {
+        if (this._channelHandler) {
+            return;
+        }
+        ensureBrowserEnvironment();
+        const channel = new BroadcastChannel(this._channelName);
+        const handler = (event) => {
+            void this._handleChannelEvent(event);
+        };
+        channel.addEventListener('message', handler);
+        this._channel = channel;
+        this._channelHandler = handler;
+    }
+    _unregisterChannelListener() {
+        if (!this._channel || !this._channelHandler) {
+            return;
+        }
+        this._channel.removeEventListener('message', this._channelHandler);
+        this._channel.close();
+        this._channel = null;
+        this._channelHandler = null;
+    }
+    async _handleChannelEvent(event) {
+        if (!this._routingNode) {
+            return;
+        }
+        const normalized = this._parseChannelEvent(event);
+        if (!normalized) {
+            return;
+        }
+        const { senderId, envelope } = normalized;
+        if (this._isNodeAttachFrame(envelope.frame)) {
+            await this._handleAttachFrame(senderId, envelope);
+            return;
+        }
+        const entry = this._senderRegistry.get(senderId);
+        if (!entry) {
+            logger.debug('broadcast_channel_listener_no_connector_for_sender', {
+                sender_id: senderId,
+                frame_type: envelope.frame?.type ?? 'unknown',
+            });
+            return;
+        }
+        await this._deliverEnvelope(entry, envelope);
+    }
+    _parseChannelEvent(event) {
+        if (!event || typeof event !== 'object') {
+            return null;
+        }
+        const payloadContainer = event.data;
+        if (!payloadContainer || typeof payloadContainer !== 'object') {
+            return null;
+        }
+        const record = payloadContainer;
+        const senderId = record.senderId;
+        if (typeof senderId !== 'string' || senderId.length === 0) {
+            return null;
+        }
+        const payload = coercePayload(record.payload);
+        if (!payload) {
+            logger.debug('broadcast_channel_listener_ignored_event_without_payload', {
+                sender_id: senderId,
+            });
+            return null;
+        }
+        let envelope;
+        try {
+            const decoded = new TextDecoder().decode(payload);
+            const parsed = JSON.parse(decoded);
+            envelope = deserializeEnvelope(parsed);
+        }
+        catch (error) {
+            const decoded = (() => {
+                try {
+                    return new TextDecoder().decode(payload);
+                }
+                catch {
+                    return null;
+                }
+            })();
+            if (error instanceof ZodError &&
+                decoded &&
+                decoded.length > 0) {
+                try {
+                    const reparsed = JSON.parse(decoded);
+                    const candidate = reparsed.rtype;
+                    if (typeof candidate === 'number' &&
+                        (candidate & ~RESPONSE_TYPE_MASK) === 0) {
+                        const sanitized = { ...reparsed };
+                        delete sanitized.rtype;
+                        const baseEnvelope = deserializeEnvelope(sanitized);
+                        envelope = {
+                            ...baseEnvelope,
+                            rtype: candidate,
+                        };
+                        logger.debug('broadcast_channel_listener_envelope_rtype_bitmask_coerced', {
+                            sender_id: senderId,
+                            rtype: candidate,
+                        });
+                        return { senderId, envelope };
+                    }
+                }
+                catch (fallbackError) {
+                    logger.debug('broadcast_channel_listener_envelope_parse_failed', {
+                        sender_id: senderId,
+                        error: fallbackError instanceof Error
+                            ? fallbackError.message
+                            : String(fallbackError),
+                        raw_payload: decoded,
+                    });
+                    return null;
+                }
+            }
+            logger.debug('broadcast_channel_listener_envelope_parse_failed', {
+                sender_id: senderId,
+                error: error instanceof Error ? error.message : String(error),
+                raw_payload: decoded ?? '<un-decodable>',
+            });
+            return null;
+        }
+        return { senderId, envelope };
+    }
+    async _handleAttachFrame(senderId, envelope) {
+        const frame = envelope.frame;
+        const systemId = frame.systemId;
+        if (typeof systemId !== 'string' || systemId.length === 0) {
+            logger.warning('broadcast_channel_listener_attach_missing_system_id', {
+                sender_id: senderId,
+            });
+            return;
+        }
+        logger.debug('broadcast_channel_listener_attach_frame_received', {
+            sender_id: senderId,
+            fields: Object.keys(frame ?? {}),
+        });
+        const normalizedOrigin = frame.originType ?? DeliveryOriginType.DOWNSTREAM;
+        const existingEntry = this._senderRegistry.get(senderId);
+        if (existingEntry) {
+            await this._deliverEnvelope(existingEntry, envelope);
+            return;
+        }
+        const pending = this._pendingAttachments.get(senderId);
+        if (pending) {
+            await pending.catch(() => null);
+            return;
+        }
+        const creationPromise = this._createConnectorForAttach({
+            senderId,
+            frame,
+            envelope,
+            originType: normalizedOrigin,
+        });
+        this._pendingAttachments.set(senderId, creationPromise);
+        const entry = await creationPromise.catch(() => null);
+        this._pendingAttachments.delete(senderId);
+        if (!entry) {
+            return;
+        }
+        this._senderRegistry.set(senderId, entry);
+        this._systemToSender.set(entry.systemId, senderId);
+        await this._deliverEnvelope(entry, envelope);
+    }
+    async _createConnectorForAttach(params) {
+        const routingNode = this._routingNode;
+        if (!routingNode) {
+            return null;
+        }
+        const { frame, originType } = params;
+        const systemId = frame.systemId;
+        let connectorConfig = null;
+        try {
+            const selectionContext = new GrantSelectionContext({
+                childId: systemId,
+                attachFrame: frame,
+                callbackGrantType: BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE,
+                node: routingNode,
+            });
+            const selection = defaultGrantSelectionPolicy.selectCallbackGrant(selectionContext);
+            connectorConfig = this._grantToConnectorConfig(selection.grant);
+        }
+        catch (error) {
+            logger.debug('broadcast_channel_listener_grant_selection_failed', {
+                sender_id: params.senderId,
+                system_id: systemId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            connectorConfig =
+                this._extractBroadcastConnectorConfig(frame) ??
+                    {
+                        type: BROADCAST_CHANNEL_CONNECTOR_TYPE,
+                        channelName: this._channelName,
+                        inboxCapacity: this._inboxCapacity,
+                    };
+        }
+        try {
+            const connector = await routingNode.createOriginConnector({
+                originType,
+                systemId,
+                connectorConfig,
+            });
+            this._monitorConnectorLifecycle(params.senderId, systemId, connector);
+            logger.debug('broadcast_channel_listener_created_connector', {
+                sender_id: params.senderId,
+                system_id: systemId,
+                origin_type: originType,
+                connector_type: connector.constructor?.name ?? 'unknown',
+            });
+            return { connector, systemId, originType };
+        }
+        catch (error) {
+            logger.error('broadcast_channel_listener_connector_creation_failed', {
+                sender_id: params.senderId,
+                system_id: systemId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    _extractBroadcastConnectorConfig(frame) {
+        const rawGrants = frame.callbackGrants;
+        if (!Array.isArray(rawGrants)) {
+            return null;
+        }
+        for (const grant of rawGrants) {
+            if (grant &&
+                typeof grant === 'object' &&
+                (grant.type === BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE ||
+                    grant.type === BROADCAST_CHANNEL_CONNECTOR_TYPE)) {
+                try {
+                    return this._grantToConnectorConfig(grant);
+                }
+                catch (error) {
+                    logger.debug('broadcast_channel_listener_grant_normalization_failed', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+        return null;
+    }
+    _grantToConnectorConfig(grant) {
+        if (grant.type !== BROADCAST_CHANNEL_CONNECTOR_TYPE) {
+            if (grant.type === BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE) {
+                return broadcastChannelGrantToConnectorConfig(grant);
+            }
+            throw new Error(`Unsupported grant type: ${grant.type}`);
+        }
+        const candidate = grant;
+        const config = {
+            type: BROADCAST_CHANNEL_CONNECTOR_TYPE,
+            channelName: this._channelName,
+            inboxCapacity: this._inboxCapacity,
+        };
+        const channelCandidate = candidate.channelName ?? candidate['channel_name'];
+        if (typeof channelCandidate === 'string' && channelCandidate.trim().length > 0) {
+            config.channelName = channelCandidate.trim();
+        }
+        const inboxCandidate = candidate.inboxCapacity ?? candidate['inbox_capacity'];
+        if (typeof inboxCandidate === 'number' &&
+            Number.isFinite(inboxCandidate) &&
+            inboxCandidate > 0) {
+            config.inboxCapacity = Math.floor(inboxCandidate);
+        }
+        return config;
+    }
+    _monitorConnectorLifecycle(senderId, systemId, connector) {
+        const maybeClosable = connector;
+        if (typeof maybeClosable.waitUntilClosed !== 'function') {
+            return;
+        }
+        void maybeClosable
+            .waitUntilClosed()
+            .then(() => {
+            this._senderRegistry.delete(senderId);
+            if (this._systemToSender.get(systemId) === senderId) {
+                this._systemToSender.delete(systemId);
+            }
+        })
+            .catch((error) => {
+            logger.debug('broadcast_channel_listener_wait_until_closed_failed', {
+                sender_id: senderId,
+                system_id: systemId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this._senderRegistry.delete(senderId);
+            if (this._systemToSender.get(systemId) === senderId) {
+                this._systemToSender.delete(systemId);
+            }
+        });
+    }
+    async _deliverEnvelope(entry, envelope) {
+        const message = this._buildChannelMessage({
+            envelope,
+            connector: entry.connector,
+            originType: entry.originType,
+            systemId: entry.systemId,
+        });
+        try {
+            await entry.connector.pushToReceive(message);
+        }
+        catch (error) {
+            if (error instanceof QueueFullError) {
+                logger.warning('broadcast_channel_listener_receive_queue_full', {
+                    system_id: entry.systemId,
+                });
+                return;
+            }
+            logger.error('broadcast_channel_listener_push_failed', {
+                system_id: entry.systemId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    _buildChannelMessage(params) {
+        const context = {
+            originType: params.originType,
+            fromConnector: params.connector,
+            fromSystemId: params.systemId,
+            expectedResponseType: FameResponseType.NONE,
+        };
+        return new FameChannelMessage(params.envelope, context);
+    }
+    _isNodeAttachFrame(frame) {
+        return Boolean(frame &&
+            typeof frame === 'object' &&
+            frame.type === 'NodeAttach');
+    }
+}
+export function getBroadcastChannelListenerInstance() {
+    return _lastBroadcastChannelListenerInstance;
+}

package/dist/esm/naylence/fame/connector/connector-config.js

@@ -30,4 +30,3 @@ export function createConnectorConfig(config) {
         ...config,
     };
 }
-//# sourceMappingURL=connector-config.js.map

package/dist/esm/naylence/fame/connector/connector-factory.js

@@ -206,4 +206,3 @@ export async function createResource(config, ...kwargs) {
     }
     throw new Error(`No factory found for connector type: ${config.type}`);
 }
-//# sourceMappingURL=connector-factory.js.map

package/dist/esm/naylence/fame/connector/default-http-server.js

@@ -203,4 +203,3 @@ export class DefaultHttpServer extends BaseNodeEventListener {
 DefaultHttpServer.registry = new Map();
 DefaultHttpServer.referenceCounts = new Map();
 DefaultHttpServer.lock = new AsyncLock();
-//# sourceMappingURL=default-http-server.js.map

package/dist/esm/naylence/fame/connector/grant-selection-policy.js

@@ -1,7 +1,31 @@
 import { HTTP_CONNECTION_GRANT_TYPE, httpGrantToConnectorConfig, normalizeHttpConnectionGrant, } from '../grants/http-connection-grant.js';
 import { WEBSOCKET_CONNECTION_GRANT_TYPE, normalizeWebSocketConnectionGrant, websocketGrantToConnectorConfig, } from '../grants/websocket-connection-grant.js';
+import { INPAGE_CONNECTION_GRANT_TYPE, inPageGrantToConnectorConfig, normalizeInPageConnectionGrant, } from '../grants/inpage-connection-grant.js';
+import { BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE, broadcastChannelGrantToConnectorConfig, normalizeBroadcastChannelConnectionGrant, } from '../grants/broadcast-channel-connection-grant.js';
 import { getLogger } from '../util/logging.js';
+import { BROADCAST_CHANNEL_CONNECTOR_TYPE } from './broadcast-channel-connector.js';
+import { GRANT_PURPOSE_NODE_ATTACH } from '../grants/grant.js';
 const logger = getLogger('naylence.fame.connector.grant_selection_policy');
+const CALLBACK_TYPE_ALIASES = {
+    [BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE]: [
+        BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE,
+        BROADCAST_CHANNEL_CONNECTOR_TYPE,
+    ],
+    [BROADCAST_CHANNEL_CONNECTOR_TYPE]: [
+        BROADCAST_CHANNEL_CONNECTOR_TYPE,
+        BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE,
+    ],
+};
+function grantTypeMatches(target, candidate) {
+    if (!candidate) {
+        return false;
+    }
+    if (candidate === target) {
+        return true;
+    }
+    const aliases = CALLBACK_TYPE_ALIASES[target];
+    return aliases ? aliases.includes(candidate) : false;
+}
 function isSerializedGrant(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -49,6 +73,12 @@ function createGrantFromRecord(serialized) {
             return createHttpGrant(serialized);
         case WEBSOCKET_CONNECTION_GRANT_TYPE:
             return createWebSocketGrant(serialized);
+        case INPAGE_CONNECTION_GRANT_TYPE:
+            return createInPageGrant(serialized);
+        case BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE:
+            return createBroadcastChannelGrant(serialized);
+        case BROADCAST_CHANNEL_CONNECTOR_TYPE:
+            return createBroadcastChannelConnectorGrant(serialized);
         default:
             return null;
     }
@@ -85,11 +115,66 @@ function createWebSocketGrant(serialized) {
         return null;
     }
 }
+function createInPageGrant(serialized) {
+    try {
+        const normalized = normalizeInPageConnectionGrant(serialized);
+        const grant = {
+            ...normalized,
+            toConnectorConfig: () => inPageGrantToConnectorConfig(serialized),
+        };
+        return grant;
+    }
+    catch (error) {
+        logger.debug('grant_selection_inpage_normalization_failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+function createBroadcastChannelGrant(serialized) {
+    try {
+        const normalized = normalizeBroadcastChannelConnectionGrant(serialized);
+        const grant = {
+            ...normalized,
+            toConnectorConfig: () => broadcastChannelGrantToConnectorConfig(serialized),
+        };
+        return grant;
+    }
+    catch (error) {
+        logger.debug('grant_selection_broadcast_channel_normalization_failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+function createBroadcastChannelConnectorGrant(serialized) {
+    try {
+        const grantCandidate = {
+            ...serialized,
+            type: BROADCAST_CHANNEL_CONNECTION_GRANT_TYPE,
+            purpose: typeof serialized.purpose === 'string'
+                ? serialized.purpose
+                : GRANT_PURPOSE_NODE_ATTACH,
+        };
+        const normalized = normalizeBroadcastChannelConnectionGrant(grantCandidate);
+        const grant = {
+            ...normalized,
+            toConnectorConfig: () => broadcastChannelGrantToConnectorConfig(grantCandidate),
+        };
+        return grant;
+    }
+    catch (error) {
+        logger.debug('grant_selection_broadcast_channel_connector_normalization_failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
 class PreferSameTypeStrategy {
     selectCallbackGrant(context) {
         const targetType = context.callbackGrantType;
         for (const serialized of context.clientSupportedCallbackGrants) {
-            if (serialized.type !== targetType) {
+            if (!grantTypeMatches(targetType, serialized.type)) {
                 continue;
             }
             const grant = createGrantFromRecord(serialized);
@@ -176,4 +261,3 @@ export class GrantSelectionPolicy {
     }
 }
 export const defaultGrantSelectionPolicy = new GrantSelectionPolicy();
-//# sourceMappingURL=grant-selection-policy.js.map

package/dist/esm/naylence/fame/connector/http-listener-factory.js

@@ -107,4 +107,3 @@ export class HttpListenerFactory extends TransportListenerFactory {
     }
 }
 export default HttpListenerFactory;
-//# sourceMappingURL=http-listener-factory.js.map

package/dist/esm/naylence/fame/connector/http-listener.js

@@ -5,7 +5,7 @@ import { GrantSelectionContext, defaultGrantSelectionPolicy, } from './grant-sel
 import { HTTP_CONNECTION_GRANT_TYPE, httpGrantToConnectorConfig, } from '../grants/http-connection-grant.js';
 import { WEBSOCKET_CONNECTION_GRANT_TYPE, websocketGrantToConnectorConfig, } from '../grants/websocket-connection-grant.js';
 import { getLogger } from '../util/logging.js';
-import { QueueFullError } from './http-stateless-connector.js';
+import { QueueFullError } from '../util/bounded-async-queue.js';
 const logger = getLogger('naylence.fame.connector.http_listener');
 function isRoutingNodeLike(node) {
     return typeof node.createOriginConnector === 'function';
@@ -385,4 +385,3 @@ export class HttpListener extends TransportListener {
 export function getHttpListenerInstance() {
     return _lastHttpListenerInstance;
 }
-//# sourceMappingURL=http-listener.js.map

package/dist/esm/naylence/fame/connector/http-server.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=http-server.js.map

package/dist/esm/naylence/fame/connector/http-stateless-connector-factory.js

@@ -175,4 +175,3 @@ export class HttpStatelessConnectorFactory extends ConnectorFactory {
     }
 }
 export default HttpStatelessConnectorFactory;
-//# sourceMappingURL=http-stateless-connector-factory.js.map