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

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

@@ -1,64 +1,9 @@
 import { BaseAsyncConnector, } from './base-async-connector.js';
 import { FameTransportClose } from '../errors/errors.js';
 import { getLogger } from '../util/logging.js';
+import { BoundedAsyncQueue, QueueFullError, } from '../util/bounded-async-queue.js';
+export { QueueFullError } from '../util/bounded-async-queue.js';
 const logger = getLogger('naylence.fame.connector.http_stateless_connector');
-export class QueueFullError extends Error {
-    constructor(message = 'Receive queue is full') {
-        super(message);
-        this.name = 'QueueFullError';
-    }
-}
-class BoundedAsyncQueue {
-    constructor(capacity) {
-        this.capacity = capacity;
-        this.queue = [];
-        this.waiters = [];
-        this.closed = false;
-        if (!Number.isInteger(capacity) || capacity <= 0) {
-            throw new Error('Queue capacity must be a positive integer');
-        }
-    }
-    enqueue(item) {
-        if (this.closed) {
-            return;
-        }
-        if (this.waiters.length > 0) {
-            const waiter = this.waiters.shift();
-            waiter.resolve(item);
-            return;
-        }
-        if (this.queue.length >= this.capacity) {
-            throw new QueueFullError();
-        }
-        this.queue.push(item);
-    }
-    async dequeue() {
-        if (this.closed) {
-            throw this.closeError ?? new Error('Queue closed');
-        }
-        if (this.queue.length > 0) {
-            return this.queue.shift();
-        }
-        return await new Promise((resolve, reject) => {
-            this.waiters.push({ resolve, reject });
-        });
-    }
-    drain(error) {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        this.closeError = error ?? new Error('Queue closed');
-        while (this.waiters.length > 0) {
-            const waiter = this.waiters.shift();
-            waiter.reject(this.closeError);
-        }
-        this.queue.length = 0;
-    }
-    get remainingCapacity() {
-        return Math.max(this.capacity - this.queue.length, 0);
-    }
-}
 export class HttpStatelessConnector extends BaseAsyncConnector {
     constructor(config, dependencies = {}) {
         super(config);
@@ -171,4 +116,3 @@ export class HttpStatelessConnector extends BaseAsyncConnector {
         this.receiveQueue.drain(shutdownError);
     }
 }
-//# sourceMappingURL=http-stateless-connector.js.map

package/dist/esm/naylence/fame/connector/index.js

@@ -1,7 +1,11 @@
 import './http-listener-factory.js';
 import './websocket-listener-factory.js';
+import './inpage-listener-factory.js';
+import './broadcast-channel-listener-factory.js';
 import './websocket-connector-factory.js';
 import './http-stateless-connector-factory.js';
+import './inpage-connector-factory.js';
+import './broadcast-channel-connector-factory.js';
 /**
  * Fame Connector Exports
  */
@@ -12,7 +16,10 @@ export { ConnectorConfigDefaults, isConnectorConfig, createConnectorConfig, } fr
 export { ConnectorFactory, createResource, } from './connector-factory.js';
 // WebSocket connector
 export { WebSocketConnector, WebSocketState, } from './websocket-connector.js';
-export { HttpStatelessConnector, QueueFullError, } from './http-stateless-connector.js';
+export { HttpStatelessConnector, } from './http-stateless-connector.js';
+export { QueueFullError, BoundedAsyncQueue, } from '../util/bounded-async-queue.js';
+export { InPageConnector, INPAGE_CONNECTOR_TYPE, } from './inpage-connector.js';
+export { BroadcastChannelConnector, BROADCAST_CHANNEL_CONNECTOR_TYPE, } from './broadcast-channel-connector.js';
 // Flow controller
 export { _NoopFlowController } from './noop-flow-controller.js';
 // Transport listener
@@ -21,4 +28,5 @@ export { TRANSPORT_LISTENER_FACTORY_BASE_TYPE } from './transport-listener-facto
 export { DefaultHttpServer } from './default-http-server.js';
 export { WebSocketListener, getWebsocketListenerInstance, } from './websocket-listener.js';
 export { HttpListener, getHttpListenerInstance } from './http-listener.js';
-//# sourceMappingURL=index.js.map
+export { InPageListener, getInPageListenerInstance } from './inpage-listener.js';
+export { BroadcastChannelListener, getBroadcastChannelListenerInstance, } from './broadcast-channel-listener.js';

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

@@ -0,0 +1,158 @@
+import { CONNECTOR_FACTORY_BASE_TYPE, ConnectorFactory, } from './connector-factory.js';
+import { InPageConnector, INPAGE_CONNECTOR_TYPE, } from './inpage-connector.js';
+import { INPAGE_CONNECTION_GRANT_TYPE, inPageGrantToConnectorConfig, normalizeInPageConnectionGrant, } from '../grants/inpage-connection-grant.js';
+const DEFAULT_CHANNEL = 'naylence-fabric';
+const DEFAULT_INBOX_CAPACITY = 2048;
+class InPageConnectionGrantImpl {
+    constructor() {
+        this.type = INPAGE_CONNECTION_GRANT_TYPE;
+        this.purpose = 'connection';
+    }
+}
+export const FACTORY_META = {
+    base: CONNECTOR_FACTORY_BASE_TYPE,
+    key: INPAGE_CONNECTOR_TYPE,
+};
+export class InPageConnectorFactory extends ConnectorFactory {
+    constructor() {
+        super(...arguments);
+        this.type = INPAGE_CONNECTOR_TYPE;
+    }
+    supportedGrantTypes() {
+        return [INPAGE_CONNECTION_GRANT_TYPE, INPAGE_CONNECTOR_TYPE];
+    }
+    supportedGrants() {
+        return {
+            [INPAGE_CONNECTION_GRANT_TYPE]: InPageConnectionGrantImpl,
+        };
+    }
+    configFromGrant(grant, _expressionEvaluationPolicy) {
+        const normalized = normalizeInPageConnectionGrant(grant);
+        const candidate = inPageGrantToConnectorConfig(normalized);
+        const config = {
+            type: INPAGE_CONNECTOR_TYPE,
+        };
+        if (candidate.channelName) {
+            config.channelName = candidate.channelName;
+        }
+        if (candidate.inboxCapacity !== undefined) {
+            config.inboxCapacity = candidate.inboxCapacity;
+        }
+        return config;
+    }
+    grantFromConfig(config, _expressionEvaluationPolicy) {
+        const normalized = this._normalizeConfig(config);
+        const raw = config;
+        const grant = {
+            type: INPAGE_CONNECTION_GRANT_TYPE,
+            purpose: 'connection',
+        };
+        const rawChannel = raw.channelName ?? raw['channel_name'];
+        if (typeof rawChannel === 'string' && rawChannel.trim().length > 0) {
+            grant.channelName = normalized.channelName;
+        }
+        const rawInbox = raw.inboxCapacity ?? raw['inbox_capacity'];
+        if (typeof rawInbox === 'number' &&
+            Number.isFinite(rawInbox) &&
+            rawInbox > 0) {
+            grant.inboxCapacity = normalized.inboxCapacity;
+        }
+        return grant;
+    }
+    async create(config, ...factoryArgs) {
+        if (!config) {
+            throw new Error('InPageConnectorFactory requires a configuration');
+        }
+        const normalized = this._normalizeConfig(config);
+        const options = (factoryArgs[0] ?? {});
+        const channelName = normalized.channelName ?? DEFAULT_CHANNEL;
+        const inboxCapacity = normalized.inboxCapacity ?? DEFAULT_INBOX_CAPACITY;
+        const baseConfig = {
+            drainTimeout: normalized.drainTimeout,
+            flowControl: normalized.flowControl,
+            initialWindow: normalized.initialWindow,
+            maxQueueSize: normalized.maxQueueSize,
+            metricsEmitter: normalized.metricsEmitter,
+            shutdownTimeouts: normalized.shutdownTimeouts,
+            taskSpawner: normalized.taskSpawner,
+            authorizationContext: normalized.authorizationContext,
+        };
+        const connectorConfig = {
+            type: INPAGE_CONNECTOR_TYPE,
+            channelName,
+            inboxCapacity,
+        };
+        const connector = new InPageConnector(connectorConfig, baseConfig);
+        if (options.authorization) {
+            connector.authorizationContext = options.authorization;
+        }
+        return connector;
+    }
+    _normalizeConfig(config) {
+        if (!config || typeof config !== 'object') {
+            throw new Error('Configuration must be an object');
+        }
+        const candidate = config;
+        if (candidate.type !== INPAGE_CONNECTOR_TYPE) {
+            throw new Error(`InPageConnectorFactory only supports ${INPAGE_CONNECTOR_TYPE} config`);
+        }
+        const normalized = {
+            type: INPAGE_CONNECTOR_TYPE,
+        };
+        const channel = candidate.channelName;
+        if (typeof channel === 'string' && channel.trim().length > 0) {
+            normalized.channelName = channel.trim();
+        }
+        const legacyChannel = candidate['channel_name'];
+        if (!normalized.channelName && typeof legacyChannel === 'string') {
+            const trimmed = legacyChannel.trim();
+            if (trimmed.length > 0) {
+                normalized.channelName = trimmed;
+            }
+        }
+        const capacity = candidate.inboxCapacity ?? candidate['inbox_capacity'];
+        if (typeof capacity === 'number' &&
+            Number.isFinite(capacity) &&
+            capacity > 0) {
+            normalized.inboxCapacity = Math.floor(capacity);
+        }
+        if (typeof candidate.flowControl === 'boolean') {
+            normalized.flowControl = candidate.flowControl;
+        }
+        const maxQueueSize = candidate.maxQueueSize ?? candidate['max_queue_size'];
+        if (typeof maxQueueSize === 'number' &&
+            Number.isFinite(maxQueueSize) &&
+            maxQueueSize > 0) {
+            normalized.maxQueueSize = Math.floor(maxQueueSize);
+        }
+        const initialWindow = candidate.initialWindow ?? candidate['initial_window'];
+        if (typeof initialWindow === 'number' &&
+            Number.isFinite(initialWindow) &&
+            initialWindow > 0) {
+            normalized.initialWindow = Math.floor(initialWindow);
+        }
+        const drainTimeout = candidate.drainTimeout ?? candidate['drain_timeout'];
+        if (typeof drainTimeout === 'number' &&
+            Number.isFinite(drainTimeout) &&
+            drainTimeout >= 0) {
+            normalized.drainTimeout = drainTimeout;
+        }
+        if (candidate.metricsEmitter !== undefined) {
+            normalized.metricsEmitter = candidate.metricsEmitter;
+        }
+        if (candidate.taskSpawner !== undefined) {
+            normalized.taskSpawner = candidate.taskSpawner;
+        }
+        if (candidate.shutdownTimeouts !== undefined) {
+            normalized.shutdownTimeouts = candidate.shutdownTimeouts;
+        }
+        if (candidate.authorizationContext !== undefined) {
+            normalized.authorizationContext = candidate.authorizationContext;
+        }
+        normalized.channelName = normalized.channelName ?? DEFAULT_CHANNEL;
+        normalized.inboxCapacity =
+            normalized.inboxCapacity ?? DEFAULT_INBOX_CAPACITY;
+        return normalized;
+    }
+}
+export default InPageConnectorFactory;

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

@@ -0,0 +1,214 @@
+/**
+ * Browser-local connector that routes binary frames between peers via an in-page EventTarget.
+ * Relies on BaseAsyncConnector for flow control and shutdown behavior.
+ */
+import { BaseAsyncConnector, } from './base-async-connector.js';
+import { FameTransportClose } from '../errors/errors.js';
+import { getLogger } from '../util/logging.js';
+import { BoundedAsyncQueue, QueueFullError, } from '../util/bounded-async-queue.js';
+const logger = getLogger('naylence.fame.connector.inpage_connector');
+export const INPAGE_CONNECTOR_TYPE = 'inpage-connector';
+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('InPageConnector is browser-only and requires DOM EventTarget support');
+    }
+};
+const getSharedBus = () => {
+    ensureBrowserEnvironment();
+    const globalWithBus = globalThis;
+    if (!globalWithBus.__naylence_inpage_bus__) {
+        // Share a single in-page bus across all module instances (esm/cjs, realms).
+        globalWithBus.__naylence_inpage_bus__ = new EventTarget();
+    }
+    return globalWithBus.__naylence_inpage_bus__;
+};
+export class InPageConnector extends BaseAsyncConnector {
+    static generateConnectorId() {
+        const globalCrypto = globalThis.crypto;
+        if (globalCrypto?.randomUUID) {
+            return globalCrypto.randomUUID();
+        }
+        // Fallback for environments without crypto.randomUUID
+        return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
+    }
+    static 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;
+    }
+    constructor(config, baseConfig = {}) {
+        ensureBrowserEnvironment();
+        super(baseConfig);
+        this.listenerRegistered = false;
+        this.channelName =
+            typeof config.channelName === 'string' && config.channelName.trim().length > 0
+                ? config.channelName.trim()
+                : DEFAULT_CHANNEL;
+        const preferredCapacity = typeof config.inboxCapacity === 'number' &&
+            Number.isFinite(config.inboxCapacity) &&
+            config.inboxCapacity > 0
+            ? Math.floor(config.inboxCapacity)
+            : DEFAULT_INBOX_CAPACITY;
+        this.inbox = new BoundedAsyncQueue(preferredCapacity);
+        this.connectorId = InPageConnector.generateConnectorId();
+        logger.debug('inpage_connector_initialized', {
+            channel: this.channelName,
+            connector_id: this.connectorId,
+        });
+        this.onMsg = (event) => {
+            const messageEvent = event;
+            const message = messageEvent.data;
+            logger.debug('inpage_raw_event', {
+                channel: this.channelName,
+                connector_id: this.connectorId,
+                message_type: message && typeof message === 'object' ? message.constructor?.name ?? typeof message : typeof message,
+                has_sender_id: Boolean(message?.senderId),
+                payload_type: message && typeof message === 'object'
+                    ? message?.payload instanceof Uint8Array
+                        ? 'Uint8Array'
+                        : message?.payload instanceof ArrayBuffer
+                            ? 'ArrayBuffer'
+                            : typeof message?.payload
+                    : typeof message,
+                payload_constructor: message && typeof message === 'object'
+                    ? message?.payload?.constructor?.name
+                    : undefined,
+                payload_keys: message && typeof message === 'object' && message?.payload && typeof message?.payload === 'object'
+                    ? Object.keys(message.payload).slice(0, 5)
+                    : undefined,
+            });
+            if (!message || typeof message !== 'object') {
+                return;
+            }
+            const busMessage = message;
+            if (typeof busMessage.senderId !== 'string' || busMessage.senderId.length === 0) {
+                return;
+            }
+            if (busMessage.senderId === this.connectorId) {
+                return;
+            }
+            const payload = InPageConnector.coercePayload(busMessage.payload);
+            if (!payload) {
+                logger.debug('inpage_payload_rejected', {
+                    channel: this.channelName,
+                    connector_id: this.connectorId,
+                    reason: 'unrecognized_payload_type',
+                });
+                return;
+            }
+            logger.debug('inpage_message_received', {
+                channel: this.channelName,
+                sender_id: busMessage.senderId,
+                connector_id: this.connectorId,
+                payload_length: payload.byteLength,
+            });
+            try {
+                if (typeof this.inbox.tryEnqueue === 'function') {
+                    const accepted = this.inbox.tryEnqueue(payload);
+                    if (accepted) {
+                        return;
+                    }
+                }
+                this.inbox.enqueue(payload);
+            }
+            catch (error) {
+                if (error instanceof QueueFullError) {
+                    logger.warning('inpage_receive_queue_full', {
+                        channel: this.channelName,
+                    });
+                }
+                else {
+                    logger.error('inpage_receive_error', {
+                        channel: this.channelName,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        };
+        getSharedBus().addEventListener(this.channelName, this.onMsg);
+        this.listenerRegistered = true;
+    }
+    // Allow listeners to feed envelopes directly into the in-page receive queue.
+    async pushToReceive(rawOrEnvelope) {
+        const item = this._normalizeInboxItem(rawOrEnvelope);
+        try {
+            if (typeof this.inbox.tryEnqueue === 'function') {
+                const accepted = this.inbox.tryEnqueue(item);
+                if (accepted) {
+                    return;
+                }
+            }
+            this.inbox.enqueue(item);
+        }
+        catch (error) {
+            if (error instanceof QueueFullError) {
+                logger.warning('inpage_push_queue_full', {
+                    channel: this.channelName,
+                });
+                throw error;
+            }
+            logger.error('inpage_push_failed', {
+                channel: this.channelName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async _transportSendBytes(data) {
+        ensureBrowserEnvironment();
+        logger.debug('inpage_message_sending', {
+            channel: this.channelName,
+            sender_id: this.connectorId,
+        });
+        const event = new MessageEvent(this.channelName, {
+            data: {
+                senderId: this.connectorId,
+                payload: data,
+            },
+        });
+        getSharedBus().dispatchEvent(event);
+    }
+    async _transportReceive() {
+        return await this.inbox.dequeue();
+    }
+    async _transportClose(code, reason) {
+        if (this.listenerRegistered) {
+            getSharedBus().removeEventListener(this.channelName, this.onMsg);
+            this.listenerRegistered = false;
+        }
+        const closeCode = typeof code === 'number' ? code : 1000;
+        const closeReason = typeof reason === 'string' && reason.length > 0 ? reason : 'closed';
+        const shutdownError = new FameTransportClose(closeReason, closeCode);
+        this.inbox.drain(shutdownError);
+    }
+    _normalizeInboxItem(rawOrEnvelope) {
+        if (rawOrEnvelope instanceof Uint8Array) {
+            return rawOrEnvelope;
+        }
+        return rawOrEnvelope;
+    }
+}

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

@@ -0,0 +1,58 @@
+import { TransportListenerFactory, TRANSPORT_LISTENER_FACTORY_BASE_TYPE, } from './transport-listener-factory.js';
+import { safeImport } from '../util/lazy-import.js';
+let inPageListenerModulePromise = null;
+function getInPageListenerModule() {
+    if (!inPageListenerModulePromise) {
+        inPageListenerModulePromise = safeImport(() => import('./inpage-listener.js'), 'inpage listener module');
+    }
+    return inPageListenerModulePromise;
+}
+const DEFAULT_CHANNEL = 'naylence-fabric';
+const DEFAULT_INBOX_CAPACITY = 2048;
+function normalizeConfig(config) {
+    const record = (config ?? {});
+    const rawChannel = record.channelName ?? record['channel_name'];
+    const channelName = typeof rawChannel === 'string' && rawChannel.trim().length > 0
+        ? rawChannel.trim()
+        : DEFAULT_CHANNEL;
+    const rawInbox = record.inboxCapacity ?? record['inbox_capacity'];
+    let inboxCapacity = DEFAULT_INBOX_CAPACITY;
+    if (typeof rawInbox === 'number' && Number.isFinite(rawInbox) && rawInbox > 0) {
+        inboxCapacity = Math.floor(rawInbox);
+    }
+    else if (typeof rawInbox === 'string') {
+        const parsed = Number.parseInt(rawInbox.trim(), 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            inboxCapacity = Math.floor(parsed);
+        }
+    }
+    return {
+        type: 'InPageListener',
+        channelName,
+        inboxCapacity,
+    };
+}
+export const FACTORY_META = {
+    base: TRANSPORT_LISTENER_FACTORY_BASE_TYPE,
+    key: 'InPageListener',
+};
+export class InPageListenerFactory extends TransportListenerFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'InPageListener';
+        this.priority = 850;
+        this.isDefault = false;
+    }
+    async create(config, ...factoryArgs) {
+        const normalized = normalizeConfig(config);
+        const [{ InPageListener }] = await Promise.all([
+            getInPageListenerModule(),
+        ]);
+        void factoryArgs;
+        return new InPageListener({
+            channelName: normalized.channelName,
+            inboxCapacity: normalized.inboxCapacity,
+        });
+    }
+}
+export default InPageListenerFactory;