@enyo-energy/energy-app-sdk 0.0.140 → 0.0.142

package/dist/cjs/packages/eebus/eebus-cevc-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusCevcAck, EebusCevcChargingPlan, EebusOhpcfIncentiveTable } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.cevc}.
  */
@@ -28,12 +29,15 @@ export interface CevcClientOptions {
  * - **EV role:** {@link providePlan},
  *   {@link onTimeSeriesPlanReceived}.
  *
- * **Library status.** Methods throw
+ * Backed by `ElectricalConnection` (already present) +
+ * `IncentiveTable` (already present) + `TimeSeries` (pending) on the
+ * lib side. {@link publishIncentiveTable} is wired immediately; the
+ * `setTimeSeriesPlan` / `getActiveChargingPlan` / `onPlanUpdated` /
+ * `providePlan` / `onTimeSeriesPlanReceived` paths throw
  * {@link EebusFeatureUnavailableError} from the `connect-core` runtime
- * until `ElectricalConnectionClient` and `TimeSeriesClient` both land
- * in `@enyo-energy/eebus`.
+ * until `TimeSeriesClient` lands in `@enyo-energy/eebus`.
  */
-export interface EebusCevcClient {
+export interface EebusCevcClient extends EebusUseCaseClient {
     /**
      * Send a time-series charging plan to the EV. The EV ack carries
      * either acceptance or a reason for rejection (e.g. plan exceeds
@@ -54,10 +58,6 @@ export interface EebusCevcClient {
      * Publish an incentive table to the EV — the EV plans its own
      * charging from the price curve, analogous to the OHPCF flow on
      * heat pumps. Uses {@link EebusOhpcfIncentiveTable} verbatim.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     publishIncentiveTable: (table: EebusOhpcfIncentiveTable) => Promise<void>;
     /**

package/dist/cjs/packages/eebus/eebus-evcc-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusEvCommunicationStandardEnum, EebusEvConnectionState, EebusEvIdentification } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.evcc}.
  *
@@ -28,53 +29,31 @@ export interface EvccClientOptions {
  * UCs (CEVC needs ISO 15118, OPEV / OSCEV need at least asymmetric
  * support to be useful per-phase) are even relevant on this session.
  *
- * **Library status.** Every method on this client throws
- * {@link EebusFeatureUnavailableError} from the `connect-core` runtime
- * until `IdentificationClient` and `ElectricalConnectionClient` land in
- * `@enyo-energy/eebus`. The SDK interface is shipped now so consumers
- * can compile against the final shape.
+ * Backed by `Identification` + `ElectricalConnection` +
+ * `DeviceClassification` + `DeviceDiagnosis` on the lib side.
  */
-export interface EebusEvccClient {
+export interface EebusEvccClient extends EebusUseCaseClient {
     /**
      * Read the EV's identification (EVCCID and identification type).
      * Returns `undefined` when the EV does not publish an
      * `Identification` server feature.
-     *
-     * @throws {EebusFeatureUnavailableError} Until `IdentificationClient`
-     *          lands in `@enyo-energy/eebus`.
      */
     getEvIdentification: () => Promise<EebusEvIdentification | undefined>;
     /**
      * Read the communication standard negotiated between the EV and the
      * EVSE for the current session.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     getEvCommunicationStandard: () => Promise<EebusEvCommunicationStandardEnum>;
     /**
      * Read whether the EV supports asymmetric (per-phase) charging.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     getEvAsymmetricChargingSupport: () => Promise<boolean>;
     /**
      * Subscribe to EV-connect events (vehicle plugged in).
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onEvConnected: (handler: (state: EebusEvConnectionState) => void) => string;
     /**
      * Subscribe to EV-disconnect events (vehicle unplugged).
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onEvDisconnected: (handler: (state: EebusEvConnectionState) => void) => string;
     /**

package/dist/cjs/packages/eebus/eebus-evcem-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusEvcemReading } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.evcem}.
  */
@@ -22,17 +23,11 @@ export interface EvcemClientOptions {
  * started. Surfaces the same per-phase view as MGCP / MPC do for the
  * grid / appliance, but rooted on the EV entity.
  *
- * **Library status.** Methods throw
- * {@link EebusFeatureUnavailableError} from the `connect-core` runtime
- * until `ElectricalConnectionClient` lands in `@enyo-energy/eebus`.
+ * Backed by `Measurement` + `ElectricalConnection` on the lib side.
  */
-export interface EebusEvcemClient {
+export interface EebusEvcemClient extends EebusUseCaseClient {
     /**
      * Read the most recent telemetry sample from the EV charging session.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     getCurrentMeasurement: () => Promise<EebusEvcemReading>;
     /**
@@ -40,9 +35,6 @@ export interface EebusEvcemClient {
      *
      * @param handler Callback invoked with each new reading.
      * @returns Listener ID that can be passed to {@link removeListener}.
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onMeasurementUpdate: (handler: (reading: EebusEvcemReading) => void) => string;
     /**

package/dist/cjs/packages/eebus/eebus-evsecc-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusEvseManufacturerData, EebusEvseOperatingState } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.evsecc}.
  *
@@ -44,7 +45,7 @@ export interface EvseccClientOptions {
  * present in the EEBUS library, so this client is fully wired
  * immediately (no missing-library throws).
  */
-export interface EebusEvseccClient {
+export interface EebusEvseccClient extends EebusUseCaseClient {
     /**
      * Read the EVSE's `DeviceClassification.ManufacturerData` — vendor /
      * model identifiers and revisions.

package/dist/cjs/packages/eebus/eebus-evsoc-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusEvSocReading } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.evsoc}.
  */
@@ -21,17 +22,11 @@ export interface EvsocClientOptions {
  * arrives" case (e.g. by falling back to a vehicle-side service or by
  * estimating from charged energy + claimed battery capacity).
  *
- * **Library status.** Methods throw
- * {@link EebusFeatureUnavailableError} from the `connect-core` runtime
- * until `ElectricalConnectionClient` lands in `@enyo-energy/eebus`.
+ * Backed by `ElectricalConnection` + `Measurement` on the lib side.
  */
-export interface EebusEvsocClient {
+export interface EebusEvsocClient extends EebusUseCaseClient {
     /**
      * Read the most recent SoC sample, in percent (0–100).
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     getStateOfChargePercent: () => Promise<number>;
     /**
@@ -39,9 +34,6 @@ export interface EebusEvsocClient {
      *
      * @param handler Callback invoked with each new SoC reading.
      * @returns Listener ID that can be passed to {@link removeListener}.
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onStateOfChargeUpdated: (handler: (reading: EebusEvSocReading) => void) => string;
     /**

package/dist/cjs/packages/eebus/eebus-hvac-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusHvacOperationMode, EebusHvacZoneState } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.hvac}.
  *
@@ -53,7 +54,7 @@ export interface HvacClientOptions {
  * `EebusFeatureUnavailableError` is thrown only when no `Hvac` server
  * feature exists on the peer at all.
  */
-export interface EebusHvacClient {
+export interface EebusHvacClient extends EebusUseCaseClient {
     /**
      * Read the active heating/cooling operation mode from the remote node.
      */

package/dist/cjs/packages/eebus/eebus-lpc-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
-import { EebusLpcAck, EebusLpcFailsafe, EebusLpcLimit } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusLpcAck, EebusLpcFailsafe, EebusLpcLimit, EebusLpcNack } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.lpc}.
  *
@@ -38,21 +39,53 @@ export interface LpcClientOptions {
  * {@link EebusLppClient} which is a recommendation.
  *
  * The client exposes both actor roles on a single interface:
- * - **EMS role (outbound):** {@link setConsumptionLimit}, {@link getActiveConsumptionLimit},
- *   {@link getFailsafeLimit}
- * - **CS role (inbound):** {@link onConsumptionLimitReceived}, {@link provideFailsafeLimit}
+ * - **EMS role (outbound):** {@link setConsumptionLimit}, {@link setFailsafeLimit},
+ *   {@link getActiveConsumptionLimit}, {@link getFailsafeLimit}
+ * - **EMS role (inbound):** {@link onActiveConsumptionLimitChanged},
+ *   {@link onConsumptionLimitNack}, {@link onFailsafeChanged}
+ * - **CS role (inbound):** {@link onConsumptionLimitReceived},
+ *   {@link provideFailsafeLimit}
  *
  * Consumers that only act in one role simply never call the other half — there is
  * no `asManager` / `asAppliance` split.
+ *
+ * **Acknowledgement semantics.** {@link setConsumptionLimit} resolves once
+ * the SPINE write-ack lands — the CS has accepted the message into its
+ * queue. That is *not* the same as the CS having applied the limit; for
+ * the latter, subscribe to {@link onActiveConsumptionLimitChanged}.
+ * Explicit rejections (limit out of permitted set, failsafe override
+ * engaged, etc.) arrive via {@link onConsumptionLimitNack} so EMS code
+ * does not have to poll {@link getActiveConsumptionLimit} to detect them.
  */
-export interface EebusLpcClient {
+export interface EebusLpcClient extends EebusUseCaseClient {
     /**
      * Send a consumption limit to the controllable system. The remote is
      * obligated to respect the limit until it expires, is replaced, or is
      * cleared by sending a limit with `isActive: false`.
+     *
+     * Resolves on the SPINE write-ack. See the class-level note for the
+     * difference between "accepted" and "applied"; subscribe to
+     * {@link onActiveConsumptionLimitChanged} and
+     * {@link onConsumptionLimitNack} to observe the CS's downstream
+     * decision.
+     *
      * @param limit The consumption limit to apply
      */
     setConsumptionLimit: (limit: EebusLpcLimit) => Promise<void>;
+    /**
+     * Configure the controllable system's failsafe limit — the value it
+     * falls back to when the SHIP connection to this EMS drops. The
+     * canonical use case is §14a EnWG, where a grid-operator-acting
+     * EMS pushes a 4.2 kW (or jurisdictional equivalent) floor and a
+     * fall-back duration that survives transient disconnects.
+     *
+     * Resolves on the SPINE write-ack. To learn about subsequent
+     * CS-side revisions (e.g. the CS rounds the value to its nearest
+     * supported set-point), subscribe to {@link onFailsafeChanged}.
+     *
+     * @param failsafe The failsafe configuration to apply on the CS
+     */
+    setFailsafeLimit: (failsafe: EebusLpcFailsafe) => Promise<void>;
     /**
      * Read the consumption limit currently active on the controllable system,
      * if any. Useful for verifying that a previously-sent limit was applied,
@@ -65,6 +98,45 @@ export interface EebusLpcClient {
      * it loses the connection to this EMS.
      */
     getFailsafeLimit: () => Promise<EebusLpcFailsafe>;
+    /**
+     * Subscribe to changes in the *active* consumption limit reported by
+     * the CS — fires on every inbound `loadControlLimitListData` notify.
+     * The handler receives the new active limit, or `undefined` when the
+     * CS clears the active limit (e.g. on expiry).
+     *
+     * Use this instead of polling {@link getActiveConsumptionLimit} after
+     * a {@link setConsumptionLimit} call: the SPINE write-ack resolves
+     * before the CS publishes its updated active state, so the polling
+     * pattern races against the notify.
+     *
+     * @param handler Callback invoked with the new active limit (or `undefined`)
+     * @returns Listener ID that can be passed to {@link removeListener}
+     */
+    onActiveConsumptionLimitChanged: (handler: (limit: EebusLpcLimit | undefined) => void) => string;
+    /**
+     * Subscribe to explicit NACKs from the CS — fires when the CS
+     * rejects a previously-sent limit with a reason (e.g. value
+     * out-of-range, failsafe override active, command queue full).
+     * Distinct from the SPINE write-ack that {@link setConsumptionLimit}
+     * resolves on: a write-ack means "received", a NACK arrives as a
+     * separate event when the CS subsequently decides not to honour
+     * the limit.
+     *
+     * @param handler Callback invoked with the NACK payload
+     * @returns Listener ID that can be passed to {@link removeListener}
+     */
+    onConsumptionLimitNack: (handler: (nack: EebusLpcNack) => void) => string;
+    /**
+     * Subscribe to CS-published failsafe revisions — fires on every
+     * inbound `deviceConfigurationKeyValueListData` notify carrying
+     * a new failsafe value or duration. Allowed by the LPC UC TS as
+     * a mid-session signal; consumers that only read the failsafe at
+     * warm-up time will otherwise miss it.
+     *
+     * @param handler Callback invoked with the revised failsafe
+     * @returns Listener ID that can be passed to {@link removeListener}
+     */
+    onFailsafeChanged: (handler: (failsafe: EebusLpcFailsafe) => void) => string;
     /**
      * Register a handler invoked when a remote EMS sends a consumption limit
      * to this device. The handler MUST return an acknowledgement.

package/dist/cjs/packages/eebus/eebus-lpp-client.d.cts

@@ -1,4 +1,5 @@
-import { EebusLppAck, EebusLppFailsafe, EebusLppLimit } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusLppAck, EebusLppFailsafe, EebusLppLimit, EebusLppNack } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Client for the EEBUS **Limitation of Power Production (LPP)** use case.
  *
@@ -8,16 +9,46 @@ import { EebusLppAck, EebusLppFailsafe, EebusLppLimit } from '../../types/enyo-e
  * is an obligation.
  *
  * The client exposes both actor roles on a single interface:
- * - **EMS role (outbound):** {@link setProductionLimit}, {@link getActiveProductionLimit},
- *   {@link getFailsafeLimit}
- * - **CS role (inbound):** {@link onProductionLimitReceived}, {@link provideFailsafeLimit}
+ * - **EMS role (outbound):** {@link setProductionLimit}, {@link setFailsafeLimit},
+ *   {@link getActiveProductionLimit}, {@link getFailsafeLimit}
+ * - **EMS role (inbound):** {@link onActiveProductionLimitChanged},
+ *   {@link onProductionLimitNack}, {@link onFailsafeChanged}
+ * - **CS role (inbound):** {@link onProductionLimitReceived},
+ *   {@link provideFailsafeLimit}
+ *
+ * **Acknowledgement semantics.** {@link setProductionLimit} resolves once
+ * the SPINE write-ack lands — the CS has accepted the message into its
+ * queue. That is *not* the same as the CS having applied the
+ * recommendation; for the latter, subscribe to
+ * {@link onActiveProductionLimitChanged}. Because LPP is advisory, a
+ * producer is free to decline; explicit declines arrive via
+ * {@link onProductionLimitNack}.
  */
-export interface EebusLppClient {
+export interface EebusLppClient extends EebusUseCaseClient {
     /**
      * Send a production limit recommendation to the producing controllable system.
+     *
+     * Resolves on the SPINE write-ack. See the class-level note for the
+     * difference between "accepted" and "applied"; subscribe to
+     * {@link onActiveProductionLimitChanged} and
+     * {@link onProductionLimitNack} to observe the producer's downstream
+     * decision.
+     *
      * @param limit The production limit recommendation to apply
      */
     setProductionLimit: (limit: EebusLppLimit) => Promise<void>;
+    /**
+     * Configure the producing controllable system's failsafe limit — the
+     * value it falls back to when the SHIP connection to this EMS drops.
+     * Used to enforce a feed-in cap (e.g. 70 % of nameplate) that
+     * survives transient disconnects even when LPP itself is advisory.
+     *
+     * Resolves on the SPINE write-ack. To learn about subsequent
+     * CS-side revisions, subscribe to {@link onFailsafeChanged}.
+     *
+     * @param failsafe The failsafe configuration to apply on the producer
+     */
+    setFailsafeLimit: (failsafe: EebusLppFailsafe) => Promise<void>;
     /**
      * Read the production limit currently active on the controllable system,
      * if any.
@@ -29,6 +60,46 @@ export interface EebusLppClient {
      * it loses the connection to this EMS.
      */
     getFailsafeLimit: () => Promise<EebusLppFailsafe>;
+    /**
+     * Subscribe to changes in the *active* production limit reported by
+     * the producer — fires on every inbound `loadControlLimitListData`
+     * notify. The handler receives the new active limit, or `undefined`
+     * when the producer clears the active limit.
+     *
+     * Use this instead of polling {@link getActiveProductionLimit} after
+     * a {@link setProductionLimit} call: the SPINE write-ack resolves
+     * before the producer publishes its updated active state, so the
+     * polling pattern races against the notify.
+     *
+     * @param handler Callback invoked with the new active limit (or `undefined`)
+     * @returns Listener ID that can be passed to {@link removeListener}
+     */
+    onActiveProductionLimitChanged: (handler: (limit: EebusLppLimit | undefined) => void) => string;
+    /**
+     * Subscribe to explicit declines from the producer — fires when the
+     * producer rejects a previously-sent recommendation with a reason.
+     * LPP being advisory, a NACK does not breach the use case; it just
+     * tells the EMS that the producer chose not to honour the value
+     * (e.g. self-consumption priority is engaged on the inverter).
+     *
+     * Distinct from the SPINE write-ack that
+     * {@link setProductionLimit} resolves on.
+     *
+     * @param handler Callback invoked with the NACK payload
+     * @returns Listener ID that can be passed to {@link removeListener}
+     */
+    onProductionLimitNack: (handler: (nack: EebusLppNack) => void) => string;
+    /**
+     * Subscribe to producer-published failsafe revisions — fires on every
+     * inbound `deviceConfigurationKeyValueListData` notify carrying
+     * a new failsafe value or duration. Allowed by the LPP UC TS as a
+     * mid-session signal; consumers that only read the failsafe at
+     * warm-up time will otherwise miss it.
+     *
+     * @param handler Callback invoked with the revised failsafe
+     * @returns Listener ID that can be passed to {@link removeListener}
+     */
+    onFailsafeChanged: (handler: (failsafe: EebusLppFailsafe) => void) => string;
     /**
      * Register a handler invoked when a remote EMS sends a production limit
      * recommendation to this device.

package/dist/cjs/packages/eebus/eebus-mgcp-client.d.cts

@@ -1,4 +1,5 @@
 import { EebusMgcpReading } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Client for the EEBUS **Monitoring of Grid Connection Point (MGCP)** use case.
  *
@@ -10,7 +11,7 @@ import { EebusMgcpReading } from '../../types/enyo-eebus-use-cases.cjs';
  * - **CEM role (consume):** {@link getReading}, {@link onReading}
  * - **GCP role (provide):** {@link provideReading}
  */
-export interface EebusMgcpClient {
+export interface EebusMgcpClient extends EebusUseCaseClient {
     /**
      * Read the latest telemetry from the grid connection point.
      */

package/dist/cjs/packages/eebus/eebus-mpc-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusMpcReading } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.mpc}.
  *
@@ -62,7 +63,7 @@ export interface MpcClientOptions {
  * `EebusFeatureUnavailableError` when no `Measurement` server feature
  * exists at all on the peer.
  */
-export interface EebusMpcClient {
+export interface EebusMpcClient extends EebusUseCaseClient {
     /**
      * Read the latest consumption telemetry from the controllable system.
      */

package/dist/cjs/packages/eebus/eebus-ohpcf-client.d.cts

@@ -1,5 +1,6 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusOhpcfAnnouncement, EebusOhpcfApplianceContext, EebusOhpcfFlavour, EebusOhpcfFlexibility, EebusOhpcfIncentiveTable, EebusOhpcfPlanState } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.ohpcf}.
  *
@@ -59,7 +60,7 @@ export interface OhpcfClientOptions {
  * @see https://techdocs.wago.com/Software/EEBUS_Connector/en-US/3657311371.html
  * @see https://github.com/enbility/eebus-go/pull/122
  */
-export interface EebusOhpcfClient {
+export interface EebusOhpcfClient extends EebusUseCaseClient {
     /**
      * Send an incentive table to the heat pump. The heat pump will use
      * the table to plan its compressor operation over the covered horizon.

package/dist/cjs/packages/eebus/eebus-opev-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusOpevAck, EebusOpevLimit } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.opev}.
  */
@@ -29,46 +30,27 @@ export interface OpevClientOptions {
  *   {@link getActiveChargingLimits}.
  * - **EVSE role:** {@link onLimitReceived}, {@link onLimitNack}.
  *
- * **Library status.** Methods throw
- * {@link EebusFeatureUnavailableError} from the `connect-core` runtime
- * until `ElectricalConnectionClient` lands in `@enyo-energy/eebus`
- * (LoadControl itself is already present).
+ * Backed by `LoadControl` + `ElectricalConnection` on the lib side.
  */
-export interface EebusOpevClient {
+export interface EebusOpevClient extends EebusUseCaseClient {
     /**
      * Send a per-phase current limit to the EVSE. The EVSE MUST respect
      * the limit; ack is the EVSE's accept / reject decision.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     setChargingCurrentLimitsPerPhase: (limit: EebusOpevLimit) => Promise<EebusOpevAck>;
     /**
      * Read the per-phase current limits currently active on the EVSE,
      * if any.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     getActiveChargingLimits: () => Promise<EebusOpevLimit | undefined>;
     /**
      * Register a handler invoked when a remote EMS sends an OPEV limit
      * to this EVSE. The handler MUST return an ack.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onLimitReceived: (handler: (limit: EebusOpevLimit) => Promise<EebusOpevAck>) => string;
     /**
      * Subscribe to NACKs from the EVSE — fires when the EVSE rejects a
      * limit (e.g. unsupported phase count) so the EMS can renegotiate.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onLimitNack: (handler: (reason: string) => void) => string;
     /**

package/dist/cjs/packages/eebus/eebus-oscev-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusOscevAck, EebusOscevLimit } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.oscev}.
  */
@@ -18,45 +19,27 @@ export interface OscevClientOptions {
  * still draw more if the user has pressed "charge now"). Compare with
  * {@link EebusOpevClient}, which is the obligation flavour.
  *
- * **Library status.** Methods throw
- * {@link EebusFeatureUnavailableError} from the `connect-core` runtime
- * until `ElectricalConnectionClient` lands in `@enyo-energy/eebus`.
+ * Backed by `LoadControl` + `ElectricalConnection` on the lib side.
  */
-export interface EebusOscevClient {
+export interface EebusOscevClient extends EebusUseCaseClient {
     /**
      * Send a per-phase current recommendation to the EVSE.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     setSelfConsumptionLimit: (limit: EebusOscevLimit) => Promise<EebusOscevAck>;
     /**
      * Read the self-consumption recommendation currently active on the
      * EVSE, if any.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     getCurrentSelfConsumptionLimit: () => Promise<EebusOscevLimit | undefined>;
     /**
      * Subscribe to limit-adjustment notifications from the EVSE — fires
      * when the EVSE chose to draw less than the recommendation (so the
      * EMS can update its forecast).
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onLimitAdjusted: (handler: (limit: EebusOscevLimit) => void) => string;
     /**
      * Register a handler invoked when a remote EMS sends an OSCEV
      * recommendation to this EVSE.
-     *
-     * @throws {EebusFeatureUnavailableError} Until
-     *          `ElectricalConnectionClient` lands in
-     *          `@enyo-energy/eebus`.
      */
     onLimitReceived: (handler: (limit: EebusOscevLimit) => Promise<EebusOscevAck>) => string;
     /**

package/dist/cjs/packages/eebus/eebus-setpoint-client.d.cts

@@ -1,6 +1,7 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
 import { EebusSetpointValue } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
+import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.setpoint}.
  *
@@ -54,7 +55,7 @@ export interface SetpointClientOptions {
  * supported. `EebusFeatureUnavailableError` is thrown only when no
  * `Setpoint` server feature exists on the peer at all.
  */
-export interface EebusSetpointClient {
+export interface EebusSetpointClient extends EebusUseCaseClient {
     /**
      * Read the current setpoints reported by the remote node.
      * @returns The full list of setpoints currently published by the remote.

package/dist/cjs/packages/eebus/eebus-use-case-client.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/eebus/eebus-use-case-client.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Common shape inherited by every typed EEBUS use-case client.
+ *
+ * Adding a shared base avoids each client growing its own warm-up
+ * vocabulary. Today vendor packages trigger the lazy SPINE handshake
+ * by issuing a fake call (e.g. `onReading(noop)` on
+ * {@link EebusMpcClient}) just to make the description-list reads
+ * happen. {@link ready} replaces that ritual with an explicit hook.
+ */
+export interface EebusUseCaseClient {
+    /**
+     * Drive the SPINE binding + description-list reads for this
+     * use-case client to completion without dispatching any real
+     * read, write, or subscription. Resolves once the handshake has
+     * landed (or rejects with an {@link EebusFeatureUnavailableError}
+     * / {@link EebusFeatureNotResolvedError} /
+     * {@link EebusRequestTimeoutError} if the peer cannot satisfy it
+     * within the client's configured `descriptionReadTimeoutMs`).
+     *
+     * Idempotent: subsequent calls resolve as soon as the handshake
+     * has succeeded once. Safe to call from package start-up to
+     * surface "peer is not ready" early instead of letting the first
+     * real call fail later.
+     */
+    ready: () => Promise<void>;
+}