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

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

@@ -0,0 +1,313 @@
+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.broadcast_channel_connector');
+export const BROADCAST_CHANNEL_CONNECTOR_TYPE = 'broadcast-channel-connector';
+const DEFAULT_CHANNEL = 'naylence-fabric';
+const DEFAULT_INBOX_CAPACITY = 2048;
+const isBrowserEnvironment = () => typeof window !== 'undefined' &&
+    typeof BroadcastChannel !== 'undefined' &&
+    typeof MessageEvent !== 'undefined';
+const ensureBroadcastEnvironment = () => {
+    if (!isBrowserEnvironment()) {
+        throw new Error('BroadcastChannelConnector is browser-only and requires BroadcastChannel support');
+    }
+};
+export class BroadcastChannelConnector extends BaseAsyncConnector {
+    static generateConnectorId() {
+        const globalCrypto = globalThis.crypto;
+        if (globalCrypto?.randomUUID) {
+            return globalCrypto.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 = {}) {
+        ensureBroadcastEnvironment();
+        super(baseConfig);
+        this.listenerRegistered = false;
+        this.seenAckKeys = new Map();
+        this.seenAckOrder = [];
+        this.ackDedupTtlMs = 30000;
+        this.ackDedupMaxEntries = 4096;
+        this.textDecoder = new TextDecoder();
+        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 = BroadcastChannelConnector.generateConnectorId();
+        this.channel = new BroadcastChannel(this.channelName);
+        logger.debug('broadcast_channel_connector_initialized', {
+            channel: this.channelName,
+            connector_id: this.connectorId,
+            inbox_capacity: preferredCapacity,
+        });
+        this.onMsg = (event) => {
+            const message = event.data;
+            logger.debug('broadcast_channel_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),
+            });
+            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 = BroadcastChannelConnector.coercePayload(busMessage.payload);
+            if (!payload) {
+                logger.debug('broadcast_channel_payload_rejected', {
+                    channel: this.channelName,
+                    connector_id: this.connectorId,
+                    reason: 'unrecognized_payload_type',
+                });
+                return;
+            }
+            logger.debug('broadcast_channel_message_received', {
+                channel: this.channelName,
+                sender_id: busMessage.senderId,
+                connector_id: this.connectorId,
+                payload_length: payload.byteLength,
+            });
+            if (this._shouldSkipDuplicateAck(busMessage.senderId, payload)) {
+                return;
+            }
+            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('broadcast_channel_receive_queue_full', {
+                        channel: this.channelName,
+                    });
+                }
+                else {
+                    logger.error('broadcast_channel_receive_error', {
+                        channel: this.channelName,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        };
+        this.channel.addEventListener('message', this.onMsg);
+        this.listenerRegistered = true;
+    }
+    async pushToReceive(rawOrEnvelope) {
+        const item = this._normalizeInboxItem(rawOrEnvelope);
+        if (this._shouldSkipDuplicateAckFromInboxItem(item)) {
+            return;
+        }
+        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('broadcast_channel_push_queue_full', {
+                    channel: this.channelName,
+                });
+                throw error;
+            }
+            logger.error('broadcast_channel_push_failed', {
+                channel: this.channelName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async _transportSendBytes(data) {
+        ensureBroadcastEnvironment();
+        logger.debug('broadcast_channel_message_sending', {
+            channel: this.channelName,
+            sender_id: this.connectorId,
+        });
+        this.channel.postMessage({
+            senderId: this.connectorId,
+            payload: data,
+        });
+    }
+    async _transportReceive() {
+        return await this.inbox.dequeue();
+    }
+    async _transportClose(code, reason) {
+        if (this.listenerRegistered) {
+            this.channel.removeEventListener('message', this.onMsg);
+            this.listenerRegistered = false;
+        }
+        this.channel.close();
+        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);
+        this.seenAckKeys.clear();
+        this.seenAckOrder.length = 0;
+    }
+    _normalizeInboxItem(rawOrEnvelope) {
+        if (rawOrEnvelope instanceof Uint8Array) {
+            return rawOrEnvelope;
+        }
+        return rawOrEnvelope;
+    }
+    _shouldSkipDuplicateAck(senderId, payload) {
+        const dedupKey = this._extractAckDedupKey(payload);
+        if (!dedupKey) {
+            return false;
+        }
+        const normalizedSenderId = typeof senderId === 'string' && senderId.length > 0
+            ? senderId
+            : undefined;
+        return this._checkDuplicateAck(dedupKey, normalizedSenderId);
+    }
+    _shouldSkipDuplicateAckFromInboxItem(item) {
+        if (item instanceof Uint8Array) {
+            return this._shouldSkipDuplicateAck(undefined, item);
+        }
+        const envelope = this._extractEnvelopeFromInboxItem(item);
+        if (!envelope) {
+            return false;
+        }
+        const frame = envelope.frame;
+        if (!frame || frame.type !== 'DeliveryAck') {
+            return false;
+        }
+        const refId = typeof frame.refId === 'string' && frame.refId.length > 0
+            ? frame.refId
+            : null;
+        const dedupKey = refId ?? envelope.id ?? null;
+        if (!dedupKey) {
+            return false;
+        }
+        const senderId = this._extractSenderIdFromInboxItem(item);
+        return this._checkDuplicateAck(dedupKey, senderId);
+    }
+    _checkDuplicateAck(dedupKey, senderId) {
+        const now = Date.now();
+        const lastSeen = this.seenAckKeys.get(dedupKey);
+        if (lastSeen && now - lastSeen < this.ackDedupTtlMs) {
+            logger.debug('broadcast_channel_duplicate_ack_suppressed', {
+                channel: this.channelName,
+                connector_id: this.connectorId,
+                sender_id: senderId ?? null,
+                dedup_key: dedupKey,
+            });
+            return true;
+        }
+        this.seenAckKeys.set(dedupKey, now);
+        this.seenAckOrder.push(dedupKey);
+        this._trimSeenAcks(now);
+        return false;
+    }
+    _extractEnvelopeFromInboxItem(item) {
+        if (!item || typeof item !== 'object') {
+            return null;
+        }
+        if ('envelope' in item) {
+            return item.envelope;
+        }
+        if ('frame' in item) {
+            return item;
+        }
+        return null;
+    }
+    _extractSenderIdFromInboxItem(item) {
+        if (!item || typeof item !== 'object') {
+            return undefined;
+        }
+        if ('context' in item) {
+            const context = item.context;
+            if (context && typeof context.fromSystemId === 'string') {
+                return context.fromSystemId;
+            }
+        }
+        return undefined;
+    }
+    _trimSeenAcks(now) {
+        while (this.seenAckOrder.length > 0) {
+            const candidate = this.seenAckOrder[0];
+            const timestamp = this.seenAckKeys.get(candidate);
+            if (timestamp === undefined) {
+                this.seenAckOrder.shift();
+                continue;
+            }
+            if (this.seenAckKeys.size > this.ackDedupMaxEntries ||
+                now - timestamp > this.ackDedupTtlMs) {
+                this.seenAckKeys.delete(candidate);
+                this.seenAckOrder.shift();
+                continue;
+            }
+            break;
+        }
+    }
+    _extractAckDedupKey(payload) {
+        try {
+            const decoded = this.textDecoder.decode(payload);
+            const parsed = JSON.parse(decoded);
+            const envelopeId = typeof parsed?.id === 'string' ? parsed.id : null;
+            const frameType = parsed?.frame?.type;
+            if (typeof frameType !== 'string' || frameType !== 'DeliveryAck') {
+                return null;
+            }
+            const refId = parsed.frame?.refId;
+            if (typeof refId === 'string' && refId.length > 0) {
+                return refId;
+            }
+            return envelopeId;
+        }
+        catch (error) {
+            logger.debug('broadcast_channel_ack_dedup_parse_failed', {
+                channel: this.channelName,
+                connector_id: this.connectorId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { BroadcastChannelConnector as BrowserBroadcastChannelConnector, BROADCAST_CHANNEL_CONNECTOR_TYPE, } from './broadcast-channel-connector.browser.js';
+import { BroadcastChannelConnector as NodeBroadcastChannelConnector } from './broadcast-channel-connector.node.js';
+const hasBroadcastChannelSupport = typeof globalThis !== 'undefined' &&
+    typeof globalThis
+        .BroadcastChannel !== 'undefined';
+const ConnectorImpl = hasBroadcastChannelSupport
+    ? BrowserBroadcastChannelConnector
+    : NodeBroadcastChannelConnector;
+class BroadcastChannelConnector extends ConnectorImpl {
+}
+export { BroadcastChannelConnector, BROADCAST_CHANNEL_CONNECTOR_TYPE };

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

@@ -0,0 +1,22 @@
+import { BaseAsyncConnector, } from './base-async-connector.js';
+export const BROADCAST_CHANNEL_CONNECTOR_TYPE = 'broadcast-channel-connector';
+const ERROR_MESSAGE = 'BroadcastChannelConnector is browser-only and requires BroadcastChannel support';
+export class BroadcastChannelConnector extends BaseAsyncConnector {
+    constructor(config, baseConfig = {}) {
+        super(baseConfig);
+        void config;
+        throw new Error(ERROR_MESSAGE);
+    }
+    async pushToReceive(_rawOrEnvelope) {
+        throw new Error(ERROR_MESSAGE);
+    }
+    async _transportSendBytes(_data) {
+        throw new Error(ERROR_MESSAGE);
+    }
+    async _transportReceive() {
+        throw new Error(ERROR_MESSAGE);
+    }
+    async _transportClose(_code, _reason) {
+        throw new Error(ERROR_MESSAGE);
+    }
+}

package/dist/esm/naylence/fame/connector/broadcast-channel-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 broadcastChannelListenerModulePromise = null;
+function getBroadcastChannelListenerModule() {
+    if (!broadcastChannelListenerModulePromise) {
+        broadcastChannelListenerModulePromise = safeImport(() => import('./broadcast-channel-listener.js'), 'broadcast channel listener module');
+    }
+    return broadcastChannelListenerModulePromise;
+}
+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: 'BroadcastChannelListener',
+        channelName,
+        inboxCapacity,
+    };
+}
+export const FACTORY_META = {
+    base: TRANSPORT_LISTENER_FACTORY_BASE_TYPE,
+    key: 'BroadcastChannelListener',
+};
+export class BroadcastChannelListenerFactory extends TransportListenerFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'BroadcastChannelListener';
+        this.priority = 840;
+        this.isDefault = false;
+    }
+    async create(config, ...factoryArgs) {
+        const normalized = normalizeConfig(config);
+        const [{ BroadcastChannelListener }] = await Promise.all([
+            getBroadcastChannelListenerModule(),
+        ]);
+        void factoryArgs;
+        return new BroadcastChannelListener({
+            channelName: normalized.channelName,
+            inboxCapacity: normalized.inboxCapacity,
+        });
+    }
+}
+export default BroadcastChannelListenerFactory;