@enyo-energy/energy-app-sdk 0.0.144 → 0.0.145

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

@@ -60,6 +60,25 @@ export interface EebusCevcClient extends EebusUseCaseClient {
      * heat pumps. Uses {@link EebusOhpcfIncentiveTable} verbatim.
      */
     publishIncentiveTable: (table: EebusOhpcfIncentiveTable) => Promise<void>;
+    /**
+     * Return the most recent time-series charging plan the SDK has
+     * observed on this peer, without dispatching a wire read.
+     * Synchronous and side-effect-free.
+     *
+     * Returns `undefined` until the first plan notify has landed, and
+     * will keep returning `undefined` on peers that do not implement
+     * `TimeSeries` until that client lands in `@enyo-energy/eebus`.
+     */
+    getLastTimeSeriesPlan: () => EebusCevcChargingPlan | undefined;
+    /**
+     * Return the most recent incentive table the SDK has observed on
+     * this peer, without dispatching a wire read. Synchronous and
+     * side-effect-free.
+     *
+     * Returns `undefined` until the first `incentiveTableData` notify
+     * has landed.
+     */
+    getLastIncentiveTable: () => EebusOhpcfIncentiveTable | undefined;
     /**
      * Subscribe to plan-state updates published by the EV (e.g. revised
      * plan after the EV revised its capacity estimate).

package/dist/cjs/packages/eebus/eebus-device-management.d.cts

@@ -1,4 +1,4 @@
-import { EebusConnectionStatusEnum, EebusDevice, EebusDiscoveredDevice } from '../../types/enyo-eebus.cjs';
+import { EebusConnectionStatusEnum, EebusDevice, EebusDiscoveredDevice, EebusPeerManufacturerData } from '../../types/enyo-eebus.cjs';
 /**
  * SHIP-level device lifecycle management for EEbus devices.
  *
@@ -62,6 +62,31 @@ export interface EebusDeviceManagement {
      * @returns The current connection status (Connected, Disconnected, or Connecting)
      */
     getConnectionStatus: (ski: string) => Promise<EebusConnectionStatusEnum>;
+    /**
+     * Read the cached `DeviceClassification.ManufacturerData` payload
+     * the peer published after the SHIP handshake — the compact
+     * identity record vendor packages need to gate vendor-specific
+     * behaviour (e.g. enabling partial LoadControl writes on Vaillant
+     * VR940 firmware).
+     *
+     * Synchronous on the wire — the lib auto-fetches the payload after
+     * connect and surfaces the cached value here. Returns:
+     * - the populated record once the peer has answered the post-handshake fetch
+     * - `null` when the peer is paired but has not answered the fetch yet
+     * - `undefined` when the SDK has no record of the peer (never paired or fully forgotten)
+     *
+     * The async wrapper is preserved for symmetry with the other
+     * `EebusDeviceManagement` methods; the result resolves immediately
+     * from the cached snapshot.
+     *
+     * Prefer this over reaching for {@link EebusIdentityService.get}
+     * when all you need is vendor sniffing — it avoids waking the full
+     * identity pipeline and keeps vendor matching at the consumer
+     * boundary.
+     *
+     * @param ski Subject Key Identifier of the remote node
+     */
+    getPeerManufacturerData: (ski: string) => Promise<EebusPeerManufacturerData | null | undefined>;
     /**
      * Register a listener for connection status changes of EEbus devices.
      * The listener is invoked whenever any paired device's connection status changes.

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

@@ -1,5 +1,5 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
-import { EebusEvCommunicationStandardEnum, EebusEvConnectionState, EebusEvIdentification } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusEvCommunicationStandardEnum, EebusEvConfigurationSnapshot, EebusEvConnectionState, EebusEvElectricalLimits, EebusEvIdentification } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
 import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
 /**
@@ -48,6 +48,58 @@ export interface EebusEvccClient extends EebusUseCaseClient {
      * Read whether the EV supports asymmetric (per-phase) charging.
      */
     getEvAsymmetricChargingSupport: () => Promise<boolean>;
+    /**
+     * Return the most recent EV identification (EVCCID + identification
+     * type) the SDK has observed on this peer, without dispatching a
+     * wire read. Synchronous and side-effect-free.
+     *
+     * Returns `undefined` until the first `identificationListData`
+     * notify has landed.
+     */
+    getLastEvIdentification: () => EebusEvIdentification | undefined;
+    /**
+     * Return the most recent `DeviceConfiguration.keyValueListData`
+     * snapshot the SDK has observed on this peer. Surfaces every
+     * configuration key the EV advertises with its current value;
+     * consumers that only need a specific key can use
+     * {@link getCommunicationStandard} or
+     * {@link supportsAsymmetricCharging} which already narrow the
+     * lookup.
+     *
+     * Returns `undefined` until the first notify has landed.
+     */
+    getLastEvConfiguration: () => EebusEvConfigurationSnapshot | undefined;
+    /**
+     * Return the most recent EV electrical permitted-value snapshot the
+     * SDK has observed on this peer — per-phase minimum / maximum
+     * current and total power the EV reports as allowable.
+     *
+     * Returns `undefined` until the first
+     * `permittedValueSetListData` notify has landed.
+     */
+    getLastEvElectricalLimits: () => EebusEvElectricalLimits | undefined;
+    /**
+     * Read the EV's negotiated communication standard from the cached
+     * configuration snapshot — `'IEC61851'`, `'ISO15118-2'`,
+     * `'ISO15118-20'`, etc. Synchronous; does not hit the wire.
+     *
+     * Distinct from {@link getEvCommunicationStandard} (async, returns
+     * the typed enum) — this getter returns the raw wire string for
+     * vendor-specific values the enum doesn't cover, and `undefined`
+     * when the key is not yet cached.
+     */
+    getCommunicationStandard: () => string | undefined;
+    /**
+     * Read whether the EV advertises asymmetric (per-phase) charging
+     * support from the cached configuration snapshot. Synchronous;
+     * does not hit the wire.
+     *
+     * Returns `undefined` when the key is not yet cached (handshake
+     * still in progress, or the EV does not publish the key at all).
+     * Callers that need a boolean-only answer should treat `undefined`
+     * as `false` only after {@link ready} reports the client is bound.
+     */
+    supportsAsymmetricCharging: () => boolean | undefined;
     /**
      * Subscribe to EV-connect events (vehicle plugged in).
      */

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

@@ -30,6 +30,14 @@ export interface EebusEvcemClient extends EebusUseCaseClient {
      * Read the most recent telemetry sample from the EV charging session.
      */
     getCurrentMeasurement: () => Promise<EebusEvcemReading>;
+    /**
+     * Return the most recent telemetry sample the SDK has observed on
+     * this peer, without dispatching a wire read. Synchronous and
+     * side-effect-free.
+     *
+     * Returns `undefined` until the first inbound notify has landed.
+     */
+    getLastMeasurement: () => EebusEvcemReading | undefined;
     /**
      * Subscribe to per-update telemetry samples.
      *

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

@@ -29,6 +29,16 @@ export interface EebusEvsocClient extends EebusUseCaseClient {
      * Read the most recent SoC sample, in percent (0–100).
      */
     getStateOfChargePercent: () => Promise<number>;
+    /**
+     * Return the most recent SoC sample the SDK has observed on this
+     * peer, without dispatching a wire read. Synchronous and
+     * side-effect-free.
+     *
+     * Returns `undefined` until the first SoC notify has landed — and
+     * may stay `undefined` indefinitely on vehicles that do not publish
+     * their SoC over EEBUS (see the class-level note).
+     */
+    getLastStateOfCharge: () => EebusEvSocReading | undefined;
     /**
      * Subscribe to SoC updates.
      *

package/dist/cjs/packages/eebus/eebus-feature-catalog.d.cts

@@ -1,5 +1,38 @@
 import { EebusFeatureRole, EebusRemoteFeatureCatalog } from '../../types/enyo-eebus-features.cjs';
 import { SpineEntityType, SpineFeatureType, SpineFunctionType } from '../../types/enyo-spine.cjs';
+/**
+ * Options for {@link EebusFeatureCatalog.findFeatureAddressForClient}.
+ *
+ * Mirrors the lib's priority-ordered resolver used internally by the
+ * typed use-case clients. Consumers that needed to reimplement this
+ * resolver (heat pumps that host the same feature type on several
+ * entities) can now call into the SDK instead.
+ */
+export interface EebusFindFeatureForClientOptions {
+    /** SPINE feature type to look up (e.g. `SpineFeatureType.LOAD_CONTROL`). */
+    featureType: SpineFeatureType;
+    /** SPINE role to match (`'server'` or `'client'`). */
+    role: EebusFeatureRole;
+    /**
+     * Entity types to prefer, in priority order. The resolver picks the
+     * first feature found whose host entity matches the earliest entry
+     * in this list. Mix {@link SpineEntityType} values with raw wire
+     * strings for vendor-specific entity types that pre-date the
+     * catalogue.
+     *
+     * Omit to skip preference-based matching and fall straight back to
+     * {@link fallbackToAny}.
+     */
+    preferredEntityTypes?: Array<SpineEntityType | string>;
+    /**
+     * When no entity in {@link preferredEntityTypes} hosts the feature,
+     * return the first match from any entity instead of resolving to
+     * `undefined`. Defaults to `true` — preserves the legacy
+     * "first-match-wins" behaviour. Set `false` to force a strict match
+     * on {@link preferredEntityTypes}.
+     */
+    fallbackToAny?: boolean;
+}
 /**
  * One match returned by {@link EebusFeatureCatalog.findFeatureAddresses}.
  *
@@ -137,6 +170,25 @@ export interface EebusFeatureCatalog {
      * @returns Every matching feature address on the peer, in catalog order
      */
     findFeatureAddresses: (ski: string, featureType: SpineFeatureType, role: EebusFeatureRole) => Promise<EebusFeatureAddressMatch[]>;
+    /**
+     * Resolve a single best-fit feature address for a typed client
+     * binding, applying the lib's priority-ordered resolver.
+     *
+     * Walks {@link findFeatureAddresses} and picks the first match that
+     * (a) sits on one of {@link EebusFindFeatureForClientOptions.preferredEntityTypes}
+     * in the supplied order, or (b) — when no preferred entity hosts the
+     * feature and {@link EebusFindFeatureForClientOptions.fallbackToAny}
+     * is `true` (the default) — the first match from any entity.
+     *
+     * Returns `undefined` when the peer is not connected, when no
+     * entity hosts a matching feature, or when
+     * `fallbackToAny: false` is set and no entity in the preferred
+     * list hosts one.
+     *
+     * @param ski Subject Key Identifier of the remote node
+     * @param opts Match parameters; see {@link EebusFindFeatureForClientOptions}
+     */
+    findFeatureAddressForClient: (ski: string, opts: EebusFindFeatureForClientOptions) => Promise<EebusFeatureAddressMatch | undefined>;
     /**
      * Remove a feature-catalog listener previously registered via
      * {@link onFeaturesChanged}.

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

@@ -1,7 +1,56 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
-import { EebusLpcAck, EebusLpcFailsafe, EebusLpcLimit, EebusLpcNack } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusLpcAck, EebusLpcFailsafe, EebusLpcLimit, EebusLpcLimitCategory, EebusLpcLimitDescriptor, EebusLpcLimitDirection, EebusLpcNack } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
 import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
+/**
+ * Options for {@link EebusLpcClient.findLimit} — used to disambiguate
+ * peers that advertise more than one LoadControl limit slot.
+ */
+export interface FindLpcLimitOptions {
+    /**
+     * Limit direction to match — `'consume'` for LPC obligations on a
+     * controllable load, `'produce'` for production limits on a
+     * battery / inverter.
+     */
+    direction: EebusLpcLimitDirection;
+    /**
+     * Optional limit category to match. Omit to accept either category
+     * (the resolver picks the first match it finds in description-list
+     * order). Pin when the peer advertises both an obligation and a
+     * recommendation in the same direction.
+     */
+    category?: EebusLpcLimitCategory;
+}
+/**
+ * Options for {@link EebusLpcClient.findPerPhaseLimitIds} — used by EMS
+ * code that needs to write per-phase limits (OPEV-style) over the
+ * LoadControl feature.
+ */
+export interface FindPerPhaseLimitIdsOptions {
+    /**
+     * Limit category to match — see
+     * {@link FindLpcLimitOptions.category}.
+     */
+    category: EebusLpcLimitCategory;
+}
+/**
+ * Options for {@link EebusLpcClient.setConsumptionLimit}.
+ */
+export interface SetConsumptionLimitOptions {
+    /**
+     * When `true`, write the limit as a partial
+     * `LoadControlLimitListData` payload (only the addressed limit slot,
+     * not the full list). Some non-conformant firmwares — notably
+     * Vaillant VR940 — reject the full-list write the spec mandates;
+     * partial writes are the only way to push a limit there.
+     *
+     * Default `false` — the spec-conformant full-list write. Consumers
+     * should gate `true` on
+     * {@link EebusDeviceManagement.getPeerManufacturerData} so the
+     * vendor sniff stays at the consumer boundary.
+     */
+    partial?: boolean;
+}
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.lpc}.
  *
@@ -69,9 +118,17 @@ export interface EebusLpcClient extends EebusUseCaseClient {
      * {@link onConsumptionLimitNack} to observe the CS's downstream
      * decision.
      *
+     * Pass `{ partial: true }` in {@link options} for peers that only
+     * accept partial `LoadControlLimitListData` writes — currently
+     * Vaillant VR940 firmware, which rejects the full-list write the
+     * SPINE spec mandates. Default is a bare full-list write; consumers
+     * should gate `partial: true` on
+     * {@link EebusDeviceManagement.getPeerManufacturerData}.
+     *
      * @param limit The consumption limit to apply
+     * @param options Optional write-style configuration
      */
-    setConsumptionLimit: (limit: EebusLpcLimit) => Promise<void>;
+    setConsumptionLimit: (limit: EebusLpcLimit, options?: SetConsumptionLimitOptions) => Promise<void>;
     /**
      * Configure the controllable system's failsafe limit — the value it
      * falls back to when the SHIP connection to this EMS drops. The
@@ -155,4 +212,31 @@ export interface EebusLpcClient extends EebusUseCaseClient {
      * @param listenerId The ID returned by the registration method
      */
     removeListener: (listenerId: string) => void;
+    /**
+     * Resolve the descriptor for a LoadControl limit slot on the peer,
+     * using the SDK's cached `loadControlLimitDescriptionListData`.
+     * Synchronous; does not hit the wire.
+     *
+     * Returns the matching descriptor, or `undefined` when no slot on
+     * the resolved entity satisfies the requested
+     * {@link FindLpcLimitOptions.direction} (and, when supplied,
+     * {@link FindLpcLimitOptions.category}). On peers that advertise
+     * several matching slots the resolver returns the first one in
+     * description-list order — consumers that need a different slot
+     * should use {@link EebusFeatureCatalog.findFeatureAddressForClient}
+     * + a per-slot enumeration.
+     */
+    findLimit: (opts: FindLpcLimitOptions) => EebusLpcLimitDescriptor | undefined;
+    /**
+     * Resolve the per-phase `limitId`s advertised by the peer for a
+     * given limit {@link FindPerPhaseLimitIdsOptions.category}, in
+     * phase order (L1, L2, L3). Used by EMS code that pushes per-phase
+     * current limits over LoadControl (the OPEV / OSCEV path on
+     * wallboxes that don't expose a dedicated OPEV feature).
+     *
+     * Returns `undefined` when the peer does not advertise per-phase
+     * slots for the requested category. Synchronous; does not hit the
+     * wire.
+     */
+    findPerPhaseLimitIds: (opts: FindPerPhaseLimitIdsOptions) => number[] | undefined;
 }

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

@@ -16,6 +16,16 @@ export interface EebusMgcpClient extends EebusUseCaseClient {
      * Read the latest telemetry from the grid connection point.
      */
     getReading: () => Promise<EebusMgcpReading>;
+    /**
+     * Return the most recent reading the SDK has observed on this peer
+     * without dispatching a wire read. Synchronous and side-effect-free.
+     *
+     * Returns `undefined` until the first inbound notify lands.
+     * Subsequent notifies update the snapshot — callers that only need
+     * to poll the latest value can drop their {@link onReading}
+     * subscription in favour of this getter.
+     */
+    getLastReading: () => EebusMgcpReading | undefined;
     /**
      * Subscribe to updates whenever the grid connection point publishes new telemetry.
      * @param listener Callback invoked with each new reading

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

@@ -1,7 +1,24 @@
 import { SpineRemoteTarget } from '../../types/enyo-eebus.cjs';
-import { EebusMpcReading } from '../../types/enyo-eebus-use-cases.cjs';
+import { EebusMpcMeasurementDescriptor, EebusMpcReading } from '../../types/enyo-eebus-use-cases.cjs';
 import { SpineEntityType } from '../../types/enyo-spine.cjs';
 import { EebusUseCaseClient } from './eebus-use-case-client.cjs';
+/**
+ * Options for {@link EebusMpcClient.findMeasurement} — disambiguates
+ * peers that advertise more than one measurement slot.
+ */
+export interface FindMpcMeasurementOptions {
+    /**
+     * SPINE scope-type wire string to match (e.g. `'acPowerTotal'`,
+     * `'acEnergyConsumed'`). Identifies *what* the slot represents.
+     */
+    scope: string;
+    /**
+     * Optional SPINE commodity-type wire string (e.g. `'electricity'`,
+     * `'heat'`). Pin when the peer advertises the same scope across
+     * commodities — uncommon outside multi-commodity heat-pump peers.
+     */
+    commodity?: string;
+}
 /**
  * Per-call configuration for {@link EebusUseCaseRegistry.mpc}.
  *
@@ -68,6 +85,18 @@ export interface EebusMpcClient extends EebusUseCaseClient {
      * Read the latest consumption telemetry from the controllable system.
      */
     getReading: () => Promise<EebusMpcReading>;
+    /**
+     * Return the most recent reading the SDK has observed on this peer
+     * without dispatching a wire read. Synchronous and side-effect-free.
+     *
+     * Returns `undefined` until the first `measurementListData` notify
+     * lands after attach (the SPINE binding is in progress, or the peer
+     * has not pushed any sample yet). Once populated, the snapshot
+     * tracks every subsequent notify — callers do not need to combine
+     * this with a manual {@link onReading} subscription unless they
+     * want push-style delivery.
+     */
+    getLastReading: () => EebusMpcReading | undefined;
     /**
      * Subscribe to updates whenever the controllable system publishes new telemetry.
      * @param listener Callback invoked with each new reading
@@ -85,4 +114,17 @@ export interface EebusMpcClient extends EebusUseCaseClient {
      * @param listenerId The ID returned by the registration method
      */
     removeListener: (listenerId: string) => void;
+    /**
+     * Resolve the descriptor for a Measurement slot on the peer, using
+     * the SDK's cached `measurementDescriptionListData`. Synchronous;
+     * does not hit the wire.
+     *
+     * Returns the matching descriptor, or `undefined` when no slot on
+     * the resolved entity satisfies the requested
+     * {@link FindMpcMeasurementOptions.scope} (and, when supplied,
+     * {@link FindMpcMeasurementOptions.commodity}). On peers that
+     * advertise several matching slots the resolver returns the first
+     * one in description-list order.
+     */
+    findMeasurement: (opts: FindMpcMeasurementOptions) => EebusMpcMeasurementDescriptor | undefined;
 }

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

@@ -1,26 +1,59 @@
+/**
+ * Why this peer is (or is not) ready to service calls on a typed use-case
+ * client. The shape mirrors the underlying lib's `ready(ski)` probe — the
+ * SDK simply surfaces what the lib already keeps cached.
+ *
+ * The {@link reason} strings are the canonical set the lib publishes; the
+ * type widens with `string` so a lib upgrade that adds a new variant does
+ * not break consumers that pattern-match on it.
+ */
+export interface EebusUseCaseReadiness {
+    /**
+     * `true` once the SHIP session is live, the peer advertises a
+     * compatible entity for this use case, and the SPINE binding +
+     * subscription have landed. `false` while any of those preconditions
+     * is outstanding.
+     */
+    ready: boolean;
+    /**
+     * Why the peer is not yet ready. Populated only when {@link ready}
+     * is `false`. The canonical values published by the lib are:
+     *
+     * - `'no connection for ski'` — no SHIP session for this peer.
+     * - `'peer advertises no compatible entity with scenarios for this use case'` —
+     *   the peer is connected but its `NodeManagement` view does not
+     *   include an entity that hosts the scenarios this use case needs.
+     * - `'peer session not yet bound/subscribed'` — the binding /
+     *   subscription is still in flight; usually transient (resolves
+     *   within a couple of seconds of the connection coming up).
+     */
+    reason?: 'no connection for ski' | 'peer advertises no compatible entity with scenarios for this use case' | 'peer session not yet bound/subscribed' | string;
+}
 /**
  * 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.
+ * The lib drives the SPINE binding + description-list reads automatically
+ * once a use-case client is created — consumers do not have to "warm it
+ * up" with a noop call any more. {@link ready} surfaces the lib's cached
+ * readiness state so a consumer can answer "is this peer ready for me to
+ * use this use case yet?" without firing any wire traffic.
+ *
+ * The probe is synchronous and side-effect-free: it neither triggers nor
+ * waits for the handshake. Call it from a render path, an event handler,
+ * or a polling loop without worrying about cost.
  */
 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`).
+     * Probe the lib's cached readiness state for this use-case client.
+     *
+     * Returns `{ ready: true }` once the peer is fully bound and
+     * subscribed. Returns `{ ready: false, reason }` while any
+     * precondition is outstanding — {@link EebusUseCaseReadiness.reason}
+     * carries the lib-published explanation so callers can distinguish
+     * "peer is offline" from "peer does not support this use case" from
+     * "binding is still in flight".
      *
-     * 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.
+     * Synchronous and side-effect-free. Safe to call from hot paths.
      */
-    ready: () => Promise<void>;
+    ready: () => EebusUseCaseReadiness;
 }

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

@@ -42,6 +42,17 @@ export interface EebusVabdClient extends EebusUseCaseClient {
      * Read the battery's nominal capacity in Watt-hours, if advertised.
      */
     getBatteryNominalCapacityWh: () => Promise<number | undefined>;
+    /**
+     * Return the most recent consolidated battery telemetry the SDK has
+     * observed on this peer, without dispatching a wire read.
+     * Synchronous and side-effect-free.
+     *
+     * Returns `undefined` until the first `measurementListData` notify
+     * has landed. Once populated, the snapshot tracks every subsequent
+     * notify — callers can drop their {@link onTelemetry} subscription
+     * if they only need to poll the latest value.
+     */
+    getLastTelemetry: () => EebusVabdTelemetry | undefined;
     /**
      * Subscribe to consolidated battery telemetry updates.
      */

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

@@ -36,6 +36,14 @@ export interface EebusVapdClient extends EebusUseCaseClient {
      * Read the PV system's nominal peak power in Watts, if advertised.
      */
     getPvNominalPeakPowerW: () => Promise<number | undefined>;
+    /**
+     * Return the most recent consolidated PV telemetry the SDK has
+     * observed on this peer, without dispatching a wire read.
+     * Synchronous and side-effect-free.
+     *
+     * Returns `undefined` until the first inbound notify has landed.
+     */
+    getLastTelemetry: () => EebusVapdTelemetry | undefined;
     /**
      * Subscribe to consolidated PV telemetry updates.
      */

package/dist/cjs/packages/eebus/energy-app-eebus.d.cts

@@ -4,16 +4,16 @@ import { EebusIdentityService } from './eebus-identity-service.cjs';
 import { EebusSpineLowLevel } from './eebus-spine-low-level.cjs';
 import { EebusUseCaseRegistry } from './eebus-use-case-registry.cjs';
 export { EebusDeviceManagement } from './eebus-device-management.cjs';
-export { EebusFeatureCatalog, EebusFeatureAddressMatch } from './eebus-feature-catalog.cjs';
+export { EebusFeatureCatalog, EebusFeatureAddressMatch, EebusFindFeatureForClientOptions, } from './eebus-feature-catalog.cjs';
 export { EebusIdentityService } from './eebus-identity-service.cjs';
 export { EebusSpineLowLevel } from './eebus-spine-low-level.cjs';
-export { EebusUseCaseClient } from './eebus-use-case-client.cjs';
+export { EebusUseCaseClient, EebusUseCaseReadiness } from './eebus-use-case-client.cjs';
 export { EebusUseCaseRegistry } from './eebus-use-case-registry.cjs';
 export { EebusHvacClient, HvacClientOptions } from './eebus-hvac-client.cjs';
-export { EebusLpcClient, LpcClientOptions } from './eebus-lpc-client.cjs';
+export { EebusLpcClient, LpcClientOptions, FindLpcLimitOptions, FindPerPhaseLimitIdsOptions, SetConsumptionLimitOptions, } from './eebus-lpc-client.cjs';
 export { EebusLppClient } from './eebus-lpp-client.cjs';
 export { EebusMgcpClient } from './eebus-mgcp-client.cjs';
-export { EebusMpcClient, MpcClientOptions } from './eebus-mpc-client.cjs';
+export { EebusMpcClient, MpcClientOptions, FindMpcMeasurementOptions } from './eebus-mpc-client.cjs';
 export { EebusOhpcfClient, OhpcfClientOptions } from './eebus-ohpcf-client.cjs';
 export { EebusSetpointClient, SetpointClientOptions } from './eebus-setpoint-client.cjs';
 export { EebusCevcClient, CevcClientOptions } from './eebus-cevc-client.cjs';

package/dist/cjs/types/enyo-battery-appliance.cjs

@@ -11,14 +11,28 @@ var EnyoBatteryStorageMode;
 })(EnyoBatteryStorageMode || (exports.EnyoBatteryStorageMode = EnyoBatteryStorageMode = {}));
 var EnyoBatteryFeature;
 (function (EnyoBatteryFeature) {
-    /** If the battery supports being charged from the grid */
+    /**
+     * If the battery supports being charged from the grid
+     */
     EnyoBatteryFeature["GridCharging"] = "grid-charging";
-    /** If the battery supports discharging into the grid */
+    /**
+     * If the battery supports discharging into the grid
+     */
     EnyoBatteryFeature["GridDischarging"] = "grid-discharging";
-    /** If the battery supports discharge power limitation */
+    /**
+     * If the battery supports discharge power limitation
+     * @deprecated
+     */
     EnyoBatteryFeature["DischargeLimitation"] = "discharge-limitation";
-    /** If the battery supports charge power limitation */
+    /**
+     * If the battery supports charge power limitation
+     * @deprecated
+     */
     EnyoBatteryFeature["ChargeLimitation"] = "charge-limitation";
     /** If the battery is connected between DC strings and the inverter */
     EnyoBatteryFeature["BetweenDcStringAndInverter"] = "between-dc-string-and-inverter";
+    /** If the battery supports manual charging */
+    EnyoBatteryFeature["ManualCharge"] = "manual-charge";
+    /** If the battery supports manual discharging */
+    EnyoBatteryFeature["ManualDischarge"] = "manual-discharge";
 })(EnyoBatteryFeature || (exports.EnyoBatteryFeature = EnyoBatteryFeature = {}));

package/dist/cjs/types/enyo-battery-appliance.d.cts

@@ -6,16 +6,30 @@ export declare enum EnyoBatteryStorageMode {
     Unknown = "unknown"
 }
 export declare enum EnyoBatteryFeature {
-    /** If the battery supports being charged from the grid */
+    /**
+     * If the battery supports being charged from the grid
+     */
     GridCharging = "grid-charging",
-    /** If the battery supports discharging into the grid */
+    /**
+     * If the battery supports discharging into the grid
+     */
     GridDischarging = "grid-discharging",
-    /** If the battery supports discharge power limitation */
+    /**
+     * If the battery supports discharge power limitation
+     * @deprecated
+     */
     DischargeLimitation = "discharge-limitation",
-    /** If the battery supports charge power limitation */
+    /**
+     * If the battery supports charge power limitation
+     * @deprecated
+     */
     ChargeLimitation = "charge-limitation",
     /** If the battery is connected between DC strings and the inverter */
-    BetweenDcStringAndInverter = "between-dc-string-and-inverter"
+    BetweenDcStringAndInverter = "between-dc-string-and-inverter",
+    /** If the battery supports manual charging */
+    ManualCharge = "manual-charge",
+    /** If the battery supports manual discharging */
+    ManualDischarge = "manual-discharge"
 }
 export interface EnyoBatteryApplianceMetadata {
     connectedToApplianceId?: string;