@totemsdk/act-ocpp 0.0.0-stage → 0.1.1

package/dist/cjs/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * RFC-024 — governed OCPP / EV charging profile.
+ *
+ * `@totemsdk/act-ocpp` authorizes and bounds a charging operation; the connector
+ * (`@totemsdk/edge-ocpp`) carries the wire frames and the charger/CSMS owns
+ * electrical protection and the control loop.
+ */
+export { OCPP_ACCEPTED, OcppTransportError, assertAccepted, } from './transport.js';
+export type { OcppChargingProfileRequest, OcppClearProfileRequest, OcppMeterQuery, OcppMeterValue, OcppReserveRequest, OcppResponse, OcppStartRequest, OcppStopRequest, OcppTransactionEvent, OcppTransactionEventType, OcppTransactionState, OcppTransportPort, } from './transport.js';
+export { OCPP_CORE_PROFILES, OCPP_VERSION_PREFERENCE, negotiateOcppCapabilities, supportsOcppProfile, } from './capabilities.js';
+export type { NegotiateOptions, OcppCapabilitySet, OcppProfileName, OcppVersion } from './capabilities.js';
+export { deriveChargingEffects } from './effects.js';
+export type { ChargingLimits } from './effects.js';
+export { meterEvidenceDigest, reconcileChargingSession } from './meter.js';
+export type { ChargingMeterEvidence, ChargingMeterQuery, ChargingReconcileResult, ChargingReconcileStatus, } from './meter.js';
+export { OCPP_PROTOCOL, chargingInterlocks, chargingResource, chargingResourceId, createOcppProfile, ocppErrorTaxonomy, } from './profile.js';
+export type { ChargingConnector, OcppProfileOptions } from './profile.js';
+export { createOcppDefinitions, errorCodeOf } from './adapter.js';
+export type { ChargingCommand, OcppAdapterOptions } from './adapter.js';

package/dist/cjs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * RFC-024 — governed OCPP / EV charging profile.
+ *
+ * `@totemsdk/act-ocpp` authorizes and bounds a charging operation; the connector
+ * (`@totemsdk/edge-ocpp`) carries the wire frames and the charger/CSMS owns
+ * electrical protection and the control loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorCodeOf = exports.createOcppDefinitions = exports.ocppErrorTaxonomy = exports.createOcppProfile = exports.chargingResourceId = exports.chargingResource = exports.chargingInterlocks = exports.OCPP_PROTOCOL = exports.reconcileChargingSession = exports.meterEvidenceDigest = exports.deriveChargingEffects = exports.supportsOcppProfile = exports.negotiateOcppCapabilities = exports.OCPP_VERSION_PREFERENCE = exports.OCPP_CORE_PROFILES = exports.assertAccepted = exports.OcppTransportError = exports.OCPP_ACCEPTED = void 0;
+var transport_js_1 = require("./transport.js");
+Object.defineProperty(exports, "OCPP_ACCEPTED", { enumerable: true, get: function () { return transport_js_1.OCPP_ACCEPTED; } });
+Object.defineProperty(exports, "OcppTransportError", { enumerable: true, get: function () { return transport_js_1.OcppTransportError; } });
+Object.defineProperty(exports, "assertAccepted", { enumerable: true, get: function () { return transport_js_1.assertAccepted; } });
+var capabilities_js_1 = require("./capabilities.js");
+Object.defineProperty(exports, "OCPP_CORE_PROFILES", { enumerable: true, get: function () { return capabilities_js_1.OCPP_CORE_PROFILES; } });
+Object.defineProperty(exports, "OCPP_VERSION_PREFERENCE", { enumerable: true, get: function () { return capabilities_js_1.OCPP_VERSION_PREFERENCE; } });
+Object.defineProperty(exports, "negotiateOcppCapabilities", { enumerable: true, get: function () { return capabilities_js_1.negotiateOcppCapabilities; } });
+Object.defineProperty(exports, "supportsOcppProfile", { enumerable: true, get: function () { return capabilities_js_1.supportsOcppProfile; } });
+var effects_js_1 = require("./effects.js");
+Object.defineProperty(exports, "deriveChargingEffects", { enumerable: true, get: function () { return effects_js_1.deriveChargingEffects; } });
+var meter_js_1 = require("./meter.js");
+Object.defineProperty(exports, "meterEvidenceDigest", { enumerable: true, get: function () { return meter_js_1.meterEvidenceDigest; } });
+Object.defineProperty(exports, "reconcileChargingSession", { enumerable: true, get: function () { return meter_js_1.reconcileChargingSession; } });
+var profile_js_1 = require("./profile.js");
+Object.defineProperty(exports, "OCPP_PROTOCOL", { enumerable: true, get: function () { return profile_js_1.OCPP_PROTOCOL; } });
+Object.defineProperty(exports, "chargingInterlocks", { enumerable: true, get: function () { return profile_js_1.chargingInterlocks; } });
+Object.defineProperty(exports, "chargingResource", { enumerable: true, get: function () { return profile_js_1.chargingResource; } });
+Object.defineProperty(exports, "chargingResourceId", { enumerable: true, get: function () { return profile_js_1.chargingResourceId; } });
+Object.defineProperty(exports, "createOcppProfile", { enumerable: true, get: function () { return profile_js_1.createOcppProfile; } });
+Object.defineProperty(exports, "ocppErrorTaxonomy", { enumerable: true, get: function () { return profile_js_1.ocppErrorTaxonomy; } });
+var adapter_js_1 = require("./adapter.js");
+Object.defineProperty(exports, "createOcppDefinitions", { enumerable: true, get: function () { return adapter_js_1.createOcppDefinitions; } });
+Object.defineProperty(exports, "errorCodeOf", { enumerable: true, get: function () { return adapter_js_1.errorCodeOf; } });

