ocpp-ws-io 1.0.0-alpha

package/dist/types-6LVUoXof.d.mts

@@ -0,0 +1,284 @@
+import * as node_https from 'node:https';
+import * as node_http from 'node:http';
+import { IncomingMessage } from 'node:http';
+import { TLSSocket } from 'node:tls';
+import { Duplex } from 'node:stream';
+import Ajv from 'ajv';
+
+interface ValidatorSchema {
+    $schema?: string;
+    $id?: string;
+    [key: string]: unknown;
+}
+/**
+ * Schema validator using AJV for OCPP message validation.
+ * Each validator is bound to a specific subprotocol version.
+ */
+declare class Validator {
+    readonly subprotocol: string;
+    /** @internal */
+    _ajv: Ajv;
+    constructor(subprotocol: string, schemas: ValidatorSchema[]);
+    /**
+     * Normalize a schema ID from OCPP URN format to internal path format.
+     */
+    private _normalizeSchemaId;
+    /**
+     * Validate a payload against a schema identified by its $id.
+     * Throws a typed RPCError if validation fails.
+     */
+    validate(schemaId: string, params: unknown): void;
+    /**
+     * Check if a schema exists for the given $id.
+     */
+    hasSchema(schemaId: string): boolean;
+}
+/**
+ * Create a validator for a specific subprotocol version.
+ */
+declare function createValidator(subprotocol: string, schemas: ValidatorSchema[]): Validator;
+
+type OCPPProtocol = "ocpp1.6" | "ocpp2.0.1" | "ocpp2.1";
+declare const ConnectionState: {
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+};
+type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+declare enum SecurityProfile {
+    /** No security — plain WS, no auth (dev/testing only) */
+    NONE = 0,
+    /** Profile 1: Basic Auth over unsecured WS (ws://) — password-based */
+    BASIC_AUTH = 1,
+    /** Profile 2: TLS + Basic Auth (wss://) — server cert + password */
+    TLS_BASIC_AUTH = 2,
+    /** Profile 3: Mutual TLS (wss://) — client + server certificates */
+    TLS_CLIENT_CERT = 3
+}
+declare const MessageType: {
+    readonly CALL: 2;
+    readonly CALLRESULT: 3;
+    readonly CALLERROR: 4;
+};
+type MessageType = (typeof MessageType)[keyof typeof MessageType];
+type OCPPCall<T = unknown> = [2, string, string, T];
+type OCPPCallResult<T = unknown> = [3, string, T];
+type OCPPCallError = [
+    4,
+    string,
+    string,
+    string,
+    Record<string, unknown>
+];
+type OCPPMessage<T = unknown> = OCPPCall<T> | OCPPCallResult<T> | OCPPCallError;
+interface TLSOptions {
+    /** Server/client certificate (PEM) */
+    cert?: string | Buffer;
+    /** Private key (PEM) */
+    key?: string | Buffer;
+    /** CA certificate(s) for verification */
+    ca?: string | Buffer | Array<string | Buffer>;
+    /** Reject unauthorized certs (default: true) */
+    rejectUnauthorized?: boolean;
+    /** Passphrase for encrypted private key */
+    passphrase?: string;
+}
+interface HandlerContext<T = unknown> {
+    messageId: string;
+    method: string;
+    params: T;
+    signal: AbortSignal;
+}
+type CallHandler<TParams = unknown, TResult = unknown> = (context: HandlerContext<TParams>) => TResult | Promise<TResult>;
+type WildcardHandler = (method: string, context: HandlerContext) => unknown | Promise<unknown>;
+interface CallOptions {
+    /** Timeout in milliseconds for this specific call */
+    timeoutMs?: number;
+    /** Abort signal */
+    signal?: AbortSignal;
+    /** Suppress sending a response (server-side, NOREPLY) */
+    noReply?: boolean;
+}
+interface CloseOptions {
+    /** WebSocket close code (default: 1000) */
+    code?: number;
+    /** Close reason string */
+    reason?: string;
+    /** Wait for pending calls to complete before closing */
+    awaitPending?: boolean;
+    /** Force-close without waiting */
+    force?: boolean;
+}
+interface HandshakeInfo {
+    /** Charging station identity (from URL path) */
+    identity: string;
+    /** Remote IP address */
+    remoteAddress: string;
+    /** Request headers */
+    headers: Record<string, string | string[] | undefined>;
+    /** Negotiated subprotocols */
+    protocols: Set<string>;
+    /** Request endpoint URL path */
+    endpoint: string;
+    /** URL query parameters */
+    query: URLSearchParams;
+    /** Original HTTP request */
+    request: IncomingMessage;
+    /** Password from Basic Auth (Profile 1 & 2) */
+    password?: Buffer;
+    /** Client certificate (Profile 3 — mTLS) */
+    clientCertificate?: ReturnType<TLSSocket["getPeerCertificate"]>;
+    /** Active security profile */
+    securityProfile: SecurityProfile;
+}
+type SessionData<T = Record<string, unknown>> = T;
+interface ClientOptions {
+    /** Unique identity for this client (charging station ID) */
+    identity: string;
+    /** WebSocket endpoint URL (ws:// or wss://) */
+    endpoint: string;
+    /** OCPP Security Profile (default: NONE) */
+    securityProfile?: SecurityProfile;
+    /** Password for Basic Auth (Profile 1 & 2) */
+    password?: string | Buffer;
+    /** TLS options (Profile 2 & 3) */
+    tls?: TLSOptions;
+    /** OCPP subprotocols to negotiate */
+    protocols?: string[];
+    /** Additional WebSocket headers */
+    headers?: Record<string, string>;
+    /** Additional query parameters */
+    query?: Record<string, string>;
+    /** Enable automatic reconnection (default: true) */
+    reconnect?: boolean;
+    /** Maximum reconnection attempts (default: Infinity) */
+    maxReconnects?: number;
+    /** Back-off base delay in ms (default: 1000) */
+    backoffMin?: number;
+    /** Back-off max delay in ms (default: 30000) */
+    backoffMax?: number;
+    /** Call timeout in ms (default: 30000) */
+    callTimeoutMs?: number;
+    /** Ping interval in ms (default: 30000, 0 to disable) */
+    pingIntervalMs?: number;
+    /** Defer pings if activity detected (default: false) */
+    deferPingsOnActivity?: boolean;
+    /** Maximum concurrent outbound calls (default: 1) */
+    callConcurrency?: number;
+    /** Enable strict mode validation (default: false) */
+    strictMode?: boolean | string[];
+    /** Custom validators for strict mode */
+    strictModeValidators?: Validator[];
+    /** Max number of bad messages before closing (default: Infinity) */
+    maxBadMessages?: number;
+    /** Include error details in responses (default: false) */
+    respondWithDetailedErrors?: boolean;
+}
+interface ServerOptions {
+    /** OCPP Security Profile (default: NONE) */
+    securityProfile?: SecurityProfile;
+    /** TLS options for HTTPS server (Profile 2 & 3) */
+    tls?: TLSOptions;
+    /** Accepted OCPP subprotocols */
+    protocols?: string[];
+    /** Call timeout in ms — inherited by server clients (default: 30000) */
+    callTimeoutMs?: number;
+    /** Ping interval in ms — inherited by server clients (default: 30000) */
+    pingIntervalMs?: number;
+    /** Defer pings if activity detected — inherited (default: false) */
+    deferPingsOnActivity?: boolean;
+    /** Max concurrent outbound calls — inherited (default: 1) */
+    callConcurrency?: number;
+    /** Enable strict mode — inherited (default: false) */
+    strictMode?: boolean | string[];
+    /** Custom validators — inherited */
+    strictModeValidators?: Validator[];
+    /** Max bad messages — inherited (default: Infinity) */
+    maxBadMessages?: number;
+    /** Include error details in responses — inherited (default: false) */
+    respondWithDetailedErrors?: boolean;
+}
+interface ListenOptions {
+    /** Existing HTTP/HTTPS server to attach to */
+    server?: node_http.Server | node_https.Server;
+    /** Hostname to bind to */
+    host?: string;
+    /** Signal to abort the listen */
+    signal?: AbortSignal;
+}
+interface AuthAccept<TSession = Record<string, unknown>> {
+    /** Subprotocol to use for this client */
+    protocol?: string;
+    /** Session data attached to the client */
+    session?: TSession;
+}
+type AuthCallback<TSession = Record<string, unknown>> = (accept: (options?: AuthAccept<TSession>) => void, reject: (code?: number, message?: string) => void, handshake: HandshakeInfo, signal: AbortSignal) => void | Promise<void>;
+interface ClientEvents {
+    open: [{
+        response: IncomingMessage;
+    }];
+    close: [{
+        code: number;
+        reason: string;
+    }];
+    error: [Error];
+    connecting: [{
+        url: string;
+    }];
+    reconnect: [{
+        attempt: number;
+        delay: number;
+    }];
+    message: [OCPPMessage];
+    call: [OCPPCall];
+    callResult: [OCPPCallResult];
+    callError: [OCPPCallError];
+    badMessage: [{
+        message: string;
+        error: Error;
+    }];
+    ping: [];
+    pong: [];
+    strictValidationFailure: [{
+        message: unknown;
+        error: Error;
+    }];
+}
+interface ServerEvents<TSession = Record<string, unknown>> {
+    client: [ServerClientInstance<TSession>];
+    error: [Error];
+    upgradeError: [{
+        error: Error;
+        socket: Duplex;
+    }];
+}
+type ServerClientInstance<TSession = Record<string, unknown>> = {
+    readonly identity: string;
+    readonly protocol: string | undefined;
+    readonly session: TSession;
+    readonly handshake: HandshakeInfo;
+    readonly state: ConnectionState;
+    close(options?: CloseOptions): Promise<{
+        code: number;
+        reason: string;
+    }>;
+    handle<TParams, TResult>(method: string, handler: CallHandler<TParams, TResult>): void;
+    handle(handler: WildcardHandler): void;
+    call<TResult>(method: string, params?: unknown, options?: CallOptions): Promise<TResult>;
+    removeHandler(method?: string): void;
+    removeAllHandlers(): void;
+    reconfigure(options: Partial<ClientOptions>): void;
+    on<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): void;
+    once<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): void;
+    off<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): void;
+};
+interface EventAdapterInterface {
+    publish(channel: string, data: unknown): Promise<void>;
+    subscribe(channel: string, handler: (data: unknown) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    disconnect(): Promise<void>;
+}
+declare const NOREPLY: unique symbol;
+
+export { type AuthCallback as A, type ClientOptions as C, type EventAdapterInterface as E, type HandshakeInfo as H, type ListenOptions as L, MessageType as M, NOREPLY as N, type OCPPCall as O, SecurityProfile as S, type TLSOptions as T, Validator as V, type WildcardHandler as W, ConnectionState as a, type CloseOptions as b, type CallHandler as c, type CallOptions as d, type ServerOptions as e, type AuthAccept as f, type ClientEvents as g, type HandlerContext as h, type OCPPCallError as i, type OCPPCallResult as j, type OCPPMessage as k, type OCPPProtocol as l, type ServerEvents as m, type SessionData as n, createValidator as o };

package/dist/types-6LVUoXof.d.ts

@@ -0,0 +1,284 @@
+import * as node_https from 'node:https';
+import * as node_http from 'node:http';
+import { IncomingMessage } from 'node:http';
+import { TLSSocket } from 'node:tls';
+import { Duplex } from 'node:stream';
+import Ajv from 'ajv';
+
+interface ValidatorSchema {
+    $schema?: string;
+    $id?: string;
+    [key: string]: unknown;
+}
+/**
+ * Schema validator using AJV for OCPP message validation.
+ * Each validator is bound to a specific subprotocol version.
+ */
+declare class Validator {
+    readonly subprotocol: string;
+    /** @internal */
+    _ajv: Ajv;
+    constructor(subprotocol: string, schemas: ValidatorSchema[]);
+    /**
+     * Normalize a schema ID from OCPP URN format to internal path format.
+     */
+    private _normalizeSchemaId;
+    /**
+     * Validate a payload against a schema identified by its $id.
+     * Throws a typed RPCError if validation fails.
+     */
+    validate(schemaId: string, params: unknown): void;
+    /**
+     * Check if a schema exists for the given $id.
+     */
+    hasSchema(schemaId: string): boolean;
+}
+/**
+ * Create a validator for a specific subprotocol version.
+ */
+declare function createValidator(subprotocol: string, schemas: ValidatorSchema[]): Validator;
+
+type OCPPProtocol = "ocpp1.6" | "ocpp2.0.1" | "ocpp2.1";
+declare const ConnectionState: {
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+};
+type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+declare enum SecurityProfile {
+    /** No security — plain WS, no auth (dev/testing only) */
+    NONE = 0,
+    /** Profile 1: Basic Auth over unsecured WS (ws://) — password-based */
+    BASIC_AUTH = 1,
+    /** Profile 2: TLS + Basic Auth (wss://) — server cert + password */
+    TLS_BASIC_AUTH = 2,
+    /** Profile 3: Mutual TLS (wss://) — client + server certificates */
+    TLS_CLIENT_CERT = 3
+}
+declare const MessageType: {
+    readonly CALL: 2;
+    readonly CALLRESULT: 3;
+    readonly CALLERROR: 4;
+};
+type MessageType = (typeof MessageType)[keyof typeof MessageType];
+type OCPPCall<T = unknown> = [2, string, string, T];
+type OCPPCallResult<T = unknown> = [3, string, T];
+type OCPPCallError = [
+    4,
+    string,
+    string,
+    string,
+    Record<string, unknown>
+];
+type OCPPMessage<T = unknown> = OCPPCall<T> | OCPPCallResult<T> | OCPPCallError;
+interface TLSOptions {
+    /** Server/client certificate (PEM) */
+    cert?: string | Buffer;
+    /** Private key (PEM) */
+    key?: string | Buffer;
+    /** CA certificate(s) for verification */
+    ca?: string | Buffer | Array<string | Buffer>;
+    /** Reject unauthorized certs (default: true) */
+    rejectUnauthorized?: boolean;
+    /** Passphrase for encrypted private key */
+    passphrase?: string;
+}
+interface HandlerContext<T = unknown> {
+    messageId: string;
+    method: string;
+    params: T;
+    signal: AbortSignal;
+}
+type CallHandler<TParams = unknown, TResult = unknown> = (context: HandlerContext<TParams>) => TResult | Promise<TResult>;
+type WildcardHandler = (method: string, context: HandlerContext) => unknown | Promise<unknown>;
+interface CallOptions {
+    /** Timeout in milliseconds for this specific call */
+    timeoutMs?: number;
+    /** Abort signal */
+    signal?: AbortSignal;
+    /** Suppress sending a response (server-side, NOREPLY) */
+    noReply?: boolean;
+}
+interface CloseOptions {
+    /** WebSocket close code (default: 1000) */
+    code?: number;
+    /** Close reason string */
+    reason?: string;
+    /** Wait for pending calls to complete before closing */
+    awaitPending?: boolean;
+    /** Force-close without waiting */
+    force?: boolean;
+}
+interface HandshakeInfo {
+    /** Charging station identity (from URL path) */
+    identity: string;
+    /** Remote IP address */
+    remoteAddress: string;
+    /** Request headers */
+    headers: Record<string, string | string[] | undefined>;
+    /** Negotiated subprotocols */
+    protocols: Set<string>;
+    /** Request endpoint URL path */
+    endpoint: string;
+    /** URL query parameters */
+    query: URLSearchParams;
+    /** Original HTTP request */
+    request: IncomingMessage;
+    /** Password from Basic Auth (Profile 1 & 2) */
+    password?: Buffer;
+    /** Client certificate (Profile 3 — mTLS) */
+    clientCertificate?: ReturnType<TLSSocket["getPeerCertificate"]>;
+    /** Active security profile */
+    securityProfile: SecurityProfile;
+}
+type SessionData<T = Record<string, unknown>> = T;
+interface ClientOptions {
+    /** Unique identity for this client (charging station ID) */
+    identity: string;
+    /** WebSocket endpoint URL (ws:// or wss://) */
+    endpoint: string;
+    /** OCPP Security Profile (default: NONE) */
+    securityProfile?: SecurityProfile;
+    /** Password for Basic Auth (Profile 1 & 2) */
+    password?: string | Buffer;
+    /** TLS options (Profile 2 & 3) */
+    tls?: TLSOptions;
+    /** OCPP subprotocols to negotiate */
+    protocols?: string[];
+    /** Additional WebSocket headers */
+    headers?: Record<string, string>;
+    /** Additional query parameters */
+    query?: Record<string, string>;
+    /** Enable automatic reconnection (default: true) */
+    reconnect?: boolean;
+    /** Maximum reconnection attempts (default: Infinity) */
+    maxReconnects?: number;
+    /** Back-off base delay in ms (default: 1000) */
+    backoffMin?: number;
+    /** Back-off max delay in ms (default: 30000) */
+    backoffMax?: number;
+    /** Call timeout in ms (default: 30000) */
+    callTimeoutMs?: number;
+    /** Ping interval in ms (default: 30000, 0 to disable) */
+    pingIntervalMs?: number;
+    /** Defer pings if activity detected (default: false) */
+    deferPingsOnActivity?: boolean;
+    /** Maximum concurrent outbound calls (default: 1) */
+    callConcurrency?: number;
+    /** Enable strict mode validation (default: false) */
+    strictMode?: boolean | string[];
+    /** Custom validators for strict mode */
+    strictModeValidators?: Validator[];
+    /** Max number of bad messages before closing (default: Infinity) */
+    maxBadMessages?: number;
+    /** Include error details in responses (default: false) */
+    respondWithDetailedErrors?: boolean;
+}
+interface ServerOptions {
+    /** OCPP Security Profile (default: NONE) */
+    securityProfile?: SecurityProfile;
+    /** TLS options for HTTPS server (Profile 2 & 3) */
+    tls?: TLSOptions;
+    /** Accepted OCPP subprotocols */
+    protocols?: string[];
+    /** Call timeout in ms — inherited by server clients (default: 30000) */
+    callTimeoutMs?: number;
+    /** Ping interval in ms — inherited by server clients (default: 30000) */
+    pingIntervalMs?: number;
+    /** Defer pings if activity detected — inherited (default: false) */
+    deferPingsOnActivity?: boolean;
+    /** Max concurrent outbound calls — inherited (default: 1) */
+    callConcurrency?: number;
+    /** Enable strict mode — inherited (default: false) */
+    strictMode?: boolean | string[];
+    /** Custom validators — inherited */
+    strictModeValidators?: Validator[];
+    /** Max bad messages — inherited (default: Infinity) */
+    maxBadMessages?: number;
+    /** Include error details in responses — inherited (default: false) */
+    respondWithDetailedErrors?: boolean;
+}
+interface ListenOptions {
+    /** Existing HTTP/HTTPS server to attach to */
+    server?: node_http.Server | node_https.Server;
+    /** Hostname to bind to */
+    host?: string;
+    /** Signal to abort the listen */
+    signal?: AbortSignal;
+}
+interface AuthAccept<TSession = Record<string, unknown>> {
+    /** Subprotocol to use for this client */
+    protocol?: string;
+    /** Session data attached to the client */
+    session?: TSession;
+}
+type AuthCallback<TSession = Record<string, unknown>> = (accept: (options?: AuthAccept<TSession>) => void, reject: (code?: number, message?: string) => void, handshake: HandshakeInfo, signal: AbortSignal) => void | Promise<void>;
+interface ClientEvents {
+    open: [{
+        response: IncomingMessage;
+    }];
+    close: [{
+        code: number;
+        reason: string;
+    }];
+    error: [Error];
+    connecting: [{
+        url: string;
+    }];
+    reconnect: [{
+        attempt: number;
+        delay: number;
+    }];
+    message: [OCPPMessage];
+    call: [OCPPCall];
+    callResult: [OCPPCallResult];
+    callError: [OCPPCallError];
+    badMessage: [{
+        message: string;
+        error: Error;
+    }];
+    ping: [];
+    pong: [];
+    strictValidationFailure: [{
+        message: unknown;
+        error: Error;
+    }];
+}
+interface ServerEvents<TSession = Record<string, unknown>> {
+    client: [ServerClientInstance<TSession>];
+    error: [Error];
+    upgradeError: [{
+        error: Error;
+        socket: Duplex;
+    }];
+}
+type ServerClientInstance<TSession = Record<string, unknown>> = {
+    readonly identity: string;
+    readonly protocol: string | undefined;
+    readonly session: TSession;
+    readonly handshake: HandshakeInfo;
+    readonly state: ConnectionState;
+    close(options?: CloseOptions): Promise<{
+        code: number;
+        reason: string;
+    }>;
+    handle<TParams, TResult>(method: string, handler: CallHandler<TParams, TResult>): void;
+    handle(handler: WildcardHandler): void;
+    call<TResult>(method: string, params?: unknown, options?: CallOptions): Promise<TResult>;
+    removeHandler(method?: string): void;
+    removeAllHandlers(): void;
+    reconfigure(options: Partial<ClientOptions>): void;
+    on<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): void;
+    once<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): void;
+    off<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): void;
+};
+interface EventAdapterInterface {
+    publish(channel: string, data: unknown): Promise<void>;
+    subscribe(channel: string, handler: (data: unknown) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    disconnect(): Promise<void>;
+}
+declare const NOREPLY: unique symbol;
+
+export { type AuthCallback as A, type ClientOptions as C, type EventAdapterInterface as E, type HandshakeInfo as H, type ListenOptions as L, MessageType as M, NOREPLY as N, type OCPPCall as O, SecurityProfile as S, type TLSOptions as T, Validator as V, type WildcardHandler as W, ConnectionState as a, type CloseOptions as b, type CallHandler as c, type CallOptions as d, type ServerOptions as e, type AuthAccept as f, type ClientEvents as g, type HandlerContext as h, type OCPPCallError as i, type OCPPCallResult as j, type OCPPMessage as k, type OCPPProtocol as l, type ServerEvents as m, type SessionData as n, createValidator as o };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "ocpp-ws-io",
+  "version": "1.0.0-alpha",
+  "description": "Type-safe OCPP WebSocket RPC client & server with pub/sub, session management, and clustering support",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rohittiwari-dev/ocpp-ws-io"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./adapters/redis": {
+      "types": "./dist/adapters/redis.d.ts",
+      "import": "./dist/adapters/redis.mjs",
+      "require": "./dist/adapters/redis.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "ocpp",
+    "websocket",
+    "rpc",
+    "ocpp1.6",
+    "ocpp2.0.1",
+    "ocpp2.1",
+    "ev-charging",
+    "iot",
+    "pubsub",
+    "clustering",
+    "type-safe"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.4",
+    "@types/ws": "^8.5.13",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  }
+}

package/src/adapters/adapter.ts

@@ -0,0 +1,40 @@
+import type { EventAdapterInterface } from "../types.js";
+
+/**
+ * In-memory event adapter for single-process use.
+ * Events are dispatched synchronously within the same process.
+ */
+export class InMemoryAdapter implements EventAdapterInterface {
+  private _channels = new Map<string, Set<(data: unknown) => void>>();
+
+  async publish(channel: string, data: unknown): Promise<void> {
+    const handlers = this._channels.get(channel);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch {
+          // Swallow handler errors
+        }
+      }
+    }
+  }
+
+  async subscribe(
+    channel: string,
+    handler: (data: unknown) => void,
+  ): Promise<void> {
+    if (!this._channels.has(channel)) {
+      this._channels.set(channel, new Set());
+    }
+    this._channels.get(channel)!.add(handler);
+  }
+
+  async unsubscribe(channel: string): Promise<void> {
+    this._channels.delete(channel);
+  }
+
+  async disconnect(): Promise<void> {
+    this._channels.clear();
+  }
+}