kirby-ocpp 0.1.0

package/dist/station/connector-status.js

@@ -0,0 +1,66 @@
+export const CONNECTOR_STATUS_SEQUENCE = [
+    "Available",
+    "Preparing",
+    "Charging",
+    "SuspendedEVSE",
+    "SuspendedEV",
+    "Finishing",
+    "Reserved",
+    "Unavailable",
+    "Faulted"
+];
+export function nextConnectorStatus(status) {
+    const currentIndex = CONNECTOR_STATUS_SEQUENCE.indexOf(status);
+    return CONNECTOR_STATUS_SEQUENCE[(currentIndex + 1) % CONNECTOR_STATUS_SEQUENCE.length] ?? "Available";
+}
+export function faultErrorCode(connector) {
+    return connector.errorCode === "NoError" ? "OtherError" : connector.errorCode;
+}
+export function statusAfterReservationClear(connector) {
+    if (connector.availability === "Inoperative" || connector.status === "Unavailable") {
+        return "Unavailable";
+    }
+    if (connector.status === "Faulted") {
+        return "Faulted";
+    }
+    if (connector.transactionId) {
+        return "Charging";
+    }
+    if (connector.evConnected) {
+        return "Preparing";
+    }
+    return "Available";
+}
+export function statusAfterFaultClear(connector) {
+    if (connector.availability === "Inoperative") {
+        return "Unavailable";
+    }
+    if (connector.transactionId) {
+        return "Charging";
+    }
+    if (connector.evConnected) {
+        return "Preparing";
+    }
+    if (connector.reservationId) {
+        return "Reserved";
+    }
+    return "Available";
+}
+export function statusAfterAvailabilityChange(connector, availability) {
+    if (connector.status === "Faulted") {
+        return "Faulted";
+    }
+    if (availability === "Inoperative") {
+        return "Unavailable";
+    }
+    if (connector.status === "Finishing") {
+        return "Finishing";
+    }
+    if (connector.reservationId) {
+        return "Reserved";
+    }
+    if (connector.evConnected) {
+        return "Preparing";
+    }
+    return "Available";
+}

package/dist/station/local-auth-list.d.ts

@@ -0,0 +1,8 @@
+export interface LocalAuthListUpdateResult {
+    status: "Accepted" | "Failed" | "NotSupported" | "VersionMismatch";
+    listVersion: number;
+}
+export declare function applyLocalAuthListUpdate(localAuthorizationList: Map<string, Record<string, unknown> | undefined>, currentVersion: number, payload: Record<string, unknown>, options: {
+    enabled: boolean;
+    maxLength: number;
+}): LocalAuthListUpdateResult;

package/dist/station/local-auth-list.js

@@ -0,0 +1,31 @@
+import { readNumber, readObject, readString } from "./payload.js";
+export function applyLocalAuthListUpdate(localAuthorizationList, currentVersion, payload, options) {
+    const listVersion = readNumber(payload.listVersion, currentVersion);
+    const updateType = readString(payload.updateType, "Full");
+    const entries = Array.isArray(payload.localAuthorizationList) ? payload.localAuthorizationList : [];
+    if (!options.enabled) {
+        return { status: "NotSupported", listVersion: currentVersion };
+    }
+    if (entries.length > options.maxLength) {
+        return { status: "Failed", listVersion: currentVersion };
+    }
+    if (updateType === "Differential" && listVersion <= currentVersion) {
+        return { status: "VersionMismatch", listVersion: currentVersion };
+    }
+    if (updateType === "Full") {
+        localAuthorizationList.clear();
+    }
+    for (const item of entries) {
+        const entry = readObject(item);
+        const idTag = readString(entry.idTag, "");
+        if (!idTag) {
+            continue;
+        }
+        if (updateType === "Differential" && !("idTagInfo" in entry)) {
+            localAuthorizationList.delete(idTag);
+            continue;
+        }
+        localAuthorizationList.set(idTag, "idTagInfo" in entry ? readObject(entry.idTagInfo) : undefined);
+    }
+    return { status: "Accepted", listVersion };
+}

