@hamak/event-channel 0.5.3

package/dist/api/actions/event-channel-actions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Redux action types and creators for the event channel.
+ */
+import type { ConnectionInfo } from '../types/connection-types';
+import type { EventChannelEvent, RemoteAction } from '../types/event-types';
+export declare const EventChannelActionTypes: {
+    readonly CONNECTION_STATUS_CHANGED: "eventChannel/connectionStatusChanged";
+    readonly EVENT_RECEIVED: "eventChannel/eventReceived";
+    readonly REMOTE_ACTION_RECEIVED: "eventChannel/remoteActionReceived";
+    readonly CONNECT: "eventChannel/connect";
+    readonly DISCONNECT: "eventChannel/disconnect";
+};
+export interface ConnectionStatusChangedAction {
+    type: typeof EventChannelActionTypes.CONNECTION_STATUS_CHANGED;
+    payload: ConnectionInfo;
+}
+export interface EventReceivedAction {
+    type: typeof EventChannelActionTypes.EVENT_RECEIVED;
+    payload: EventChannelEvent;
+}
+export interface RemoteActionReceivedAction {
+    type: typeof EventChannelActionTypes.REMOTE_ACTION_RECEIVED;
+    payload: RemoteAction;
+}
+export interface ConnectAction {
+    type: typeof EventChannelActionTypes.CONNECT;
+}
+export interface DisconnectAction {
+    type: typeof EventChannelActionTypes.DISCONNECT;
+}
+export type EventChannelAction = ConnectionStatusChangedAction | EventReceivedAction | RemoteActionReceivedAction | ConnectAction | DisconnectAction;
+export declare const eventChannelActions: {
+    connectionStatusChanged(info: ConnectionInfo): ConnectionStatusChangedAction;
+    eventReceived(event: EventChannelEvent): EventReceivedAction;
+    remoteActionReceived(action: RemoteAction): RemoteActionReceivedAction;
+    connect(): ConnectAction;
+    disconnect(): DisconnectAction;
+};
+//# sourceMappingURL=event-channel-actions.d.ts.map

package/dist/api/actions/event-channel-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-channel-actions.d.ts","sourceRoot":"","sources":["../../../src/api/actions/event-channel-actions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAG5E,eAAO,MAAM,uBAAuB;;;;;;CAM1B,CAAC;AAGX,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,OAAO,uBAAuB,CAAC,yBAAyB,CAAC;IAC/D,OAAO,EAAE,cAAc,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,OAAO,uBAAuB,CAAC,cAAc,CAAC;IACpD,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,OAAO,uBAAuB,CAAC,sBAAsB,CAAC;IAC5D,OAAO,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,OAAO,uBAAuB,CAAC,OAAO,CAAC;CAC9C;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,uBAAuB,CAAC,UAAU,CAAC;CACjD;AAED,MAAM,MAAM,kBAAkB,GAC1B,6BAA6B,GAC7B,mBAAmB,GACnB,0BAA0B,GAC1B,aAAa,GACb,gBAAgB,CAAC;AAGrB,eAAO,MAAM,mBAAmB;kCACA,cAAc,GAAG,6BAA6B;yBAIvD,iBAAiB,GAAG,mBAAmB;iCAI/B,YAAY,GAAG,0BAA0B;eAI3D,aAAa;kBAIV,gBAAgB;CAG/B,CAAC"}

package/dist/api/actions/event-channel-actions.js

@@ -0,0 +1,29 @@
+/**
+ * Redux action types and creators for the event channel.
+ */
+// Action type constants
+export const EventChannelActionTypes = {
+    CONNECTION_STATUS_CHANGED: 'eventChannel/connectionStatusChanged',
+    EVENT_RECEIVED: 'eventChannel/eventReceived',
+    REMOTE_ACTION_RECEIVED: 'eventChannel/remoteActionReceived',
+    CONNECT: 'eventChannel/connect',
+    DISCONNECT: 'eventChannel/disconnect',
+};
+// Action creators
+export const eventChannelActions = {
+    connectionStatusChanged(info) {
+        return { type: EventChannelActionTypes.CONNECTION_STATUS_CHANGED, payload: info };
+    },
+    eventReceived(event) {
+        return { type: EventChannelActionTypes.EVENT_RECEIVED, payload: event };
+    },
+    remoteActionReceived(action) {
+        return { type: EventChannelActionTypes.REMOTE_ACTION_RECEIVED, payload: action };
+    },
+    connect() {
+        return { type: EventChannelActionTypes.CONNECT };
+    },
+    disconnect() {
+        return { type: EventChannelActionTypes.DISCONNECT };
+    },
+};

package/dist/api/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @hamak/event-channel API
+ *
+ * Public types, interfaces, tokens, and action creators.
+ */
+export type { ConnectionStatus, ConnectionInfo, } from './types/connection-types';
+export type { EventChannelEvent, RemoteAction, IEventChannel, } from './types/event-types';
+export { EVENT_CHANNEL_TOKEN, EVENT_CHANNEL_CONFIG_TOKEN, } from './tokens/service-tokens';
+export { EventChannelActionTypes, eventChannelActions, type EventChannelAction, type ConnectionStatusChangedAction, type EventReceivedAction, type RemoteActionReceivedAction, type ConnectAction, type DisconnectAction, } from './actions/event-channel-actions';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,gBAAgB,EAChB,cAAc,GACf,MAAM,0BAA0B,CAAC;AAElC,YAAY,EACV,iBAAiB,EACjB,YAAY,EACZ,aAAa,GACd,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,6BAA6B,EAClC,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,aAAa,EAClB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,9 @@
+/**
+ * @hamak/event-channel API
+ *
+ * Public types, interfaces, tokens, and action creators.
+ */
+// Tokens
+export { EVENT_CHANNEL_TOKEN, EVENT_CHANNEL_CONFIG_TOKEN, } from './tokens/service-tokens';
+// Actions
+export { EventChannelActionTypes, eventChannelActions, } from './actions/event-channel-actions';

