ocpp-ws-io 2.1.3

package/dist/browser.mjs

@@ -0,0 +1,1284 @@
+// src/helpers/index.ts
+function defineMiddleware(mw) {
+  return mw;
+}
+function defineRpcMiddleware(mw) {
+  return mw;
+}
+function defineAuth(cb) {
+  return cb;
+}
+function combineAuth(...cbs) {
+  return async (ctx) => {
+    let accepted = false;
+    let rejected = false;
+    const trackedAccept = (opts) => {
+      accepted = true;
+      ctx.accept(opts);
+    };
+    const trackedReject = (code, message) => {
+      rejected = true;
+      return ctx.reject(code, message);
+    };
+    const trackedCtx = {
+      ...ctx,
+      accept: trackedAccept,
+      reject: trackedReject
+    };
+    try {
+      for (const cb of cbs) {
+        if (ctx.signal.aborted || accepted || rejected) break;
+        const p = cb(trackedCtx);
+        if (p instanceof Promise) {
+          await p;
+        }
+        if (accepted || rejected) break;
+      }
+      if (!accepted && !rejected) {
+        trackedReject(
+          401,
+          "Unauthorized (All composeAuth handlers passed without accepting)"
+        );
+      }
+    } catch (_err) {
+      if (!rejected) {
+        trackedReject(
+          500,
+          "Internal Server Error during auth compose execution"
+        );
+      }
+    }
+  };
+}
+function createLoggingMiddleware(logger, identity, config = {}) {
+  const options = typeof config === "object" ? config : {};
+  const { exchangeLog = false, prettify = false } = options;
+  return async (ctx, next) => {
+    const start = Date.now();
+    const method = ctx.method;
+    const level = exchangeLog ? "info" : "debug";
+    switch (ctx.type) {
+      case "incoming_call":
+        if (exchangeLog && prettify) {
+          logger[level]?.(`\u26A1 ${identity}  \u2190  ${method}  [IN]`, {
+            messageId: ctx.messageId,
+            method: ctx.method,
+            protocol: ctx.protocol,
+            payload: ctx.params,
+            direction: "IN"
+          });
+        } else {
+          logger[level]?.(`CALL \u2190`, {
+            messageId: ctx.messageId,
+            method: ctx.method,
+            protocol: ctx.protocol,
+            payload: ctx.params,
+            direction: "IN"
+          });
+        }
+        break;
+      case "outgoing_call":
+        if (exchangeLog && prettify) {
+          logger[level]?.(`\u26A1 ${identity}  \u2192  ${method}  [OUT]`, {
+            method: ctx.method,
+            params: ctx.params,
+            direction: "OUT"
+          });
+        } else {
+          logger[level]?.(`CALL \u2192`, {
+            method: ctx.method,
+            params: ctx.params,
+            direction: "OUT"
+          });
+        }
+        break;
+    }
+    try {
+      const result = await next();
+      const durationMs = Date.now() - start;
+      switch (ctx.type) {
+        case "incoming_call":
+          if (result !== void 0 && result !== null) {
+            if (exchangeLog && prettify) {
+              logger[level]?.(`\u2705 ${identity}  \u2192  ${method}  [RES]`, {
+                messageId: ctx.messageId,
+                method: ctx.method,
+                durationMs,
+                params: result,
+                direction: "OUT"
+              });
+            } else {
+              logger[level]?.(`CALLRESULT \u2192`, {
+                messageId: ctx.messageId,
+                method: ctx.method,
+                durationMs,
+                params: result,
+                direction: "OUT"
+              });
+            }
+          }
+          break;
+        case "outgoing_call":
+          if (exchangeLog && prettify) {
+            logger[level]?.(`\u2705 ${identity}  \u2190  ${method}  [RES]`, {
+              messageId: ctx.messageId,
+              method: ctx.method,
+              durationMs,
+              payload: result,
+              direction: "IN"
+            });
+          } else {
+            logger[level]?.(`CALLRESULT \u2190`, {
+              messageId: ctx.messageId,
+              method: ctx.method,
+              durationMs,
+              payload: result,
+              direction: "IN"
+            });
+          }
+          break;
+      }
+      return result;
+    } catch (err) {
+      const msg = err.message;
+      const durationMs = Date.now() - start;
+      if (ctx.type === "incoming_call") {
+        if (exchangeLog && prettify) {
+          logger.error?.(`\u{1F6A8} ${identity}  \u2192  ${method}  [ERR]`, {
+            messageId: ctx.messageId,
+            method: ctx.method,
+            durationMs,
+            error: msg,
+            direction: "OUT"
+          });
+        } else {
+          logger.error?.(`CALLERROR \u2192`, {
+            messageId: ctx.messageId,
+            method: ctx.method,
+            durationMs,
+            error: msg,
+            direction: "OUT"
+          });
+        }
+      } else if (ctx.type === "outgoing_call") {
+        if (exchangeLog && prettify) {
+          logger.warn?.(`\u{1F6A8} ${identity}  \u2190  ${method}  [ERR]`, {
+            messageId: ctx.messageId,
+            method: ctx.method,
+            durationMs,
+            error: msg,
+            direction: "IN"
+          });
+        } else {
+          logger.warn?.(`CALLERROR \u2190`, {
+            messageId: ctx.messageId,
+            method: ctx.method,
+            durationMs,
+            error: msg,
+            direction: "IN"
+          });
+        }
+      }
+      throw err;
+    }
+  };
+}
+
+// src/middleware.ts
+var MiddlewareStack = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _stack = [];
+  /**
+   * Add a middleware function to the stack.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  use(middleware) {
+    this._stack.push(middleware);
+  }
+  /**
+   * Execute the middleware stack composed with a runner function.
+   *
+   * @param context The context object to pass through middleware
+   * @param runner The final function to execute (the "core" logic)
+   */
+  async execute(context, runner) {
+    let index = -1;
+    const dispatch = async (i) => {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      const fn = this._stack[i];
+      if (i === this._stack.length) {
+        return runner(context);
+      }
+      if (!fn) {
+        return void 0;
+      }
+      return fn(context, () => dispatch(i + 1));
+    };
+    return dispatch(0);
+  }
+};
+
+// src/init-logger.ts
+import {
+  consoleTransport,
+  createLogger,
+  prettyTransport
+} from "voltlog-io";
+function hasDisplayCustomization(config) {
+  return config.showMetadata === false || config.showSourceMeta === false || config.prettifySource === true || config.prettifyMetadata === true;
+}
+function buildDisplayMiddleware(config) {
+  const showMeta = config.showMetadata ?? true;
+  const showSource = config.showSourceMeta ?? true;
+  const prettySrc = config.prettifySource ?? false;
+  const prettyMeta = config.prettifyMetadata ?? false;
+  const DIM = "\x1B[2;37m";
+  const RESET = "\x1B[0m";
+  const CYAN = "\x1B[36m";
+  return (entry, next) => {
+    if (!showSource) {
+      entry.context = void 0;
+    } else if (prettySrc && entry.context) {
+      const parts = [];
+      if (entry.context.component) parts.push(String(entry.context.component));
+      if (entry.context.identity) parts.push(String(entry.context.identity));
+      if (parts.length > 0) {
+        entry.message = `${DIM}[${parts.join("/")}]${RESET} ${entry.message}`;
+        entry.context = void 0;
+      }
+    }
+    const meta = entry.meta;
+    if (!showMeta) {
+      entry.meta = {};
+    } else if (prettyMeta && meta && Object.keys(meta).length > 0) {
+      const pairs = Object.entries(meta).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => {
+        let valStr = typeof v === "object" ? JSON.stringify(v) : String(v);
+        if (typeof v === "string") {
+          valStr = `${DIM}${valStr}${RESET}`;
+        } else {
+          valStr = `${DIM}${valStr}${RESET}`;
+        }
+        return `${CYAN}${k}${RESET}=${valStr}`;
+      }).join(" ");
+      if (pairs) {
+        entry.message = `${entry.message}  ${pairs}`;
+      }
+      entry.meta = {};
+    }
+    next(entry);
+  };
+}
+function initLogger(config, defaultContext) {
+  if (config === false) return null;
+  if (config?.enabled === false) return null;
+  if (config?.logger) {
+    if (defaultContext && config.logger.child) {
+      return config.logger.child(defaultContext);
+    }
+    return config.logger;
+  }
+  const level = config?.level ?? "INFO";
+  const usePrettify = config?.prettify ?? false;
+  const transports = usePrettify ? [prettyTransport({ level })] : [consoleTransport({ level })];
+  if (config?.handler) {
+    const customTransport = config.handler;
+    transports.push({
+      name: "customHandler",
+      write: (entry) => customTransport(entry)
+    });
+  }
+  const middleware = [];
+  if (config && hasDisplayCustomization(config)) {
+    middleware.push(buildDisplayMiddleware(config));
+  }
+  const logger = createLogger({
+    level,
+    transports,
+    middleware: middleware.length > 0 ? middleware : void 0
+  });
+  if (defaultContext && Object.keys(defaultContext).length > 0) {
+    return logger.child(defaultContext);
+  }
+  return logger;
+}
+
+// src/browser/emitter.ts
+var EventEmitter = class {
+  _listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    const arr = this._listeners.get(event);
+    if (arr) {
+      arr.push(listener);
+    } else {
+      this._listeners.set(event, [listener]);
+    }
+    return this;
+  }
+  once(event, listener) {
+    const wrapper = (...args) => {
+      this.off(event, wrapper);
+      listener(...args);
+    };
+    wrapper.__wrapped = listener;
+    return this.on(event, wrapper);
+  }
+  off(event, listener) {
+    const arr = this._listeners.get(event);
+    if (!arr) return this;
+    const idx = arr.findIndex(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (fn) => fn === listener || fn.__wrapped === listener
+    );
+    if (idx !== -1) arr.splice(idx, 1);
+    if (arr.length === 0) this._listeners.delete(event);
+    return this;
+  }
+  emit(event, ...args) {
+    const arr = this._listeners.get(event);
+    if (!arr || arr.length === 0) return false;
+    for (const fn of [...arr]) {
+      fn(...args);
+    }
+    return true;
+  }
+  addListener(event, listener) {
+    return this.on(event, listener);
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this._listeners.delete(event);
+    } else {
+      this._listeners.clear();
+    }
+    return this;
+  }
+  listenerCount(event) {
+    return this._listeners.get(event)?.length ?? 0;
+  }
+};
+
+// src/browser/errors.ts
+var TimeoutError = class extends Error {
+  constructor(message = "Operation timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var RPCGenericError = class extends Error {
+  rpcErrorCode = "GenericError";
+  rpcErrorMessage = "";
+  details;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "RPCGenericError";
+    this.details = details;
+  }
+};
+var RPCNotImplementedError = class extends RPCGenericError {
+  rpcErrorCode = "NotImplemented";
+  rpcErrorMessage = "Requested method is not known";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCNotImplementedError";
+  }
+};
+var RPCNotSupportedError = class extends RPCGenericError {
+  rpcErrorCode = "NotSupported";
+  rpcErrorMessage = "Requested method is recognised but not supported";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCNotSupportedError";
+  }
+};
+var RPCInternalError = class extends RPCGenericError {
+  rpcErrorCode = "InternalError";
+  rpcErrorMessage = "An internal error occurred and the receiver was not able to process the requested action successfully";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCInternalError";
+  }
+};
+var RPCProtocolError = class extends RPCGenericError {
+  rpcErrorCode = "ProtocolError";
+  rpcErrorMessage = "Payload for action is incomplete";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCProtocolError";
+  }
+};
+var RPCSecurityError = class extends RPCGenericError {
+  rpcErrorCode = "SecurityError";
+  rpcErrorMessage = "During the processing of action a security issue occurred preventing receiver from completing the action successfully";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCSecurityError";
+  }
+};
+var RPCFormationViolationError = class extends RPCGenericError {
+  rpcErrorCode = "FormationViolation";
+  rpcErrorMessage = "Payload for action is syntactically incorrect or not conform the PDU structure for action";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCFormationViolationError";
+  }
+};
+var RPCFormatViolationError = class extends RPCGenericError {
+  rpcErrorCode = "FormatViolation";
+  rpcErrorMessage = "Payload is syntactically correct but at least one field contains an invalid value";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCFormatViolationError";
+  }
+};
+var RPCPropertyConstraintViolationError = class extends RPCGenericError {
+  rpcErrorCode = "PropertyConstraintViolation";
+  rpcErrorMessage = "Payload is syntactically correct but at least one of the fields violates data type constraints";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCPropertyConstraintViolationError";
+  }
+};
+var RPCOccurrenceConstraintViolationError = class extends RPCGenericError {
+  rpcErrorCode = "OccurrenceConstraintViolation";
+  rpcErrorMessage = "Payload for action is syntactically correct but at least one of the fields violates occurrence constraints";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCOccurrenceConstraintViolationError";
+  }
+};
+var RPCTypeConstraintViolationError = class extends RPCGenericError {
+  rpcErrorCode = "TypeConstraintViolation";
+  rpcErrorMessage = "Payload for action is syntactically correct but at least one of the fields violates type constraints";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCTypeConstraintViolationError";
+  }
+};
+var RPCMessageTypeNotSupportedError = class extends RPCGenericError {
+  rpcErrorCode = "MessageTypeNotSupported";
+  rpcErrorMessage = "A message with a Message Type Number received that is not supported by this implementation";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCMessageTypeNotSupportedError";
+  }
+};
+var RPCFrameworkError = class extends RPCGenericError {
+  rpcErrorCode = "RpcFrameworkError";
+  rpcErrorMessage = "Content of the call is not a valid RPC request";
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "RPCFrameworkError";
+  }
+};
+
+// src/browser/queue.ts
+var Queue = class {
+  _concurrency;
+  _running = 0;
+  _queue = [];
+  constructor(concurrency = 1) {
+    this._concurrency = Math.max(1, concurrency);
+  }
+  get concurrency() {
+    return this._concurrency;
+  }
+  get pending() {
+    return this._queue.length;
+  }
+  get running() {
+    return this._running;
+  }
+  get size() {
+    return this._running + this._queue.length;
+  }
+  setConcurrency(concurrency) {
+    this._concurrency = Math.max(1, concurrency);
+    this._drain();
+  }
+  push(fn) {
+    return new Promise((resolve, reject) => {
+      this._queue.push({
+        fn,
+        resolve,
+        reject
+      });
+      this._drain();
+    });
+  }
+  _drain() {
+    while (this._running < this._concurrency && this._queue.length > 0) {
+      const item = this._queue.shift();
+      this._running++;
+      item?.fn().then(item.resolve).catch(item.reject).finally(() => {
+        this._running--;
+        this._drain();
+      });
+    }
+  }
+};
+
+// src/types.ts
+var ConnectionState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+var MessageType = {
+  CALL: 2,
+  CALLRESULT: 3,
+  CALLERROR: 4
+};
+var NOREPLY = /* @__PURE__ */ Symbol("NOREPLY");
+
+// src/util.ts
+var NOOP_LOGGER = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  child: () => NOOP_LOGGER
+};
+
+// src/browser/util.ts
+var RPC_ERROR_REGISTRY = /* @__PURE__ */ new Map([
+  ["GenericError", RPCGenericError],
+  ["RpcFrameworkError", RPCFrameworkError],
+  ["MessageTypeNotSupported", RPCMessageTypeNotSupportedError],
+  ["NotImplemented", RPCNotImplementedError],
+  ["NotSupported", RPCNotSupportedError],
+  ["InternalError", RPCInternalError],
+  ["ProtocolError", RPCProtocolError],
+  ["SecurityError", RPCSecurityError],
+  ["FormatViolation", RPCFormatViolationError],
+  ["FormationViolation", RPCFormationViolationError],
+  ["PropertyConstraintViolation", RPCPropertyConstraintViolationError],
+  [
+    "OccurrenceConstraintViolation",
+    RPCOccurrenceConstraintViolationError
+  ],
+  ["TypeConstraintViolation", RPCTypeConstraintViolationError]
+]);
+function createRPCError(code, message, details = {}) {
+  const Ctor = RPC_ERROR_REGISTRY.get(code) ?? RPCGenericError;
+  return new Ctor(message, details);
+}
+var ERROR_PROPERTIES = [
+  "name",
+  "message",
+  "stack",
+  "code",
+  "rpcErrorCode",
+  "rpcErrorMessage",
+  "details"
+];
+function getErrorPlainObject(err) {
+  const result = {};
+  for (const prop of ERROR_PROPERTIES) {
+    const value = err[prop];
+    if (value !== void 0) {
+      if (typeof value === "function" || typeof value === "symbol") continue;
+      if (typeof value === "object" && value !== null) {
+        try {
+          JSON.stringify(value);
+          result[prop] = value;
+        } catch {
+        }
+      } else {
+        result[prop] = value;
+      }
+    }
+  }
+  if (!result.name) result.name = err.name;
+  if (!result.message) result.message = err.message;
+  return result;
+}
+
+// src/browser/client.ts
+var { CONNECTING, OPEN, CLOSING, CLOSED } = ConnectionState;
+var BrowserOCPPClient = class _BrowserOCPPClient extends EventEmitter {
+  // Static connection states
+  static CONNECTING = CONNECTING;
+  static OPEN = OPEN;
+  static CLOSING = CLOSING;
+  static CLOSED = CLOSED;
+  _options;
+  _state = CLOSED;
+  _ws = null;
+  _protocol;
+  _identity;
+  _handlers = /* @__PURE__ */ new Map();
+  _wildcardHandler = null;
+  _pendingCalls = /* @__PURE__ */ new Map();
+  _pendingResponses = /* @__PURE__ */ new Set();
+  _callQueue;
+  _closePromise = null;
+  _reconnectAttempt = 0;
+  _reconnectTimer = null;
+  _badMessageCount = 0;
+  _outboundBuffer = [];
+  _logger;
+  _middleware;
+  constructor(options) {
+    super();
+    if (!options.identity) {
+      throw new Error("identity is required");
+    }
+    this._identity = options.identity;
+    this._options = {
+      reconnect: true,
+      maxReconnects: Infinity,
+      backoffMin: 1e3,
+      backoffMax: 3e4,
+      callTimeoutMs: 3e4,
+      callConcurrency: 1,
+      maxBadMessages: Infinity,
+      respondWithDetailedErrors: false,
+      ...options
+    };
+    this._callQueue = new Queue(this._options.callConcurrency);
+    this._middleware = new MiddlewareStack();
+    const loggerInstance = initLogger(this._options.logging, {
+      component: "BrowserOCPPClient",
+      identity: this._identity
+    });
+    this._logger = loggerInstance || NOOP_LOGGER;
+  }
+  // ─── Getters ─────────────────────────────────────────────────
+  get log() {
+    return this._logger;
+  }
+  get identity() {
+    return this._identity;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  get state() {
+    return this._state;
+  }
+  // ─── Connect ─────────────────────────────────────────────────
+  async connect() {
+    if (this._state !== CLOSED) {
+      throw new Error(`Cannot connect: client is in state ${this._state}`);
+    }
+    this._state = CONNECTING;
+    this._reconnectAttempt = 0;
+    return this._connectInternal();
+  }
+  async _connectInternal() {
+    return new Promise((resolve, reject) => {
+      const endpoint = this._buildEndpoint();
+      this._logger.debug?.("Connecting", { url: endpoint });
+      this.emit("connecting", { url: endpoint });
+      let ws;
+      try {
+        ws = this._options.protocols?.length ? new WebSocket(endpoint, this._options.protocols) : new WebSocket(endpoint);
+      } catch (err) {
+        this._state = CLOSED;
+        reject(err);
+        return;
+      }
+      this._ws = ws;
+      const onOpen = (event) => {
+        cleanup();
+        this._state = OPEN;
+        this._protocol = ws.protocol || void 0;
+        this._badMessageCount = 0;
+        if (ws.protocol && this._reconnectAttempt === 0) {
+          this._options.protocols = [ws.protocol];
+        }
+        this._attachWebsocket(ws);
+        if (this._outboundBuffer.length > 0) {
+          const buffer = this._outboundBuffer;
+          this._outboundBuffer = [];
+          for (const msg of buffer) this._ws?.send(msg);
+        }
+        this._logger.info?.("Connected", {
+          protocol: ws.protocol || void 0
+        });
+        this.emit("open", event);
+        resolve();
+      };
+      const onError = (event) => {
+        cleanup();
+        this._state = CLOSED;
+        this._logger.error?.("Connection error");
+        this.emit("error", event);
+        reject(event);
+      };
+      const onClose = () => {
+        cleanup();
+        if (this._state === CONNECTING) {
+          this._state = CLOSED;
+          reject(new Error("WebSocket closed during connection"));
+        }
+      };
+      const cleanup = () => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        ws.removeEventListener("close", onClose);
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+      ws.addEventListener("close", onClose);
+    });
+  }
+  // ─── Close ───────────────────────────────────────────────────
+  async close(options = {}) {
+    const {
+      code = 1e3,
+      reason = "",
+      awaitPending = true,
+      force = false
+    } = options;
+    if (this._closePromise) return this._closePromise;
+    if (this._state === CLOSED) {
+      return { code: 1e3, reason: "" };
+    }
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    this._closePromise = this._closeInternal(code, reason, awaitPending, force);
+    return this._closePromise;
+  }
+  async _closeInternal(code, reason, awaitPending, force) {
+    this._state = CLOSING;
+    if (!force && awaitPending) {
+      const pendingPromises = Array.from(this._pendingCalls.values()).map(
+        (p) => new Promise((resolve) => {
+          const origResolve = p.resolve;
+          const origReject = p.reject;
+          p.resolve = (v) => {
+            origResolve(v);
+            resolve();
+          };
+          p.reject = (r) => {
+            origReject(r);
+            resolve();
+          };
+        })
+      );
+      if (pendingPromises.length > 0) {
+        await Promise.allSettled(pendingPromises);
+      }
+    }
+    return new Promise((resolve) => {
+      if (!this._ws || this._ws.readyState === WebSocket.CLOSED) {
+        this._state = CLOSED;
+        this._cleanup();
+        const result = { code, reason };
+        this.emit("close", result);
+        resolve(result);
+        return;
+      }
+      const onClose = (event) => {
+        this._ws?.removeEventListener("close", onClose);
+        this._state = CLOSED;
+        this._cleanup();
+        const result = { code: event.code, reason: event.reason };
+        this.emit("close", result);
+        resolve(result);
+      };
+      this._ws.addEventListener("close", onClose);
+      if (force) {
+        this._ws.close();
+      } else {
+        const validCode = code >= 1e3 && code <= 4999 && ![1004, 1005, 1006].includes(code);
+        this._ws.close(validCode ? code : 1e3, reason);
+      }
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handle(...args) {
+    if (args.length === 1 && typeof args[0] === "function") {
+      this._wildcardHandler = args[0];
+    } else if (args.length === 2 && typeof args[0] === "string" && typeof args[1] === "function") {
+      this._handlers.set(args[0], args[1]);
+    } else if (args.length === 3 && typeof args[0] === "string" && typeof args[1] === "string" && typeof args[2] === "function") {
+      this._handlers.set(`${args[0]}:${args[1]}`, args[2]);
+    } else {
+      throw new Error(
+        "Invalid arguments: provide (version, method, handler), (method, handler), or (wildcardHandler)"
+      );
+    }
+  }
+  removeHandler(versionOrMethod, method) {
+    if (versionOrMethod && method) {
+      this._handlers.delete(`${versionOrMethod}:${method}`);
+    } else if (versionOrMethod) {
+      this._handlers.delete(versionOrMethod);
+    } else {
+      this._wildcardHandler = null;
+    }
+  }
+  removeAllHandlers() {
+    this._handlers.clear();
+    this._wildcardHandler = null;
+  }
+  // ─── Middleware ──────────────────────────────────────────────
+  /**
+   * Register a middleware function to intercept calls and results.
+   * Middleware executes in the order registered.
+   */
+  use(middleware) {
+    this._middleware.use(middleware);
+  }
+  async call(...args) {
+    let method;
+    let params;
+    let options;
+    if (args.length >= 3 && typeof args[0] === "string" && typeof args[1] === "string") {
+      method = args[1];
+      params = args[2] ?? {};
+      options = args[3] ?? {};
+    } else {
+      method = args[0];
+      params = args[1] ?? {};
+      options = args[2] ?? {};
+    }
+    if (this._state !== OPEN) {
+      throw new Error(`Cannot call: client is in state ${this._state}`);
+    }
+    return this._callQueue.push(() => this._sendCall(method, params, options));
+  }
+  async _sendCall(method, params, options) {
+    const msgId = this._generateMessageId();
+    const timeoutMs = options.timeoutMs ?? this._options.callTimeoutMs;
+    const ctx = {
+      type: "outgoing_call",
+      messageId: msgId,
+      method,
+      params,
+      options
+    };
+    let callResult;
+    await this._middleware.execute(ctx, async (c) => {
+      const ctxvals = c;
+      const message = [
+        MessageType.CALL,
+        msgId,
+        ctxvals.method,
+        ctxvals.params
+      ];
+      const messageStr = JSON.stringify(message);
+      callResult = await new Promise((resolve, reject) => {
+        const timeoutHandle = setTimeout(() => {
+          this._pendingCalls.delete(msgId);
+          this._logger.warn?.("Call timed out", {
+            messageId: msgId,
+            method: ctxvals.method,
+            timeoutMs
+          });
+          reject(
+            new TimeoutError(
+              `Call to "${ctxvals.method}" timed out after ${timeoutMs}ms`
+            )
+          );
+        }, timeoutMs);
+        const pending = {
+          resolve,
+          reject,
+          timeoutHandle,
+          method: ctxvals.method,
+          sentAt: Date.now()
+        };
+        if (options.signal) {
+          if (options.signal.aborted) {
+            clearTimeout(timeoutHandle);
+            reject(options.signal.reason ?? new Error("Aborted"));
+            return;
+          }
+          const abortHandler = () => {
+            clearTimeout(timeoutHandle);
+            this._pendingCalls.delete(msgId);
+            reject(options.signal?.reason ?? new Error("Aborted"));
+          };
+          options.signal.addEventListener("abort", abortHandler, {
+            once: true
+          });
+          pending.abortHandler = abortHandler;
+        }
+        this._pendingCalls.set(msgId, pending);
+        this._ws?.send(messageStr);
+        this.emit("message", message);
+        this.emit("call", message);
+      });
+    });
+    return callResult;
+  }
+  /**
+   * Send a raw string message over the WebSocket (use with caution).
+   * Messages sent while CONNECTING are buffered and flushed on open.
+   */
+  sendRaw(message) {
+    if (this._state === OPEN && this._ws) {
+      this._ws.send(message);
+    } else if (this._state === CONNECTING) {
+      this._outboundBuffer.push(message);
+    } else {
+      throw new Error("Cannot send: client is not connected");
+    }
+  }
+  // ─── Reconfigure ─────────────────────────────────────────────
+  reconfigure(options) {
+    Object.assign(this._options, options);
+    if (options.callConcurrency !== void 0) {
+      this._callQueue.setConcurrency(options.callConcurrency);
+    }
+  }
+  // ─── Internal: WebSocket attachment ──────────────────────────
+  _attachWebsocket(ws) {
+    ws.addEventListener(
+      "message",
+      (event) => this._onMessage(event.data)
+    );
+    ws.addEventListener(
+      "close",
+      (event) => this._onClose(event.code, event.reason)
+    );
+    ws.addEventListener("error", (event) => this.emit("error", event));
+  }
+  // ─── Internal: Message handling ──────────────────────────────
+  _onMessage(data) {
+    const raw = typeof data === "string" ? data : String(data);
+    let message;
+    try {
+      message = JSON.parse(raw);
+      if (!Array.isArray(message)) throw new Error("Message is not an array");
+    } catch (err) {
+      this._onBadMessage(raw, err);
+      return;
+    }
+    const messageType = message[0];
+    switch (messageType) {
+      case MessageType.CALL:
+        this._handleIncomingCall(message);
+        break;
+      case MessageType.CALLRESULT:
+        this._handleCallResult(message);
+        break;
+      case MessageType.CALLERROR:
+        this._handleCallError(message);
+        break;
+      default:
+        this._onBadMessage(
+          JSON.stringify(message),
+          new RPCMessageTypeNotSupportedError(
+            `Unknown message type: ${messageType}`
+          )
+        );
+    }
+  }
+  async _handleIncomingCall(message) {
+    const [, msgId, method, params] = message;
+    const ctx = {
+      type: "incoming_call",
+      messageId: msgId,
+      method,
+      params,
+      protocol: this._protocol
+    };
+    await this._middleware.execute(ctx, async (c) => {
+      const ctxvals = c;
+      const modifiedMessage = [
+        MessageType.CALL,
+        ctxvals.messageId,
+        ctxvals.method,
+        ctxvals.params
+      ];
+      this.emit("call", modifiedMessage);
+      if (this._state !== OPEN) {
+        return;
+      }
+      try {
+        if (this._pendingResponses.has(ctxvals.messageId)) {
+          throw createRPCError(
+            "RpcFrameworkError",
+            `Already processing call with ID: ${ctxvals.messageId}`
+          );
+        }
+        const specificHandler = (this._protocol ? this._handlers.get(`${this._protocol}:${ctxvals.method}`) : void 0) ?? this._handlers.get(ctxvals.method);
+        if (!specificHandler && !this._wildcardHandler) {
+          throw createRPCError(
+            "NotImplemented",
+            `No handler for method: ${ctxvals.method}`
+          );
+        }
+        this._pendingResponses.add(ctxvals.messageId);
+        const ac = new AbortController();
+        const context = {
+          messageId: ctxvals.messageId,
+          method: ctxvals.method,
+          protocol: this._protocol,
+          params: ctxvals.params,
+          signal: ac.signal
+        };
+        let result;
+        if (specificHandler) {
+          result = await specificHandler(context);
+        } else if (this._wildcardHandler) {
+          result = await this._wildcardHandler(ctxvals.method, context);
+        }
+        this._pendingResponses.delete(ctxvals.messageId);
+        if (result === NOREPLY) return;
+        const response = [
+          MessageType.CALLRESULT,
+          ctxvals.messageId,
+          result
+        ];
+        this._ws?.send(JSON.stringify(response));
+        this.emit("callResult", response);
+      } catch (err) {
+        this._pendingResponses.delete(ctxvals.messageId);
+        this._logger.error?.("Handler error", {
+          messageId: ctxvals.messageId,
+          method: ctxvals.method,
+          error: err.message
+        });
+        const rpcErr = err instanceof RPCGenericError || err.rpcErrorCode ? err : createRPCError("InternalError", err.message);
+        const details = this._options.respondWithDetailedErrors ? getErrorPlainObject(err) : {};
+        const errorResponse = [
+          MessageType.CALLERROR,
+          ctxvals.messageId,
+          rpcErr.rpcErrorCode,
+          rpcErr.rpcErrorMessage || err.message || "",
+          details
+        ];
+        this._ws?.send(JSON.stringify(errorResponse));
+        this.emit("callError", errorResponse);
+      }
+    });
+  }
+  async _handleCallResult(message) {
+    const [, msgId, result] = message;
+    if (!this._pendingCalls.has(msgId)) {
+      this._logger.warn?.("Received CallResult for unknown messageId", {
+        messageId: msgId
+      });
+      return;
+    }
+    const pending = this._pendingCalls.get(msgId);
+    const ctx = {
+      type: "incoming_result",
+      messageId: msgId,
+      method: pending.method,
+      payload: result
+    };
+    await this._middleware.execute(ctx, async (c) => {
+      const ctxvals = c;
+      const modifiedMessage = [
+        MessageType.CALLRESULT,
+        msgId,
+        ctxvals.payload
+      ];
+      this.emit("callResult", modifiedMessage);
+      clearTimeout(pending.timeoutHandle);
+      this._pendingCalls.delete(msgId);
+      pending.resolve(ctxvals.payload);
+    });
+  }
+  async _handleCallError(message) {
+    const [, msgId, errorCode, errorMessage, errorDetails] = message;
+    if (!this._pendingCalls.has(msgId)) {
+      this._logger.warn?.("Received CallError for unknown messageId", {
+        messageId: msgId
+      });
+      return;
+    }
+    const pending = this._pendingCalls.get(msgId);
+    const error = createRPCError(errorCode, errorMessage, errorDetails);
+    const ctx = {
+      type: "incoming_error",
+      messageId: msgId,
+      method: pending.method,
+      error
+      // Map to types.ts expected `error` shape which takes OCPPCallError specifically here, though we pass it via RPCError
+    };
+    await this._middleware.execute(ctx, async (c) => {
+      const ctxvals = c;
+      const resolvedRpcErr = ctxvals.error;
+      const modifiedMessage = [
+        MessageType.CALLERROR,
+        msgId,
+        resolvedRpcErr.rpcErrorCode,
+        resolvedRpcErr.message,
+        resolvedRpcErr.rpcErrorDetails ?? {}
+      ];
+      this.emit("callError", modifiedMessage);
+      clearTimeout(pending.timeoutHandle);
+      this._pendingCalls.delete(msgId);
+      pending.reject(resolvedRpcErr);
+    });
+  }
+  // ─── Internal: Bad message handling ──────────────────────────
+  _onBadMessage(rawMessage, error) {
+    this._badMessageCount++;
+    this._logger?.warn?.("Bad message", {
+      error: error.message,
+      count: this._badMessageCount
+    });
+    this.emit("badMessage", { message: rawMessage, error });
+    const match = rawMessage.match(/^\s*\[\s*2\s*,\s*"([^"]+)"/);
+    if (match?.[1] && this._ws) {
+      const errorResponse = [
+        MessageType.CALLERROR,
+        match[1],
+        "FormatViolation",
+        error.message || "Invalid message format",
+        {}
+      ];
+      this._ws.send(JSON.stringify(errorResponse));
+      this.emit("callError", errorResponse);
+    }
+    if (this._badMessageCount >= this._options.maxBadMessages) {
+      this.close({ code: 1002, reason: "Too many bad messages" }).catch(
+        () => {
+        }
+      );
+    }
+  }
+  // ─── Internal: Close handling ────────────────────────────────
+  /**
+   * Reject all in-flight calls and clear pending state.
+   */
+  _rejectPendingCalls(reason) {
+    for (const [, pending] of this._pendingCalls) {
+      clearTimeout(pending.timeoutHandle);
+      pending.reject(new Error(reason));
+    }
+    this._pendingCalls.clear();
+    this._pendingResponses.clear();
+  }
+  _onClose(code, reason) {
+    this._rejectPendingCalls(`Connection closed (${code}: ${reason})`);
+    if (this._state !== CLOSING) {
+      this._logger?.info?.("Disconnected", { code, reason });
+      this.emit("disconnect", { code, reason });
+      if (this._options.reconnect && this._reconnectAttempt < this._options.maxReconnects) {
+        this._scheduleReconnect();
+      } else {
+        this._state = CLOSED;
+        this.emit("close", { code, reason });
+      }
+    } else {
+      this._state = CLOSED;
+    }
+  }
+  // ─── Internal: Reconnection ──────────────────────────────────
+  /** Errors that should stop reconnection immediately */
+  static _INTOLERABLE_ERRORS = /* @__PURE__ */ new Set([
+    "Maximum redirects exceeded",
+    "Server sent no subprotocol",
+    "Server sent an invalid subprotocol",
+    "Server sent a subprotocol but none was requested",
+    "Invalid Sec-WebSocket-Accept header"
+  ]);
+  _scheduleReconnect() {
+    this._reconnectAttempt++;
+    this._state = CONNECTING;
+    const base = this._options.backoffMin;
+    const max = this._options.backoffMax;
+    const delayMs = Math.min(
+      max,
+      base * 2 ** (this._reconnectAttempt - 1) * (0.5 + Math.random() * 0.5)
+    );
+    this._logger?.warn?.("Reconnecting", {
+      attempt: this._reconnectAttempt,
+      delayMs: Math.round(delayMs)
+    });
+    this.emit("reconnect", { attempt: this._reconnectAttempt, delay: delayMs });
+    this._reconnectTimer = setTimeout(async () => {
+      this._reconnectTimer = null;
+      try {
+        await this._connectInternal();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "";
+        if (_BrowserOCPPClient._INTOLERABLE_ERRORS.has(msg)) {
+          this._logger?.error?.("Intolerable error \u2014 stopping reconnection", {
+            error: msg
+          });
+          this._state = CLOSED;
+          this.emit("close", { code: 1001, reason: msg });
+          return;
+        }
+        if (this._reconnectAttempt < this._options.maxReconnects && this._options.reconnect) {
+          this._scheduleReconnect();
+        } else {
+          this._state = CLOSED;
+          this.emit("close", {
+            code: 1001,
+            reason: "Max reconnection attempts exhausted"
+          });
+        }
+      }
+    }, delayMs);
+  }
+  // ─── Internal: Endpoint building ─────────────────────────────
+  _buildEndpoint() {
+    let url = this._options.endpoint;
+    if (!url.endsWith("/")) url += "/";
+    url += encodeURIComponent(this._identity);
+    if (this._options.query) {
+      const params = new URLSearchParams(this._options.query);
+      url += (url.includes("?") ? "&" : "?") + params.toString();
+    }
+    return url;
+  }
+  // ─── Internal: Cleanup ───────────────────────────────────────
+  _cleanup() {
+    this._closePromise = null;
+    this._ws = null;
+  }
+  // ─── Internal: ID Generation ─────────────────────────────────
+  _generateMessageId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+};
+export {
+  BrowserOCPPClient,
+  ConnectionState,
+  MessageType,
+  MiddlewareStack,
+  NOREPLY,
+  RPCFormatViolationError,
+  RPCFormationViolationError,
+  RPCFrameworkError,
+  RPCGenericError,
+  RPCInternalError,
+  RPCMessageTypeNotSupportedError,
+  RPCNotImplementedError,
+  RPCNotSupportedError,
+  RPCOccurrenceConstraintViolationError,
+  RPCPropertyConstraintViolationError,
+  RPCProtocolError,
+  RPCSecurityError,
+  RPCTypeConstraintViolationError,
+  TimeoutError,
+  combineAuth,
+  createLoggingMiddleware,
+  createRPCError,
+  defineAuth,
+  defineMiddleware,
+  defineRpcMiddleware,
+  getErrorPlainObject
+};
+//# sourceMappingURL=browser.mjs.map