package/dist/station/maintenance-lifecycle.d.ts

@@ -0,0 +1,25 @@
+import type { DiagnosticsStatus, FirmwareStatus } from "../ocpp/types.js";
+export type DiagnosticsOutcome = "success" | "uploadFailure";
+export type FirmwareOutcome = "success" | "downloadFailure" | "installationFailure";
+export declare class MaintenanceLifecycle {
+    private readonly options;
+    private diagnosticsTimers;
+    private firmwareTimers;
+    private diagnosticsOutcome;
+    private firmwareOutcome;
+    constructor(options: {
+        run: (task: () => Promise<void>) => void;
+        diagnosticsStatus: (status: DiagnosticsStatus) => Promise<void>;
+        firmwareStatus: (status: FirmwareStatus) => Promise<void>;
+        log: (level: "info" | "warn", message: string) => void;
+    });
+    setDiagnosticsOutcome(outcome: DiagnosticsOutcome): void;
+    setFirmwareOutcome(outcome: FirmwareOutcome): void;
+    startDiagnostics(payload: Record<string, unknown>): string;
+    startFirmware(payload: Record<string, unknown>): void;
+    clearAll(): void;
+    private clearDiagnostics;
+    private clearFirmware;
+    private schedule;
+    private clear;
+}

package/dist/station/maintenance-lifecycle.js

@@ -0,0 +1,110 @@
+import { readNumber, readString } from "./payload.js";
+export class MaintenanceLifecycle {
+    options;
+    diagnosticsTimers = [];
+    firmwareTimers = [];
+    diagnosticsOutcome = "success";
+    firmwareOutcome = "success";
+    constructor(options) {
+        this.options = options;
+    }
+    setDiagnosticsOutcome(outcome) {
+        this.diagnosticsOutcome = outcome;
+    }
+    setFirmwareOutcome(outcome) {
+        this.firmwareOutcome = outcome;
+    }
+    startDiagnostics(payload) {
+        this.clearDiagnostics();
+        const location = readString(payload.location, "");
+        const fileName = diagnosticsFileName(location);
+        const retries = boundedRetries(readNumber(payload.retries, 0));
+        const retryInterval = readNumber(payload.retryInterval, 0);
+        const startDelay = retryInterval > 0 ? Math.min(retryInterval * 1000, 1000) : 100;
+        const stepDelay = retryInterval > 0 ? Math.min(retryInterval * 1000, 1000) : 400;
+        const statuses = diagnosticsStatuses(this.diagnosticsOutcome, retries, startDelay, stepDelay);
+        this.options.log("info", `Diagnostics upload scheduled to ${location}`);
+        this.diagnosticsTimers = this.schedule(statuses, this.options.diagnosticsStatus);
+        return fileName;
+    }
+    startFirmware(payload) {
+        this.clearFirmware();
+        const location = readString(payload.location, "");
+        const retrieveDate = readString(payload.retrieveDate, "");
+        const retries = boundedRetries(readNumber(payload.retries, 0));
+        const retryInterval = readNumber(payload.retryInterval, 0);
+        const startDelay = Math.min(Math.max(Date.parse(retrieveDate) - Date.now(), 100), 1000);
+        const stepDelay = retryInterval > 0 ? Math.min(retryInterval * 1000, 1000) : 400;
+        const statuses = firmwareStatuses(this.firmwareOutcome, retries, startDelay, stepDelay);
+        this.options.log("info", `Firmware update scheduled from ${location}`);
+        this.firmwareTimers = this.schedule(statuses, this.options.firmwareStatus);
+    }
+    clearAll() {
+        this.clearDiagnostics();
+        this.clearFirmware();
+    }
+    clearDiagnostics() {
+        this.clear(this.diagnosticsTimers);
+        this.diagnosticsTimers = [];
+    }
+    clearFirmware() {
+        this.clear(this.firmwareTimers);
+        this.firmwareTimers = [];
+    }
+    schedule(statuses, send) {
+        return statuses.map(({ status, delayMs }) => setTimeout(() => {
+            this.options.run(() => send(status));
+        }, delayMs));
+    }
+    clear(timers) {
+        for (const timer of timers) {
+            clearTimeout(timer);
+        }
+    }
+}
+function diagnosticsFileName(location) {
+    try {
+        const url = new URL(location);
+        const leaf = url.pathname.split("/").filter(Boolean).at(-1);
+        return leaf || "kirby-ocpp-diagnostics.log";
+    }
+    catch {
+        return "kirby-ocpp-diagnostics.log";
+    }
+}
+function diagnosticsStatuses(outcome, retries, startDelay, stepDelay) {
+    if (outcome === "uploadFailure") {
+        return retryingStatuses("Uploading", "UploadFailed", retries, startDelay, stepDelay);
+    }
+    return [
+        ...Array.from({ length: retries + 1 }, (_, index) => ({ status: "Uploading", delayMs: startDelay + stepDelay * index })),
+        { status: "Uploaded", delayMs: startDelay + stepDelay * (retries + 1) }
+    ];
+}
+function firmwareStatuses(outcome, retries, startDelay, stepDelay) {
+    if (outcome === "downloadFailure") {
+        return retryingStatuses("Downloading", "DownloadFailed", retries, startDelay, stepDelay);
+    }
+    if (outcome === "installationFailure") {
+        return [
+            { status: "Downloading", delayMs: startDelay },
+            { status: "Downloaded", delayMs: startDelay + stepDelay },
+            ...retryingStatuses("Installing", "InstallationFailed", retries, startDelay + stepDelay * 2, stepDelay)
+        ];
+    }
+    return [
+        { status: "Downloading", delayMs: startDelay },
+        { status: "Downloaded", delayMs: startDelay + stepDelay },
+        { status: "Installing", delayMs: startDelay + stepDelay * 2 },
+        { status: "Installed", delayMs: startDelay + stepDelay * 3 }
+    ];
+}
+function retryingStatuses(activeStatus, failureStatus, retries, startDelay, stepDelay) {
+    return [
+        ...Array.from({ length: retries + 1 }, (_, index) => ({ status: activeStatus, delayMs: startDelay + stepDelay * index })),
+        { status: failureStatus, delayMs: startDelay + stepDelay * (retries + 1) }
+    ];
+}
+function boundedRetries(value) {
+    return Number.isInteger(value) && value > 0 ? Math.min(value, 5) : 0;
+}