package/dist/api/tokens/service-tokens.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Dependency injection tokens for the event channel.
+ */
+export declare const EVENT_CHANNEL_TOKEN: unique symbol;
+export declare const EVENT_CHANNEL_CONFIG_TOKEN: unique symbol;
+//# sourceMappingURL=service-tokens.d.ts.map

package/dist/api/tokens/service-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-tokens.d.ts","sourceRoot":"","sources":["../../../src/api/tokens/service-tokens.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,mBAAmB,eAAkD,CAAC;AACnF,eAAO,MAAM,0BAA0B,eAA4C,CAAC"}

package/dist/api/tokens/service-tokens.js

@@ -0,0 +1,5 @@
+/**
+ * Dependency injection tokens for the event channel.
+ */
+export const EVENT_CHANNEL_TOKEN = Symbol.for('@hamak/event-channel:EventChannel');
+export const EVENT_CHANNEL_CONFIG_TOKEN = Symbol.for('@hamak/event-channel:Config');

package/dist/api/types/connection-types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Connection status and info types for the event channel.
+ */
+export type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+export interface ConnectionInfo {
+    /** Current connection status */
+    status: ConnectionStatus;
+    /** Number of reconnect attempts so far */
+    reconnectAttempts: number;
+    /** ISO timestamp of last successful connection */
+    lastConnectedAt?: string;
+    /** Error message if status is 'error' */
+    error?: string;
+    /** URL of the event stream */
+    url: string;
+}
+//# sourceMappingURL=connection-types.d.ts.map

package/dist/api/types/connection-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-types.d.ts","sourceRoot":"","sources":["../../../src/api/types/connection-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,OAAO,CAAC;AAEtG,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,MAAM,EAAE,gBAAgB,CAAC;IACzB,0CAA0C;IAC1C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;CACb"}

package/dist/api/types/connection-types.js

@@ -0,0 +1,4 @@
+/**
+ * Connection status and info types for the event channel.
+ */
+export {};

package/dist/api/types/event-types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Core event channel types.
+ */
+import type { ConnectionStatus } from './connection-types';
+/**
+ * A typed event from the event channel.
+ */
+export interface EventChannelEvent<T = unknown> {
+    /** Unique event ID (server-generated) */
+    id: string;
+    /** Event type discriminator */
+    type: string;
+    /** Event payload */
+    data: T;
+    /** ISO timestamp from server */
+    timestamp: string;
+    /** Source identifier (which backend service emitted this) */
+    source?: string;
+}
+/**
+ * A remote Redux action dispatched from the backend.
+ * Delivered as an EventChannelEvent with type='remote-action'.
+ */
+export interface RemoteAction {
+    /** The Redux action type to dispatch */
+    actionType: string;
+    /** The action payload */
+    payload?: unknown;
+    /** Optional metadata */
+    meta?: {
+        source: string;
+        correlationId?: string;
+        timestamp: string;
+    };
+}
+/**
+ * Event channel service interface.
+ */
+export interface IEventChannel {
+    /** Connect to the event stream */
+    connect(): void;
+    /** Disconnect from the event stream */
+    disconnect(): void;
+    /** Current connection status */
+    getStatus(): ConnectionStatus;
+    /**
+     * Subscribe to events of a specific type.
+     * @returns unsubscribe function
+     */
+    on<T = unknown>(eventType: string, handler: (event: EventChannelEvent<T>) => void): () => void;
+    /**
+     * Subscribe to all events.
+     * @returns unsubscribe function
+     */
+    onAny(handler: (event: EventChannelEvent) => void): () => void;
+    /**
+     * Subscribe to connection status changes.
+     * @returns unsubscribe function
+     */
+    onStatusChange(handler: (status: ConnectionStatus) => void): () => void;
+    /** Destroy the channel and clean up all subscriptions */
+    destroy(): void;
+}
+//# sourceMappingURL=event-types.d.ts.map

package/dist/api/types/event-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-types.d.ts","sourceRoot":"","sources":["../../../src/api/types/event-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO;IAC5C,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,IAAI,EAAE,CAAC,CAAC;IACR,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,yBAAyB;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,wBAAwB;IACxB,IAAI,CAAC,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,OAAO,IAAI,IAAI,CAAC;IAEhB,uCAAuC;IACvC,UAAU,IAAI,IAAI,CAAC;IAEnB,gCAAgC;IAChC,SAAS,IAAI,gBAAgB,CAAC;IAE9B;;;OAGG;IACH,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAE/F;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAE/D;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAExE,yDAAyD;IACzD,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/api/types/event-types.js

@@ -0,0 +1,4 @@
+/**
+ * Core event channel types.
+ */
+export {};

