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

package/dist/cjs/naylence/fame/connector/inpage-listener.js

@@ -0,0 +1,422 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InPageListener = void 0;
+exports.getInPageListenerInstance = getInPageListenerInstance;
+const core_1 = require("@naylence/core");
+const transport_listener_js_1 = require("./transport-listener.js");
+const logging_js_1 = require("../util/logging.js");
+const grant_js_1 = require("../grants/grant.js");
+const inpage_connector_js_1 = require("./inpage-connector.js");
+const grant_selection_policy_js_1 = require("./grant-selection-policy.js");
+const inpage_connection_grant_js_1 = require("../grants/inpage-connection-grant.js");
+const bounded_async_queue_js_1 = require("../util/bounded-async-queue.js");
+const logger = (0, logging_js_1.getLogger)('naylence.fame.connector.inpage_listener');
+const DEFAULT_CHANNEL = 'naylence-fabric';
+const DEFAULT_INBOX_CAPACITY = 2048;
+const isBrowserEnvironment = () => typeof window !== 'undefined' &&
+    typeof document !== 'undefined' &&
+    typeof EventTarget !== 'undefined' &&
+    typeof MessageEvent !== 'undefined';
+const ensureBrowserEnvironment = () => {
+    if (!isBrowserEnvironment()) {
+        throw new Error('InPageListener is browser-only and requires DOM EventTarget support');
+    }
+};
+let _lastInPageListenerInstance = null;
+const getSharedBus = () => {
+    ensureBrowserEnvironment();
+    const globalWithBus = globalThis;
+    if (!globalWithBus.__naylence_inpage_bus__) {
+        globalWithBus.__naylence_inpage_bus__ = new EventTarget();
+    }
+    return globalWithBus.__naylence_inpage_bus__;
+};
+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';
+class InPageListener extends transport_listener_js_1.TransportListener {
+    constructor(options) {
+        super();
+        this._isRunning = false;
+        this._initialized = false;
+        this._routingNode = null;
+        this._bus = null;
+        this._busHandler = 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;
+        _lastInPageListenerInstance = 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('inpage_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._registerBusListener();
+        }
+        else {
+            logger.warning('inpage_listener_missing_routing_capability');
+        }
+        this._isRunning = true;
+        logger.debug('inpage_listener_started', {
+            channel: this._channelName,
+        });
+    }
+    async onNodeStopped(_node) {
+        if (!this._isRunning) {
+            return;
+        }
+        this._isRunning = false;
+        this._unregisterBusListener();
+        this._senderRegistry.clear();
+        this._systemToSender.clear();
+        this._pendingAttachments.clear();
+        logger.debug('inpage_listener_stopped', {
+            channel: this._channelName,
+        });
+    }
+    getCallbackGrant() {
+        return this.withLegacySnakeCaseKeys({
+            type: inpage_connection_grant_js_1.INPAGE_CONNECTION_GRANT_TYPE,
+            purpose: grant_js_1.GRANT_PURPOSE_NODE_ATTACH,
+            channelName: this._channelName,
+            inboxCapacity: this._inboxCapacity,
+        });
+    }
+    asCallbackGrant() {
+        return this.withLegacySnakeCaseKeys({
+            type: inpage_connector_js_1.INPAGE_CONNECTOR_TYPE,
+            channelName: this._channelName,
+            inboxCapacity: this._inboxCapacity,
+        });
+    }
+    _registerBusListener() {
+        if (this._busHandler) {
+            return;
+        }
+        const handler = (event) => {
+            void this._handleBusEvent(event);
+        };
+        const bus = getSharedBus();
+        bus.addEventListener(this._channelName, handler);
+        this._bus = bus;
+        this._busHandler = handler;
+    }
+    _unregisterBusListener() {
+        if (!this._bus || !this._busHandler) {
+            return;
+        }
+        this._bus.removeEventListener(this._channelName, this._busHandler);
+        this._bus = null;
+        this._busHandler = null;
+    }
+    async _handleBusEvent(event) {
+        if (!this._routingNode) {
+            return;
+        }
+        const normalized = this._parseBusEvent(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('inpage_listener_no_connector_for_sender', {
+                sender_id: senderId,
+                frame_type: envelope.frame?.type ?? 'unknown',
+            });
+            return;
+        }
+        await this._deliverEnvelope(entry, envelope);
+    }
+    _parseBusEvent(event) {
+        if (!event || typeof event !== 'object') {
+            return null;
+        }
+        const messageEvent = event;
+        const payloadContainer = messageEvent?.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('inpage_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 = (0, core_1.deserializeEnvelope)(parsed);
+        }
+        catch (error) {
+            logger.debug('inpage_listener_envelope_parse_failed', {
+                sender_id: senderId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            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('inpage_listener_attach_missing_system_id', {
+                sender_id: senderId,
+            });
+            return;
+        }
+        const normalizedOrigin = frame.originType ?? core_1.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 grant_selection_policy_js_1.GrantSelectionContext({
+                childId: systemId,
+                attachFrame: frame,
+                callbackGrantType: inpage_connection_grant_js_1.INPAGE_CONNECTION_GRANT_TYPE,
+                node: routingNode,
+            });
+            const selection = grant_selection_policy_js_1.defaultGrantSelectionPolicy.selectCallbackGrant(selectionContext);
+            connectorConfig = this._grantToConnectorConfig(selection.grant);
+        }
+        catch (error) {
+            logger.debug('inpage_listener_grant_selection_failed', {
+                sender_id: params.senderId,
+                system_id: systemId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            connectorConfig =
+                this._extractInPageConnectorConfig(frame) ??
+                    {
+                        type: inpage_connector_js_1.INPAGE_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('inpage_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('inpage_listener_connector_creation_failed', {
+                sender_id: params.senderId,
+                system_id: systemId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    _extractInPageConnectorConfig(frame) {
+        const rawGrants = frame.callbackGrants;
+        if (!Array.isArray(rawGrants)) {
+            return null;
+        }
+        for (const grant of rawGrants) {
+            if (grant &&
+                typeof grant === 'object' &&
+                (grant.type === inpage_connection_grant_js_1.INPAGE_CONNECTION_GRANT_TYPE ||
+                    grant.type === inpage_connector_js_1.INPAGE_CONNECTOR_TYPE)) {
+                try {
+                    return (0, inpage_connection_grant_js_1.inPageGrantToConnectorConfig)(grant);
+                }
+                catch (error) {
+                    logger.debug('inpage_listener_grant_normalization_failed', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+        return null;
+    }
+    _grantToConnectorConfig(grant) {
+        if (grant.type === inpage_connection_grant_js_1.INPAGE_CONNECTION_GRANT_TYPE) {
+            return (0, inpage_connection_grant_js_1.inPageGrantToConnectorConfig)(grant);
+        }
+        if (typeof grant?.toConnectorConfig === 'function') {
+            return grant.toConnectorConfig();
+        }
+        throw new Error(`Unsupported grant type: ${grant.type}`);
+    }
+    _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('inpage_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 bounded_async_queue_js_1.QueueFullError) {
+                logger.warning('inpage_listener_receive_queue_full', {
+                    system_id: entry.systemId,
+                });
+                return;
+            }
+            logger.error('inpage_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: core_1.FameResponseType.NONE,
+        };
+        return new core_1.FameChannelMessage(params.envelope, context);
+    }
+    _isNodeAttachFrame(frame) {
+        return Boolean(frame &&
+            typeof frame === 'object' &&
+            frame.type === 'NodeAttach');
+    }
+}
+exports.InPageListener = InPageListener;
+function getInPageListenerInstance() {
+    return _lastInPageListenerInstance;
+}

package/dist/cjs/naylence/fame/connector/noop-flow-controller.js

@@ -47,4 +47,3 @@ class _NoopFlowController {
     }
 }
 exports._NoopFlowController = _NoopFlowController;
-//# sourceMappingURL=noop-flow-controller.js.map

package/dist/cjs/naylence/fame/connector/transport-listener-config.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=transport-listener-config.js.map

package/dist/cjs/naylence/fame/connector/transport-listener-factory.js

@@ -34,4 +34,3 @@ class TransportListenerFactory extends factory_1.AbstractResourceFactory {
     }
 }
 exports.TransportListenerFactory = TransportListenerFactory;
-//# sourceMappingURL=transport-listener-factory.js.map

package/dist/cjs/naylence/fame/connector/transport-listener.js

@@ -44,4 +44,3 @@ class TransportListener {
     }
 }
 exports.TransportListener = TransportListener;
-//# sourceMappingURL=transport-listener.js.map

package/dist/cjs/naylence/fame/connector/websocket-connector-factory.js

@@ -423,4 +423,3 @@ class WebSocketConnectorFactory extends connector_factory_js_1.ConnectorFactory
 }
 exports.WebSocketConnectorFactory = WebSocketConnectorFactory;
 exports.default = WebSocketConnectorFactory;
-//# sourceMappingURL=websocket-connector-factory.js.map

package/dist/cjs/naylence/fame/connector/websocket-connector-node-ssl.js

@@ -70,4 +70,3 @@ const websocket_connector_factory_js_1 = require("./websocket-connector-factory.
         return undefined;
     }
 });
-//# sourceMappingURL=websocket-connector-node-ssl.js.map

package/dist/cjs/naylence/fame/connector/websocket-connector.js

@@ -56,6 +56,23 @@ class WebSocketConnector extends base_async_connector_js_1.BaseAsyncConnector {
             ready_state: websocket.readyState,
             url: websocket.url,
         });
+        if (!this._isFastApiLike) {
+            const socketAny = this._websocket;
+            if (socketAny &&
+                typeof socketAny === 'object' &&
+                'binaryType' in socketAny &&
+                socketAny.binaryType !== 'arraybuffer') {
+                try {
+                    socketAny.binaryType = 'arraybuffer';
+                }
+                catch (error) {
+                    logger.debug('websocket_set_binary_type_failed', {
+                        error: error instanceof Error ? error.message : String(error),
+                        current_type: socketAny.binaryType,
+                    });
+                }
+            }
+        }
         // For non-FastAPI WebSockets (browser/Node.js ws), attach receive handlers immediately
         // to avoid race conditions where messages arrive before the first _transportReceive() call
         if (!this._isFastApiLike) {
@@ -514,6 +531,10 @@ class WebSocketConnector extends base_async_connector_js_1.BaseAsyncConnector {
         if (typeof Buffer !== 'undefined' && Buffer.isBuffer?.(data)) {
             return new Uint8Array(data);
         }
+        if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(data)) {
+            const view = data;
+            return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        }
         if (data instanceof ArrayBuffer) {
             return new Uint8Array(data);
         }
@@ -543,4 +564,3 @@ class WebSocketConnector extends base_async_connector_js_1.BaseAsyncConnector {
     }
 }
 exports.WebSocketConnector = WebSocketConnector;
-//# sourceMappingURL=websocket-connector.js.map

package/dist/cjs/naylence/fame/connector/websocket-listener-factory.js

@@ -144,4 +144,3 @@ class WebSocketListenerFactory extends transport_listener_factory_js_1.Transport
 }
 exports.WebSocketListenerFactory = WebSocketListenerFactory;
 exports.default = WebSocketListenerFactory;
-//# sourceMappingURL=websocket-listener-factory.js.map

package/dist/cjs/naylence/fame/connector/websocket-listener.js

@@ -526,4 +526,3 @@ function getWebsocketConnector(_systemId) {
 function getWebsocketListenerInstance() {
     return _lastWebSocketListenerInstance;
 }
-//# sourceMappingURL=websocket-listener.js.map

package/dist/cjs/naylence/fame/constants/index.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./ttl-constants.js"), exports);
-//# sourceMappingURL=index.js.map

package/dist/cjs/naylence/fame/constants/ttl-constants.js

@@ -19,4 +19,3 @@ exports.TTL_IMMEDIATE_EXPIRY = -1;
 exports.TEST_SHORT_TTL_SEC = 2;
 exports.TEST_MEDIUM_TTL_SEC = 10;
 exports.TEST_LONG_TTL_SEC = 600;
-//# sourceMappingURL=ttl-constants.js.map

package/dist/cjs/naylence/fame/delivery/at-least-once-delivery-policy-factory.js

@@ -105,4 +105,3 @@ exports.FACTORY_META = {
     key: 'AtLeastOnceDeliveryPolicy',
 };
 exports.default = AtLeastOnceDeliveryPolicyFactory;
-//# sourceMappingURL=at-least-once-delivery-policy-factory.js.map

package/dist/cjs/naylence/fame/delivery/at-least-once-delivery-policy.js

@@ -19,4 +19,3 @@ class AtLeastOnceDeliveryPolicy extends delivery_policy_js_1.DeliveryPolicy {
     }
 }
 exports.AtLeastOnceDeliveryPolicy = AtLeastOnceDeliveryPolicy;
-//# sourceMappingURL=at-least-once-delivery-policy.js.map

package/dist/cjs/naylence/fame/delivery/at-most-once-delivery-policy-factory.js

@@ -20,4 +20,3 @@ exports.FACTORY_META = {
     key: 'AtMostOnceDeliveryPolicy',
 };
 exports.default = AtMostOnceDeliveryPolicyFactory;
-//# sourceMappingURL=at-most-once-delivery-policy-factory.js.map

package/dist/cjs/naylence/fame/delivery/at-most-once-delivery-policy.js

@@ -14,4 +14,3 @@ class AtMostOnceDeliveryPolicy extends delivery_policy_js_1.DeliveryPolicy {
     }
 }
 exports.AtMostOnceDeliveryPolicy = AtMostOnceDeliveryPolicy;
-//# sourceMappingURL=at-most-once-delivery-policy.js.map

package/dist/cjs/naylence/fame/delivery/default-delivery-tracker-factory.js

@@ -94,4 +94,3 @@ function resolveStorageProvider(provided) {
     return new in_memory_storage_js_1.InMemoryStorageProvider();
 }
 (0, delivery_tracker_factory_js_1.registerDeliveryTrackerFactory)('DefaultDeliveryTracker', DefaultDeliveryTrackerFactory);
-//# sourceMappingURL=default-delivery-tracker-factory.js.map