package/dist/cjs/meter.d.ts

@@ -0,0 +1,39 @@
+/**
+ * RFC-024 §5.7 — metering and settlement evidence.
+ *
+ * Meter values must come from the charger through the transport, never from the
+ * caller. The evidence digest is canonical so a settlement action can cite the
+ * charging operation id and prove which meter readings backed it.
+ */
+import type { OcppMeterValue, OcppTransportPort } from './transport.js';
+export interface ChargingMeterEvidence {
+    operationId: string;
+    connectorId: number;
+    transactionId: number;
+    /** Latest cumulative energy register, in Wh. */
+    energyWattHours: string;
+    readings: readonly OcppMeterValue[];
+    digest: string;
+}
+export interface ChargingMeterQuery {
+    operationId: string;
+    connectorId: number;
+    transactionId: number;
+}
+export type ChargingReconcileStatus = 'running' | 'confirmed' | 'unknown';
+export interface ChargingReconcileResult {
+    status: ChargingReconcileStatus;
+    energyWattHours?: string;
+    evidence?: ChargingMeterEvidence;
+    detail?: string;
+}
+export declare function meterEvidenceDigest(evidence: Omit<ChargingMeterEvidence, 'digest'>): string;
+/**
+ * Reconcile an accepted charging operation against the charger.
+ *
+ * - `confirmed` only when the charger reports the transaction ended (an energy
+ *   register alone is progress, not completion);
+ * - `running` while the transaction is active or meter values advance;
+ * - `unknown` when the charger cannot be read — the reservation must stay held.
+ */
+export declare function reconcileChargingSession(transport: OcppTransportPort, query: ChargingMeterQuery): Promise<ChargingReconcileResult>;