package/dist/station/meter-value-scheduler.d.ts

@@ -0,0 +1,21 @@
+export declare class MeterValueScheduler {
+    private readonly options;
+    private readonly periodicTimers;
+    private clockAlignedTimer?;
+    constructor(options: {
+        sampleIntervalSeconds: () => number;
+        clockAlignedIntervalSeconds: () => number;
+        isConnected: () => boolean;
+        activeConnectorIds: () => number[];
+        isPeriodicConnectorActive: (connectorId: number) => boolean;
+        sendPeriodic: (connectorId: number, deltaWh: number) => Promise<void>;
+        sendClockAligned: (connectorIds: number[], deltaWh: number) => Promise<void>;
+        runSafely: (task: () => Promise<void>) => void;
+    });
+    startPeriodic(connectorId: number): void;
+    stopPeriodic(connectorId: number): void;
+    stopAllPeriodic(): void;
+    reschedulePeriodic(connectorIds: number[]): void;
+    startClockAligned(): void;
+    stopClockAligned(): void;
+}

package/dist/station/meter-value-scheduler.js

@@ -0,0 +1,78 @@
+import { clockAlignedDelayMs, periodicMeterDeltaWh } from "./metering.js";
+export class MeterValueScheduler {
+    options;
+    periodicTimers = new Map();
+    clockAlignedTimer;
+    constructor(options) {
+        this.options = options;
+    }
+    startPeriodic(connectorId) {
+        this.stopPeriodic(connectorId);
+        const intervalSeconds = this.options.sampleIntervalSeconds();
+        if (intervalSeconds <= 0) {
+            return;
+        }
+        const timer = setInterval(() => {
+            this.options.runSafely(async () => {
+                if (!this.options.isConnected()) {
+                    return;
+                }
+                if (!this.options.isPeriodicConnectorActive(connectorId)) {
+                    this.stopPeriodic(connectorId);
+                    return;
+                }
+                await this.options.sendPeriodic(connectorId, periodicMeterDeltaWh(intervalSeconds));
+            });
+        }, intervalSeconds * 1000);
+        this.periodicTimers.set(connectorId, timer);
+    }
+    stopPeriodic(connectorId) {
+        const timer = this.periodicTimers.get(connectorId);
+        if (!timer) {
+            return;
+        }
+        clearInterval(timer);
+        this.periodicTimers.delete(connectorId);
+    }
+    stopAllPeriodic() {
+        for (const connectorId of [...this.periodicTimers.keys()]) {
+            this.stopPeriodic(connectorId);
+        }
+    }
+    reschedulePeriodic(connectorIds) {
+        for (const connectorId of connectorIds) {
+            if (this.options.isPeriodicConnectorActive(connectorId)) {
+                this.startPeriodic(connectorId);
+                continue;
+            }
+            this.stopPeriodic(connectorId);
+        }
+    }
+    startClockAligned() {
+        this.stopClockAligned();
+        const intervalSeconds = this.options.clockAlignedIntervalSeconds();
+        if (intervalSeconds <= 0 || !this.options.isConnected()) {
+            return;
+        }
+        this.clockAlignedTimer = setTimeout(() => {
+            this.clockAlignedTimer = undefined;
+            this.options.runSafely(async () => {
+                try {
+                    await this.options.sendClockAligned(this.options.activeConnectorIds(), periodicMeterDeltaWh(intervalSeconds));
+                }
+                finally {
+                    if (this.options.isConnected()) {
+                        this.startClockAligned();
+                    }
+                }
+            });
+        }, clockAlignedDelayMs(intervalSeconds));
+    }
+    stopClockAligned() {
+        if (!this.clockAlignedTimer) {
+            return;
+        }
+        clearTimeout(this.clockAlignedTimer);
+        this.clockAlignedTimer = undefined;
+    }
+}