package/dist/impl/core/event-channel.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Event Channel Service
+ *
+ * Manages the event stream connection with auto-reconnect
+ * and typed event subscriptions.
+ */
+import type { EventChannelEvent, ConnectionStatus, IEventChannel } from '../../api';
+import type { IEventTransport } from '../../spi/transport/i-event-transport';
+import type { EventChannelPluginConfig } from '../../spi/config/event-channel-plugin-config';
+export declare class EventChannel implements IEventChannel {
+    private transport;
+    private config;
+    private typedHandlers;
+    private anyHandlers;
+    private statusHandlers;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private destroyed;
+    private unsubscribers;
+    constructor(pluginConfig: EventChannelPluginConfig, transport: IEventTransport);
+    connect(): void;
+    disconnect(): void;
+    getStatus(): ConnectionStatus;
+    on<T = unknown>(eventType: string, handler: (event: EventChannelEvent<T>) => void): () => void;
+    onAny(handler: (event: EventChannelEvent) => void): () => void;
+    onStatusChange(handler: (status: ConnectionStatus) => void): () => void;
+    destroy(): void;
+    private handleEvent;
+    private handleStatusChange;
+    private handleError;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private log;
+}
+//# sourceMappingURL=event-channel.d.ts.map

package/dist/impl/core/event-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-channel.d.ts","sourceRoot":"","sources":["../../../src/impl/core/event-channel.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AAE7F,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,MAAM,CAAgJ;IAC9J,OAAO,CAAC,aAAa,CAA8D;IACnF,OAAO,CAAC,WAAW,CAAiD;IACpE,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAAyB;gBAElC,YAAY,EAAE,wBAAwB,EAAE,SAAS,EAAE,eAAe;IAmB9E,OAAO,IAAI,IAAI;IAQf,UAAU,IAAI,IAAI;IAMlB,SAAS,IAAI,gBAAgB;IAI7B,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAS9F,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,MAAM,IAAI;IAK9D,cAAc,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,MAAM,IAAI;IAKvE,OAAO,IAAI,IAAI;IAcf,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,iBAAiB;IAyBzB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,GAAG;CAKZ"}

package/dist/impl/core/event-channel.js