package/dist/cjs/meter.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * RFC-024 §5.7 — metering and settlement evidence.
+ *
+ * Meter values must come from the charger through the transport, never from the
+ * caller. The evidence digest is canonical so a settlement action can cite the
+ * charging operation id and prove which meter readings backed it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meterEvidenceDigest = meterEvidenceDigest;
+exports.reconcileChargingSession = reconcileChargingSession;
+const act_core_1 = require("@totemsdk/act-core");
+function meterEvidenceDigest(evidence) {
+    return (0, act_core_1.hashCanonical)('TOTEM_ACT_OCPP_METER_EVIDENCE_V1', {
+        operationId: evidence.operationId,
+        connectorId: evidence.connectorId,
+        transactionId: evidence.transactionId,
+        energyWattHours: evidence.energyWattHours,
+        readings: evidence.readings
+            .map((reading) => ({
+            transactionId: reading.transactionId,
+            connectorId: reading.connectorId,
+            timestamp: reading.timestamp,
+            energyWattHours: reading.energyWattHours,
+            measurand: reading.measurand ?? null,
+        }))
+            .sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)),
+    });
+}
+function latestReading(readings) {
+    return readings
+        .slice()
+        .sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp))
+        .at(-1);
+}
+/**
+ * Reconcile an accepted charging operation against the charger.
+ *
+ * - `confirmed` only when the charger reports the transaction ended (an energy
+ *   register alone is progress, not completion);
+ * - `running` while the transaction is active or meter values advance;
+ * - `unknown` when the charger cannot be read — the reservation must stay held.
+ */
+async function reconcileChargingSession(transport, query) {
+    const readings = await transport.readMeterValues({
+        connectorId: query.connectorId,
+        transactionId: query.transactionId,
+    });
+    const scoped = readings.filter((reading) => reading.transactionId === query.transactionId);
+    const latest = latestReading(scoped);
+    let state = { status: 'unknown' };
+    if (transport.readTransactionState) {
+        state = await transport.readTransactionState({
+            connectorId: query.connectorId,
+            transactionId: query.transactionId,
+        });
+    }
+    const energyWattHours = state.energyWattHours ?? latest?.energyWattHours;
+    if (state.status === 'ended' && energyWattHours !== undefined) {
+        const base = {
+            operationId: query.operationId,
+            connectorId: query.connectorId,
+            transactionId: query.transactionId,
+            energyWattHours,
+            readings: scoped,
+        };
+        return {
+            status: 'confirmed',
+            energyWattHours,
+            evidence: { ...base, digest: meterEvidenceDigest(base) },
+        };
+    }
+    if (state.status === 'active' || scoped.length > 0) {
+        return {
+            status: 'running',
+            ...(energyWattHours !== undefined ? { energyWattHours } : {}),
+            detail: state.status === 'active' ? 'transaction active' : 'meter values observed',
+        };
+    }
+    return { status: 'unknown', detail: 'no transaction state or meter readback' };
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/profile.d.ts

@@ -0,0 +1,40 @@
+/**
+ * RFC-024 §5.4 / §5.9 — OCPP charging profile.
+ *
+ * Connectors are resources; the safe state is `stop session` (never leave an
+ * active transaction). Interlocks enforce the connector's declared physical
+ * ceiling before authorization, and the error taxonomy classifies OCPP status
+ * codes so a safety error is never retried.
+ */
+import { type DeviceErrorTaxonomy, type IndustrialProfile, type Interlock, type Resource, type ResourceId } from '@totemsdk/act-core';
+import type { OcppCapabilitySet } from './capabilities.js';
+import { OCPP_CORE_PROFILES } from './capabilities.js';
+export declare const OCPP_PROTOCOL = "ocpp";
+export interface ChargingConnector {
+    connectorId: number;
+    /** Physical ceiling at this connector, in W (decimal string). */
+    maxPowerWatts: string;
+    /** Contract/session energy ceiling, in Wh. */
+    maxEnergyWattHours?: string;
+    /** Maximum session duration, in seconds. */
+    maxSessionSeconds?: string;
+    phases?: 1 | 3;
+    connectorType?: string;
+}
+export declare function chargingResourceId(site: string, connectorId: number, asset?: string): ResourceId;
+export declare function chargingResource(site: string, connector: ChargingConnector): Resource;
+/** Interlocks that enforce a connector's declared ceiling before authorization. */
+export declare function chargingInterlocks(site: string, connector: ChargingConnector): Interlock[];
+/**
+ * OCPP status → device error classification (RFC-011 §4.7).
+ * Safety codes require a safe state and are never retried.
+ */
+export declare function ocppErrorTaxonomy(): DeviceErrorTaxonomy;
+export interface OcppProfileOptions {
+    site: string;
+    connectors: readonly ChargingConnector[];
+    capabilities?: OcppCapabilitySet;
+}
+/** Data-only charger profile (definitions are supplied by the adapter). */
+export declare function createOcppProfile(options: OcppProfileOptions): IndustrialProfile;
+export { OCPP_CORE_PROFILES };

package/dist/cjs/profile.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * RFC-024 §5.4 / §5.9 — OCPP charging profile.
+ *
+ * Connectors are resources; the safe state is `stop session` (never leave an
+ * active transaction). Interlocks enforce the connector's declared physical
+ * ceiling before authorization, and the error taxonomy classifies OCPP status
+ * codes so a safety error is never retried.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCPP_CORE_PROFILES = exports.OCPP_PROTOCOL = void 0;
+exports.chargingResourceId = chargingResourceId;
+exports.chargingResource = chargingResource;
+exports.chargingInterlocks = chargingInterlocks;
+exports.ocppErrorTaxonomy = ocppErrorTaxonomy;
+exports.createOcppProfile = createOcppProfile;
+const act_core_1 = require("@totemsdk/act-core");
+const capabilities_js_1 = require("./capabilities.js");
+Object.defineProperty(exports, "OCPP_CORE_PROFILES", { enumerable: true, get: function () { return capabilities_js_1.OCPP_CORE_PROFILES; } });
+exports.OCPP_PROTOCOL = 'ocpp';
+function chargingResourceId(site, connectorId, asset = `EVSE-${connectorId}`) {
+    return { site, area: 'charging', asset, point: 'connector' };
+}
+function chargingResource(site, connector) {
+    const id = chargingResourceId(site, connector.connectorId);
+    return {
+        id,
+        kind: 'actuator',
+        addresses: [{ protocol: exports.OCPP_PROTOCOL, endpoint: `connector:${connector.connectorId}` }],
+        // Never leave an active transaction: the safe state stops the session.
+        safeState: {
+            resourceId: id,
+            command: { action: 'charging:stopSession', connectorId: connector.connectorId },
+        },
+        metadata: {
+            connectorId: connector.connectorId,
+            maxPowerWatts: connector.maxPowerWatts,
+            ...(connector.maxEnergyWattHours !== undefined
+                ? { maxEnergyWattHours: connector.maxEnergyWattHours }
+                : {}),
+            ...(connector.maxSessionSeconds !== undefined
+                ? { maxSessionSeconds: connector.maxSessionSeconds }
+                : {}),
+            ...(connector.phases !== undefined ? { phases: connector.phases } : {}),
+            ...(connector.connectorType !== undefined ? { connectorType: connector.connectorType } : {}),
+        },
+    };
+}
+function numeric(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value))) {
+        return Number(value);
+    }
+    if (value && typeof value === 'object' && 'value' in value) {
+        return numeric(value.value);
+    }
+    return undefined;
+}
+/** Interlocks that enforce a connector's declared ceiling before authorization. */
+function chargingInterlocks(site, connector) {
+    const id = chargingResourceId(site, connector.connectorId);
+    const safeState = {
+        resourceId: id,
+        command: { action: 'charging:stopSession', connectorId: connector.connectorId },
+    };
+    const interlocks = [
+        {
+            id: `ocpp:power-ceiling:${connector.connectorId}`,
+            kind: 'precondition',
+            resources: [id],
+            safeState,
+            evaluate({ parameters }) {
+                const requested = numeric(parameters.maxPowerWatts);
+                if (requested === undefined)
+                    return { satisfied: true };
+                const ceiling = Number(connector.maxPowerWatts);
+                return requested <= ceiling
+                    ? { satisfied: true }
+                    : { satisfied: false, reason: `requested ${requested} W exceeds connector ceiling ${ceiling} W` };
+            },
+        },
+    ];
+    if (connector.maxEnergyWattHours !== undefined) {
+        interlocks.push({
+            id: `ocpp:energy-ceiling:${connector.connectorId}`,
+            kind: 'precondition',
+            resources: [id],
+            safeState,
+            evaluate({ parameters }) {
+                const requested = numeric(parameters.maxEnergyWattHours);
+                if (requested === undefined)
+                    return { satisfied: true };
+                const ceiling = Number(connector.maxEnergyWattHours);
+                return requested <= ceiling
+                    ? { satisfied: true }
+                    : { satisfied: false, reason: `requested ${requested} Wh exceeds connector ceiling ${ceiling} Wh` };
+            },
+        });
+    }
+    if (connector.maxSessionSeconds !== undefined) {
+        interlocks.push({
+            id: `ocpp:duration-ceiling:${connector.connectorId}`,
+            kind: 'precondition',
+            resources: [id],
+            safeState,
+            evaluate({ parameters }) {
+                const requested = numeric(parameters.maxSessionSeconds);
+                if (requested === undefined)
+                    return { satisfied: true };
+                const ceiling = Number(connector.maxSessionSeconds);
+                return requested <= ceiling
+                    ? { satisfied: true }
+                    : { satisfied: false, reason: `requested ${requested} s exceeds connector ceiling ${ceiling} s` };
+            },
+        });
+    }
+    return interlocks;
+}
+/**
+ * OCPP status → device error classification (RFC-011 §4.7).
+ * Safety codes require a safe state and are never retried.
+ */
+function ocppErrorTaxonomy() {
+    const taxonomy = (0, act_core_1.createDeviceErrorTaxonomy)();
+    const classes = {
+        // Charger/connector protection — never retry.
+        ConnectorLockFailure: 'safety',
+        EVCommunicationError: 'safety',
+        GroundFailure: 'safety',
+        HighTemperature: 'safety',
+        InternalError: 'safety',
+        OverCurrentFailure: 'safety',
+        OverVoltage: 'safety',
+        PowerMeterFailure: 'safety',
+        PowerSwitchFailure: 'safety',
+        ResetFailure: 'safety',
+        UnderVoltage: 'safety',
+        Faulted: 'safety',
+        // Occupancy/state — retrying the same command cannot succeed.
+        Occupied: 'permanent',
+        Reserved: 'permanent',
+        Unavailable: 'permanent',
+        NotSupported: 'permanent',
+        Rejected: 'permanent',
+        Invalid: 'permanent',
+        // Link/availability — a retry with the same operation id is safe.
+        Offline: 'transient',
+        Timeout: 'transient',
+        WeakSignal: 'transient',
+        // Identity — never retry without a new authorization.
+        InvalidIdTag: 'auth',
+        UnknownIdTag: 'auth',
+        AuthorizationFailed: 'auth',
+    };
+    for (const [code, classification] of Object.entries(classes)) {
+        taxonomy.register(exports.OCPP_PROTOCOL, code, classification);
+    }
+    return taxonomy;
+}
+/** Data-only charger profile (definitions are supplied by the adapter). */
+function createOcppProfile(options) {
+    const resources = options.connectors.map((connector) => chargingResource(options.site, connector));
+    const interlocks = options.connectors.flatMap((connector) => chargingInterlocks(options.site, connector));
+    return {
+        id: 'ocpp',
+        version: 1,
+        resources,
+        interlocks,
+        errorTaxonomy: ocppErrorTaxonomy(),
+        capabilities: ['industrial:action', 'industrial:read', 'transport:ocpp'],
+        recipes: [],
+        definitions: [],
+    };
+}

