kirby-ocpp 0.1.0

package/dist/station.js

@@ -0,0 +1,1201 @@
+import EventEmitter from "node:events";
+import { OcppClient } from "./ocpp/client.js";
+import { StationStore } from "./station-store.js";
+import { authorizeLocally, isAcceptedIdTagInfo, normalizeIdTagInfo, serializeIdTagInfo } from "./station/authorization.js";
+import { faultErrorCode, nextConnectorStatus, statusAfterAvailabilityChange, statusAfterFaultClear, statusAfterReservationClear } from "./station/connector-status.js";
+import { ConnectorRegistry } from "./station/connector-registry.js";
+import { ChargingProfileRegistry } from "./station/charging-profile-registry.js";
+import { changeConfiguration, getConfiguration } from "./station/configuration-commands.js";
+import { ConfigurationRegistry } from "./station/configuration-registry.js";
+import { buildMeterValue, isValidSampledDataConfiguration, readConfiguredMeasurands } from "./station/metering.js";
+import { MeterValueScheduler } from "./station/meter-value-scheduler.js";
+import { ReservationScheduler } from "./station/reservation-scheduler.js";
+import { buildPersistedStationState, restorePersistedStationState } from "./station/persistence.js";
+import { readNumber, readObject, readOptionalString, readString } from "./station/payload.js";
+import { applyLocalAuthListUpdate } from "./station/local-auth-list.js";
+import { MaintenanceLifecycle } from "./station/maintenance-lifecycle.js";
+import { describeOcppMessage } from "./station/ocpp-message.js";
+import { StatusNotificationScheduler } from "./station/status-scheduler.js";
+import { canTriggerMessage } from "./station/trigger-message.js";
+import { reserveNowRejection } from "./station/reservation-rules.js";
+import { canRemoteStart, startTransactionRejection, statusAfterStopTransaction } from "./station/transaction-rules.js";
+import { readChargingProfile } from "./station/smart-charging.js";
+import { isTransactionMessage, retryDelay } from "./station/transaction-message-retry.js";
+import { localTransactionId, OfflineTransactionSync, pendingStopPayload } from "./station/offline-transaction-sync.js";
+export class Station extends EventEmitter {
+    config;
+    client;
+    state = {
+        connected: false,
+        booted: false,
+        registrationStatus: "Unknown",
+        connectorStatus: "Available",
+        availability: "Operative",
+        localListVersion: 0,
+        meterWh: 0,
+        connectors: [],
+        diagnosticsStatus: "Idle",
+        firmwareStatus: "Idle"
+    };
+    heartbeatTimer;
+    resetTimer;
+    bootRetryTimer;
+    reconnectTimer;
+    reconnectAttempts = 0;
+    manuallyDisconnected = true;
+    store;
+    configuration;
+    localAuthorizationList = new Map();
+    authorizationCache = new Map();
+    connectors;
+    statusScheduler;
+    meterValueScheduler;
+    reservationScheduler;
+    maintenance;
+    chargingProfiles = new ChargingProfileRegistry();
+    offlineTransactions;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.client = new OcppClient(config.centralSystemUrl, config.chargePointId, {
+            subprotocol: config.webSocketSubprotocol,
+            pingIntervalSeconds: config.webSocketPingIntervalSeconds,
+            tlsRejectUnauthorized: config.tlsRejectUnauthorized,
+            tlsCaFile: config.tlsCaFile,
+            tlsCertFile: config.tlsCertFile,
+            tlsKeyFile: config.tlsKeyFile,
+            tlsServerName: config.tlsServerName
+        });
+        this.configuration = new ConfigurationRegistry(config);
+        this.connectors = new ConnectorRegistry(config.connectorId, config.connectorCount);
+        this.connectors.setOnChange(() => this.refreshConnectorSnapshot());
+        this.configuration.setValue("NumberOfConnectors", String(this.connectors.size));
+        this.statusScheduler = new StatusNotificationScheduler({
+            minimumSeconds: () => this.configuration.integer("MinimumStatusDuration", 0),
+            currentStatus: (connectorId) => this.connectors.find(connectorId)?.status,
+            send: (connectorId, status) => void this.runSafely(() => this.sendStatusNotification(connectorId, status))
+        });
+        this.meterValueScheduler = new MeterValueScheduler({
+            sampleIntervalSeconds: () => this.configuration.integer("MeterValueSampleInterval", 0),
+            clockAlignedIntervalSeconds: () => this.configuration.integer("ClockAlignedDataInterval", 0),
+            isConnected: () => this.state.connected,
+            activeConnectorIds: () => this.connectors.all()
+                .filter((connector) => connector.transactionId && connector.status === "Charging")
+                .map((connector) => connector.id),
+            isPeriodicConnectorActive: (connectorId) => {
+                const connector = this.connectors.find(connectorId);
+                return Boolean(connector?.transactionId && connector.status === "Charging");
+            },
+            sendPeriodic: (connectorId, deltaWh) => this.sendMeterValues(connectorId, "Sample.Periodic", deltaWh, this.configuration.measurands("MeterValuesSampledData")),
+            sendClockAligned: (connectorIds, deltaWh) => this.sendClockAlignedMeterValues(connectorIds, deltaWh),
+            runSafely: (task) => void this.runSafely(task)
+        });
+        this.reservationScheduler = new ReservationScheduler({
+            expiryDate: (connectorId) => this.connectors.find(connectorId)?.reservationExpiryDate,
+            expire: (connectorId) => this.expireReservation(connectorId)
+        });
+        this.maintenance = new MaintenanceLifecycle({
+            run: (task) => void this.runSafely(task),
+            diagnosticsStatus: (status) => this.diagnosticsStatusNotification(status),
+            firmwareStatus: (status) => this.firmwareStatusNotification(status),
+            log: (level, message) => this.log(level, message)
+        });
+        this.offlineTransactions = new OfflineTransactionSync({
+            connectors: this.connectors,
+            chargingProfiles: this.chargingProfiles,
+            send: (action, payload) => this.send(action, payload),
+            readIdTagInfo: (value) => this.readIdTagInfo(value),
+            rememberAuthorization: (idTag, idTagInfo) => this.rememberAuthorization(idTag, idTagInfo),
+            save: () => this.savePersistedState(),
+            log: (level, message) => this.log(level, message),
+            statusNotification: (connectorId, status) => this.statusNotification(connectorId, status)
+        });
+        this.store = config.persistState ? new StationStore(config.chargePointId, config.stateDirectory) : undefined;
+        this.loadPersistedState();
+        this.refreshConnectorSnapshot();
+        this.bindClientEvents();
+    }
+    connect() {
+        this.manuallyDisconnected = false;
+        this.clearReconnectTimer();
+        this.log("info", `Connecting to ${this.config.centralSystemUrl}`);
+        this.client.connect();
+    }
+    disconnect() {
+        this.manuallyDisconnected = true;
+        this.clearReconnectTimer();
+        this.stopHeartbeatTimer();
+        this.clearResetTimer();
+        this.clearBootRetryTimer();
+        this.meterValueScheduler.stopAllPeriodic();
+        this.meterValueScheduler.stopClockAligned();
+        this.reservationScheduler.clearAll();
+        this.statusScheduler.clearAll();
+        this.maintenance.clearAll();
+        this.client.close();
+        this.patchState({ connected: false });
+    }
+    reconnect() {
+        this.disconnect();
+        this.connect();
+    }
+    async boot(options = {}) {
+        const scheduleRetry = options.scheduleRetry ?? true;
+        this.clearBootRetryTimer();
+        const response = await this.send("BootNotification", {
+            chargePointVendor: this.config.vendor,
+            chargePointModel: this.config.model
+        });
+        const status = readString(response.payload.status, "Unknown");
+        const interval = readNumber(response.payload.interval, this.config.heartbeatIntervalSeconds);
+        this.patchState({
+            booted: status === "Accepted",
+            registrationStatus: status
+        });
+        if (status === "Accepted") {
+            this.reconnectAttempts = 0;
+            this.configuration.setValue("HeartbeatInterval", String(interval));
+            this.savePersistedState();
+            this.startHeartbeatTimer(interval);
+            await this.offlineTransactions.syncPendingTransactions();
+            this.meterValueScheduler.reschedulePeriodic(this.connectors.all().map((connector) => connector.id));
+            this.meterValueScheduler.startClockAligned();
+            await Promise.all(this.connectors.all().map((connector) => this.statusNotification(connector.id, connector.status, true)));
+            return;
+        }
+        this.stopHeartbeatTimer();
+        if (scheduleRetry) {
+            this.scheduleBootRetry(interval);
+        }
+    }
+    async heartbeat() {
+        const response = await this.send("Heartbeat", {});
+        this.patchState({ lastHeartbeatAt: new Date() });
+        if (response.payload.currentTime) {
+            this.log("success", `Heartbeat accepted, Central System time: ${String(response.payload.currentTime)}`);
+        }
+    }
+    async statusNotification(connectorId = this.config.connectorId, status = this.connectors.get(connectorId).status, force = false) {
+        if (!this.client.isConnected) {
+            return;
+        }
+        if (!force && this.statusScheduler.schedule(connectorId, status)) {
+            return;
+        }
+        this.statusScheduler.clear(connectorId);
+        await this.sendStatusNotification(connectorId, status);
+    }
+    async sendStatusNotification(connectorId, status) {
+        const connector = this.connectors.get(connectorId);
+        const payload = {
+            connectorId,
+            errorCode: status === "Faulted" ? faultErrorCode(connector) : "NoError",
+            status,
+            timestamp: new Date().toISOString()
+        };
+        if (connector.info) {
+            payload.info = connector.info;
+        }
+        if (connector.vendorId) {
+            payload.vendorId = connector.vendorId;
+        }
+        if (connector.vendorErrorCode) {
+            payload.vendorErrorCode = connector.vendorErrorCode;
+        }
+        await this.send("StatusNotification", payload);
+        this.statusScheduler.markSent(connectorId, status);
+    }
+    async authorize(idTag) {
+        if (!idTag) {
+            this.log("warn", "Authorize requires idTag");
+            return { accepted: false, idTagInfo: { status: "Invalid" }, source: "None" };
+        }
+        if (this.client.isConnected) {
+            const response = await this.send("Authorize", { idTag });
+            const idTagInfo = this.readIdTagInfo(response.payload.idTagInfo);
+            this.rememberAuthorization(idTag, idTagInfo);
+            const accepted = isAcceptedIdTagInfo(idTagInfo);
+            this.log(accepted ? "success" : "warn", `Authorization status: ${idTagInfo.status} (${idTag})`);
+            if (!accepted) {
+                await this.stopTransactionsForInvalidIdTag(idTag);
+            }
+            return { accepted, idTagInfo, source: "CentralSystem" };
+        }
+        const decision = this.authorizeLocally(idTag, true);
+        this.log(decision.accepted ? "success" : "warn", `Offline authorization status: ${decision.idTagInfo.status} (${idTag}, ${decision.source})`);
+        return decision;
+    }
+    async toggleTransaction(connectorId = this.config.connectorId, idTag) {
+        if (!idTag) {
+            this.log("warn", "StartTransaction requires idTag");
+            return;
+        }
+        const connector = this.connectors.get(connectorId);
+        if (connector.transactionId) {
+            await this.stopTransaction(connectorId, "Local", idTag);
+            return;
+        }
+        await this.startTransaction(connectorId, idTag);
+    }
+    async startTransaction(connectorId = this.config.connectorId, idTag) {
+        if (!idTag) {
+            this.log("warn", "StartTransaction requires idTag");
+            return undefined;
+        }
+        const connector = this.connectors.get(connectorId);
+        const rejection = startTransactionRejection(connector, idTag);
+        if (rejection) {
+            this.log("warn", rejection);
+            return undefined;
+        }
+        if (!connector.evConnected && connector.status === "Available") {
+            this.connectors.patch(connectorId, { evConnected: true, status: "Preparing" });
+            void this.runSafely(() => this.statusNotification(connectorId, "Preparing"));
+        }
+        else if (connector.status === "Available") {
+            this.connectors.patch(connectorId, { status: "Preparing" });
+            void this.runSafely(() => this.statusNotification(connectorId, "Preparing"));
+        }
+        const payload = {
+            connectorId,
+            idTag,
+            meterStart: Math.round(connector.meterWh),
+            timestamp: new Date().toISOString()
+        };
+        if (connector.reservationId) {
+            payload.reservationId = connector.reservationId;
+        }
+        const localPreAuthorize = this.configuration.boolean("LocalPreAuthorize", false);
+        if (localPreAuthorize) {
+            const decision = this.authorizeLocally(idTag, false);
+            if (!decision.accepted) {
+                this.log("warn", `StartTransaction blocked by local authorization: ${decision.idTagInfo.status} (${idTag})`);
+                return undefined;
+            }
+        }
+        if (!this.client.isConnected) {
+            const decision = this.authorizeLocally(idTag, true);
+            if (!decision.accepted) {
+                this.log("warn", `Offline StartTransaction blocked: ${decision.idTagInfo.status} (${idTag}, ${decision.source})`);
+                return undefined;
+            }
+            const transactionId = localTransactionId(connectorId);
+            this.reservationScheduler.clear(connectorId);
+            this.connectors.patch(connectorId, {
+                transactionId,
+                transactionStartedAt: readString(payload.timestamp, new Date().toISOString()),
+                reservationId: undefined,
+                reservationIdTag: undefined,
+                reservationParentIdTag: undefined,
+                reservationExpiryDate: undefined,
+                lastIdTag: idTag,
+                stopTransactionAtWh: undefined,
+                pendingStartTransaction: payload,
+                pendingStopTransaction: undefined,
+                status: "Charging"
+            });
+            this.savePersistedState();
+            this.meterValueScheduler.startPeriodic(connectorId);
+            this.log("warn", `Started local offline transaction ${transactionId} on connector ${connectorId}; will sync after reconnect`);
+            void this.runSafely(() => this.statusNotification(connectorId, "Charging"));
+            return transactionId;
+        }
+        const response = await this.send("StartTransaction", payload);
+        const idTagInfo = this.readIdTagInfo(response.payload.idTagInfo);
+        this.rememberAuthorization(idTag, idTagInfo);
+        if (!isAcceptedIdTagInfo(idTagInfo)) {
+            this.log("warn", `StartTransaction rejected by Central System: ${idTagInfo.status} (${idTag})`);
+            return undefined;
+        }
+        const transactionId = readNumber(response.payload.transactionId, Date.now());
+        this.reservationScheduler.clear(connectorId);
+        this.connectors.patch(connectorId, {
+            transactionId,
+            transactionStartedAt: new Date().toISOString(),
+            reservationId: undefined,
+            reservationIdTag: undefined,
+            reservationParentIdTag: undefined,
+            reservationExpiryDate: undefined,
+            lastIdTag: idTag,
+            stopTransactionAtWh: undefined,
+            pendingStartTransaction: undefined,
+            pendingStopTransaction: undefined,
+            status: "Charging"
+        });
+        this.savePersistedState();
+        this.meterValueScheduler.startPeriodic(connectorId);
+        this.meterValueScheduler.startClockAligned();
+        void this.runSafely(() => this.statusNotification(connectorId, "Charging"));
+        return transactionId;
+    }
+    async stopTransaction(connectorId = this.config.connectorId, reason = "Local", idTag) {
+        const connector = this.connectors.get(connectorId);
+        if (!connector.transactionId) {
+            this.log("warn", `Connector ${connectorId} has no active transaction`);
+            return;
+        }
+        this.meterValueScheduler.stopPeriodic(connectorId);
+        const transactionId = connector.transactionId;
+        const pendingStop = {
+            meterStop: Math.round(connector.meterWh),
+            timestamp: new Date().toISOString(),
+            reason,
+            transactionData: this.buildStopTransactionData(connectorId)
+        };
+        if (idTag) {
+            pendingStop.idTag = idTag;
+        }
+        if (!this.client.isConnected || connector.pendingStartTransaction) {
+            const { evConnected, status } = statusAfterStopTransaction(reason, connector.evConnected, connector.availability);
+            this.connectors.patch(connectorId, {
+                pendingStopTransaction: pendingStop,
+                evConnected,
+                status
+            });
+            this.savePersistedState();
+            this.log("warn", `Queued ${connector.pendingStartTransaction ? "offline" : "disconnected"} StopTransaction for connector ${connectorId}; will sync after reconnect`);
+            void this.runSafely(() => this.statusNotification(connectorId, status));
+            return;
+        }
+        const payload = { ...pendingStopPayload(pendingStop), transactionId };
+        this.connectors.patch(connectorId, { status: "Finishing" });
+        void this.runSafely(() => this.statusNotification(connectorId, "Finishing"));
+        try {
+            await this.send("StopTransaction", payload);
+        }
+        catch (error) {
+            const restoredStatus = connector.evConnected ? "Charging" : "SuspendedEV";
+            this.connectors.patch(connectorId, { status: restoredStatus });
+            if (restoredStatus === "Charging") {
+                this.meterValueScheduler.startPeriodic(connectorId);
+                this.meterValueScheduler.startClockAligned();
+            }
+            void this.runSafely(() => this.statusNotification(connectorId, restoredStatus));
+            throw error;
+        }
+        const { evConnected, status } = statusAfterStopTransaction(reason, connector.evConnected, connector.availability);
+        this.connectors.patch(connectorId, {
+            transactionId: undefined,
+            transactionStartedAt: undefined,
+            stopTransactionAtWh: undefined,
+            pendingStartTransaction: undefined,
+            pendingStopTransaction: undefined,
+            evConnected,
+            status
+        });
+        this.chargingProfiles.clearForTransaction(transactionId);
+        this.savePersistedState();
+        if (status !== "Finishing") {
+            void this.runSafely(() => this.statusNotification(connectorId, status));
+        }
+    }
+    async plugIn(connectorId = this.config.connectorId) {
+        const connector = this.connectors.get(connectorId);
+        if (connector.evConnected) {
+            this.log("warn", `Connector ${connectorId} already has EV connected`);
+            return;
+        }
+        if (connector.availability === "Inoperative" || connector.status === "Unavailable" || connector.status === "Faulted") {
+            this.log("warn", `Connector ${connectorId} cannot accept EV while ${connector.status}`);
+            return;
+        }
+        if (connector.transactionId) {
+            this.connectors.patch(connectorId, { evConnected: true, status: "Charging" });
+            this.meterValueScheduler.startPeriodic(connectorId);
+            this.meterValueScheduler.startClockAligned();
+            await this.statusNotification(connectorId, "Charging");
+            return;
+        }
+        const status = connector.reservationId ? "Reserved" : "Preparing";
+        this.connectors.patch(connectorId, { evConnected: true, status });
+        await this.statusNotification(connectorId, status);
+    }
+    async unplug(connectorId = this.config.connectorId) {
+        const connector = this.connectors.get(connectorId);
+        if (connector.transactionId) {
+            if (!this.configuration.boolean("StopTransactionOnEVSideDisconnect", true)) {
+                this.meterValueScheduler.stopPeriodic(connectorId);
+                this.connectors.patch(connectorId, { evConnected: false, status: "SuspendedEV" });
+                await this.statusNotification(connectorId, "SuspendedEV");
+                return;
+            }
+            await this.stopTransaction(connectorId, "EVDisconnected", connector.lastIdTag);
+            return;
+        }
+        if (!connector.evConnected && connector.status !== "Finishing") {
+            this.log("warn", `Connector ${connectorId} has no EV connected`);
+            return;
+        }
+        const status = connector.availability === "Inoperative" || connector.status === "Unavailable" ? "Unavailable" : "Available";
+        this.connectors.patch(connectorId, { evConnected: false, status });
+        await this.statusNotification(connectorId, status);
+    }
+    async setFault(connectorId = this.config.connectorId, errorCode = "OtherError", info, vendorErrorCode) {
+        const connector = this.connectors.get(connectorId);
+        if (connector.transactionId) {
+            await this.stopTransaction(connectorId, "Other", connector.lastIdTag);
+        }
+        this.connectors.patch(connectorId, {
+            status: "Faulted",
+            errorCode: errorCode === "NoError" ? "OtherError" : errorCode,
+            info: trimOptional(info, 50),
+            vendorId: this.config.vendor,
+            vendorErrorCode: trimOptional(vendorErrorCode, 50)
+        });
+        await this.statusNotification(connectorId, "Faulted");
+    }
+    async clearFault(connectorId = this.config.connectorId) {
+        const connector = this.connectors.get(connectorId);
+        const status = statusAfterFaultClear(connector);
+        this.connectors.patch(connectorId, {
+            status,
+            errorCode: "NoError",
+            info: undefined,
+            vendorId: undefined,
+            vendorErrorCode: undefined
+        });
+        await this.statusNotification(connectorId, status);
+    }
+    async meterValues(connectorId = this.config.connectorId, deltaWh = 120, sampledData) {
+        if (sampledData !== undefined && !isValidSampledDataConfiguration(sampledData)) {
+            this.log("warn", `Invalid MeterValues sampled data: ${sampledData}`);
+            return;
+        }
+        const connector = this.connectors.get(connectorId);
+        const measurands = sampledData === undefined ? this.configuration.measurands("MeterValuesSampledData") : readConfiguredMeasurands(sampledData);
+        if (!connector) {
+            return;
+        }
+        await this.sendMeterValues(connectorId, "Sample.Periodic", deltaWh, measurands);
+    }
+    async dataTransfer(payload = { vendorId: this.config.vendor }) {
+        const response = await this.send("DataTransfer", payload);
+        const status = readString(response.payload.status, "Unknown");
+        this.log(status === "Accepted" ? "success" : "warn", `DataTransfer status: ${status}`);
+        if (response.payload.data) {
+            this.log("info", `DataTransfer response data: ${String(response.payload.data)}`);
+        }
+    }
+    async firmwareStatusNotification(status = "Installed") {
+        this.patchState({ firmwareStatus: status });
+        await this.send("FirmwareStatusNotification", { status });
+    }
+    async diagnosticsStatusNotification(status = "Uploaded") {
+        this.patchState({ diagnosticsStatus: status });
+        await this.send("DiagnosticsStatusNotification", { status });
+    }
+    setDiagnosticsOutcome(outcome) {
+        this.maintenance.setDiagnosticsOutcome(outcome);
+        this.log("info", `Diagnostics outcome set to ${outcome}`);
+    }
+    setFirmwareOutcome(outcome) {
+        this.maintenance.setFirmwareOutcome(outcome);
+        this.log("info", `Firmware outcome set to ${outcome}`);
+    }
+    async cycleStatus(connectorId = this.config.connectorId) {
+        const connector = this.connectors.get(connectorId);
+        const next = nextConnectorStatus(connector.status);
+        this.connectors.patch(connectorId, {
+            status: next,
+            errorCode: next === "Faulted" ? "OtherError" : "NoError",
+            info: next === "Faulted" ? "Manual fault" : undefined,
+            vendorId: next === "Faulted" ? this.config.vendor : undefined,
+            vendorErrorCode: undefined
+        });
+        await this.statusNotification(connectorId, next);
+    }
+    addConnector() {
+        const { id: nextId } = this.connectors.add();
+        this.configuration.setValue("NumberOfConnectors", String(this.connectors.size));
+        this.savePersistedState();
+        void this.runSafely(() => this.statusNotification(nextId, "Available"));
+        return nextId;
+    }
+    bindClientEvents() {
+        this.client.on("connected", () => {
+            this.clearReconnectTimer();
+            this.patchState({ connected: true });
+            this.log("success", "Connected");
+            void this.runSafely(() => this.boot());
+        });
+        this.client.on("disconnected", (code, reason) => {
+            this.stopHeartbeatTimer();
+            this.clearResetTimer();
+            this.clearBootRetryTimer();
+            this.patchState({ connected: false, booted: false });
+            this.log("warn", `Disconnected${code ? ` (${code})` : ""}${reason ? `: ${reason}` : ""}`);
+            this.scheduleReconnect();
+        });
+        this.client.on("error", (error) => this.log("error", error.message));
+        this.client.on("log", (direction, message) => {
+            this.log(direction, describeOcppMessage(message), JSON.stringify(message));
+        });
+        this.client.on("call", (messageId, action, payload) => {
+            void this.handleCentralSystemCall(messageId, action, payload);
+        });
+    }
+    async handleCentralSystemCall(messageId, action, payload) {
+        try {
+            switch (action) {
+                case "CancelReservation":
+                    this.handleCancelReservation(messageId, payload);
+                    break;
+                case "ChangeAvailability":
+                    await this.handleChangeAvailability(messageId, payload);
+                    break;
+                case "ChangeConfiguration":
+                    this.handleChangeConfiguration(messageId, payload);
+                    break;
+                case "ClearCache":
+                    this.authorizationCache.clear();
+                    this.savePersistedState();
+                    this.client.reply(messageId, { status: "Accepted" });
+                    break;
+                case "ClearChargingProfile":
+                    this.handleClearChargingProfile(messageId, payload);
+                    break;
+                case "DataTransfer":
+                    this.handleDataTransfer(messageId, payload);
+                    break;
+                case "GetCompositeSchedule":
+                    this.handleGetCompositeSchedule(messageId, payload);
+                    break;
+                case "GetConfiguration":
+                    this.handleGetConfiguration(messageId, payload);
+                    break;
+                case "GetDiagnostics":
+                    this.client.reply(messageId, { fileName: this.maintenance.startDiagnostics(payload) });
+                    break;
+                case "GetLocalListVersion":
+                    this.client.reply(messageId, { listVersion: this.state.localListVersion });
+                    break;
+                case "RemoteStartTransaction":
+                    await this.handleRemoteStartTransaction(messageId, payload);
+                    break;
+                case "RemoteStopTransaction":
+                    await this.handleRemoteStopTransaction(messageId, payload);
+                    break;
+                case "ReserveNow":
+                    await this.handleReserveNow(messageId, payload);
+                    break;
+                case "Reset":
+                    this.handleReset(messageId, payload);
+                    break;
+                case "SendLocalList":
+                    this.handleSendLocalList(messageId, payload);
+                    break;
+                case "SetChargingProfile":
+                    this.handleSetChargingProfile(messageId, payload);
+                    break;
+                case "TriggerMessage":
+                    await this.handleTriggerMessage(messageId, payload);
+                    break;
+                case "UnlockConnector":
+                    await this.handleUnlockConnector(messageId, payload);
+                    break;
+                case "UpdateFirmware":
+                    this.client.reply(messageId, {});
+                    this.maintenance.startFirmware(payload);
+                    break;
+                default:
+                    this.client.replyError(messageId, "NotSupported", `${action} is not supported by this emulator`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.client.replyError(messageId, "InternalError", message);
+        }
+    }
+    handleCancelReservation(messageId, payload) {
+        const reservationId = readNumber(payload.reservationId, -1);
+        const connector = this.connectors.findByReservation(reservationId);
+        if (!connector) {
+            this.client.reply(messageId, { status: "Rejected" });
+            return;
+        }
+        this.clearReservation(connector.id);
+        this.client.reply(messageId, { status: "Accepted" });
+        void this.runSafely(() => this.statusNotification(connector.id, this.connectors.get(connector.id).status));
+    }
+    async handleChangeAvailability(messageId, payload) {
+        const availability = readString(payload.type, "Operative");
+        const connectorId = readNumber(payload.connectorId, 0);
+        const requestedConnector = connectorId === 0 ? undefined : this.connectors.find(connectorId);
+        if (connectorId !== 0 && !requestedConnector) {
+            this.client.reply(messageId, { status: "Rejected" });
+            return;
+        }
+        const connectors = connectorId === 0 ? this.connectors.all() : [requestedConnector ?? this.connectors.get(connectorId)];
+        const scheduled = connectors.some((connector) => connector.transactionId);
+        for (const connector of connectors) {
+            if (connector.transactionId) {
+                this.connectors.patch(connector.id, { availability });
+                continue;
+            }
+            this.connectors.patch(connector.id, { availability, status: statusAfterAvailabilityChange(connector, availability) });
+        }
+        this.client.reply(messageId, { status: scheduled ? "Scheduled" : "Accepted" });
+        for (const connector of connectors.filter((connector) => !connector.transactionId)) {
+            void this.runSafely(() => this.statusNotification(connector.id, this.connectors.get(connector.id).status));
+        }
+    }
+    handleChangeConfiguration(messageId, payload) {
+        const result = changeConfiguration(this.configuration, payload);
+        this.client.reply(messageId, { status: result.status });
+        if (result.status !== "Accepted") {
+            return;
+        }
+        this.savePersistedState();
+        if (result.key === "HeartbeatInterval") {
+            const interval = Number.parseInt(result.value, 10);
+            if (Number.isFinite(interval) && interval > 0) {
+                this.startHeartbeatTimer(interval);
+            }
+        }
+        if (result.key === "MeterValueSampleInterval") {
+            this.meterValueScheduler.reschedulePeriodic(this.connectors.all().map((connector) => connector.id));
+        }
+        if (result.key === "ClockAlignedDataInterval") {
+            this.meterValueScheduler.startClockAligned();
+        }
+        if (result.key === "MinimumStatusDuration" && result.value === "0") {
+            this.statusScheduler.flush();
+        }
+    }
+    handleDataTransfer(messageId, payload) {
+        const vendorId = readString(payload.vendorId, "");
+        if (vendorId !== this.config.vendor) {
+            this.client.reply(messageId, { status: "UnknownVendorId" });
+            return;
+        }
+        this.client.reply(messageId, { status: "Accepted", data: readString(payload.data, "") });
+    }
+    handleGetConfiguration(messageId, payload) {
+        this.client.reply(messageId, getConfiguration(this.configuration, payload));
+    }
+    handleSetChargingProfile(messageId, payload) {
+        const connectorId = readNumber(payload.connectorId, -1);
+        const status = this.chargingProfiles.set(connectorId, payload.csChargingProfiles, {
+            hasConnector: (id) => Boolean(this.connectors.find(id)),
+            transactionIdForConnector: (id) => this.connectors.find(id)?.transactionId
+        });
+        if (status !== "Accepted") {
+            this.client.reply(messageId, { status });
+            return;
+        }
+        this.savePersistedState();
+        this.client.reply(messageId, { status: "Accepted" });
+    }
+    handleClearChargingProfile(messageId, payload) {
+        const status = this.chargingProfiles.clear(payload);
+        if (status === "Accepted") {
+            this.savePersistedState();
+        }
+        this.client.reply(messageId, { status });
+    }
+    handleGetCompositeSchedule(messageId, payload) {
+        const connectorId = readNumber(payload.connectorId, -1);
+        const connector = connectorId === 0 ? undefined : this.connectors.find(connectorId);
+        if (connectorId !== 0 && !connector) {
+            this.client.reply(messageId, { status: "Rejected" });
+            return;
+        }
+        const schedule = this.chargingProfiles.compositeSchedulePayload(payload, connector?.transactionId, connector?.transactionStartedAt);
+        if (!schedule) {
+            this.client.reply(messageId, { status: "Rejected" });
+            return;
+        }
+        if (schedule.prunedExpired) {
+            this.savePersistedState();
+        }
+        this.client.reply(messageId, schedule.payload);
+    }
+    handleSendLocalList(messageId, payload) {
+        const result = applyLocalAuthListUpdate(this.localAuthorizationList, this.state.localListVersion, payload, {
+            enabled: this.configuration.boolean("LocalAuthListEnabled", true),
+            maxLength: this.configuration.integer("SendLocalListMaxLength", 1000)
+        });
+        if (result.status !== "Accepted") {
+            this.client.reply(messageId, { status: result.status });
+            return;
+        }
+        this.patchState({ localListVersion: result.listVersion });
+        this.savePersistedState();
+        this.client.reply(messageId, { status: "Accepted" });
+    }
+    async handleRemoteStartTransaction(messageId, payload) {
+        const requestedConnector = readNumber(payload.connectorId, 0);
+        const connector = requestedConnector > 0 ? this.connectors.find(requestedConnector) : this.connectors.findAvailable();
+        const idTag = readString(payload.idTag, "");
+        if (!idTag || !canRemoteStart(connector) || !this.canAcceptRemoteStartChargingProfile(payload)) {
+            this.client.reply(messageId, { status: "Rejected" });
+            return;
+        }
+        if (this.configuration.boolean("AuthorizeRemoteTxRequests", false)) {
+            const decision = await this.authorize(idTag);
+            if (!decision.accepted) {
+                this.client.reply(messageId, { status: "Rejected" });
+                return;
+            }
+        }
+        this.client.reply(messageId, { status: "Accepted" });
+        if (connector) {
+            const transactionId = await this.startTransaction(connector.id, idTag);
+            if (transactionId !== undefined) {
+                this.applyRemoteStartChargingProfile(connector.id, payload.chargingProfile, transactionId);
+            }
+        }
+    }
+    async handleRemoteStopTransaction(messageId, payload) {
+        const transactionId = readNumber(payload.transactionId, -1);
+        const connector = this.connectors.findByTransaction(transactionId);
+        const accepted = Boolean(connector);
+        this.client.reply(messageId, { status: accepted ? "Accepted" : "Rejected" });
+        if (accepted && connector) {
+            await this.stopTransaction(connector.id, "Remote");
+        }
+    }
+    async handleReserveNow(messageId, payload) {
+        const requestedConnectorId = readNumber(payload.connectorId, this.config.connectorId);
+        const connector = requestedConnectorId === 0 ? this.connectors.findAvailable() : this.connectors.find(requestedConnectorId);
+        const connectorId = connector?.id ?? requestedConnectorId;
+        const expiryDate = readString(payload.expiryDate, "");
+        const rejection = reserveNowRejection(connector, expiryDate);
+        if (rejection) {
+            this.client.reply(messageId, { status: rejection });
+            return;
+        }
+        this.connectors.patch(connectorId, {
+            reservationId: readNumber(payload.reservationId, Date.now()),
+            reservationIdTag: readString(payload.idTag, ""),
+            reservationParentIdTag: readOptionalString(payload.parentIdTag),
+            reservationExpiryDate: expiryDate,
+            status: "Reserved"
+        });
+        this.reservationScheduler.schedule(connectorId);
+        this.savePersistedState();
+        this.client.reply(messageId, { status: "Accepted" });
+        void this.runSafely(() => this.statusNotification(connectorId, "Reserved"));
+    }
+    handleReset(messageId, payload) {
+        const resetType = readString(payload.type, "Soft");
+        const reason = resetType === "Hard" ? "HardReset" : "SoftReset";
+        this.client.reply(messageId, { status: "Accepted" });
+        void this.runSafely(() => this.performReset(reason, resetType));
+    }
+    async handleTriggerMessage(messageId, payload) {
+        const requestedMessage = readString(payload.requestedMessage, "");
+        if (!canTriggerMessage(requestedMessage)) {
+            this.client.reply(messageId, { status: "NotImplemented" });
+            return;
+        }
+        if (!this.canTriggerMessageForPayload(requestedMessage, payload)) {
+            this.client.reply(messageId, { status: "Rejected" });
+            return;
+        }
+        this.client.reply(messageId, { status: "Accepted" });
+        await this.triggerMessage(requestedMessage, payload);
+    }
+    async handleUnlockConnector(messageId, payload = {}) {
+        const connectorId = readNumber(payload.connectorId, this.config.connectorId);
+        const connector = this.connectors.find(connectorId);
+        if (!connector) {
+            this.client.reply(messageId, { status: "NotSupported" });
+            return;
+        }
+        if (connector.transactionId) {
+            this.client.reply(messageId, { status: "Unlocked" });
+            await this.stopTransaction(connectorId, "UnlockCommand");
+            return;
+        }
+        this.client.reply(messageId, { status: "Unlocked" });
+    }
+    async triggerMessage(requestedMessage, payload = {}) {
+        switch (requestedMessage) {
+            case "BootNotification":
+                await this.boot();
+                break;
+            case "DiagnosticsStatusNotification":
+                await this.diagnosticsStatusNotification("Idle");
+                break;
+            case "FirmwareStatusNotification":
+                await this.firmwareStatusNotification("Idle");
+                break;
+            case "Heartbeat":
+                await this.heartbeat();
+                break;
+            case "MeterValues":
+                await this.meterValues(this.triggerConnectorId(payload), 0);
+                break;
+            case "StatusNotification":
+                await this.statusNotification(this.triggerConnectorId(payload), this.connectors.get(this.triggerConnectorId(payload)).status, true);
+                break;
+            default:
+                this.log("warn", `TriggerMessage requested unsupported message: ${requestedMessage}`);
+        }
+    }
+    canTriggerMessageForPayload(requestedMessage, payload) {
+        if (requestedMessage !== "MeterValues" && requestedMessage !== "StatusNotification") {
+            return true;
+        }
+        return Boolean(this.connectors.find(this.triggerConnectorId(payload)));
+    }
+    triggerConnectorId(payload) {
+        return "connectorId" in payload ? readNumber(payload.connectorId, -1) : this.config.connectorId;
+    }
+    canAcceptRemoteStartChargingProfile(payload) {
+        if (!("chargingProfile" in payload)) {
+            return true;
+        }
+        const profile = readChargingProfile(payload.chargingProfile);
+        return Boolean(profile &&
+            profile.chargingProfilePurpose === "TxProfile" &&
+            profile.transactionId === undefined);
+    }
+    applyRemoteStartChargingProfile(connectorId, profilePayload, transactionId) {
+        const profile = readChargingProfile(profilePayload);
+        if (!profile) {
+            return;
+        }
+        const status = this.chargingProfiles.set(connectorId, { ...profile, transactionId }, {
+            hasConnector: (id) => Boolean(this.connectors.find(id)),
+            transactionIdForConnector: (id) => this.connectors.find(id)?.transactionId
+        });
+        if (status === "Accepted") {
+            this.savePersistedState();
+        }
+    }
+    async send(action, payload) {
+        if (isTransactionMessage(action)) {
+            return this.sendTransactionMessage(action, payload);
+        }
+        try {
+            const response = await this.client.call(action, payload, this.config.callTimeoutMs ?? 30_000);
+            this.log("success", `${action} accepted`);
+            return response;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log("error", message);
+            throw error;
+        }
+    }
+    async sendTransactionMessage(action, payload) {
+        const attempts = this.configuration.integer("TransactionMessageAttempts", 1);
+        const retryInterval = this.configuration.integer("TransactionMessageRetryInterval", 30);
+        let lastError;
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+            try {
+                const response = await this.client.call(action, payload, this.config.callTimeoutMs ?? 30_000);
+                this.log("success", `${action} accepted`);
+                return response;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= attempts) {
+                    break;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                this.log("warn", `${action} attempt ${attempt}/${attempts} failed: ${message}; retrying in ${retryInterval}s`);
+                await retryDelay(retryInterval);
+            }
+        }
+        const message = lastError instanceof Error ? lastError.message : String(lastError);
+        this.log("error", message);
+        throw lastError instanceof Error ? lastError : new Error(message);
+    }
+    async sendMeterValues(connectorId, context, deltaWh, measurands) {
+        const connector = this.connectors.get(connectorId);
+        const nextMeter = connector.meterWh + deltaWh;
+        this.connectors.patch(connectorId, { meterWh: nextMeter });
+        this.savePersistedState();
+        if (!this.client.isConnected || connector.pendingStartTransaction) {
+            await this.stopTransactionIfInvalidEnergyLimitReached(connectorId, nextMeter);
+            return;
+        }
+        const payload = {
+            connectorId,
+            meterValue: [buildMeterValue(this.connectors.get(connectorId), context, measurands)]
+        };
+        if (connector.transactionId) {
+            payload.transactionId = connector.transactionId;
+        }
+        await this.send("MeterValues", payload);
+        await this.stopTransactionIfInvalidEnergyLimitReached(connectorId, nextMeter);
+    }
+    buildStopTransactionData(connectorId) {
+        return [
+            buildMeterValue(this.connectors.get(connectorId), "Transaction.End", this.configuration.measurands("StopTxnSampledData")),
+            buildMeterValue(this.connectors.get(connectorId), "Sample.Clock", this.configuration.measurands("StopTxnAlignedData"))
+        ];
+    }
+    authorizeLocally(idTag, requireOfflinePermission) {
+        return authorizeLocally(idTag, requireOfflinePermission, this.localAuthorizationList, this.authorizationCache, {
+            localAuthListEnabled: this.configuration.boolean("LocalAuthListEnabled", true),
+            localAuthorizeOffline: this.configuration.boolean("LocalAuthorizeOffline", false),
+            authorizationCacheEnabled: this.configuration.boolean("AuthorizationCacheEnabled", true),
+            allowOfflineTxForUnknownId: this.configuration.boolean("AllowOfflineTxForUnknownId", false)
+        });
+    }
+    rememberAuthorization(idTag, idTagInfo) {
+        if (!this.configuration.boolean("AuthorizationCacheEnabled", true)) {
+            return;
+        }
+        this.authorizationCache.set(idTag, serializeIdTagInfo(idTagInfo));
+        this.savePersistedState();
+    }
+    readIdTagInfo(value) {
+        return normalizeIdTagInfo(readObject(value));
+    }
+    async stopTransactionsForInvalidIdTag(idTag) {
+        if (!this.configuration.boolean("StopTransactionOnInvalidId", false)) {
+            return;
+        }
+        const maxEnergyOnInvalidId = this.configuration.integer("MaxEnergyOnInvalidId", 0);
+        const connectors = this.connectors.all().filter((connector) => connector.transactionId && connector.lastIdTag === idTag);
+        for (const connector of connectors) {
+            if (maxEnergyOnInvalidId <= 0) {
+                await this.stopTransaction(connector.id, "DeAuthorized", idTag);
+                continue;
+            }
+            this.connectors.patch(connector.id, { stopTransactionAtWh: connector.meterWh + maxEnergyOnInvalidId });
+            this.log("warn", `Connector ${connector.id} will stop after ${maxEnergyOnInvalidId}Wh because idTag ${idTag} is no longer authorized`);
+        }
+    }
+    async stopTransactionIfInvalidEnergyLimitReached(connectorId, meterWh) {
+        const connector = this.connectors.get(connectorId);
+        if (!connector.transactionId || connector.stopTransactionAtWh === undefined || meterWh < connector.stopTransactionAtWh) {
+            return;
+        }
+        await this.stopTransaction(connectorId, "DeAuthorized", connector.lastIdTag);
+    }
+    refreshConnectorSnapshot() {
+        const { connectors, primary } = this.connectors.snapshot();
+        this.state.connectors = connectors;
+        if (primary) {
+            this.state.connectorStatus = primary.status;
+            this.state.availability = primary.availability;
+            this.state.transactionId = primary.transactionId;
+            this.state.reservationId = primary.reservationId;
+            this.state.meterWh = primary.meterWh;
+        }
+        this.emit("state", { ...this.state, connectors });
+    }
+    clearReservation(connectorId) {
+        const connector = this.connectors.get(connectorId);
+        this.reservationScheduler.clear(connectorId);
+        this.connectors.patch(connectorId, {
+            reservationId: undefined,
+            reservationIdTag: undefined,
+            reservationParentIdTag: undefined,
+            reservationExpiryDate: undefined,
+            status: statusAfterReservationClear(connector)
+        });
+        this.savePersistedState();
+    }
+    async sendClockAlignedMeterValues(connectorIds, deltaWh) {
+        const measurands = this.configuration.measurands("MeterValuesAlignedData");
+        for (const connectorId of connectorIds) {
+            await this.sendMeterValues(connectorId, "Sample.Clock", deltaWh, measurands);
+        }
+    }
+    expireReservation(connectorId) {
+        const connector = this.connectors.find(connectorId);
+        if (!connector?.reservationId) {
+            return;
+        }
+        this.log("warn", `Reservation ${connector.reservationId} expired on connector ${connectorId}`);
+        this.clearReservation(connectorId);
+        void this.runSafely(() => this.statusNotification(connectorId, this.connectors.get(connectorId).status));
+    }
+    loadPersistedState() {
+        if (!this.store) {
+            return;
+        }
+        let persisted;
+        try {
+            persisted = this.store.load();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log("warn", `Could not load persisted station state: ${message}`);
+            return;
+        }
+        if (!persisted) {
+            return;
+        }
+        const restored = restorePersistedStationState({
+            persisted,
+            connectorId: this.config.connectorId,
+            connectors: this.connectors,
+            configuration: this.configuration,
+            localAuthorizationList: this.localAuthorizationList,
+            authorizationCache: this.authorizationCache,
+            scheduleReservation: (connectorId) => this.reservationScheduler.schedule(connectorId)
+        });
+        this.state.localListVersion = restored.localListVersion;
+        this.chargingProfiles.replace(restored.chargingProfiles);
+    }
+    savePersistedState() {
+        if (!this.store) {
+            return;
+        }
+        try {
+            this.store.save(buildPersistedStationState({
+                chargePointId: this.config.chargePointId,
+                connectorId: this.config.connectorId,
+                connectors: this.connectors.all(),
+                localListVersion: this.state.localListVersion,
+                localAuthorizationList: this.localAuthorizationList,
+                authorizationCache: this.authorizationCache,
+                chargingProfiles: this.chargingProfiles.entries(),
+                configuration: this.configuration.values
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log("error", `Could not save station state: ${message}`);
+        }
+    }
+    startHeartbeatTimer(intervalSeconds) {
+        this.stopHeartbeatTimer();
+        this.heartbeatTimer = setInterval(() => {
+            void this.runSafely(() => this.heartbeat());
+        }, intervalSeconds * 1000);
+    }
+    stopHeartbeatTimer() {
+        if (!this.heartbeatTimer) {
+            return;
+        }
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = undefined;
+    }
+    async performReset(reason, resetType) {
+        this.log("warn", `${resetType} reset accepted; rebooting station`);
+        this.stopHeartbeatTimer();
+        this.clearResetTimer();
+        this.maintenance.clearAll();
+        this.meterValueScheduler.stopClockAligned();
+        for (const connector of this.connectors.all()) {
+            if (connector.transactionId) {
+                await this.stopTransaction(connector.id, reason);
+                const resetStatus = this.connectors.get(connector.id).availability === "Inoperative" ? "Unavailable" : "Available";
+                this.connectors.patch(connector.id, { evConnected: false, status: resetStatus });
+                void this.runSafely(() => this.statusNotification(connector.id, resetStatus));
+            }
+        }
+        this.meterValueScheduler.stopAllPeriodic();
+        for (const connector of this.connectors.all()) {
+            if (!connector.reservationId) {
+                continue;
+            }
+            this.clearReservation(connector.id);
+            void this.runSafely(() => this.statusNotification(connector.id, this.connectors.get(connector.id).status));
+        }
+        this.patchState({ booted: false, registrationStatus: "Unknown" });
+        this.resetTimer = setTimeout(() => {
+            this.resetTimer = undefined;
+            if (this.state.connected) {
+                void this.runSafely(() => this.bootAfterReset(this.configuration.integer("ResetRetries", 0)));
+            }
+        }, 500);
+    }
+    async bootAfterReset(remainingRetries) {
+        await this.boot({ scheduleRetry: false });
+        if (this.state.registrationStatus === "Accepted" || remainingRetries <= 0 || !this.state.connected) {
+            return;
+        }
+        this.log("warn", `Reset reboot BootNotification was ${this.state.registrationStatus}; retrying (${remainingRetries} left)`);
+        this.resetTimer = setTimeout(() => {
+            this.resetTimer = undefined;
+            if (this.state.connected) {
+                void this.runSafely(() => this.bootAfterReset(remainingRetries - 1));
+            }
+        }, 500);
+    }
+    clearResetTimer() {
+        if (!this.resetTimer) {
+            return;
+        }
+        clearTimeout(this.resetTimer);
+        this.resetTimer = undefined;
+    }
+    scheduleBootRetry(intervalSeconds) {
+        if (this.bootRetryTimer || !this.state.connected) {
+            return;
+        }
+        const delayMs = Math.max(1, intervalSeconds) * 1000;
+        this.log("warn", `BootNotification was ${this.state.registrationStatus}; retrying in ${delayMs}ms`);
+        this.bootRetryTimer = setTimeout(() => {
+            this.bootRetryTimer = undefined;
+            if (this.state.connected) {
+                void this.runSafely(() => this.boot());
+            }
+        }, delayMs);
+    }
+    clearBootRetryTimer() {
+        if (!this.bootRetryTimer) {
+            return;
+        }
+        clearTimeout(this.bootRetryTimer);
+        this.bootRetryTimer = undefined;
+    }
+    scheduleReconnect() {
+        if (this.manuallyDisconnected ||
+            !this.config.webSocketReconnectEnabled ||
+            this.reconnectTimer ||
+            this.state.connected) {
+            return;
+        }
+        const maxAttempts = this.config.webSocketReconnectMaxAttempts;
+        if (maxAttempts > 0 && this.reconnectAttempts >= maxAttempts) {
+            this.log("error", `Reconnect stopped after ${this.reconnectAttempts} failed attempt(s)`);
+            return;
+        }
+        this.reconnectAttempts += 1;
+        const delayMs = this.reconnectDelayMs(this.reconnectAttempts);
+        this.log("warn", `Reconnect attempt ${this.reconnectAttempts}${maxAttempts > 0 ? `/${maxAttempts}` : ""} in ${delayMs}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            if (this.manuallyDisconnected || this.state.connected) {
+                return;
+            }
+            this.log("info", `Reconnecting to ${this.config.centralSystemUrl}`);
+            this.client.connect();
+        }, delayMs);
+    }
+    reconnectDelayMs(attempt) {
+        const initial = Math.max(0, this.config.webSocketReconnectInitialDelayMs);
+        const max = Math.max(initial, this.config.webSocketReconnectMaxDelayMs);
+        return Math.min(initial * 2 ** Math.max(0, attempt - 1), max);
+    }
+    clearReconnectTimer() {
+        if (!this.reconnectTimer) {
+            return;
+        }
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = undefined;
+    }
+    patchState(patch) {
+        Object.assign(this.state, patch);
+        this.emit("state", { ...this.state });
+    }
+    log(level, message, details) {
+        this.emit("log", { at: new Date(), level, message, details });
+    }
+    async runSafely(task) {
+        try {
+            await task();
+        }
+        catch {
+            // Errors are logged in send(); keeping async UI handlers quiet avoids unhandled rejections.
+        }
+    }
+}
+function trimOptional(value, maxLength) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.slice(0, maxLength);
+}