ocpp-ws-io 2.1.6 → 2.1.8

package/dist/index.js

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AdaptiveLimiter: () => AdaptiveLimiter,
+  ClusterDriver: () => ClusterDriver,
   ConnectionState: () => ConnectionState,
   InMemoryAdapter: () => InMemoryAdapter,
   LRUMap: () => LRUMap,
@@ -61,6 +63,7 @@ __export(src_exports, {
   WebsocketUpgradeError: () => WebsocketUpgradeError,
   combineAuth: () => combineAuth,
   createLoggingMiddleware: () => createLoggingMiddleware,
+  createPlugin: () => createPlugin,
   createRPCError: () => createRPCError,
   createRouter: () => createRouter,
   createValidator: () => createValidator,
@@ -130,6 +133,145 @@ function defineAdapter(adapter) {
   return adapter;
 }
 
+// src/adapters/redis/cluster-driver.ts
+var ClusterDriver = class {
+  _cluster;
+  _subscriber;
+  _handlers = /* @__PURE__ */ new Map();
+  constructor(_options) {
+    try {
+      const { createRequire } = require("module");
+      const dynamicRequire = createRequire(__filename);
+      const Redis = dynamicRequire("ioredis");
+      const redisOpts = _options.redisOptions ?? {};
+      if (_options.natMap) {
+        redisOpts.natMap = _options.natMap;
+      }
+      this._cluster = new Redis.Cluster(
+        _options.nodes.map((n) => ({ host: n.host, port: n.port })),
+        { redisOptions: redisOpts }
+      );
+      this._subscriber = new Redis.Cluster(
+        _options.nodes.map((n) => ({ host: n.host, port: n.port })),
+        { redisOptions: redisOpts }
+      );
+      this._subscriber.on("message", (channel, message) => {
+        const handler = this._handlers.get(channel);
+        if (handler) handler(message);
+      });
+    } catch {
+      throw new Error(
+        "ClusterDriver requires 'ioredis' as a peer dependency. Install it with: npm i ioredis"
+      );
+    }
+  }
+  async publish(channel, message) {
+    await this._cluster.publish(channel, message);
+  }
+  async subscribe(channel, handler) {
+    this._handlers.set(channel, handler);
+    await this._subscriber.subscribe(channel);
+  }
+  async unsubscribe(channel) {
+    await this._subscriber.unsubscribe(channel);
+    this._handlers.delete(channel);
+  }
+  async set(key, value, ttlSeconds) {
+    if (ttlSeconds) {
+      await this._cluster.set(key, value, "EX", ttlSeconds);
+    } else {
+      await this._cluster.set(key, value);
+    }
+  }
+  async get(key) {
+    return await this._cluster.get(key) || null;
+  }
+  async mget(keys) {
+    if (keys.length === 0) return [];
+    try {
+      return await this._cluster.mget(...keys);
+    } catch {
+      return await Promise.all(keys.map((k) => this.get(k)));
+    }
+  }
+  async del(key) {
+    await this._cluster.del(key);
+  }
+  async xadd(stream, args, maxLen) {
+    const flatArgs = [];
+    if (maxLen) {
+      flatArgs.push("MAXLEN", "~", maxLen.toString());
+    }
+    flatArgs.push("*");
+    for (const [k, v] of Object.entries(args)) {
+      flatArgs.push(k, v);
+    }
+    return await this._cluster.xadd(stream, ...flatArgs);
+  }
+  async xaddBatch(messages, maxLen) {
+    if (messages.length === 0) return;
+    const pipeline = this._cluster.pipeline();
+    for (const msg of messages) {
+      const flatArgs = [];
+      if (maxLen) {
+        flatArgs.push("MAXLEN", "~", maxLen.toString());
+      }
+      flatArgs.push("*");
+      for (const [k, v] of Object.entries(msg.args)) {
+        flatArgs.push(k, v);
+      }
+      pipeline.xadd(msg.stream, ...flatArgs);
+    }
+    await pipeline.exec();
+  }
+  async xread(streams, count, block) {
+    const args = [];
+    if (count) args.push("COUNT", count);
+    if (typeof block === "number") args.push("BLOCK", block);
+    args.push("STREAMS");
+    for (const s of streams) args.push(s.key);
+    for (const s of streams) args.push(s.id);
+    const result = await this._cluster.xread(...args);
+    if (!result) return null;
+    return result.map(([stream, messages]) => ({
+      stream,
+      messages: messages.map(([id, fields]) => {
+        const data = {};
+        for (let i = 0; i < fields.length; i += 2) {
+          data[fields[i]] = fields[i + 1];
+        }
+        return { id, data };
+      })
+    }));
+  }
+  async xlen(stream) {
+    return await this._cluster.xlen(stream);
+  }
+  async disconnect() {
+    this._handlers.clear();
+    await Promise.allSettled([this._cluster.quit(), this._subscriber.quit()]);
+  }
+  async setPresenceBatch(entries) {
+    if (entries.length === 0) return;
+    const pipeline = this._cluster.pipeline();
+    for (const { key, value, ttlSeconds } of entries) {
+      pipeline.set(key, value, "EX", ttlSeconds);
+    }
+    await pipeline.exec();
+  }
+  async expire(key, ttlSeconds) {
+    await this._cluster.expire(key, ttlSeconds);
+  }
+  onError(handler) {
+    this._cluster.on("error", handler);
+    return () => this._cluster.removeListener("error", handler);
+  }
+  onReconnect(handler) {
+    this._cluster.on("reconnecting", handler);
+    return () => this._cluster.removeListener("reconnecting", handler);
+  }
+};
+
 // src/adapters/redis/helpers.ts
 var IoRedisDriver = class {
   constructor(pub, sub, blocking) {
@@ -393,6 +535,9 @@ var RedisAdapter = class {
   _unsubReconnect;
   // Stored presence entries for rehydration on reconnect
   _presenceCache = /* @__PURE__ */ new Map();
+  // Connection pool
+  _driverPool;
+  _nextPoolIndex;
   constructor(options) {
     this._prefix = options.prefix ?? "ocpp-ws-io:";
     this._streamMaxLen = options.streamMaxLen ?? 1e3;
@@ -403,6 +548,14 @@ var RedisAdapter = class {
       options.subClient,
       options.blockingClient
     );
+    const poolSize = options.poolSize ?? 1;
+    this._driverPool = [this._driver];
+    this._nextPoolIndex = 0;
+    if (poolSize > 1 && options.driverFactory) {
+      for (let i = 1; i < poolSize; i++) {
+        this._driverPool.push(options.driverFactory());
+      }
+    }
     if (this._driver.onError) {
       this._unsubError = this._driver.onError((err) => {
         console.error("[RedisAdapter] Redis error:", err.message);
@@ -415,6 +568,13 @@ var RedisAdapter = class {
       });
     }
   }
+  /** Get the next driver from the pool (round-robin) */
+  _getPoolDriver() {
+    if (this._driverPool.length === 1) return this._driver;
+    const driver = this._driverPool[this._nextPoolIndex];
+    this._nextPoolIndex = (this._nextPoolIndex + 1) % this._driverPool.length;
+    return driver;
+  }
   async publish(channel, data) {
     const prefixedChannel = this._prefix + channel;
     const payload = data;
@@ -425,11 +585,12 @@ var RedisAdapter = class {
     }
     const message = JSON.stringify(data);
     if (channel.startsWith("ocpp:node:")) {
-      await this._driver.xadd(prefixedChannel, { message }, this._streamMaxLen);
-      await this._driver.expire(prefixedChannel, this._streamTtlSeconds).catch(() => {
+      const poolDriver = this._getPoolDriver();
+      await poolDriver.xadd(prefixedChannel, { message }, this._streamMaxLen);
+      await poolDriver.expire(prefixedChannel, this._streamTtlSeconds).catch(() => {
       });
     } else {
-      await this._driver.publish(prefixedChannel, message);
+      await this._getPoolDriver().publish(prefixedChannel, message);
     }
   }
   async publishBatch(messages) {
@@ -446,13 +607,15 @@ var RedisAdapter = class {
     }
     const promises = [];
     if (streamMessages.length > 0) {
-      promises.push(this._driver.xaddBatch(streamMessages, this._streamMaxLen));
+      promises.push(
+        this._getPoolDriver().xaddBatch(streamMessages, this._streamMaxLen)
+      );
     }
     if (broadcastMessages.length > 0) {
       promises.push(
         Promise.all(
           broadcastMessages.map(
-            (bm) => this._driver.publish(bm.channel, bm.message)
+            (bm) => this._getPoolDriver().publish(bm.channel, bm.message)
           )
         ).then(() => {
         })
@@ -497,7 +660,7 @@ var RedisAdapter = class {
     this._sequenceCounters.clear();
     if (this._unsubError) this._unsubError();
     if (this._unsubReconnect) this._unsubReconnect();
-    await this._driver.disconnect();
+    await Promise.allSettled(this._driverPool.map((d) => d.disconnect()));
   }
   _handleMessage(channel, message) {
     const handlers = this._handlers.get(channel);
@@ -526,7 +689,7 @@ var RedisAdapter = class {
   async _pollLoop() {
     while (!this._closed) {
       if (this._streams.size === 0) {
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        await new Promise((resolve2) => setTimeout(resolve2, 1e3));
         continue;
       }
       const streamsArg = Array.from(this._streams).map((key) => ({
@@ -548,7 +711,7 @@ var RedisAdapter = class {
           }
         }
       } catch (_err) {
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        await new Promise((resolve2) => setTimeout(resolve2, 1e3));
       }
     }
     this._polling = false;
@@ -627,8 +790,84 @@ var RedisAdapter = class {
   }
 };
 
-// src/client.ts
+// src/adaptive-limiter.ts
 var import_node_events = require("events");
+var import_node_os = require("os");
+var AdaptiveLimiter = class extends import_node_events.EventEmitter {
+  _cpuThreshold;
+  _memThreshold;
+  _cooldownMs;
+  _sampleInterval;
+  _timer = null;
+  _lastOverloadTime = 0;
+  _multiplier = 1;
+  _prevCpuUsage = null;
+  _prevTimestamp = 0;
+  constructor(options = {}) {
+    super();
+    this._cpuThreshold = options.cpuThresholdPercent ?? 70;
+    this._memThreshold = options.memThresholdPercent ?? 85;
+    this._cooldownMs = options.cooldownMs ?? 1e4;
+    this._sampleInterval = options.sampleIntervalMs ?? 2e3;
+  }
+  /** Current rate multiplier: 1.0 = normal, 0.25 = heavily throttled */
+  get multiplier() {
+    return this._multiplier;
+  }
+  /** Start periodic sampling */
+  start() {
+    if (this._timer) return;
+    this._prevCpuUsage = process.cpuUsage();
+    this._prevTimestamp = Date.now();
+    this._timer = setInterval(() => this._sample(), this._sampleInterval);
+    if (this._timer.unref) this._timer.unref();
+  }
+  /** Stop sampling and reset multiplier */
+  stop() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    this._multiplier = 1;
+  }
+  _sample() {
+    const now = Date.now();
+    const cpuUsage = process.cpuUsage(this._prevCpuUsage ?? void 0);
+    const elapsedMs = now - this._prevTimestamp;
+    const cpuPercent = (cpuUsage.user + cpuUsage.system) / 1e3 / elapsedMs / (0, import_node_os.cpus)().length * 100;
+    this._prevCpuUsage = process.cpuUsage();
+    this._prevTimestamp = now;
+    const total = (0, import_node_os.totalmem)();
+    const free = (0, import_node_os.freemem)();
+    const memPercent = (total - free) / total * 100;
+    const cpuOverload = cpuPercent > this._cpuThreshold;
+    const memOverload = memPercent > this._memThreshold;
+    const prevMultiplier = this._multiplier;
+    if (cpuOverload || memOverload) {
+      this._lastOverloadTime = now;
+      this._multiplier = Math.max(0.25, this._multiplier * 0.5);
+    } else if (now - this._lastOverloadTime > this._cooldownMs) {
+      this._multiplier = Math.min(1, this._multiplier + 0.1);
+    }
+    if (this._multiplier !== prevMultiplier) {
+      this.emit("adapted", {
+        multiplier: this._multiplier,
+        cpuPercent: Math.round(cpuPercent * 100) / 100,
+        memPercent: Math.round(memPercent * 100) / 100
+      });
+    }
+  }
+  // Typed event emitter overrides
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, data) {
+    return super.emit(event, data);
+  }
+};
+
+// src/client.ts
+var import_node_events2 = require("events");
 var import_cuid2 = require("@paralleldrive/cuid2");
 var import_ws = __toESM(require("ws"));
 
@@ -766,6 +1005,9 @@ var RPCFrameworkError = class extends RPCGenericError {
 function defineMiddleware(mw) {
   return mw;
 }
+function createPlugin(plugin) {
+  return plugin;
+}
 function defineRpcMiddleware(mw) {
   return mw;
 }
@@ -1090,10 +1332,10 @@ var Queue = class {
     this._drain();
   }
   push(fn) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this._queue.push({
         fn,
-        resolve,
+        resolve: resolve2,
         reject
       });
       this._drain();
@@ -37193,7 +37435,7 @@ ${body}`
 
 // src/client.ts
 var { CONNECTING, OPEN, CLOSING, CLOSED } = ConnectionState;
-var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
+var OCPPClient = class _OCPPClient extends import_node_events2.EventEmitter {
   // Static connection states
   static CONNECTING = CONNECTING;
   static OPEN = OPEN;
@@ -37352,7 +37594,7 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
     return this._connectInternal();
   }
   async _connectInternal() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const endpoint = this._buildEndpoint();
       const wsOptions = this._buildWsOptions();
       this._logger?.debug?.("Connecting", { url: endpoint });
@@ -37385,7 +37627,7 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
           response
         };
         this.emit("open", result);
-        resolve(result);
+        resolve2(result);
       };
       const onError = (err) => {
         cleanup();
@@ -37449,16 +37691,16 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
     this._stopPing();
     if (!force && awaitPending) {
       const pendingPromises = Array.from(this._pendingCalls.values()).map(
-        (p) => new Promise((resolve) => {
+        (p) => new Promise((resolve2) => {
           const origResolve = p.resolve;
           const origReject = p.reject;
           p.resolve = (v) => {
             origResolve(v);
-            resolve();
+            resolve2();
           };
           p.reject = (r) => {
             origReject(r);
-            resolve();
+            resolve2();
           };
         })
       );
@@ -37466,13 +37708,13 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
         await Promise.allSettled(pendingPromises);
       }
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       if (!this._ws || this._ws.readyState === import_ws.default.CLOSED) {
         this._state = CLOSED;
         this._cleanup();
         const result = { code, reason };
         this.emit("close", result);
-        resolve(result);
+        resolve2(result);
         return;
       }
       const onClose = (closeCode, closeReason) => {
@@ -37481,7 +37723,7 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
         this._cleanup();
         const result = { code: closeCode, reason: closeReason.toString() };
         this.emit("close", result);
-        resolve(result);
+        resolve2(result);
       };
       this._ws.on("close", onClose);
       if (force) {
@@ -37556,7 +37798,7 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
     }
     if (this._state !== OPEN) {
       if (this._options.offlineQueue && (this._state === CLOSED || this._state === CONNECTING)) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const maxSize = this._options.offlineQueueMaxSize ?? 100;
           if (this._offlineQueue.length >= maxSize) {
             this._offlineQueue.shift();
@@ -37568,7 +37810,7 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
               }
             );
           }
-          this._offlineQueue.push({ method, params, options, resolve, reject });
+          this._offlineQueue.push({ method, params, options, resolve: resolve2, reject });
           this._logger?.debug?.("Call queued offline", {
             method,
             queueSize: this._offlineQueue.length
@@ -37627,7 +37869,7 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
         ctxvals.params
       ];
       const messageStr = JSON.stringify(message);
-      callResult = await new Promise((resolve, reject) => {
+      callResult = await new Promise((resolve2, reject) => {
         const timeoutHandle = setTimeout(() => {
           this._pendingCalls.delete(msgId);
           reject(
@@ -37645,7 +37887,7 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
           options.signal.addEventListener("abort", abortHandler);
         }
         this._pendingCalls.set(msgId, {
-          resolve,
+          resolve: resolve2,
           reject,
           timeoutHandle,
           abortHandler: options.signal ? () => options.signal?.removeEventListener("abort", abortHandler) : void 0,
@@ -37725,11 +37967,15 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
     });
   }
   // ─── Internal: Message handling ──────────────────────────────
-  _onMessage(rawData) {
+  _onMessage(rawData, preParsed) {
     this._recordActivity();
     let message;
     try {
-      message = JSON.parse(rawData);
+      if (preParsed !== void 0) {
+        message = preParsed;
+      } else {
+        message = JSON.parse(rawData);
+      }
       if (!Array.isArray(message)) throw new Error("Message is not an array");
     } catch (err) {
       this._onBadMessage(
@@ -37739,6 +37985,36 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
       return;
     }
     const messageType = message[0];
+    const messageId = message[1];
+    if (typeof messageId !== "string") {
+      this._onBadMessage(
+        typeof rawData === "string" ? rawData : rawData.toString(),
+        new RPCMessageTypeNotSupportedError(
+          `Invalid MessageId type: ${typeof messageId} (expected string)`
+        )
+      );
+      return;
+    }
+    if (messageType === MessageType.CALL && message.length < 4 || messageType === MessageType.CALLRESULT && message.length < 3 || messageType === MessageType.CALLERROR && message.length < 5) {
+      this._onBadMessage(
+        JSON.stringify(message),
+        new RPCMessageTypeNotSupportedError(
+          `Missing payload elements for message type ${messageType}`
+        )
+      );
+      return;
+    }
+    const payloadIndex = messageType === MessageType.CALLERROR ? 4 : messageType === MessageType.CALL ? 3 : 2;
+    const payload = message[payloadIndex];
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+      this._onBadMessage(
+        JSON.stringify(message),
+        new RPCMessageTypeNotSupportedError(
+          `Payload must be a JSON object, got ${payload === null ? "null" : Array.isArray(payload) ? "array" : typeof payload}`
+        )
+      );
+      return;
+    }
     switch (messageType) {
       case MessageType.CALL:
         this._handleIncomingCall(message);
@@ -38218,6 +38494,23 @@ var OCPPClient = class _OCPPClient extends import_node_events.EventEmitter {
         if (tls.passphrase) opts.passphrase = tls.passphrase;
       }
     }
+    const compression = this._options.compression;
+    if (compression) {
+      opts.perMessageDeflate = compression === true ? {
+        zlibDeflateOptions: { level: 6, memLevel: 8 },
+        zlibInflateOptions: {},
+        clientNoContextTakeover: true,
+        serverNoContextTakeover: true
+      } : {
+        zlibDeflateOptions: {
+          level: compression.level ?? 6,
+          memLevel: compression.memLevel ?? 8
+        },
+        zlibInflateOptions: {},
+        clientNoContextTakeover: compression.clientNoContextTakeover ?? true,
+        serverNoContextTakeover: compression.serverNoContextTakeover ?? true
+      };
+    }
     return opts;
   }
   // ─── Internal: Cleanup ───────────────────────────────────────
@@ -38283,7 +38576,7 @@ var LRUMap = class extends Map {
 };
 
 // src/router.ts
-var import_node_events2 = require("events");
+var import_node_events3 = require("events");
 async function executeMiddlewareChain(middlewares, ctx) {
   let index = -1;
   const dispatch = async (i, payload) => {
@@ -38307,7 +38600,7 @@ async function executeMiddlewareChain(middlewares, ctx) {
   };
   await dispatch(0);
 }
-var OCPPRouter = class extends import_node_events2.EventEmitter {
+var OCPPRouter = class extends import_node_events3.EventEmitter {
   /** Raw registered patterns (strings and/or RegExp) for reference. */
   patterns;
   /** Connection middlewares attached to this router. */
@@ -38403,7 +38696,7 @@ function createRouter(...patterns) {
 }
 
 // src/server.ts
-var import_node_events3 = require("events");
+var import_node_events4 = require("events");
 var import_node_http2 = require("http");
 var import_node_https = require("https");
 var import_cuid22 = require("@paralleldrive/cuid2");
@@ -38633,6 +38926,8 @@ var OCPPServerClient = class extends OCPPClient {
     super(options);
     this._serverSession = context.session;
     this._serverHandshake = context.handshake;
+    this._adaptiveMultiplier = context.adaptiveMultiplier ?? null;
+    this._workerPool = context.workerPool ?? null;
     this._state = ConnectionState.OPEN;
     this._identity = this._options.identity;
     this._ws = context.ws;
@@ -38642,6 +38937,8 @@ var OCPPServerClient = class extends OCPPClient {
   }
   // ─── Rate Limiting State ──────────────────────────────────────────
   _rateLimits = {};
+  _adaptiveMultiplier = null;
+  _workerPool = null;
   _checkRateLimit(method) {
     const limits = this._options.rateLimit;
     if (!limits) return true;
@@ -38653,7 +38950,8 @@ var OCPPServerClient = class extends OCPPClient {
         this._rateLimits[key] = bucket;
       } else {
         const timePassed = now - bucket.lastRefill;
-        const refillRate = limit / windowMs;
+        const adaptiveScale = this._adaptiveMultiplier?.() ?? 1;
+        const refillRate = limit / windowMs * adaptiveScale;
         const tokensToAdd = timePassed * refillRate;
         if (tokensToAdd > 0) {
           bucket.tokens = Math.min(limit, bucket.tokens + tokensToAdd);
@@ -38698,6 +38996,19 @@ var OCPPServerClient = class extends OCPPClient {
           this._handleRateLimitExceeded(pData || data.toString());
           return;
         }
+        if (pData !== void 0) {
+          this._onMessage(data, pData);
+          return;
+        }
+      }
+      if (this._workerPool) {
+        const raw = typeof data === "string" ? data : data;
+        this._workerPool.parse(raw).then((result) => {
+          this._onMessage(data, result.message);
+        }).catch(() => {
+          this._onMessage(data);
+        });
+        return;
       }
       this._onMessage(data);
     });
@@ -38708,7 +39019,18 @@ var OCPPServerClient = class extends OCPPClient {
         this._onClose(code, reason)
       )
     );
-    ws.on("error", (err) => this.emit("error", err));
+    ws.on("error", (err) => {
+      if (this.listenerCount("error") > 0) {
+        this.emit("error", err);
+      } else {
+        this._logger?.debug?.(
+          "WebSocket error (unhandled by client listener)",
+          {
+            error: err.message
+          }
+        );
+      }
+    });
     ws.on("ping", () => {
       this._recordActivity();
       this.emit("ping");
@@ -38787,8 +39109,110 @@ var OCPPServerClient = class extends OCPPClient {
   }
 };
 
+// src/worker-pool.ts
+var import_node_os2 = require("os");
+var import_node_path = require("path");
+var import_node_worker_threads = require("worker_threads");
+var WorkerPool = class {
+  _workers = [];
+  _nextWorker = 0;
+  _taskId = 0;
+  _pending = /* @__PURE__ */ new Map();
+  _maxQueueSize;
+  _terminated = false;
+  constructor(options = {}) {
+    const poolSize = options.poolSize ?? Math.max(2, (0, import_node_os2.cpus)().length - 2);
+    this._maxQueueSize = options.maxQueueSize ?? 1e4;
+    const workerPath = (0, import_node_path.resolve)(__dirname, "parse-worker.js");
+    for (let i = 0; i < poolSize; i++) {
+      const worker = new import_node_worker_threads.Worker(workerPath);
+      worker.on(
+        "message",
+        (response) => {
+          const task = this._pending.get(response.id);
+          if (!task) return;
+          this._pending.delete(response.id);
+          if (response.error) {
+            task.reject(new Error(response.error));
+          } else {
+            task.resolve({
+              message: response.message,
+              validationError: response.validationError
+            });
+          }
+        }
+      );
+      worker.on("error", (err) => {
+        console.error(`[WorkerPool] Worker ${i} error:`, err.message);
+      });
+      this._workers.push(worker);
+    }
+  }
+  /** Number of worker threads in the pool */
+  get size() {
+    return this._workers.length;
+  }
+  /** Number of pending (unresolved) parse tasks */
+  get pendingTasks() {
+    return this._pending.size;
+  }
+  /**
+   * Send raw data to a worker for JSON parsing + optional validation.
+   * Uses round-robin worker selection.
+   */
+  parse(data, schemaInfo) {
+    if (this._terminated) {
+      return Promise.reject(new Error("WorkerPool has been shut down"));
+    }
+    if (this._pending.size >= this._maxQueueSize) {
+      return Promise.reject(
+        new Error(
+          `WorkerPool queue full (${this._maxQueueSize} pending tasks)`
+        )
+      );
+    }
+    return new Promise((resolve2, reject) => {
+      const id = this._taskId++;
+      this._pending.set(id, {
+        resolve: resolve2,
+        reject
+      });
+      const worker = this._workers[this._nextWorker % this._workers.length];
+      this._nextWorker = (this._nextWorker + 1) % this._workers.length;
+      worker.postMessage({ id, buffer: data, schemaInfo });
+    });
+  }
+  /** Gracefully terminate all workers */
+  async shutdown() {
+    if (this._terminated) return;
+    this._terminated = true;
+    for (const [id, task] of this._pending) {
+      task.reject(new Error("WorkerPool shutting down"));
+      this._pending.delete(id);
+    }
+    const terminatePromises = this._workers.map(async (worker) => {
+      try {
+        await Promise.race([
+          worker.terminate(),
+          new Promise((resolve2) => setTimeout(resolve2, 5e3))
+        ]);
+      } catch {
+      }
+    });
+    await Promise.allSettled(terminatePromises);
+    this._workers = [];
+  }
+};
+function createWorkerPool(options = {}) {
+  try {
+    return new WorkerPool(options);
+  } catch {
+    return null;
+  }
+}
+
 // src/server.ts
-var OCPPServer = class extends import_node_events3.EventEmitter {
+var OCPPServer = class extends import_node_events4.EventEmitter {
   _options;
   /** Radix trie for O(k) route matching (string patterns). */
   _trie = new RadixTrie();
@@ -38807,6 +39231,9 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
   _globalCORS;
   // Connection-level rate limiting (per-IP token bucket)
   _connectionBuckets = /* @__PURE__ */ new Map();
+  _adaptiveLimiter = null;
+  _plugins = [];
+  _workerPool = null;
   // Robustness & Clustering
   _nodeId = (0, import_cuid22.createId)();
   _sessions;
@@ -38816,9 +39243,9 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
     super();
     this.setMaxListeners(0);
     if (options.strictMode) {
-      if (!options.strictModeValidators && !options.protocols?.length) {
+      if (!options.protocols?.length) {
         throw new Error(
-          "strictMode requires either strictModeValidators or protocols to be specified"
+          "strictMode requires protocols to be specified (e.g. protocols: ['ocpp1.6'])"
         );
       }
     }
@@ -38839,7 +39266,8 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
     this._sessions = new LRUMap(maxSessions);
     this._wss = new import_ws2.WebSocketServer({
       noServer: true,
-      maxPayload: this._options.maxPayloadBytes ?? 65536
+      maxPayload: this._options.maxPayloadBytes ?? 65536,
+      perMessageDeflate: this._buildCompressionConfig()
     });
     this._gcInterval = setInterval(() => {
       const now = Date.now();
@@ -38852,6 +39280,32 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
     this._logger = initLogger(this._options.logging, {
       component: "OCPPServer"
     });
+    const rl = this._options.rateLimit;
+    if (rl?.adaptive) {
+      this._adaptiveLimiter = new AdaptiveLimiter({
+        cpuThresholdPercent: rl.cpuThresholdPercent,
+        memThresholdPercent: rl.memThresholdPercent,
+        cooldownMs: rl.cooldownMs
+      });
+      this._adaptiveLimiter.on(
+        "adapted",
+        (event) => {
+          this._logger?.info?.("Adaptive rate limit adjusted", event);
+          this.emit("rateLimit:adapted", event);
+        }
+      );
+      this._adaptiveLimiter.start();
+    }
+    const wt = this._options.workerThreads;
+    if (wt) {
+      const poolOpts = typeof wt === "object" ? wt : {};
+      this._workerPool = createWorkerPool(poolOpts);
+      if (this._workerPool) {
+        this._logger?.info?.("Worker thread pool initialized", {
+          poolSize: this._workerPool.size
+        });
+      }
+    }
   }
   // ─── Getters ─────────────────────────────────────────────────
   get log() {
@@ -38974,8 +39428,44 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
     return this;
   }
   /**
-   * Registers a new middleware chain, acting as a wildcard/catch-all router if no patterns are added.
-   * `server.use(middleware).route("/api").on("client", ...)`
+   * Registers one or more plugins for server lifecycle hooks.
+   * Plugins are called in registration order for all lifecycle events.
+   *
+   * @example Single plugin
+   * ```ts
+   * server.plugin(metricsPlugin);
+   * ```
+   *
+   * @example Multiple plugins
+   * ```ts
+   * server.plugin(metricsPlugin, loggingPlugin, otelPlugin);
+   * ```
+   */
+  plugin(...plugins) {
+    for (const plugin of plugins) {
+      this._plugins.push(plugin);
+      this._logger?.info?.("Plugin registered", { name: plugin.name });
+      if (plugin.onInit) {
+        const result = plugin.onInit(this);
+        if (result instanceof Promise) {
+          result.catch((err) => {
+            this._logger?.error?.("Plugin onInit error", {
+              name: plugin.name,
+              error: err.message
+            });
+          });
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Registers middleware chain(s) as a wildcard/catch-all router.
+   *
+   * @example
+   * ```ts
+   * server.use(myMiddleware).route("/api").on("client", ...);
+   * ```
    */
   use(...middlewares) {
     const router = new OCPPRouter();
@@ -39131,7 +39621,7 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
       );
     }
     if (!options?.server) {
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         httpServer.on("error", reject);
         httpServer.listen(port, host, () => {
           httpServer.removeListener("error", reject);
@@ -39140,7 +39630,7 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
             port: typeof addr === "object" ? addr?.port : port,
             host: host ?? "0.0.0.0"
           });
-          resolve();
+          resolve2();
         });
       });
     }
@@ -39449,13 +39939,13 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
             selectedProtocol = handshake.protocols.values().next().value ?? void 0;
           } else {
             acceptOptions = await new Promise(
-              (resolve, reject) => {
+              (resolve2, reject) => {
                 let settled = false;
                 const accept = (opts) => {
                   if (settled) return;
                   settled = true;
                   if (opts?.protocol) selectedProtocol = opts.protocol;
-                  resolve(opts);
+                  resolve2(opts);
                 };
                 const rejectAuth = (code = 401, message = "Unauthorized") => {
                   if (!settled) {
@@ -39587,7 +40077,9 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
         ws,
         handshake,
         session: finalSession,
-        protocol: selectedProtocol
+        protocol: selectedProtocol,
+        adaptiveMultiplier: this._adaptiveLimiter ? () => this._adaptiveLimiter.multiplier : void 0,
+        workerPool: this._workerPool ?? void 0
       });
       this._updateSessionActivity(identity, client.session);
       const existingClient = this._clientsByIdentity.get(identity);
@@ -39619,21 +40111,52 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
         remoteAddress: req.socket.remoteAddress,
         protocol: selectedProtocol
       });
-      client.on("close", () => {
-        this._clients.delete(client);
-        if (this._clientsByIdentity.get(identity) === client) {
-          this._clientsByIdentity.delete(identity);
+      client.on(
+        "close",
+        ({ code, reason }) => {
+          this._clients.delete(client);
+          if (this._clientsByIdentity.get(identity) === client) {
+            this._clientsByIdentity.delete(identity);
+          }
+          if (this?._adapter?.removePresence) {
+            this._adapter.removePresence(identity).catch((err) => {
+              this._logger?.error?.("Error removing presence", {
+                identity,
+                error: err
+              });
+            });
+          }
+          for (const plugin of this._plugins) {
+            try {
+              plugin.onDisconnect?.(client, code, reason);
+            } catch (err) {
+              this._logger?.error?.("Plugin onDisconnect error", {
+                name: plugin.name,
+                error: err.message
+              });
+            }
+          }
+          this._logger?.info?.("Client disconnected", { identity });
         }
-        if (this?._adapter?.removePresence) {
-          this._adapter.removePresence(identity).catch((err) => {
-            this._logger?.error?.("Error removing presence", {
-              identity,
-              error: err
+      );
+      for (const plugin of this._plugins) {
+        try {
+          const result = plugin.onConnection?.(client);
+          if (result instanceof Promise) {
+            result.catch((err) => {
+              this._logger?.error?.("Plugin onConnection error", {
+                name: plugin.name,
+                error: err.message
+              });
             });
+          }
+        } catch (err) {
+          this._logger?.error?.("Plugin onConnection error", {
+            name: plugin.name,
+            error: err.message
           });
         }
-        this._logger?.info?.("Client disconnected", { identity });
-      });
+      }
       this.emit("client", client);
       for (const router of matchedRouters) {
         router.emit("client", client);
@@ -39668,13 +40191,13 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
             identity: client.identity,
             bufferedAmount: ws.bufferedAmount
           });
-          await new Promise((resolve) => {
+          await new Promise((resolve2) => {
             let elapsed = 0;
             const check = setInterval(() => {
               elapsed += 50;
               if (!ws || ws.bufferedAmount === 0 || elapsed >= drainTimeout) {
                 clearInterval(check);
-                resolve();
+                resolve2();
               }
             }, 50);
           });
@@ -39696,12 +40219,28 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
       this._wss = new import_ws2.WebSocketServer({ noServer: true });
     }
     const serverClosePromises = Array.from(this._httpServers).map(
-      (server) => new Promise((resolve) => {
-        server.close(() => resolve());
+      (server) => new Promise((resolve2) => {
+        server.close(() => resolve2());
       })
     );
     await Promise.allSettled(serverClosePromises);
     this._httpServers.clear();
+    if (this._adaptiveLimiter) {
+      this._adaptiveLimiter.stop();
+    }
+    for (const plugin of this._plugins) {
+      try {
+        const result = plugin.onClose?.();
+        if (result instanceof Promise) {
+          await result;
+        }
+      } catch (err) {
+        this._logger?.error?.("Plugin onClose error", {
+          name: plugin.name,
+          error: err.message
+        });
+      }
+    }
     if (this._adapter) {
       await this._adapter.disconnect();
     }
@@ -39763,6 +40302,55 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
       return void 0;
     }
   }
+  // ─── Batch Calls ──────────────────────────────────────────────
+  /**
+   * Pipeline multiple calls to a single client into a concurrent batch.
+   * Useful for reconnection warm-up (e.g. GetConfiguration, ChangeAvailability, etc.)
+   * where sequential calls would add unnecessary round-trip latency.
+   *
+   * @param identity The client identity to send calls to
+   * @param calls Array of { method, params, options? } to execute concurrently
+   * @returns Array of results in the same order as the calls array.
+   *          Each element is the call result, or `undefined` if that individual call failed.
+   *
+   * @example
+   * ```ts
+   * const results = await server.sendBatch('CP-101', [
+   *   { method: 'GetConfiguration', params: { key: ['MeterInterval'] } },
+   *   { method: 'ChangeAvailability', params: { type: 'Operative' } },
+   *   { method: 'TriggerMessage', params: { requestedMessage: 'StatusNotification' } },
+   * ]);
+   * ```
+   */
+  async sendBatch(identity, calls) {
+    if (calls.length === 0) return [];
+    const client = this._clientsByIdentity.get(identity);
+    if (!client) {
+      this._logger?.warn?.("sendBatch: client not found locally", { identity });
+      return calls.map(() => void 0);
+    }
+    const originalConcurrency = client.options.callConcurrency ?? 1;
+    if (calls.length > originalConcurrency) {
+      client.reconfigure({ callConcurrency: calls.length });
+    }
+    try {
+      const results = await Promise.allSettled(
+        calls.map((c) => client.call(c.method, c.params, c.options ?? {}))
+      );
+      return results.map((r) => {
+        if (r.status === "fulfilled") return r.value;
+        this._logger?.warn?.("sendBatch: individual call failed", {
+          identity,
+          error: r.reason?.message
+        });
+        return void 0;
+      });
+    } finally {
+      if (calls.length > originalConcurrency) {
+        client.reconfigure({ callConcurrency: originalConcurrency });
+      }
+    }
+  }
   // ─── Pub/Sub Adapter ─────────────────────────────────────────
   async setAdapter(adapter) {
     this._adapter = adapter;
@@ -39904,9 +40492,35 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
     }
     await Promise.all(localPromises);
   }
+  // ─── Internal: Compression Config ───────────────────────────────
+  _buildCompressionConfig() {
+    const compression = this._options.compression;
+    if (!compression) return false;
+    if (compression === true) {
+      return {
+        threshold: 1024,
+        zlibDeflateOptions: { level: 6, memLevel: 8 },
+        zlibInflateOptions: {},
+        serverNoContextTakeover: true,
+        clientNoContextTakeover: true
+      };
+    }
+    return {
+      threshold: compression.threshold ?? 1024,
+      zlibDeflateOptions: {
+        level: compression.level ?? 6,
+        memLevel: compression.memLevel ?? 8
+      },
+      zlibInflateOptions: {},
+      serverNoContextTakeover: compression.serverNoContextTakeover ?? true,
+      clientNoContextTakeover: compression.clientNoContextTakeover ?? true
+    };
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AdaptiveLimiter,
+  ClusterDriver,
   ConnectionState,
   InMemoryAdapter,
   LRUMap,
@@ -39938,6 +40552,7 @@ var OCPPServer = class extends import_node_events3.EventEmitter {
   WebsocketUpgradeError,
   combineAuth,
   createLoggingMiddleware,
+  createPlugin,
   createRPCError,
   createRouter,
   createValidator,