package/dist/cjs/transport.d.ts

@@ -0,0 +1,104 @@
+/**
+ * RFC-024 §5.2 — OCPP transport port.
+ *
+ * The caller injects a transport that talks to a CSMS or a local charger stack.
+ * This package owns the governed operation semantics only: it never opens a
+ * socket and never implements an OCPP stack. A deployment can back the port
+ * with a CSMS client, a charger stack, or a simulator.
+ *
+ * Every operation is idempotent at the port boundary: the prepared command and
+ * the operation id are stable across retries (RFC-022 §5.1), so a transport may
+ * safely deduplicate a replayed request.
+ */
+export interface OcppResponse {
+    /** OCPP status (`Accepted`, `Rejected`, `Occupied`, `Faulted`, …). */
+    status?: string;
+    payload?: Record<string, unknown>;
+    errorCode?: string;
+    errorDescription?: string;
+}
+export interface OcppStartRequest {
+    connectorId: number;
+    idTag: string;
+    maxPowerWatts?: string;
+    maxEnergyWattHours?: string;
+    maxSessionSeconds?: string;
+}
+export interface OcppStopRequest {
+    connectorId: number;
+    transactionId: number;
+}
+export interface OcppChargingProfileRequest {
+    connectorId: number;
+    profileId: number;
+    maxPowerWatts: string;
+    maxEnergyWattHours?: string;
+    maxSessionSeconds?: string;
+}
+export interface OcppClearProfileRequest {
+    connectorId: number;
+    profileId?: number;
+}
+export interface OcppReserveRequest {
+    connectorId: number;
+    idTag: string;
+    reservationId: number;
+    expiresInSeconds: number;
+}
+export interface OcppMeterValue {
+    transactionId: number;
+    connectorId: number;
+    /** ISO-8601 timestamp from the charger. */
+    timestamp: string;
+    /** Cumulative energy register for the transaction, in Wh (decimal string). */
+    energyWattHours: string;
+    measurand?: string;
+}
+export type OcppTransactionEventType = 'Started' | 'Updated' | 'Ended';
+export interface OcppTransactionEvent {
+    transactionId: number;
+    connectorId: number;
+    eventType: OcppTransactionEventType;
+    timestamp: string;
+    energyWattHours?: string;
+}
+export interface OcppMeterQuery {
+    connectorId: number;
+    transactionId?: number;
+}
+export interface OcppTransactionState {
+    status: 'active' | 'ended' | 'unknown';
+    /** Final cumulative energy register, in Wh. */
+    energyWattHours?: string;
+    endedAt?: string;
+}
+/**
+ * Injected OCPP port. Implementations map these calls onto their CSMS/charger
+ * stack (RemoteStartTransaction, SetChargingProfile, ReserveNow, …).
+ */
+export interface OcppTransportPort {
+    remoteStartTransaction(request: OcppStartRequest): Promise<OcppResponse>;
+    remoteStopTransaction(request: OcppStopRequest): Promise<OcppResponse>;
+    /**
+     * Stop whatever session is active on a connector. Used as the connector's
+     * safe state, where the transaction id may not be known.
+     */
+    stopConnector?(connectorId: number): Promise<OcppResponse>;
+    setChargingProfile(request: OcppChargingProfileRequest): Promise<OcppResponse>;
+    clearChargingProfile(request: OcppClearProfileRequest): Promise<OcppResponse>;
+    reserveNow(request: OcppReserveRequest): Promise<OcppResponse>;
+    /** Readback path used for reconciliation; must originate from the charger. */
+    readMeterValues(query: OcppMeterQuery): Promise<OcppMeterValue[]>;
+    /** Charger/CSMS view of the transaction; required for definitive completion. */
+    readTransactionState?(query: OcppMeterQuery): Promise<OcppTransactionState>;
+    /** Optional push path for transaction events (Started/Updated/Ended). */
+    onTransactionEvent?(handler: (event: OcppTransactionEvent) => void): () => void;
+}
+/** Transport/OCPP rejection carrying the protocol code. */
+export declare class OcppTransportError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare const OCPP_ACCEPTED = "Accepted";
+/** Throw unless the response status is `Accepted`. */
+export declare function assertAccepted(response: OcppResponse, action: string): void;