package/dist/station/metering.d.ts

@@ -0,0 +1,15 @@
+import type { ConnectorStatus } from "../ocpp/types.js";
+export type MeterValueContext = "Sample.Clock" | "Sample.Periodic" | "Transaction.End";
+export type Measurand = "Energy.Active.Export.Register" | "Energy.Active.Import.Register" | "Energy.Reactive.Export.Register" | "Energy.Reactive.Import.Register" | "Energy.Active.Export.Interval" | "Energy.Active.Import.Interval" | "Energy.Reactive.Export.Interval" | "Energy.Reactive.Import.Interval" | "Power.Active.Export" | "Power.Active.Import" | "Power.Offered" | "Power.Reactive.Export" | "Power.Reactive.Import" | "Power.Factor" | "Current.Import" | "Current.Export" | "Current.Offered" | "Voltage" | "Frequency" | "Temperature" | "SoC" | "RPM";
+export type MeteringConfigurationKey = "MeterValuesAlignedData" | "MeterValuesSampledData" | "StopTxnAlignedData" | "StopTxnSampledData";
+export interface MeteringConnector {
+    status: ConnectorStatus;
+    meterWh: number;
+}
+export declare const DEFAULT_SAMPLED_DATA: Measurand[];
+export declare const MEASURANDS: Set<Measurand>;
+export declare function buildMeterValue(connector: MeteringConnector, context: MeterValueContext, measurands: Measurand[]): Record<string, unknown>;
+export declare function readConfiguredMeasurands(value: string | undefined): Measurand[];
+export declare function isValidSampledDataConfiguration(value: string): boolean;
+export declare function periodicMeterDeltaWh(intervalSeconds: number): number;
+export declare function clockAlignedDelayMs(intervalSeconds: number): number;

package/dist/station/metering.js