@@ -0,0 +1,177 @@
+/**
+ * Event Channel Service
+ *
+ * Manages the event stream connection with auto-reconnect
+ * and typed event subscriptions.
+ */
+export class EventChannel {
+    constructor(pluginConfig, transport) {
+        Object.defineProperty(this, "transport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "typedHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "anyHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "statusHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "reconnectTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "destroyed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "unsubscribers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.transport = transport;
+        this.config = {
+            url: pluginConfig.url ?? '/api/events',
+            autoReconnect: pluginConfig.autoReconnect ?? true,
+            maxReconnectAttempts: pluginConfig.maxReconnectAttempts ?? 0,
+            reconnectDelay: pluginConfig.reconnectDelay ?? 1000,
+            maxReconnectDelay: pluginConfig.maxReconnectDelay ?? 30000,
+            debug: pluginConfig.debug ?? false,
+        };
+        // Wire transport events
+        this.unsubscribers.push(this.transport.onEvent((event) => this.handleEvent(event)), this.transport.onStatusChange((status) => this.handleStatusChange(status)), this.transport.onError((error) => this.handleError(error)));
+    }
+    connect() {
+        if (this.destroyed)
+            return;
+        this.reconnectAttempts = 0;
+        this.cancelReconnect();
+        this.transport.connect(this.config.url);
+        this.log('Connecting to', this.config.url);
+    }
+    disconnect() {
+        this.cancelReconnect();
+        this.transport.disconnect();
+        this.log('Disconnected');
+    }
+    getStatus() {
+        return this.transport.getStatus();
+    }
+    on(eventType, handler) {
+        if (!this.typedHandlers.has(eventType)) {
+            this.typedHandlers.set(eventType, new Set());
+        }
+        const handlers = this.typedHandlers.get(eventType);
+        handlers.add(handler);
+        return () => { handlers.delete(handler); };
+    }
+    onAny(handler) {
+        this.anyHandlers.add(handler);
+        return () => { this.anyHandlers.delete(handler); };
+    }
+    onStatusChange(handler) {
+        this.statusHandlers.add(handler);
+        return () => { this.statusHandlers.delete(handler); };
+    }
+    destroy() {
+        this.destroyed = true;
+        this.cancelReconnect();
+        this.transport.disconnect();
+        for (const unsub of this.unsubscribers) {
+            unsub();
+        }
+        this.unsubscribers = [];
+        this.typedHandlers.clear();
+        this.anyHandlers.clear();
+        this.statusHandlers.clear();
+        this.log('Destroyed');
+    }
+    handleEvent(event) {
+        // Notify typed handlers
+        const handlers = this.typedHandlers.get(event.type);
+        if (handlers) {
+            for (const handler of handlers) {
+                handler(event);
+            }
+        }
+        // Notify wildcard handlers
+        for (const handler of this.anyHandlers) {
+            handler(event);
+        }
+    }
+    handleStatusChange(status) {
+        if (status === 'connected') {
+            this.reconnectAttempts = 0;
+            this.log('Connected');
+        }
+        if ((status === 'error' || status === 'reconnecting') && this.config.autoReconnect) {
+            this.scheduleReconnect();
+        }
+        for (const handler of this.statusHandlers) {
+            handler(status);
+        }
+    }
+    handleError(error) {
+        this.log('Error:', error.message);
+    }
+    scheduleReconnect() {
+        if (this.destroyed || this.reconnectTimer)
+            return;
+        if (this.config.maxReconnectAttempts > 0 && this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+            this.log('Max reconnect attempts reached');
+            return;
+        }
+        const jitter = Math.random() * 500;
+        const delay = Math.min(this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts) + jitter, this.config.maxReconnectDelay);
+        this.reconnectAttempts++;
+        this.log(`Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.destroyed) {
+                this.transport.connect(this.config.url);
+            }
+        }, delay);
+    }
+    cancelReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[event-channel]', ...args);
+        }
+    }
+}

package/dist/impl/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @hamak/event-channel Implementation
+ *
+ * Re-exports API + SPI + concrete implementations.
+ */
+export * from '../api';
+export type { IEventTransport } from '../spi/transport/i-event-transport';
+export type { IRemoteActionFilter } from '../spi/security/i-action-filter';
+export type { EventChannelPluginConfig } from '../spi/config/event-channel-plugin-config';
+export { SseTransport } from './transport/sse-transport';
+export { EventChannel } from './core/event-channel';
+export { ActionWhitelistFilter } from './security/action-whitelist-filter';
+export { eventChannelReducer, type EventChannelState } from './store/event-channel-reducer';
+export { createEventChannelMiddleware, type EventChannelMiddlewareConfig } from './middleware/event-channel-middleware';
+export { createEventChannelPlugin } from './plugin/event-channel-plugin-factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,QAAQ,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,YAAY,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,YAAY,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAG1F,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAG3E,OAAO,EAAE,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAG5F,OAAO,EAAE,4BAA4B,EAAE,KAAK,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAGxH,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC"}

package/dist/impl/index.js

@@ -0,0 +1,19 @@
+/**
+ * @hamak/event-channel Implementation
+ *
+ * Re-exports API + SPI + concrete implementations.
+ */
+// Re-export API and SPI
+export * from '../api';
+// Transport
+export { SseTransport } from './transport/sse-transport';
+// Core
+export { EventChannel } from './core/event-channel';
+// Security
+export { ActionWhitelistFilter } from './security/action-whitelist-filter';
+// Store
+export { eventChannelReducer } from './store/event-channel-reducer';
+// Middleware
+export { createEventChannelMiddleware } from './middleware/event-channel-middleware';
+// Plugin
+export { createEventChannelPlugin } from './plugin/event-channel-plugin-factory';

package/dist/impl/middleware/event-channel-middleware.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Event Channel Middleware
+ *
+ * Intercepts REMOTE_ACTION_RECEIVED events and dispatches
+ * the actual Redux action after checking the security filter.
+ */
+import type { Middleware } from '@reduxjs/toolkit';
+import type { IRemoteActionFilter } from '../../spi/security/i-action-filter';
+export interface EventChannelMiddlewareConfig {
+    actionFilter: IRemoteActionFilter;
+    debug?: boolean;
+}
+export declare function createEventChannelMiddleware(config: EventChannelMiddlewareConfig): Middleware;
+//# sourceMappingURL=event-channel-middleware.d.ts.map

package/dist/impl/middleware/event-channel-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-channel-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/event-channel-middleware.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,MAAM,WAAW,4BAA4B;IAC3C,YAAY,EAAE,mBAAmB,CAAC;IAClC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,4BAA4B,GACnC,UAAU,CA4BZ"}

package/dist/impl/middleware/event-channel-middleware.js

@@ -0,0 +1,33 @@
+/**
+ * Event Channel Middleware
+ *
+ * Intercepts REMOTE_ACTION_RECEIVED events and dispatches
+ * the actual Redux action after checking the security filter.
+ */
+import { EventChannelActionTypes } from '../../api/actions/event-channel-actions';
+export function createEventChannelMiddleware(config) {
+    return (store) => (next) => (action) => {
+        const result = next(action);
+        const typedAction = action;
+        if (typedAction.type === EventChannelActionTypes.REMOTE_ACTION_RECEIVED) {
+            const remoteAction = typedAction.payload;
+            if (config.actionFilter.isAllowed(remoteAction)) {
+                if (config.debug) {
+                    console.log('[event-channel] Dispatching remote action:', remoteAction.actionType);
+                }
+                store.dispatch({
+                    type: remoteAction.actionType,
+                    payload: remoteAction.payload,
+                    meta: {
+                        ...remoteAction.meta,
+                        remote: true,
+                    },
+                });
+            }
+            else if (config.debug) {
+                console.warn('[event-channel] Blocked remote action:', remoteAction.actionType);
+            }
+        }
+        return result;
+    };
+}

package/dist/impl/plugin/event-channel-plugin-factory.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Event Channel Plugin Factory
+ *
+ * Creates a microkernel plugin for the event channel.
+ */
+import type { PluginModule } from '@hamak/microkernel-spi';
+import type { EventChannelPluginConfig } from '../../spi/config/event-channel-plugin-config';
+/**
+ * Create an event channel plugin for the microkernel.
+ *
+ * @example
+ * ```typescript
+ * import { createEventChannelPlugin } from '@hamak/event-channel';
+ *
+ * host.registerPlugin(
+ *   'event-channel',
+ *   { name: 'event-channel', version: '1.0.0', entry: '', dependsOn: ['store'] },
+ *   createEventChannelPlugin({
+ *     url: '/api/events',
+ *     allowedActionTypes: ['todos/*', 'notification/*'],
+ *     debug: true,
+ *   })
+ * );
+ * ```
+ */
+export declare function createEventChannelPlugin(config?: EventChannelPluginConfig): PluginModule;
+//# sourceMappingURL=event-channel-plugin-factory.d.ts.map

package/dist/impl/plugin/event-channel-plugin-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-channel-plugin-factory.d.ts","sourceRoot":"","sources":["../../../src/impl/plugin/event-channel-plugin-factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,wBAAwB,CAAC;AAIlF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AAQ7F;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,GAAE,wBAA6B,GACpC,YAAY,CA6Hd"}

package/dist/impl/plugin/event-channel-plugin-factory.js

@@ -0,0 +1,136 @@
+/**
+ * Event Channel Plugin Factory
+ *
+ * Creates a microkernel plugin for the event channel.
+ */
+import { EVENT_CHANNEL_TOKEN } from '../../api/tokens/service-tokens';
+import { eventChannelActions } from '../../api/actions/event-channel-actions';
+import { SseTransport } from '../transport/sse-transport';
+import { EventChannel } from '../core/event-channel';
+import { ActionWhitelistFilter } from '../security/action-whitelist-filter';
+import { eventChannelReducer } from '../store/event-channel-reducer';
+import { createEventChannelMiddleware } from '../middleware/event-channel-middleware';
+/**
+ * Create an event channel plugin for the microkernel.
+ *
+ * @example
+ * ```typescript
+ * import { createEventChannelPlugin } from '@hamak/event-channel';
+ *
+ * host.registerPlugin(
+ *   'event-channel',
+ *   { name: 'event-channel', version: '1.0.0', entry: '', dependsOn: ['store'] },
+ *   createEventChannelPlugin({
+ *     url: '/api/events',
+ *     allowedActionTypes: ['todos/*', 'notification/*'],
+ *     debug: true,
+ *   })
+ * );
+ * ```
+ */
+export function createEventChannelPlugin(config = {}) {
+    let channel;
+    const debug = config.debug ?? false;
+    return {
+        async initialize(ctx) {
+            // Build action filter
+            let actionFilter;
+            if (!config.allowedActionTypes) {
+                actionFilter = { isAllowed: () => true };
+            }
+            else if (Array.isArray(config.allowedActionTypes)) {
+                actionFilter = new ActionWhitelistFilter(config.allowedActionTypes);
+            }
+            else {
+                actionFilter = config.allowedActionTypes;
+            }
+            // Build transport
+            const transport = config.transport ?? new SseTransport();
+            // Build channel
+            channel = new EventChannel(config, transport);
+            // Register in DI
+            ctx.provide({ provide: EVENT_CHANNEL_TOKEN, useValue: channel });
+            // Register reducer and middleware with store (optional dependency)
+            try {
+                const STORE_EXTENSIONS_TOKEN = Symbol.for('@hamak/ui-store:StoreExtensionsRegistry');
+                const storeExtensions = ctx.resolve(STORE_EXTENSIONS_TOKEN);
+                if (storeExtensions && typeof storeExtensions.register === 'function') {
+                    storeExtensions.register('event-channel', {
+                        reducers: {
+                            eventChannel: eventChannelReducer,
+                        },
+                        middleware: [{
+                                id: 'event-channel',
+                                middleware: createEventChannelMiddleware({ actionFilter, debug }),
+                                priority: config.middlewarePriority ?? 500,
+                                plugin: 'event-channel',
+                                description: 'Dispatches remote actions from backend event stream',
+                            }],
+                    });
+                }
+            }
+            catch {
+                if (debug) {
+                    console.log('[event-channel] Store extensions not available, skipping reducer/middleware registration');
+                }
+            }
+            // Register commands
+            ctx.commands.register('eventChannel.connect', () => channel.connect());
+            ctx.commands.register('eventChannel.disconnect', () => channel.disconnect());
+            ctx.commands.register('eventChannel.status', () => channel.getStatus());
+        },
+        async activate(ctx) {
+            const url = config.url ?? '/api/events';
+            // Wire channel events to hooks and store
+            channel.onStatusChange((status) => {
+                ctx.hooks.emit('event-channel:status', status);
+                // Dispatch connection status to store
+                try {
+                    const STORE_MANAGER_TOKEN = Symbol.for('StoreManager');
+                    const storeManager = ctx.resolve(STORE_MANAGER_TOKEN);
+                    if (storeManager) {
+                        storeManager.dispatch(eventChannelActions.connectionStatusChanged({
+                            status,
+                            reconnectAttempts: 0,
+                            url,
+                            lastConnectedAt: status === 'connected' ? new Date().toISOString() : undefined,
+                        }));
+                    }
+                }
+                catch {
+                    // Store not available
+                }
+            });
+            channel.onAny((event) => {
+                ctx.hooks.emit('event-channel:event', event);
+                // Dispatch to store
+                try {
+                    const STORE_MANAGER_TOKEN = Symbol.for('StoreManager');
+                    const storeManager = ctx.resolve(STORE_MANAGER_TOKEN);
+                    if (storeManager) {
+                        // Store the event
+                        storeManager.dispatch(eventChannelActions.eventReceived(event));
+                        // If it's a remote action, dispatch so middleware can process it
+                        if (event.type === 'remote-action') {
+                            storeManager.dispatch(eventChannelActions.remoteActionReceived(event.data));
+                        }
+                    }
+                }
+                catch {
+                    // Store not available
+                }
+            });
+            // Auto-connect if configured
+            if (config.autoConnect !== false) {
+                channel.connect();
+            }
+            ctx.hooks.emit('event-channel:ready', { channel });
+            if (debug) {
+                console.log('[event-channel] Plugin activated', config.autoConnect !== false ? '(auto-connecting)' : '');
+            }
+        },
+        async deactivate() {
+            channel?.destroy();
+        },
+    };
+}

package/dist/impl/security/action-whitelist-filter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Action Whitelist Filter
+ *
+ * Filters remote actions based on a whitelist of allowed action type patterns.
+ * Supports exact match and simple glob patterns (e.g., 'todos/*').
+ */
+import type { RemoteAction } from '../../api';
+import type { IRemoteActionFilter } from '../../spi/security/i-action-filter';
+export declare class ActionWhitelistFilter implements IRemoteActionFilter {
+    private readonly patterns;
+    constructor(allowedPatterns: string[]);
+    isAllowed(action: RemoteAction): boolean;
+    private matches;
+}
+//# sourceMappingURL=action-whitelist-filter.d.ts.map

package/dist/impl/security/action-whitelist-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-whitelist-filter.d.ts","sourceRoot":"","sources":["../../../src/impl/security/action-whitelist-filter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,qBAAa,qBAAsB,YAAW,mBAAmB;IAC/D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;gBAExB,eAAe,EAAE,MAAM,EAAE;IAIrC,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO;IAIxC,OAAO,CAAC,OAAO;CAehB"}

package/dist/impl/security/action-whitelist-filter.js

@@ -0,0 +1,34 @@
+/**
+ * Action Whitelist Filter
+ *
+ * Filters remote actions based on a whitelist of allowed action type patterns.
+ * Supports exact match and simple glob patterns (e.g., 'todos/*').
+ */
+export class ActionWhitelistFilter {
+    constructor(allowedPatterns) {
+        Object.defineProperty(this, "patterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.patterns = allowedPatterns;
+    }
+    isAllowed(action) {
+        return this.patterns.some((pattern) => this.matches(pattern, action.actionType));
+    }
+    matches(pattern, actionType) {
+        // Exact match
+        if (pattern === actionType)
+            return true;
+        // Simple glob: 'prefix/*' matches 'prefix/anything'
+        if (pattern.endsWith('/*')) {
+            const prefix = pattern.slice(0, -2);
+            return actionType.startsWith(prefix + '/') || actionType === prefix;
+        }
+        // Wildcard-only: '*' matches everything
+        if (pattern === '*')
+            return true;
+        return false;
+    }
+}

package/dist/impl/store/event-channel-reducer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Event Channel Reducer
+ *
+ * Manages connection state and recent events in the Redux store.
+ */
+import type { ConnectionInfo } from '../../api/types/connection-types';
+import type { EventChannelEvent } from '../../api/types/event-types';
+import { type EventChannelAction } from '../../api/actions/event-channel-actions';
+export interface EventChannelState {
+    connection: ConnectionInfo;
+    recentEvents: EventChannelEvent[];
+    totalEventsReceived: number;
+}
+export declare function eventChannelReducer(state: EventChannelState | undefined, action: EventChannelAction | {
+    type: string;
+}): EventChannelState;
+//# sourceMappingURL=event-channel-reducer.d.ts.map

package/dist/impl/store/event-channel-reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-channel-reducer.d.ts","sourceRoot":"","sources":["../../../src/impl/store/event-channel-reducer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAI3G,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,cAAc,CAAC;IAC3B,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAYD,wBAAgB,mBAAmB,CACjC,KAAK,+BAAkC,EACvC,MAAM,EAAE,kBAAkB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAC5C,iBAAiB,CAuBnB"}

package/dist/impl/store/event-channel-reducer.js

@@ -0,0 +1,38 @@
+/**
+ * Event Channel Reducer
+ *
+ * Manages connection state and recent events in the Redux store.
+ */
+import { EventChannelActionTypes } from '../../api/actions/event-channel-actions';
+const MAX_RECENT_EVENTS = 50;
+const initialState = {
+    connection: {
+        status: 'disconnected',
+        reconnectAttempts: 0,
+        url: '',
+    },
+    recentEvents: [],
+    totalEventsReceived: 0,
+};
+export function eventChannelReducer(state = initialState, action) {
+    switch (action.type) {
+        case EventChannelActionTypes.CONNECTION_STATUS_CHANGED: {
+            const { payload } = action;
+            return {
+                ...state,
+                connection: payload,
+            };
+        }
+        case EventChannelActionTypes.EVENT_RECEIVED: {
+            const { payload } = action;
+            const recentEvents = [payload, ...state.recentEvents].slice(0, MAX_RECENT_EVENTS);
+            return {
+                ...state,
+                recentEvents,
+                totalEventsReceived: state.totalEventsReceived + 1,
+            };
+        }
+        default:
+            return state;
+    }
+}

package/dist/impl/transport/sse-transport.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SSE Transport
+ *
+ * Browser EventSource-based transport for the event channel.
+ */
+import type { EventChannelEvent, ConnectionStatus } from '../../api';
+import type { IEventTransport } from '../../spi';
+export declare class SseTransport implements IEventTransport {
+    private eventSource;
+    private status;
+    private eventHandlers;
+    private statusHandlers;
+    private errorHandlers;
+    connect(url: string): void;
+    /** Add a listener for a specific SSE event type */
+    addEventType(type: string): void;
+    disconnect(): void;
+    getStatus(): ConnectionStatus;
+    onEvent(handler: (event: EventChannelEvent) => void): () => void;
+    onStatusChange(handler: (status: ConnectionStatus) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    private handleMessage;
+    private setStatus;
+}
+//# sourceMappingURL=sse-transport.d.ts.map

package/dist/impl/transport/sse-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-transport.d.ts","sourceRoot":"","sources":["../../../src/impl/transport/sse-transport.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,qBAAa,YAAa,YAAW,eAAe;IAClD,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,aAAa,CAAiD;IACtE,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,aAAa,CAAqC;IAE1D,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAqC1B,mDAAmD;IACnD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAOhC,UAAU,IAAI,IAAI;IAQlB,SAAS,IAAI,gBAAgB;IAI7B,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,MAAM,IAAI;IAKhE,cAAc,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,MAAM,IAAI;IAKvE,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAKpD,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,SAAS;CAOlB"}

package/dist/impl/transport/sse-transport.js

@@ -0,0 +1,119 @@
+/**
+ * SSE Transport
+ *
+ * Browser EventSource-based transport for the event channel.
+ */
+export class SseTransport {
+    constructor() {
+        Object.defineProperty(this, "eventSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'disconnected'
+        });
+        Object.defineProperty(this, "eventHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "statusHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "errorHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+    }
+    connect(url) {
+        if (this.eventSource) {
+            this.disconnect();
+        }
+        this.setStatus('connecting');
+        this.eventSource = new EventSource(url);
+        this.eventSource.onopen = () => {
+            this.setStatus('connected');
+        };
+        this.eventSource.onerror = () => {
+            // EventSource auto-reconnects on error; we report the status change
+            if (this.eventSource?.readyState === EventSource.CLOSED) {
+                this.setStatus('error');
+                for (const handler of this.errorHandlers) {
+                    handler(new Error('EventSource connection closed'));
+                }
+            }
+            else if (this.eventSource?.readyState === EventSource.CONNECTING) {
+                this.setStatus('reconnecting');
+            }
+        };
+        // Listen for all named events via a generic message listener
+        this.eventSource.onmessage = (messageEvent) => {
+            this.handleMessage(messageEvent);
+        };
+        // Also listen for named events by intercepting addEventListener
+        // EventSource fires named events that onmessage doesn't catch
+        // We use a proxy pattern: listen on the most common event types
+        // The server sends events with `event: <type>`, which EventSource routes to named listeners
+        // We'll use the 'message' event as fallback and add specific listeners for known types
+    }
+    /** Add a listener for a specific SSE event type */
+    addEventType(type) {
+        if (!this.eventSource)
+            return;
+        this.eventSource.addEventListener(type, ((event) => {
+            this.handleMessage(event);
+        }));
+    }
+    disconnect() {
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+        }
+        this.setStatus('disconnected');
+    }
+    getStatus() {
+        return this.status;
+    }
+    onEvent(handler) {
+        this.eventHandlers.add(handler);
+        return () => { this.eventHandlers.delete(handler); };
+    }
+    onStatusChange(handler) {
+        this.statusHandlers.add(handler);
+        return () => { this.statusHandlers.delete(handler); };
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return () => { this.errorHandlers.delete(handler); };
+    }
+    handleMessage(messageEvent) {
+        try {
+            const parsed = JSON.parse(messageEvent.data);
+            for (const handler of this.eventHandlers) {
+                handler(parsed);
+            }
+        }
+        catch {
+            // Non-JSON message (e.g., initial connection message), ignore
+        }
+    }
+    setStatus(newStatus) {
+        if (this.status === newStatus)
+            return;
+        this.status = newStatus;
+        for (const handler of this.statusHandlers) {
+            handler(newStatus);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @hamak/event-channel
+ * Reactive event channel with SSE transport and remote action dispatch
+ */
+export * from './impl';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+/**
+ * @hamak/event-channel
+ * Reactive event channel with SSE transport and remote action dispatch
+ */
+export * from './impl';

package/dist/spi/config/event-channel-plugin-config.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Configuration for the event channel plugin.
+ */
+import type { IEventTransport } from '../transport/i-event-transport';
+import type { IRemoteActionFilter } from '../security/i-action-filter';
+export interface EventChannelPluginConfig {
+    /**
+     * URL of the SSE endpoint.
+     * @default '/api/events'
+     */
+    url?: string;
+    /**
+     * Whether to connect automatically on plugin activation.
+     * @default true
+     */
+    autoConnect?: boolean;
+    /**
+     * Enable auto-reconnect on connection loss.
+     * @default true
+     */
+    autoReconnect?: boolean;
+    /**
+     * Max reconnect attempts (0 = infinite).
+     * @default 0
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Base reconnect delay in ms (exponential backoff applied).
+     * @default 1000
+     */
+    reconnectDelay?: number;
+    /**
+     * Maximum reconnect delay in ms.
+     * @default 30000
+     */
+    maxReconnectDelay?: number;
+    /**
+     * Allowed action types for remote dispatch.
+     * String array supports glob patterns (e.g., 'todos/*').
+     * Or provide a custom IRemoteActionFilter.
+     * If not provided, ALL remote actions are allowed.
+     */
+    allowedActionTypes?: string[] | IRemoteActionFilter;
+    /**
+     * Custom transport (defaults to SseTransport).
+     */
+    transport?: IEventTransport;
+    /**
+     * Priority for the event-channel middleware.
+     * @default 500
+     */
+    middlewarePriority?: number;
+    /**
+     * Enable debug logging.
+     * @default false
+     */
+    debug?: boolean;
+}
+//# sourceMappingURL=event-channel-plugin-config.d.ts.map

package/dist/spi/config/event-channel-plugin-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-channel-plugin-config.d.ts","sourceRoot":"","sources":["../../../src/spi/config/event-channel-plugin-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAAG,mBAAmB,CAAC;IAEpD;;OAEG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB"}

package/dist/spi/config/event-channel-plugin-config.js

@@ -0,0 +1,4 @@
+/**
+ * Configuration for the event channel plugin.
+ */
+export {};

package/dist/spi/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @hamak/event-channel SPI
+ *
+ * Extension points and provider interfaces.
+ */
+export * from '../api';
+export type { IEventTransport } from './transport/i-event-transport';
+export type { IRemoteActionFilter } from './security/i-action-filter';
+export type { EventChannelPluginConfig } from './config/event-channel-plugin-config';
+//# sourceMappingURL=index.d.ts.map

package/dist/spi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spi/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,QAAQ,CAAC;AAGvB,YAAY,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAGrE,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,YAAY,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/spi/index.js

@@ -0,0 +1,7 @@
+/**
+ * @hamak/event-channel SPI
+ *
+ * Extension points and provider interfaces.
+ */
+// Re-export API
+export * from '../api';

package/dist/spi/security/i-action-filter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Security filter for remote actions.
+ */
+import type { RemoteAction } from '../../api';
+/**
+ * Determines which action types the backend is allowed to dispatch.
+ */
+export interface IRemoteActionFilter {
+    /** Return true if this remote action should be dispatched */
+    isAllowed(action: RemoteAction): boolean;
+}
+//# sourceMappingURL=i-action-filter.d.ts.map

package/dist/spi/security/i-action-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-action-filter.d.ts","sourceRoot":"","sources":["../../../src/spi/security/i-action-filter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,6DAA6D;IAC7D,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC;CAC1C"}

package/dist/spi/security/i-action-filter.js

@@ -0,0 +1,4 @@
+/**
+ * Security filter for remote actions.
+ */
+export {};

package/dist/spi/transport/i-event-transport.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Transport abstraction for the event channel.
+ * SSE for Phase 1, WebSocket for Phase 2.
+ */
+import type { EventChannelEvent, ConnectionStatus } from '../../api';
+export interface IEventTransport {
+    /** Open the transport connection */
+    connect(url: string): void;
+    /** Close the transport connection */
+    disconnect(): void;
+    /** Current connection status */
+    getStatus(): ConnectionStatus;
+    /** Register event handler (called for each incoming event) */
+    onEvent(handler: (event: EventChannelEvent) => void): () => void;
+    /** Register status change handler */
+    onStatusChange(handler: (status: ConnectionStatus) => void): () => void;
+    /** Register error handler */
+    onError(handler: (error: Error) => void): () => void;
+}
+//# sourceMappingURL=i-event-transport.d.ts.map

package/dist/spi/transport/i-event-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-event-transport.d.ts","sourceRoot":"","sources":["../../../src/spi/transport/i-event-transport.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAErE,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B,qCAAqC;IACrC,UAAU,IAAI,IAAI,CAAC;IAEnB,gCAAgC;IAChC,SAAS,IAAI,gBAAgB,CAAC;IAE9B,8DAA8D;IAC9D,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAEjE,qCAAqC;IACrC,cAAc,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAExE,6BAA6B;IAC7B,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACtD"}

package/dist/spi/transport/i-event-transport.js

@@ -0,0 +1,5 @@
+/**
+ * Transport abstraction for the event channel.
+ * SSE for Phase 1, WebSocket for Phase 2.
+ */
+export {};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@hamak/event-channel",
+  "version": "0.5.3",
+  "private": false,
+  "type": "module",
+  "description": "Reactive event channel with SSE transport and remote action dispatch for microkernel-based applications",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amah/app-framework.git",
+    "directory": "packages/event-channel"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.ts",
+      "import": "./dist/api/index.js",
+      "default": "./dist/api/index.js"
+    },
+    "./spi": {
+      "types": "./dist/spi/index.d.ts",
+      "import": "./dist/spi/index.js",
+      "default": "./dist/spi/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "api": [
+        "./dist/api/index.d.ts"
+      ],
+      "spi": [
+        "./dist/spi/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@hamak/microkernel-spi": "*",
+    "@reduxjs/toolkit": "^2.0.0"
+  },
+  "devDependencies": {
+    "typescript": "~5.4.0",
+    "vitest": "^2.0.0",
+    "@types/node": "^20.0.0"
+  }
+}