package/dist/cjs/transport.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * RFC-024 §5.2 — OCPP transport port.
+ *
+ * The caller injects a transport that talks to a CSMS or a local charger stack.
+ * This package owns the governed operation semantics only: it never opens a
+ * socket and never implements an OCPP stack. A deployment can back the port
+ * with a CSMS client, a charger stack, or a simulator.
+ *
+ * Every operation is idempotent at the port boundary: the prepared command and
+ * the operation id are stable across retries (RFC-022 §5.1), so a transport may
+ * safely deduplicate a replayed request.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCPP_ACCEPTED = exports.OcppTransportError = void 0;
+exports.assertAccepted = assertAccepted;
+/** Transport/OCPP rejection carrying the protocol code. */
+class OcppTransportError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'OcppTransportError';
+        this.code = code;
+    }
+}
+exports.OcppTransportError = OcppTransportError;
+exports.OCPP_ACCEPTED = 'Accepted';
+/** Throw unless the response status is `Accepted`. */
+function assertAccepted(response, action) {
+    const status = response.status ?? exports.OCPP_ACCEPTED;
+    if (status !== exports.OCPP_ACCEPTED) {
+        throw new OcppTransportError(status, `${action} rejected with status '${status}'`);
+    }
+}

package/dist/effects.d.ts

