@apocaliss92/nodedreame 1.9.0 → 1.11.0

package/dist/index.d.cts

@@ -1591,6 +1591,22 @@ declare class VacuumDevice extends BaseDevice<VacuumDeviceEvents> {
      * `applyVacuumPFrame` merge primitive ships separately for that work.
      */
     getMap(input: VacuumGetMapInput): Promise<VacuumMap>;
+    /** Drop the P-frame merge base so the next I-frame re-seeds the stream. */
+    resetMapStream(): void;
+    /**
+     * Fetch the latest advertised map frame and fold it into a continuously
+     * updating map. An I-frame (re)seeds the merge base and renders standalone; a
+     * P-frame is merged onto the base via {@link applyVacuumPFrame} so the live
+     * grid stays COMPLETE (a P-frame decoded standalone is only byte-deltas). On an
+     * out-of-order P-frame or a map-id change the base is dropped and `null`
+     * returned — the next I-frame re-seeds. Returns `null` when no frame is
+     * advertised yet, or a P-frame arrives before any I-frame.
+     *
+     * Caches {@link lastMap} and emits `'map'` exactly like {@link getMap}, so a
+     * map-watching consumer (e.g. the camstack map child) gets a fresh complete
+     * frame on every push during a live clean.
+     */
+    fetchLatestMapStreaming(opts?: Omit<VacuumGetMapInput, 'filename'>): Promise<VacuumMap | null>;
     /** Props worth seeding on start() / polling — exported for the facade. */
     static readonly DEFAULT_PROPS: readonly [{
         readonly siid: 2;
@@ -1809,6 +1825,30 @@ interface MowerControlState {
     statusCode: number | null;
     zones: number[][];
 }
+/** Canonical CMS consumable counter keys (blade, brush, robot maintenance). */
+type MowerConsumableKey = 'blade' | 'brush' | 'maintenance';
+/** One CMS consumable counter: minutes used + total + remaining %. */
+interface MowerConsumableReading {
+    readonly key: MowerConsumableKey;
+    /** Minutes of run-time accrued on this counter (counts UP). */
+    readonly usedMinutes: number;
+    /** Counter's full-life duration in minutes. */
+    readonly totalMinutes: number;
+    /** Remaining life percentage (0..100, one decimal). */
+    readonly remainingPercent: number;
+}
+/** Map a consumable key (incl. aliases) to its CMS counter index. */
+declare function mowerConsumableIndex(item: string): number | null;
+/**
+ * Extract the raw `[blade, brush, robot]` minute counters from a CMS getter
+ * result, or null if the response is malformed. Cast-free, no throw.
+ */
+declare function extractMowerConsumableValues(result: unknown): number[] | null;
+/**
+ * Parse a CMS getter result into typed consumable readings (blade/brush/
+ * maintenance) with remaining %. Returns null on a malformed response.
+ */
+declare function parseMowerConsumables(result: unknown): readonly MowerConsumableReading[] | null;
 
 /**
  * Per-model mower capability records + a resolver adapting the rich record into
@@ -2047,6 +2087,27 @@ declare class MowerDevice extends BaseDevice {
     startMowingEdges(contourIds: number[][]): Promise<unknown>;
     /** Spot mowing (2:50 o:103). */
     startMowingSpots(spotAreaIds: number[]): Promise<unknown>;
+    /**
+     * Read the raw CMS consumable counters `[blade, brush, robot]` (minutes used),
+     * via the SCHEDULING_TASK (2:50) custom-action getter `{m:'g',t:'CMS'}`. This
+     * is a LIVE device action (it wakes the mower); rejects with
+     * {@link DreameDeviceOfflineError} when the mower is unreachable. Returns null
+     * if the response is malformed.
+     */
+    getConsumableValues(): Promise<readonly number[] | null>;
+    /**
+     * Read the CMS consumables as typed readings (blade/brush/maintenance) with
+     * remaining %. LIVE action — see {@link getConsumableValues}. Returns null on
+     * a malformed response.
+     */
+    getConsumables(): Promise<readonly MowerConsumableReading[] | null>;
+    /**
+     * Reset one CMS consumable counter to zero. Reads the current counters, zeroes
+     * the selected one (leaving the others), and writes them back via the
+     * `{m:'s',t:'CMS',d:{value:[…]}}` setter. LIVE action. Throws on an unknown
+     * item or when the current counters cannot be read.
+     */
+    resetConsumable(item: MowerConsumableKey): Promise<void>;
     /**
      * Seed the cache from the CLOUD SHADOW (last-known values) WITHOUT waking the
      * mower — reads {@link MowerDevice.DEFAULT_PROPS} from the cloud-cached
@@ -2432,4 +2493,4 @@ declare function createDumper(target: DumperDevice, options?: DumperOptions): Du
  */
 declare function createClientDumper(client: Nodreame, options?: DumperOptions): Dumper[];
 
-export { AI_FEATURE_BIT, AI_FEATURE_JSON_KEY, AUTO_SWITCH_JSON_KEY, type AiDetectionRaw, type AutoSwitchKey, type AutoSwitchRaw, BaseDevice, type BaseDeviceEvents, type BatchDeviceDataFetcher, type CapabilityResolver, ChargingStatus, type CleanOpts, CleaningMode, type ConsumableReading, type ConsumableSpec, type CreateDeviceArgs, DefaultCapabilityResolver, type DeviceCapabilities, type DeviceDump, type DeviceEvent, type DreameAiFeature, DreameApiError, DreameAuthError, type DreameCloudState, type DreameConsumableKey, type DreameDevice, DreameDeviceOfflineError, DreameError, type DreameRegion, type DreameSession, DreameTransportError, type DumperOptions, LIBRARY_NAME, MODEL_CAPABILITIES as MOWER_MODEL_CAPABILITIES, type MapBoundingBox, type MapCleanedAreaOverlay, type MapColorScheme, type MapDimensions, type MapFrameType, type MapLayer, type MapLayerType, type MapLowLyingArea, type MapObstacle, type MapPath, type MapPathType, type MapPoint, type MapPose, type MapRestrictedArea, type MapRoom, type MapRoomWall, type MapRun, type MapSegment, type MapStorey, type MapVirtualWall, type MapWallsInfo, type MiotAction, MiotError, type MiotProp, MiotState, type MowerAvailableMap, type MowerCapabilities, MowerCapabilityResolver, MowerChargingStatus, type MowerContour, MowerControlAction, type MowerControlState, MowerDevice, type MowerDeviceInput, MowerFault, type MowerMap, type MowerMapBoundary, type MowerMowPath, type MowerPathEntry, type MowerPoint, type MowerSpotArea, MowerStatus, type MowerTaskDescriptor, MowerTaskStatus, type MowerZone, Nodreame, type NodreameDeps, type NodreameEvents, type NodreameOptions, type OssFetchInput, type OssFetcherLike, type PropertyChangedEvent, type PropertyResult, type PropertyState, type PropertyWrite, type RenderMowerSvgOptions, type RenderVacuumPngOptions, type StateChangedEvent, SuctionLevel, TaskStatus, VACUUM_CONSUMABLES, MODEL_CAPABILITIES$1 as VACUUM_MODEL_CAPABILITIES, type VacuumCapabilities, VacuumCapabilityResolver, VacuumDevice, type VacuumGetMapInput, type VacuumMap, WaterVolume, consumableSpec, createClientDumper, createDumper, decodeAiFeature, decodeAutoSwitch, decodeAutoSwitchAll, encodeAiFeatureWrite, encodeAutoSwitchWrite, getMowerCapabilities, getVacuumCapabilities, isDreameConsumableKey, renderMowerSvg, renderVacuumPng, resolveCapabilities, supportedAutoSwitchKeys };
+export { AI_FEATURE_BIT, AI_FEATURE_JSON_KEY, AUTO_SWITCH_JSON_KEY, type AiDetectionRaw, type AutoSwitchKey, type AutoSwitchRaw, BaseDevice, type BaseDeviceEvents, type BatchDeviceDataFetcher, type CapabilityResolver, ChargingStatus, type CleanOpts, CleaningMode, type ConsumableReading, type ConsumableSpec, type CreateDeviceArgs, DefaultCapabilityResolver, type DeviceCapabilities, type DeviceDump, type DeviceEvent, type DreameAiFeature, DreameApiError, DreameAuthError, type DreameCloudState, type DreameConsumableKey, type DreameDevice, DreameDeviceOfflineError, DreameError, type DreameRegion, type DreameSession, DreameTransportError, type DumperOptions, LIBRARY_NAME, MODEL_CAPABILITIES as MOWER_MODEL_CAPABILITIES, type MapBoundingBox, type MapCleanedAreaOverlay, type MapColorScheme, type MapDimensions, type MapFrameType, type MapLayer, type MapLayerType, type MapLowLyingArea, type MapObstacle, type MapPath, type MapPathType, type MapPoint, type MapPose, type MapRestrictedArea, type MapRoom, type MapRoomWall, type MapRun, type MapSegment, type MapStorey, type MapVirtualWall, type MapWallsInfo, type MiotAction, MiotError, type MiotProp, MiotState, type MowerAvailableMap, type MowerCapabilities, MowerCapabilityResolver, MowerChargingStatus, type MowerConsumableKey, type MowerConsumableReading, type MowerContour, MowerControlAction, type MowerControlState, MowerDevice, type MowerDeviceInput, MowerFault, type MowerMap, type MowerMapBoundary, type MowerMowPath, type MowerPathEntry, type MowerPoint, type MowerSpotArea, MowerStatus, type MowerTaskDescriptor, MowerTaskStatus, type MowerZone, Nodreame, type NodreameDeps, type NodreameEvents, type NodreameOptions, type OssFetchInput, type OssFetcherLike, type PropertyChangedEvent, type PropertyResult, type PropertyState, type PropertyWrite, type RenderMowerSvgOptions, type RenderVacuumPngOptions, type StateChangedEvent, SuctionLevel, TaskStatus, VACUUM_CONSUMABLES, MODEL_CAPABILITIES$1 as VACUUM_MODEL_CAPABILITIES, type VacuumCapabilities, VacuumCapabilityResolver, VacuumDevice, type VacuumGetMapInput, type VacuumMap, WaterVolume, consumableSpec, createClientDumper, createDumper, decodeAiFeature, decodeAutoSwitch, decodeAutoSwitchAll, encodeAiFeatureWrite, encodeAutoSwitchWrite, extractMowerConsumableValues, getMowerCapabilities, getVacuumCapabilities, isDreameConsumableKey, mowerConsumableIndex, parseMowerConsumables, renderMowerSvg, renderVacuumPng, resolveCapabilities, supportedAutoSwitchKeys };

package/dist/index.d.ts

@@ -1591,6 +1591,22 @@ declare class VacuumDevice extends BaseDevice<VacuumDeviceEvents> {
      * `applyVacuumPFrame` merge primitive ships separately for that work.
      */
     getMap(input: VacuumGetMapInput): Promise<VacuumMap>;
+    /** Drop the P-frame merge base so the next I-frame re-seeds the stream. */
+    resetMapStream(): void;
+    /**
+     * Fetch the latest advertised map frame and fold it into a continuously
+     * updating map. An I-frame (re)seeds the merge base and renders standalone; a
+     * P-frame is merged onto the base via {@link applyVacuumPFrame} so the live
+     * grid stays COMPLETE (a P-frame decoded standalone is only byte-deltas). On an
+     * out-of-order P-frame or a map-id change the base is dropped and `null`
+     * returned — the next I-frame re-seeds. Returns `null` when no frame is
+     * advertised yet, or a P-frame arrives before any I-frame.
+     *
+     * Caches {@link lastMap} and emits `'map'` exactly like {@link getMap}, so a
+     * map-watching consumer (e.g. the camstack map child) gets a fresh complete
+     * frame on every push during a live clean.
+     */
+    fetchLatestMapStreaming(opts?: Omit<VacuumGetMapInput, 'filename'>): Promise<VacuumMap | null>;
     /** Props worth seeding on start() / polling — exported for the facade. */
     static readonly DEFAULT_PROPS: readonly [{
         readonly siid: 2;
@@ -1809,6 +1825,30 @@ interface MowerControlState {
     statusCode: number | null;
     zones: number[][];
 }
+/** Canonical CMS consumable counter keys (blade, brush, robot maintenance). */
+type MowerConsumableKey = 'blade' | 'brush' | 'maintenance';
+/** One CMS consumable counter: minutes used + total + remaining %. */
+interface MowerConsumableReading {
+    readonly key: MowerConsumableKey;
+    /** Minutes of run-time accrued on this counter (counts UP). */
+    readonly usedMinutes: number;
+    /** Counter's full-life duration in minutes. */
+    readonly totalMinutes: number;
+    /** Remaining life percentage (0..100, one decimal). */
+    readonly remainingPercent: number;
+}
+/** Map a consumable key (incl. aliases) to its CMS counter index. */
+declare function mowerConsumableIndex(item: string): number | null;
+/**
+ * Extract the raw `[blade, brush, robot]` minute counters from a CMS getter
+ * result, or null if the response is malformed. Cast-free, no throw.
+ */
+declare function extractMowerConsumableValues(result: unknown): number[] | null;
+/**
+ * Parse a CMS getter result into typed consumable readings (blade/brush/
+ * maintenance) with remaining %. Returns null on a malformed response.
+ */
+declare function parseMowerConsumables(result: unknown): readonly MowerConsumableReading[] | null;
 
 /**
  * Per-model mower capability records + a resolver adapting the rich record into
@@ -2047,6 +2087,27 @@ declare class MowerDevice extends BaseDevice {
     startMowingEdges(contourIds: number[][]): Promise<unknown>;
     /** Spot mowing (2:50 o:103). */
     startMowingSpots(spotAreaIds: number[]): Promise<unknown>;
+    /**
+     * Read the raw CMS consumable counters `[blade, brush, robot]` (minutes used),
+     * via the SCHEDULING_TASK (2:50) custom-action getter `{m:'g',t:'CMS'}`. This
+     * is a LIVE device action (it wakes the mower); rejects with
+     * {@link DreameDeviceOfflineError} when the mower is unreachable. Returns null
+     * if the response is malformed.
+     */
+    getConsumableValues(): Promise<readonly number[] | null>;
+    /**
+     * Read the CMS consumables as typed readings (blade/brush/maintenance) with
+     * remaining %. LIVE action — see {@link getConsumableValues}. Returns null on
+     * a malformed response.
+     */
+    getConsumables(): Promise<readonly MowerConsumableReading[] | null>;
+    /**
+     * Reset one CMS consumable counter to zero. Reads the current counters, zeroes
+     * the selected one (leaving the others), and writes them back via the
+     * `{m:'s',t:'CMS',d:{value:[…]}}` setter. LIVE action. Throws on an unknown
+     * item or when the current counters cannot be read.
+     */
+    resetConsumable(item: MowerConsumableKey): Promise<void>;
     /**
      * Seed the cache from the CLOUD SHADOW (last-known values) WITHOUT waking the
      * mower — reads {@link MowerDevice.DEFAULT_PROPS} from the cloud-cached
@@ -2432,4 +2493,4 @@ declare function createDumper(target: DumperDevice, options?: DumperOptions): Du
  */
 declare function createClientDumper(client: Nodreame, options?: DumperOptions): Dumper[];
 
-export { AI_FEATURE_BIT, AI_FEATURE_JSON_KEY, AUTO_SWITCH_JSON_KEY, type AiDetectionRaw, type AutoSwitchKey, type AutoSwitchRaw, BaseDevice, type BaseDeviceEvents, type BatchDeviceDataFetcher, type CapabilityResolver, ChargingStatus, type CleanOpts, CleaningMode, type ConsumableReading, type ConsumableSpec, type CreateDeviceArgs, DefaultCapabilityResolver, type DeviceCapabilities, type DeviceDump, type DeviceEvent, type DreameAiFeature, DreameApiError, DreameAuthError, type DreameCloudState, type DreameConsumableKey, type DreameDevice, DreameDeviceOfflineError, DreameError, type DreameRegion, type DreameSession, DreameTransportError, type DumperOptions, LIBRARY_NAME, MODEL_CAPABILITIES as MOWER_MODEL_CAPABILITIES, type MapBoundingBox, type MapCleanedAreaOverlay, type MapColorScheme, type MapDimensions, type MapFrameType, type MapLayer, type MapLayerType, type MapLowLyingArea, type MapObstacle, type MapPath, type MapPathType, type MapPoint, type MapPose, type MapRestrictedArea, type MapRoom, type MapRoomWall, type MapRun, type MapSegment, type MapStorey, type MapVirtualWall, type MapWallsInfo, type MiotAction, MiotError, type MiotProp, MiotState, type MowerAvailableMap, type MowerCapabilities, MowerCapabilityResolver, MowerChargingStatus, type MowerContour, MowerControlAction, type MowerControlState, MowerDevice, type MowerDeviceInput, MowerFault, type MowerMap, type MowerMapBoundary, type MowerMowPath, type MowerPathEntry, type MowerPoint, type MowerSpotArea, MowerStatus, type MowerTaskDescriptor, MowerTaskStatus, type MowerZone, Nodreame, type NodreameDeps, type NodreameEvents, type NodreameOptions, type OssFetchInput, type OssFetcherLike, type PropertyChangedEvent, type PropertyResult, type PropertyState, type PropertyWrite, type RenderMowerSvgOptions, type RenderVacuumPngOptions, type StateChangedEvent, SuctionLevel, TaskStatus, VACUUM_CONSUMABLES, MODEL_CAPABILITIES$1 as VACUUM_MODEL_CAPABILITIES, type VacuumCapabilities, VacuumCapabilityResolver, VacuumDevice, type VacuumGetMapInput, type VacuumMap, WaterVolume, consumableSpec, createClientDumper, createDumper, decodeAiFeature, decodeAutoSwitch, decodeAutoSwitchAll, encodeAiFeatureWrite, encodeAutoSwitchWrite, getMowerCapabilities, getVacuumCapabilities, isDreameConsumableKey, renderMowerSvg, renderVacuumPng, resolveCapabilities, supportedAutoSwitchKeys };
+export { AI_FEATURE_BIT, AI_FEATURE_JSON_KEY, AUTO_SWITCH_JSON_KEY, type AiDetectionRaw, type AutoSwitchKey, type AutoSwitchRaw, BaseDevice, type BaseDeviceEvents, type BatchDeviceDataFetcher, type CapabilityResolver, ChargingStatus, type CleanOpts, CleaningMode, type ConsumableReading, type ConsumableSpec, type CreateDeviceArgs, DefaultCapabilityResolver, type DeviceCapabilities, type DeviceDump, type DeviceEvent, type DreameAiFeature, DreameApiError, DreameAuthError, type DreameCloudState, type DreameConsumableKey, type DreameDevice, DreameDeviceOfflineError, DreameError, type DreameRegion, type DreameSession, DreameTransportError, type DumperOptions, LIBRARY_NAME, MODEL_CAPABILITIES as MOWER_MODEL_CAPABILITIES, type MapBoundingBox, type MapCleanedAreaOverlay, type MapColorScheme, type MapDimensions, type MapFrameType, type MapLayer, type MapLayerType, type MapLowLyingArea, type MapObstacle, type MapPath, type MapPathType, type MapPoint, type MapPose, type MapRestrictedArea, type MapRoom, type MapRoomWall, type MapRun, type MapSegment, type MapStorey, type MapVirtualWall, type MapWallsInfo, type MiotAction, MiotError, type MiotProp, MiotState, type MowerAvailableMap, type MowerCapabilities, MowerCapabilityResolver, MowerChargingStatus, type MowerConsumableKey, type MowerConsumableReading, type MowerContour, MowerControlAction, type MowerControlState, MowerDevice, type MowerDeviceInput, MowerFault, type MowerMap, type MowerMapBoundary, type MowerMowPath, type MowerPathEntry, type MowerPoint, type MowerSpotArea, MowerStatus, type MowerTaskDescriptor, MowerTaskStatus, type MowerZone, Nodreame, type NodreameDeps, type NodreameEvents, type NodreameOptions, type OssFetchInput, type OssFetcherLike, type PropertyChangedEvent, type PropertyResult, type PropertyState, type PropertyWrite, type RenderMowerSvgOptions, type RenderVacuumPngOptions, type StateChangedEvent, SuctionLevel, TaskStatus, VACUUM_CONSUMABLES, MODEL_CAPABILITIES$1 as VACUUM_MODEL_CAPABILITIES, type VacuumCapabilities, VacuumCapabilityResolver, VacuumDevice, type VacuumGetMapInput, type VacuumMap, WaterVolume, consumableSpec, createClientDumper, createDumper, decodeAiFeature, decodeAutoSwitch, decodeAutoSwitchAll, encodeAiFeatureWrite, encodeAutoSwitchWrite, extractMowerConsumableValues, getMowerCapabilities, getVacuumCapabilities, isDreameConsumableKey, mowerConsumableIndex, parseMowerConsumables, renderMowerSvg, renderVacuumPng, resolveCapabilities, supportedAutoSwitchKeys };

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/support/version.ts
 var LIBRARY_NAME = "nodedreame";
-var LIBRARY_VERSION = "1.9.0";
+var LIBRARY_VERSION = "1.11.0";
 
 // src/transport/errors.ts
 var DreameError = class extends Error {
@@ -2552,6 +2552,157 @@ function decodeCleanedAreaPixels(pixels, width, height) {
   return { cleaned, dirty };
 }
 
+// src/models/vacuum/map/merge.ts
+var OutOfOrderFrameError = class extends Error {
+  expectedFrameId;
+  actualFrameId;
+  constructor(expectedFrameId, actualFrameId) {
+    super(`map: out-of-order P-frame (expected frame_id=${expectedFrameId}, got ${actualFrameId})`);
+    this.name = "OutOfOrderFrameError";
+    this.expectedFrameId = expectedFrameId;
+    this.actualFrameId = actualFrameId;
+  }
+};
+function mergePFrame(prevInflated, pFrameInflated) {
+  const prevHeader = parseMapHeader(prevInflated);
+  const pHeader = parseMapHeader(pFrameInflated);
+  if (pHeader.frameType !== "P") {
+    throw new MapDecodeError(`mergePFrame: expected P-frame, got frame_type=${pHeader.frameType}`);
+  }
+  if (pHeader.mapId !== prevHeader.mapId) {
+    throw new MapDecodeError(
+      `mergePFrame: map_id mismatch (prev=${prevHeader.mapId}, P=${pHeader.mapId}) \u2014 request a fresh I-frame`
+    );
+  }
+  if (pHeader.frameId !== prevHeader.frameId + 1) {
+    throw new OutOfOrderFrameError(prevHeader.frameId + 1, pHeader.frameId);
+  }
+  if (prevHeader.gridSize !== pHeader.gridSize && pHeader.width > 0 && pHeader.height > 0) {
+    throw new MapDecodeError(
+      `mergePFrame: grid_size changed mid-stream (${prevHeader.gridSize} \u2192 ${pHeader.gridSize})`
+    );
+  }
+  const prevTail = parseMapJsonTail(sliceTailText(prevInflated, prevHeader));
+  const pTail = parseMapJsonTail(sliceTailText(pFrameInflated, pHeader));
+  const prevLeft = prevTail.origin?.[0] ?? prevHeader.left;
+  const prevTop = prevTail.origin?.[1] ?? prevHeader.top;
+  const grid = prevHeader.gridSize;
+  const prevRight = prevLeft + prevHeader.width * grid;
+  const prevBottom = prevTop + prevHeader.height * grid;
+  const hasPixelDelta = pHeader.width > 0 && pHeader.height > 0;
+  let unionLeft = prevLeft;
+  let unionTop = prevTop;
+  let unionWidth = prevHeader.width;
+  let unionHeight = prevHeader.height;
+  let pLeft = 0;
+  let pTop = 0;
+  if (hasPixelDelta) {
+    pLeft = pTail.origin?.[0] ?? pHeader.left;
+    pTop = pTail.origin?.[1] ?? pHeader.top;
+    const pRight = pLeft + pHeader.width * grid;
+    const pBottom = pTop + pHeader.height * grid;
+    if ((pLeft - prevLeft) % grid !== 0 || (pTop - prevTop) % grid !== 0) {
+      throw new MapDecodeError(
+        `mergePFrame: P-frame origin not aligned to prev grid (offset=${pLeft - prevLeft},${pTop - prevTop} vs grid=${grid})`
+      );
+    }
+    unionLeft = Math.min(prevLeft, pLeft);
+    unionTop = Math.min(prevTop, pTop);
+    const unionRight = Math.max(prevRight, pRight);
+    const unionBottom = Math.max(prevBottom, pBottom);
+    unionWidth = (unionRight - unionLeft) / grid;
+    unionHeight = (unionBottom - unionTop) / grid;
+  }
+  const newPixels = Buffer.alloc(unionWidth * unionHeight);
+  const prevPixelEnd = HEADER_SIZE + prevHeader.width * prevHeader.height;
+  if (prevInflated.length < prevPixelEnd) {
+    throw new MapDecodeError(
+      `mergePFrame: prev buffer truncated (need ${prevPixelEnd} bytes for header+pixels, got ${prevInflated.length})`
+    );
+  }
+  const prevPixels = prevInflated.subarray(HEADER_SIZE, prevPixelEnd);
+  const prevDxPx = (prevLeft - unionLeft) / grid;
+  const prevDyPx = (prevTop - unionTop) / grid;
+  for (let y = 0; y < prevHeader.height; y++) {
+    const srcOff = y * prevHeader.width;
+    const dstOff = (prevDyPx + y) * unionWidth + prevDxPx;
+    prevPixels.copy(newPixels, dstOff, srcOff, srcOff + prevHeader.width);
+  }
+  if (hasPixelDelta) {
+    const pPixelEnd = HEADER_SIZE + pHeader.width * pHeader.height;
+    if (pFrameInflated.length < pPixelEnd) {
+      throw new MapDecodeError(
+        `mergePFrame: P buffer truncated (need ${pPixelEnd} bytes for header+pixels, got ${pFrameInflated.length})`
+      );
+    }
+    const pPixels = pFrameInflated.subarray(HEADER_SIZE, pPixelEnd);
+    const pDxPx = (pLeft - unionLeft) / grid;
+    const pDyPx = (pTop - unionTop) / grid;
+    for (let y = 0; y < pHeader.height; y++) {
+      const dstRow = (pDyPx + y) * unionWidth + pDxPx;
+      const srcRow = y * pHeader.width;
+      for (let x = 0; x < pHeader.width; x++) {
+        newPixels[dstRow + x] = newPixels[dstRow + x] + pPixels[srcRow + x] & 255;
+      }
+    }
+  }
+  const newHeader = Buffer.alloc(HEADER_SIZE);
+  newHeader.writeInt16LE(prevHeader.mapId, 0);
+  newHeader.writeInt16LE(pHeader.frameId, 2);
+  newHeader[4] = FRAME_TYPE.I;
+  newHeader.writeInt16LE(pHeader.robotX, 5);
+  newHeader.writeInt16LE(pHeader.robotY, 7);
+  newHeader.writeInt16LE(pHeader.robotA, 9);
+  newHeader.writeInt16LE(pHeader.chargerX, 11);
+  newHeader.writeInt16LE(pHeader.chargerY, 13);
+  newHeader.writeInt16LE(pHeader.chargerA, 15);
+  newHeader.writeInt16LE(grid, 17);
+  newHeader.writeInt16LE(unionWidth, 19);
+  newHeader.writeInt16LE(unionHeight, 21);
+  newHeader.writeInt16LE(unionLeft, 23);
+  newHeader.writeInt16LE(unionTop, 25);
+  const mergedTail = mergeTails(prevTail, pTail, unionLeft, unionTop);
+  const tailBytes = Buffer.from(JSON.stringify(mergedTail), "utf8");
+  return Buffer.concat([newHeader, newPixels, tailBytes]);
+}
+function mergePFrameEnvelope(prev, pframe, prevOpts, pframeOpts) {
+  const prevBuf = typeof prev === "string" ? unwrapEnvelope(prev, prevOpts) : prev;
+  const pBuf = typeof pframe === "string" ? unwrapEnvelope(pframe, pframeOpts) : pframe;
+  return mergePFrame(prevBuf, pBuf);
+}
+function mergeTails(prev, p, unionLeft, unionTop) {
+  const merged = { ...p };
+  merged.origin = [unionLeft, unionTop];
+  const prevTr = typeof prev.tr === "string" ? prev.tr : "";
+  const pTr = typeof p.tr === "string" ? p.tr : "";
+  if (prevTr || pTr) {
+    merged.tr = prevTr + pTr;
+  } else {
+    delete merged.tr;
+  }
+  if (!("seg_inf" in p) && "seg_inf" in prev) {
+    merged.seg_inf = prev.seg_inf;
+  }
+  if (!("sa" in p) && "sa" in prev) {
+    merged.sa = prev.sa;
+  }
+  for (const key2 of PERSISTENT_TAIL_KEYS) {
+    if (!(key2 in p) && key2 in prev) {
+      merged[key2] = prev[key2];
+    }
+  }
+  return merged;
+}
+var PERSISTENT_TAIL_KEYS = [
+  "vw",
+  "vws",
+  "sneak_areas",
+  "sneak_areas_end",
+  "walls_info",
+  "rism",
+  "decmap"
+];
+
 // src/models/vacuum/map/decode.ts
 function decodeVacuumMap(input, opts = {}) {
   const inflated = typeof input === "string" ? unwrapEnvelope(input, opts) : looksLikeBase64Zlib(input) ? unwrapEnvelope(input.toString("latin1"), opts) : input;
@@ -2596,6 +2747,10 @@ function decodeVacuumMap(input, opts = {}) {
     cleanedArea
   };
 }
+function applyVacuumPFrame(prev, pframe, opts = {}) {
+  const merged = typeof prev === "string" || typeof pframe === "string" ? mergePFrameEnvelope(prev, pframe, opts.prev, opts.pframe) : mergePFrame(prev, pframe);
+  return { buffer: merged, data: decodeVacuumMap(merged) };
+}
 function mergeDimensions(header, tail) {
   const left = tail.origin?.[0] ?? header.left;
   const top = tail.origin?.[1] ?? header.top;
@@ -3533,6 +3688,14 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
    */
   async getMap(input) {
     this.#requireCap(this.#caps.canMap, "getMap", "map decoding");
+    const blob = await this.#fetchMapBlob(input);
+    const map = decodeVacuumMap(blob, this.#decodeOpts(input));
+    this.#lastMap = map;
+    this.emit("map", map);
+    return map;
+  }
+  /** Fetch the raw OSS blob (still the base64+zlib envelope) for a map frame. */
+  async #fetchMapBlob(input) {
     const session = this.currentSession();
     const region = this.region;
     const fetcher = input.fetcher ?? new OssFetcher();
@@ -3546,14 +3709,77 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
       ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
       ...input.signal !== void 0 ? { signal: input.signal } : {}
     };
-    const blob = await fetcher.fetchBlob(fetchInput);
-    const map = decodeVacuumMap(blob, {
+    return fetcher.fetchBlob(fetchInput);
+  }
+  /** The AES key/iv decode options, threaded from a {@link VacuumGetMapInput}. */
+  #decodeOpts(input) {
+    return {
       ...input.key !== void 0 ? { key: input.key } : {},
       ...input.iv !== void 0 ? { iv: input.iv } : {}
-    });
-    this.#lastMap = map;
-    this.emit("map", map);
-    return map;
+    };
+  }
+  /**
+   * The merge base for live P-frame streaming — always an INFLATED frame buffer.
+   * An I-frame (re)seeds it; each P-frame merge replaces it with the merged
+   * inflated buffer (so further P-frames stack). `null` until the first I-frame
+   * (or after an out-of-order / map-id reset).
+   */
+  #mapStreamBase = null;
+  /** Drop the P-frame merge base so the next I-frame re-seeds the stream. */
+  resetMapStream() {
+    this.#mapStreamBase = null;
+  }
+  /** Inflate an OSS blob to a raw frame buffer (live envelope → zlib; verbatim if already inflated). */
+  #inflateFrame(blob, opts) {
+    return looksLikeBase64Zlib(blob) ? unwrapEnvelope(blob.toString("latin1"), opts) : blob;
+  }
+  /**
+   * Fetch the latest advertised map frame and fold it into a continuously
+   * updating map. An I-frame (re)seeds the merge base and renders standalone; a
+   * P-frame is merged onto the base via {@link applyVacuumPFrame} so the live
+   * grid stays COMPLETE (a P-frame decoded standalone is only byte-deltas). On an
+   * out-of-order P-frame or a map-id change the base is dropped and `null`
+   * returned — the next I-frame re-seeds. Returns `null` when no frame is
+   * advertised yet, or a P-frame arrives before any I-frame.
+   *
+   * Caches {@link lastMap} and emits `'map'` exactly like {@link getMap}, so a
+   * map-watching consumer (e.g. the camstack map child) gets a fresh complete
+   * frame on every push during a live clean.
+   */
+  async fetchLatestMapStreaming(opts = {}) {
+    this.#requireCap(this.#caps.canMap, "fetchLatestMapStreaming", "map decoding");
+    const filename = this.mapFilename;
+    if (filename === null) return null;
+    const input = { filename, ...opts };
+    const decodeOpts = this.#decodeOpts(input);
+    const blob = await this.#fetchMapBlob(input);
+    const inflated = this.#inflateFrame(blob, decodeOpts);
+    const frame = decodeVacuumMap(inflated, decodeOpts);
+    if (frame.frameType === "I") {
+      this.#mapStreamBase = inflated;
+      this.#lastMap = frame;
+      this.emit("map", frame);
+      return frame;
+    }
+    if (frame.frameType === "P") {
+      if (this.#mapStreamBase === null) return null;
+      try {
+        const { buffer, data } = applyVacuumPFrame(this.#mapStreamBase, inflated);
+        this.#mapStreamBase = buffer;
+        this.#lastMap = data;
+        this.emit("map", data);
+        return data;
+      } catch (err) {
+        if (err instanceof OutOfOrderFrameError || err instanceof MapDecodeError) {
+          this.#mapStreamBase = null;
+          return null;
+        }
+        throw err;
+      }
+    }
+    this.#lastMap = frame;
+    this.emit("map", frame);
+    return frame;
   }
   /** Props worth seeding on start() / polling — exported for the facade. */
   static DEFAULT_PROPS = [
@@ -3624,6 +3850,19 @@ function buildEdgePayload(contourIds) {
 function buildSpotPayload(spotAreaIds) {
   return { m: "a", p: 0, o: TASK_OPCODE.SPOT, d: { area: [...spotAreaIds] } };
 }
+function buildGetConsumablePayload() {
+  return { m: "g", t: "CMS" };
+}
+function buildSetConsumablePayload(values) {
+  const normalized = values.map((v) => Math.trunc(v));
+  if (normalized.length !== 3) {
+    throw new RangeError(`CMS values must contain exactly 3 counters; got ${normalized.length}`);
+  }
+  if (normalized.some((v) => v < 0)) {
+    throw new RangeError(`CMS values cannot be negative; got ${JSON.stringify(normalized)}`);
+  }
+  return { m: "s", t: "CMS", d: { value: normalized } };
+}
 
 // src/models/mower/enums.ts
 var MowerStatus = /* @__PURE__ */ ((MowerStatus2) => {
@@ -3815,6 +4054,104 @@ function parseControlStatus(value) {
     zones
   };
 }
+var MOWER_CONSUMABLES = [
+  { key: "blade", index: 0, totalMinutes: 6e3 },
+  { key: "brush", index: 1, totalMinutes: 3e4 },
+  { key: "maintenance", index: 2, totalMinutes: 3600 }
+];
+function mowerConsumableIndex(item) {
+  switch (item.trim().toLowerCase()) {
+    case "blade":
+    case "blades":
+      return 0;
+    case "brush":
+    case "cleaning_brush":
+      return 1;
+    case "robot":
+    case "maintenance":
+    case "robot_maintenance":
+      return 2;
+    default:
+      return null;
+  }
+}
+function toInt(v) {
+  if (typeof v === "number" && Number.isFinite(v)) {
+    return Math.trunc(v);
+  }
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? Math.trunc(n) : null;
+  }
+  return null;
+}
+function extractCustomActionData(result) {
+  if (!isRecord2(result)) {
+    return null;
+  }
+  if (Array.isArray(result["value"])) {
+    return result;
+  }
+  if (isRecord2(result["d"])) {
+    return result["d"];
+  }
+  const out = result["out"];
+  if (!Array.isArray(out)) {
+    return null;
+  }
+  for (const entry of out) {
+    if (!isRecord2(entry)) {
+      continue;
+    }
+    const r = entry["r"];
+    const code = entry["code"];
+    const rError = r !== void 0 && r !== null && r !== 0;
+    const codeError = code !== void 0 && code !== null && code !== 0;
+    if (rError && codeError) {
+      continue;
+    }
+    if (isRecord2(entry["d"])) {
+      return entry["d"];
+    }
+  }
+  return null;
+}
+function extractMowerConsumableValues(result) {
+  const data = extractCustomActionData(result);
+  if (data === null) {
+    return null;
+  }
+  const values = data["value"];
+  if (!Array.isArray(values) || values.length < 3) {
+    return null;
+  }
+  const out = [];
+  for (const v of values.slice(0, 3)) {
+    const n = toInt(v);
+    if (n === null) {
+      return null;
+    }
+    out.push(n);
+  }
+  return out;
+}
+function parseMowerConsumables(result) {
+  const values = extractMowerConsumableValues(result);
+  if (values === null) {
+    return null;
+  }
+  return MOWER_CONSUMABLES.map((c) => {
+    const used = values[c.index] ?? 0;
+    const remaining = c.totalMinutes - used;
+    const pct = Math.max(0, Math.min(100, Math.round(remaining / c.totalMinutes * 1e3) / 10));
+    return {
+      key: c.key,
+      usedMinutes: used,
+      totalMinutes: c.totalMinutes,
+      remainingPercent: pct
+    };
+  });
+}
 
 // src/models/mower/capabilities.ts
 var FALLBACK2 = {
@@ -4580,6 +4917,56 @@ var MowerDevice = class _MowerDevice extends BaseDevice {
     }
     return this.#sendTask(buildSpotPayload(spotAreaIds.map((s) => Math.trunc(s))));
   }
+  // -- CMS consumables ----------------------------------------------------
+  /**
+   * Read the raw CMS consumable counters `[blade, brush, robot]` (minutes used),
+   * via the SCHEDULING_TASK (2:50) custom-action getter `{m:'g',t:'CMS'}`. This
+   * is a LIVE device action (it wakes the mower); rejects with
+   * {@link DreameDeviceOfflineError} when the mower is unreachable. Returns null
+   * if the response is malformed.
+   */
+  async getConsumableValues() {
+    const result = await this.callAction(
+      MOWER_PROP.SCHEDULING_TASK.siid,
+      MOWER_PROP.SCHEDULING_TASK.piid,
+      [buildGetConsumablePayload()]
+    );
+    return extractMowerConsumableValues(result);
+  }
+  /**
+   * Read the CMS consumables as typed readings (blade/brush/maintenance) with
+   * remaining %. LIVE action — see {@link getConsumableValues}. Returns null on
+   * a malformed response.
+   */
+  async getConsumables() {
+    const result = await this.callAction(
+      MOWER_PROP.SCHEDULING_TASK.siid,
+      MOWER_PROP.SCHEDULING_TASK.piid,
+      [buildGetConsumablePayload()]
+    );
+    return parseMowerConsumables(result);
+  }
+  /**
+   * Reset one CMS consumable counter to zero. Reads the current counters, zeroes
+   * the selected one (leaving the others), and writes them back via the
+   * `{m:'s',t:'CMS',d:{value:[…]}}` setter. LIVE action. Throws on an unknown
+   * item or when the current counters cannot be read.
+   */
+  async resetConsumable(item) {
+    const index = mowerConsumableIndex(item);
+    if (index === null) {
+      throw new DreameError(`resetConsumable: unknown consumable item "${item}"`);
+    }
+    const current = await this.getConsumableValues();
+    if (current === null) {
+      throw new DreameError("resetConsumable: failed to read current CMS counters");
+    }
+    const next = [...current];
+    next[index] = 0;
+    await this.callAction(MOWER_PROP.SCHEDULING_TASK.siid, MOWER_PROP.SCHEDULING_TASK.piid, [
+      buildSetConsumablePayload(next)
+    ]);
+  }
   /**
    * Seed the cache from the CLOUD SHADOW (last-known values) WITHOUT waking the
    * mower — reads {@link MowerDevice.DEFAULT_PROPS} from the cloud-cached
@@ -5281,9 +5668,12 @@ export {
   decodeAutoSwitchAll,
   encodeAiFeatureWrite,
   encodeAutoSwitchWrite,
+  extractMowerConsumableValues,
   getMowerCapabilities,
   getVacuumCapabilities,
   isDreameConsumableKey,
+  mowerConsumableIndex,
+  parseMowerConsumables,
   renderMowerSvg,
   renderVacuumPng,
   resolveCapabilities,