@@ -0,0 +1,138 @@
+export const DEFAULT_SAMPLED_DATA = [
+    "Energy.Active.Import.Register",
+    "Power.Active.Import",
+    "Current.Import",
+    "Voltage",
+    "Temperature",
+    "SoC"
+];
+export const MEASURANDS = new Set([
+    "Energy.Active.Export.Register",
+    "Energy.Active.Import.Register",
+    "Energy.Reactive.Export.Register",
+    "Energy.Reactive.Import.Register",
+    "Energy.Active.Export.Interval",
+    "Energy.Active.Import.Interval",
+    "Energy.Reactive.Export.Interval",
+    "Energy.Reactive.Import.Interval",
+    "Power.Active.Export",
+    "Power.Offered",
+    "Power.Active.Import",
+    "Power.Reactive.Export",
+    "Power.Reactive.Import",
+    "Power.Factor",
+    "Current.Import",
+    "Current.Export",
+    "Current.Offered",
+    "Voltage",
+    "Frequency",
+    "Temperature",
+    "SoC",
+    "RPM"
+]);
+export function buildMeterValue(connector, context, measurands) {
+    return {
+        timestamp: new Date().toISOString(),
+        sampledValue: measurands.map((measurand) => buildSampledValue(connector, context, measurand))
+    };
+}
+export function readConfiguredMeasurands(value) {
+    const measurands = (value ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .filter((item) => MEASURANDS.has(item));
+    return measurands.length > 0 ? measurands : DEFAULT_SAMPLED_DATA;
+}
+export function isValidSampledDataConfiguration(value) {
+    const items = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return items.length > 0 && items.every((item) => MEASURANDS.has(item));
+}
+export function periodicMeterDeltaWh(intervalSeconds) {
+    return Math.max(0, Math.round((7200 * intervalSeconds) / 3600));
+}
+export function clockAlignedDelayMs(intervalSeconds) {
+    const intervalMs = intervalSeconds * 1000;
+    const remainder = Date.now() % intervalMs;
+    return remainder === 0 ? intervalMs : intervalMs - remainder;
+}
+function buildSampledValue(connector, context, measurand) {
+    const sample = sampleForMeasurand(connector, measurand);
+    const sampledValue = {
+        value: sample.value,
+        context,
+        format: "Raw",
+        measurand
+    };
+    if (sample.location) {
+        sampledValue.location = sample.location;
+    }
+    if (sample.phase) {
+        sampledValue.phase = sample.phase;
+    }
+    if (sample.unit) {
+        sampledValue.unit = sample.unit;
+    }
+    return sampledValue;
+}
+function sampleForMeasurand(connector, measurand) {
+    const charging = connector.status === "Charging";
+    const cycle = Math.abs(Math.round(connector.meterWh / 120)) % 8;
+    const voltageV = charging ? 228 + (cycle % 6) : 230;
+    const activePowerW = charging ? 6800 + cycle * 90 : 0;
+    const currentA = charging ? activePowerW / voltageV : 0;
+    const temperatureC = charging ? 29 + cycle + Math.min(8, Math.floor(connector.meterWh / 3000)) : 25;
+    const soc = charging ? clampNumber(18 + Math.floor(connector.meterWh / 450), 18, 96) : 0;
+    switch (measurand) {
+        case "Energy.Active.Import.Register":
+            return { value: String(Math.round(connector.meterWh)), unit: "Wh", location: "Outlet" };
+        case "Energy.Active.Export.Register":
+            return { value: "0", unit: "Wh", location: "Outlet" };
+        case "Energy.Reactive.Import.Register":
+        case "Energy.Reactive.Export.Register":
+            return { value: "0", unit: "varh", location: "Outlet" };
+        case "Energy.Active.Import.Interval":
+            return { value: charging ? "120" : "0", unit: "Wh", location: "Outlet" };
+        case "Energy.Active.Export.Interval":
+            return { value: "0", unit: "Wh", location: "Outlet" };
+        case "Energy.Reactive.Import.Interval":
+        case "Energy.Reactive.Export.Interval":
+            return { value: "0", unit: "varh", location: "Outlet" };
+        case "Power.Active.Import":
+            return { value: String(activePowerW), unit: "W", location: "Outlet" };
+        case "Power.Active.Export":
+            return { value: "0", unit: "W", location: "Outlet" };
+        case "Power.Offered":
+            return { value: "7400", unit: "W", location: "Outlet" };
+        case "Power.Reactive.Import":
+        case "Power.Reactive.Export":
+            return { value: "0", unit: "var", location: "Outlet" };
+        case "Power.Factor":
+            return { value: charging ? "1" : "0", location: "Outlet" };
+        case "Current.Import":
+            return { value: formatDecimal(currentA, 1), unit: "A", location: "Outlet", phase: "L1" };
+        case "Current.Export":
+            return { value: "0", unit: "A", location: "Outlet", phase: "L1" };
+        case "Current.Offered":
+            return { value: "32", unit: "A", location: "Outlet", phase: "L1" };
+        case "Voltage":
+            return { value: String(voltageV), unit: "V", location: "Outlet", phase: "L1-N" };
+        case "Temperature":
+            return { value: String(temperatureC), unit: "Celsius", location: "Body" };
+        case "SoC":
+            return { value: String(soc), unit: "Percent", location: "EV" };
+        case "Frequency":
+            return { value: "50", location: "Outlet" };
+        case "RPM":
+            return { value: "0", location: "Body" };
+    }
+}
+function clampNumber(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function formatDecimal(value, digits) {
+    return value.toFixed(digits).replace(/\.0$/, "");
+}

package/dist/station/ocpp-message.d.ts

@@ -0,0 +1,2 @@
+import type { OcppMessage } from "../ocpp/types.js";
+export declare function describeOcppMessage(message: OcppMessage): string;

package/dist/station/ocpp-message.js

@@ -0,0 +1,9 @@
+export function describeOcppMessage(message) {
+    if (message[0] === 2) {
+        return `CALL ${message[2]} (${message[1]})`;
+    }
+    if (message[0] === 3) {
+        return `CALLRESULT (${message[1]})`;
+    }
+    return `CALLERROR ${message[2]} (${message[1]})`;
+}

package/dist/station/offline-transaction-sync.d.ts

@@ -0,0 +1,29 @@
+import type { CallResponse, ConnectorStatus, StopReason } from "../ocpp/types.js";
+import { type IdTagInfo } from "./authorization.js";
+import type { ChargingProfileRegistry } from "./charging-profile-registry.js";
+import type { ConnectorRegistry } from "./connector-registry.js";
+export interface OfflineTransactionSyncOptions {
+    connectors: ConnectorRegistry;
+    chargingProfiles: ChargingProfileRegistry;
+    send: (action: string, payload: Record<string, unknown>) => Promise<CallResponse>;
+    readIdTagInfo: (value: unknown) => IdTagInfo;
+    rememberAuthorization: (idTag: string, idTagInfo: IdTagInfo) => void;
+    save: () => void;
+    log: (level: "success" | "warn", message: string) => void;
+    statusNotification: (connectorId: number, status: ConnectorStatus) => Promise<void>;
+}
+export declare class OfflineTransactionSync {
+    private readonly options;
+    constructor(options: OfflineTransactionSyncOptions);
+    syncPendingTransactions(): Promise<void>;
+    private deliverPendingStartTransaction;
+    private deliverPendingStopTransaction;
+}
+export declare function localTransactionId(connectorId: number): number;
+export declare function pendingStopPayload(options: {
+    meterStop: number;
+    timestamp: string;
+    reason: StopReason;
+    idTag?: string;
+    transactionData: Record<string, unknown>[];
+}): Record<string, unknown>;

package/dist/station/offline-transaction-sync.js

@@ -0,0 +1,99 @@
+import { isAcceptedIdTagInfo } from "./authorization.js";
+import { readNumber } from "./payload.js";
+import { statusAfterStopTransaction } from "./transaction-rules.js";
+export class OfflineTransactionSync {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async syncPendingTransactions() {
+        for (const connector of this.options.connectors.all()) {
+            if (!connector.pendingStartTransaction) {
+                if (connector.pendingStopTransaction && connector.transactionId && connector.transactionId > 0) {
+                    await this.deliverPendingStopTransaction(connector.id);
+                }
+                continue;
+            }
+            await this.deliverPendingStartTransaction(connector.id);
+        }
+    }
+    async deliverPendingStartTransaction(connectorId) {
+        const connector = this.options.connectors.get(connectorId);
+        const pendingStart = connector.pendingStartTransaction;
+        if (!pendingStart) {
+            return;
+        }
+        const response = await this.options.send("StartTransaction", pendingStart);
+        const idTagInfo = this.options.readIdTagInfo(response.payload.idTagInfo);
+        this.options.rememberAuthorization(pendingStart.idTag, idTagInfo);
+        if (!isAcceptedIdTagInfo(idTagInfo)) {
+            this.options.log("warn", `Offline StartTransaction rejected during sync: ${idTagInfo.status} (${pendingStart.idTag})`);
+            this.options.connectors.patch(connectorId, {
+                transactionId: undefined,
+                transactionStartedAt: undefined,
+                pendingStartTransaction: undefined,
+                pendingStopTransaction: undefined,
+                stopTransactionAtWh: undefined,
+                status: connector.evConnected ? "Finishing" : connector.availability === "Inoperative" ? "Unavailable" : "Available"
+            });
+            this.options.save();
+            return;
+        }
+        const transactionId = readNumber(response.payload.transactionId, Date.now());
+        const oldTransactionId = connector.transactionId;
+        this.options.connectors.patch(connectorId, {
+            transactionId,
+            pendingStartTransaction: undefined
+        });
+        if (oldTransactionId && oldTransactionId !== transactionId) {
+            this.options.chargingProfiles.clearForTransaction(oldTransactionId);
+        }
+        this.options.save();
+        this.options.log("success", `Offline transaction on connector ${connectorId} synced as transaction ${transactionId}`);
+        if (this.options.connectors.get(connectorId).pendingStopTransaction) {
+            await this.deliverPendingStopTransaction(connectorId);
+        }
+    }
+    async deliverPendingStopTransaction(connectorId) {
+        const connector = this.options.connectors.get(connectorId);
+        if (!connector.pendingStopTransaction || !connector.transactionId) {
+            return;
+        }
+        const payload = {
+            ...connector.pendingStopTransaction,
+            transactionId: connector.transactionId
+        };
+        await this.options.send("StopTransaction", payload);
+        const { evConnected, status } = statusAfterStopTransaction(connector.pendingStopTransaction.reason, connector.evConnected, connector.availability);
+        const transactionId = connector.transactionId;
+        this.options.connectors.patch(connectorId, {
+            transactionId: undefined,
+            transactionStartedAt: undefined,
+            stopTransactionAtWh: undefined,
+            pendingStartTransaction: undefined,
+            pendingStopTransaction: undefined,
+            evConnected,
+            status
+        });
+        if (this.options.chargingProfiles.clearForTransaction(transactionId)) {
+            this.options.save();
+        }
+        this.options.save();
+        await this.options.statusNotification(connectorId, status);
+    }
+}
+export function localTransactionId(connectorId) {
+    return -Math.abs(Date.now() * 100 + connectorId);
+}
+export function pendingStopPayload(options) {
+    const payload = {
+        meterStop: options.meterStop,
+        timestamp: options.timestamp,
+        reason: options.reason,
+        transactionData: options.transactionData
+    };
+    if (options.idTag) {
+        payload.idTag = options.idTag;
+    }
+    return payload;
+}

package/dist/station/payload.d.ts

@@ -0,0 +1,4 @@
+export declare function readString(value: unknown, fallback: string): string;
+export declare function readOptionalString(value: unknown): string | undefined;
+export declare function readNumber(value: unknown, fallback: number): number;
+export declare function readObject(value: unknown): Record<string, unknown>;

package/dist/station/payload.js

@@ -0,0 +1,12 @@
+export function readString(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+export function readOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function readNumber(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+export function readObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}