@@ -0,0 +1,22 @@
+/**
+ * RFC-024 §5.5 — physical effects derived from the PREPARED charging command.
+ *
+ * These are the facts the authority layer commits to and RFC-023 enforces. They
+ * are computed from the prepared command only, never from caller-supplied
+ * hints, so a tampered or replayed command cannot widen the envelope.
+ */
+import type { StepEffects } from '@totemsdk/agent-policy';
+export interface ChargingLimits {
+    /** Target connector (ResourceId key). */
+    resource: string;
+    /** Instantaneous power ceiling implied by the command, in W. */
+    maxPowerWatts: string;
+    /** Total energy ceiling for the session/limit, in Wh. */
+    maxEnergyWattHours?: string;
+    /** Maximum wall-clock duration, in seconds. */
+    maxSessionSeconds?: string;
+    /** Charging profile id and schedule digest, when a profile is applied. */
+    profileId?: string;
+    profileDigest?: string;
+}
+export declare function deriveChargingEffects(limits: ChargingLimits): StepEffects;

package/dist/effects.js

@@ -0,0 +1,24 @@
+/**
+ * RFC-024 §5.5 — physical effects derived from the PREPARED charging command.
+ *
+ * These are the facts the authority layer commits to and RFC-023 enforces. They
+ * are computed from the prepared command only, never from caller-supplied
+ * hints, so a tampered or replayed command cannot widen the envelope.
+ */
+export function deriveChargingEffects(limits) {
+    const physical = {
+        power: [{ resource: limits.resource, watts: limits.maxPowerWatts }],
+    };
+    if (limits.maxEnergyWattHours !== undefined) {
+        physical.energy = [{ resource: limits.resource, wattHours: limits.maxEnergyWattHours }];
+    }
+    if (limits.maxSessionSeconds !== undefined) {
+        physical.duration = [{ resource: limits.resource, seconds: limits.maxSessionSeconds }];
+    }
+    if (limits.profileId !== undefined && limits.profileDigest !== undefined) {
+        physical.envelopes = [
+            { envelopeId: limits.profileId, envelopeDigest: limits.profileDigest },
+        ];
+    }
+    return { spends: [], physical };
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * RFC-024 — governed OCPP / EV charging profile.
+ *
+ * `@totemsdk/act-ocpp` authorizes and bounds a charging operation; the connector
+ * (`@totemsdk/edge-ocpp`) carries the wire frames and the charger/CSMS owns
+ * electrical protection and the control loop.
+ */
+export { OCPP_ACCEPTED, OcppTransportError, assertAccepted, } from './transport.js';
+export type { OcppChargingProfileRequest, OcppClearProfileRequest, OcppMeterQuery, OcppMeterValue, OcppReserveRequest, OcppResponse, OcppStartRequest, OcppStopRequest, OcppTransactionEvent, OcppTransactionEventType, OcppTransactionState, OcppTransportPort, } from './transport.js';
+export { OCPP_CORE_PROFILES, OCPP_VERSION_PREFERENCE, negotiateOcppCapabilities, supportsOcppProfile, } from './capabilities.js';
+export type { NegotiateOptions, OcppCapabilitySet, OcppProfileName, OcppVersion } from './capabilities.js';
+export { deriveChargingEffects } from './effects.js';
+export type { ChargingLimits } from './effects.js';
+export { meterEvidenceDigest, reconcileChargingSession } from './meter.js';
+export type { ChargingMeterEvidence, ChargingMeterQuery, ChargingReconcileResult, ChargingReconcileStatus, } from './meter.js';
+export { OCPP_PROTOCOL, chargingInterlocks, chargingResource, chargingResourceId, createOcppProfile, ocppErrorTaxonomy, } from './profile.js';
+export type { ChargingConnector, OcppProfileOptions } from './profile.js';
+export { createOcppDefinitions, errorCodeOf } from './adapter.js';
+export type { ChargingCommand, OcppAdapterOptions } from './adapter.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * RFC-024 — governed OCPP / EV charging profile.
+ *
+ * `@totemsdk/act-ocpp` authorizes and bounds a charging operation; the connector
+ * (`@totemsdk/edge-ocpp`) carries the wire frames and the charger/CSMS owns
+ * electrical protection and the control loop.
+ */
+export { OCPP_ACCEPTED, OcppTransportError, assertAccepted, } from './transport.js';
+export { OCPP_CORE_PROFILES, OCPP_VERSION_PREFERENCE, negotiateOcppCapabilities, supportsOcppProfile, } from './capabilities.js';
+export { deriveChargingEffects } from './effects.js';
+export { meterEvidenceDigest, reconcileChargingSession } from './meter.js';
+export { OCPP_PROTOCOL, chargingInterlocks, chargingResource, chargingResourceId, createOcppProfile, ocppErrorTaxonomy, } from './profile.js';
+export { createOcppDefinitions, errorCodeOf } from './adapter.js';

package/dist/meter.d.ts

@@ -0,0 +1,39 @@
+/**
+ * RFC-024 §5.7 — metering and settlement evidence.
+ *
+ * Meter values must come from the charger through the transport, never from the
+ * caller. The evidence digest is canonical so a settlement action can cite the
+ * charging operation id and prove which meter readings backed it.
+ */
+import type { OcppMeterValue, OcppTransportPort } from './transport.js';
+export interface ChargingMeterEvidence {
+    operationId: string;
+    connectorId: number;
+    transactionId: number;
+    /** Latest cumulative energy register, in Wh. */
+    energyWattHours: string;
+    readings: readonly OcppMeterValue[];
+    digest: string;
+}
+export interface ChargingMeterQuery {
+    operationId: string;
+    connectorId: number;
+    transactionId: number;
+}
+export type ChargingReconcileStatus = 'running' | 'confirmed' | 'unknown';
+export interface ChargingReconcileResult {
+    status: ChargingReconcileStatus;
+    energyWattHours?: string;
+    evidence?: ChargingMeterEvidence;
+    detail?: string;
+}
+export declare function meterEvidenceDigest(evidence: Omit<ChargingMeterEvidence, 'digest'>): string;
+/**
+ * Reconcile an accepted charging operation against the charger.
+ *
+ * - `confirmed` only when the charger reports the transaction ended (an energy
+ *   register alone is progress, not completion);
+ * - `running` while the transaction is active or meter values advance;
+ * - `unknown` when the charger cannot be read — the reservation must stay held.
+ */
+export declare function reconcileChargingSession(transport: OcppTransportPort, query: ChargingMeterQuery): Promise<ChargingReconcileResult>;