@camstack/addon-provider-dreame 0.2.75 → 0.2.76

package/dist/addon.js

@@ -60522,17 +60522,29 @@ var HHMM = /^([01]\d|2[0-3]):[0-5]\d$/;
 /**
 * DERIVED per-camera storage summary — the single field cheap consumers read
 * (the viewer's status dot, the camera list) instead of walking `bands`:
-*  - `off`        — no band covers the camera (or it is disabled).
-*  - `events`     — every band records around triggers only.
-*  - `continuous` — at least one band records continuously.
-*
-* NEVER authored: the recorder stamps it from the authoritative `bands` on
-* every save (`activeModeForConfig`). Writing it has no effect.
+*  - `off`               — no band covers the camera (or it is disabled).
+*  - `events`            — every band records around triggers only.
+*  - `continuous`        — at least one band records continuously.
+*  - `on-device-decision`— the DEVICE decides: recording runs for as long as the
+*    camera raises its own `recording-signal` level (a robot that cleans). There
+*    is no schedule to author, because there is no hour to program — see
+*    {@link RecordingConfigSchema}`.deviceDecision`.
+*
+* NEVER authored: the recorder stamps it from the authoritative intent
+* (`bands` + `deviceDecision`) on every save (`activeModeForConfig`). Writing it
+* has no effect.
+*
+* `on-device-decision` is named for WHO decides, not for how the recording is
+* requested. `on-demand` was rejected: in this repo's vocabulary a "demand" is
+* something the operator makes (the live gate is the recorder's own "demand
+* window"), and a knob whose name suggests the operator starts it while the
+* device actually does is the D62 shape — a control nobody can predict.
 */
 var RecordingStorageModeSchema = _enum([
 	"off",
 	"events",
-	"continuous"
+	"continuous",
+	"on-device-decision"
 ]);
 /**
 * Le macro classi che possono aprire una finestra di registrazione — le stesse
@@ -60582,22 +60594,7 @@ var RecordingTriggersSchema = object({
 	* il livello: un contatto trovato già aperto al riavvio del runner non fa
 	* registrare.
 	*/
-	sensorDeviceIds: array(number().int().positive()).min(1).max(16).refine(noDuplicates, { message: "sensorDeviceIds must not repeat a device" }).optional(),
-	/**
-	* La camera registra per tutta la durata del SEGNALE che lei stessa
-	* pubblica — la cap `recording-signal` (`active: true` mentre il device è in
-	* funzione: un robot che pulisce). È un LIVELLO, non un fronte: la finestra
-	* resta aperta finché il segnale è alto e si chiude `postBufferSec` dopo la
-	* caduta, così una pulizia di quaranta minuti è UNA clip.
-	*
-	* Non nomina un device: il segnale è della camera stessa, tenuto fresco dal
-	* suo provider (D224); il recorder lo ascolta su `DeviceStateChanged` e lo
-	* riconcilia leggendo la slice via RPC, con un tetto oltre il quale un
-	* segnale mai abbassato (un evento perso) non può tenere aperta una
-	* registrazione (D11). Vedi `recorder/addon/band-decision.ts`
-	* (`holdTrigger` / `releaseTrigger`).
-	*/
-	deviceSignal: boolean().optional()
+	sensorDeviceIds: array(number().int().positive()).min(1).max(16).refine(noDuplicates, { message: "sensorDeviceIds must not repeat a device" }).optional()
 });
 /**
 * Mode of a single recording band — the recorder per-band vocabulary.
@@ -60681,8 +60678,29 @@ var RecordingConfigSchema = object({
 	* "off" is the absence of a covering band, never a band value.
 	*/
 	bands: array(RecordingBandSchema).default([]),
+	/**
+	* THE device-decided intent: record for as long as the camera itself raises
+	* `recording-signal` (`active: true` while the device is in function — a
+	* robot that cleans). AUTHORED, unlike `mode`, and the only authored
+	* recording intent that is not a band.
+	*
+	* It carries NO schedule on purpose. A band is an HOUR, and this feature has
+	* no hour to program: the device decides. What it costs the operator is one
+	* flag — "this camera can record on its own" — and what it buys is the same
+	* hold/release the recorder already implements (D371, `holdTrigger` /
+	* `releaseTrigger`): the window opens on the rise, stays open for the whole
+	* job however long it is, and closes one pad after the fall.
+	*
+	* EXCLUSIVE with `bands` (below): two authorities deciding when the same
+	* camera records is the D62 failure. `off` remains `enabled: false`, so an
+	* operator switching this camera off is REPORTED off, never as broken.
+	*/
+	deviceDecision: boolean().optional(),
 	retention: RecordingRetentionSchema.optional()
-}).strict();
+}).strict().refine((config) => config.deviceDecision !== true || config.bands.length === 0, {
+	message: "deviceDecision is a whole-config mode and carries no schedule: it cannot be combined with bands",
+	path: ["bands"]
+});
 /**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
 *
@@ -73715,11 +73733,7 @@ var CameraAudioStatusSchema = object({
 });
 /** Recording block — null when no recording cap is active for this device. */
 var CameraRecordingStatusSchema = object({
-	mode: _enum([
-		"off",
-		"continuous",
-		"events"
-	]),
+	mode: RecordingStorageModeSchema,
 	active: boolean(),
 	storageBytes: number()
 });
@@ -82146,11 +82160,10 @@ DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceI
 var RecordingStatusSchema = object({
 	deviceId: number(),
 	enabled: boolean(),
-	activeMode: _enum([
-		"off",
-		"continuous",
-		"events"
-	]),
+	/** THE derived storage mode, from the one definition
+	*  (`deriveRecordingMode`) — never a second enum. A duplicated list is how
+	*  `on-device-decision` could have reached the recorder and not the status. */
+	activeMode: RecordingStorageModeSchema,
 	nodeId: string(),
 	storageBytes: number()
 });
@@ -96799,6 +96812,16 @@ var dreameChildSchema = object({
 	navigationDisabledEntryIds: array(string()).optional(),
 	/** Privacy PIN set at pairing — required to wake a coded camera (camera child only). */
 	navigationAccessCode: string().optional(),
+	/**
+	* ms-epoch of the ONE-SHOT recording seed (camera child only, D380).
+	*
+	* A MARK, never the value: it says this camera was seeded, which stays true
+	* after the operator switches recording off — and an operator's `off` is
+	* byte-identical to a camera that was never seeded (`enabled: false,
+	* bands: []`), so nothing but this field can tell the two apart. The
+	* authority for what is recorded remains `RecordingConfig` (D62).
+	*/
+	recordingSeededAt: number().optional(),
 	mapShowNoGo: boolean().optional(),
 	mapShowVirtualWalls: boolean().optional(),
 	mapShowObstacles: boolean().optional(),
@@ -97849,6 +97872,51 @@ var DreameNetworkLinkMonitor = class {
 	}
 };
 //#endregion
+//#region src/devices/dreame-recording-seed.ts
+/**
+* THE config the provider seeds: recording ON, decided by the device.
+*
+* No bands (the mode carries none, D380) and no profiles/retention: those are
+* cluster-wide defaults the recorder already resolves, and pinning them here
+* would be the provider deciding storage policy for a camera it does not own.
+*/
+var DEVICE_DECISION_SEED_CONFIG = Object.freeze({
+	enabled: true,
+	deviceDecision: true,
+	bands: []
+});
+/**
+* Seed `on-device-decision` recording for this camera, once, ever.
+*
+* Never throws: it runs on the activation path and a camera that fails to be
+* seeded must still come up. Every branch that does not write says why — a
+* silent skip here is indistinguishable from the feature not existing.
+*/
+async function seedDeviceDecisionRecording(deps) {
+	const { deviceId, logger } = deps;
+	if (deps.alreadySeeded) return "already-seeded";
+	try {
+		await deps.writeConfig(DEVICE_DECISION_SEED_CONFIG);
+	} catch (err) {
+		logger.warn("robot camera: could not seed on-device-decision recording — retried at the next start", {
+			tags: { deviceId },
+			meta: { error: errMsg(err) }
+		});
+		return "failed";
+	}
+	try {
+		await deps.markSeeded();
+	} catch (err) {
+		logger.warn("robot camera: recording seeded but the one-shot mark could not be persisted — a restart may seed it again and override an operator who switched it off", {
+			tags: { deviceId },
+			meta: { error: errMsg(err) }
+		});
+		return "seeded";
+	}
+	logger.info("robot camera: seeded on-device-decision recording (once, at first start)", { tags: { deviceId } });
+	return "seeded";
+}
+//#endregion
 //#region src/devices/dreame-recording-signal.ts
 /** Vacuum lifecycle states during which the camera asks to be recorded. */
 var ACTIVE_STATES = new Set(["cleaning", "returning"]);
@@ -143563,6 +143631,28 @@ var DreameCameraDevice = class extends DreameChildDevice {
 		this.networkLink.start();
 		this.registerStreamCatalogCap();
 		this.registerRecordingSignalCap();
+		this.seedRecordingConfig();
+	}
+	/**
+	* Seed `on-device-decision` recording the FIRST time this camera comes up.
+	*
+	* Gated on the durable mark and NOT on the current config: an operator who
+	* switched recording off leaves a config that is byte-identical to one that
+	* was never seeded, so reading the value would re-enable it at every restart.
+	* The value stays the recorder's (D62) — this writes a default through the
+	* same cap method an operator uses and keeps no copy of it.
+	*/
+	async seedRecordingConfig() {
+		await seedDeviceDecisionRecording({
+			deviceId: this.id,
+			alreadySeeded: this.config.get("recordingSeededAt") !== void 0,
+			writeConfig: (config) => this.ctx.api.recording.setDeviceConfig.mutate({
+				deviceId: this.id,
+				config
+			}),
+			markSeeded: () => this.config.set("recordingSeededAt", Date.now()),
+			logger: this.ctx.logger
+		});
 	}
 	/**
 	* The camera's own "record me" LEVEL, derived from the vacuum lifecycle

package/dist/addon.mjs

@@ -60519,17 +60519,29 @@ var HHMM = /^([01]\d|2[0-3]):[0-5]\d$/;
 /**
 * DERIVED per-camera storage summary — the single field cheap consumers read
 * (the viewer's status dot, the camera list) instead of walking `bands`:
-*  - `off`        — no band covers the camera (or it is disabled).
-*  - `events`     — every band records around triggers only.
-*  - `continuous` — at least one band records continuously.
-*
-* NEVER authored: the recorder stamps it from the authoritative `bands` on
-* every save (`activeModeForConfig`). Writing it has no effect.
+*  - `off`               — no band covers the camera (or it is disabled).
+*  - `events`            — every band records around triggers only.
+*  - `continuous`        — at least one band records continuously.
+*  - `on-device-decision`— the DEVICE decides: recording runs for as long as the
+*    camera raises its own `recording-signal` level (a robot that cleans). There
+*    is no schedule to author, because there is no hour to program — see
+*    {@link RecordingConfigSchema}`.deviceDecision`.
+*
+* NEVER authored: the recorder stamps it from the authoritative intent
+* (`bands` + `deviceDecision`) on every save (`activeModeForConfig`). Writing it
+* has no effect.
+*
+* `on-device-decision` is named for WHO decides, not for how the recording is
+* requested. `on-demand` was rejected: in this repo's vocabulary a "demand" is
+* something the operator makes (the live gate is the recorder's own "demand
+* window"), and a knob whose name suggests the operator starts it while the
+* device actually does is the D62 shape — a control nobody can predict.
 */
 var RecordingStorageModeSchema = _enum([
 	"off",
 	"events",
-	"continuous"
+	"continuous",
+	"on-device-decision"
 ]);
 /**
 * Le macro classi che possono aprire una finestra di registrazione — le stesse
@@ -60579,22 +60591,7 @@ var RecordingTriggersSchema = object({
 	* il livello: un contatto trovato già aperto al riavvio del runner non fa
 	* registrare.
 	*/
-	sensorDeviceIds: array(number().int().positive()).min(1).max(16).refine(noDuplicates, { message: "sensorDeviceIds must not repeat a device" }).optional(),
-	/**
-	* La camera registra per tutta la durata del SEGNALE che lei stessa
-	* pubblica — la cap `recording-signal` (`active: true` mentre il device è in
-	* funzione: un robot che pulisce). È un LIVELLO, non un fronte: la finestra
-	* resta aperta finché il segnale è alto e si chiude `postBufferSec` dopo la
-	* caduta, così una pulizia di quaranta minuti è UNA clip.
-	*
-	* Non nomina un device: il segnale è della camera stessa, tenuto fresco dal
-	* suo provider (D224); il recorder lo ascolta su `DeviceStateChanged` e lo
-	* riconcilia leggendo la slice via RPC, con un tetto oltre il quale un
-	* segnale mai abbassato (un evento perso) non può tenere aperta una
-	* registrazione (D11). Vedi `recorder/addon/band-decision.ts`
-	* (`holdTrigger` / `releaseTrigger`).
-	*/
-	deviceSignal: boolean().optional()
+	sensorDeviceIds: array(number().int().positive()).min(1).max(16).refine(noDuplicates, { message: "sensorDeviceIds must not repeat a device" }).optional()
 });
 /**
 * Mode of a single recording band — the recorder per-band vocabulary.
@@ -60678,8 +60675,29 @@ var RecordingConfigSchema = object({
 	* "off" is the absence of a covering band, never a band value.
 	*/
 	bands: array(RecordingBandSchema).default([]),
+	/**
+	* THE device-decided intent: record for as long as the camera itself raises
+	* `recording-signal` (`active: true` while the device is in function — a
+	* robot that cleans). AUTHORED, unlike `mode`, and the only authored
+	* recording intent that is not a band.
+	*
+	* It carries NO schedule on purpose. A band is an HOUR, and this feature has
+	* no hour to program: the device decides. What it costs the operator is one
+	* flag — "this camera can record on its own" — and what it buys is the same
+	* hold/release the recorder already implements (D371, `holdTrigger` /
+	* `releaseTrigger`): the window opens on the rise, stays open for the whole
+	* job however long it is, and closes one pad after the fall.
+	*
+	* EXCLUSIVE with `bands` (below): two authorities deciding when the same
+	* camera records is the D62 failure. `off` remains `enabled: false`, so an
+	* operator switching this camera off is REPORTED off, never as broken.
+	*/
+	deviceDecision: boolean().optional(),
 	retention: RecordingRetentionSchema.optional()
-}).strict();
+}).strict().refine((config) => config.deviceDecision !== true || config.bands.length === 0, {
+	message: "deviceDecision is a whole-config mode and carries no schedule: it cannot be combined with bands",
+	path: ["bands"]
+});
 /**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
 *
@@ -73712,11 +73730,7 @@ var CameraAudioStatusSchema = object({
 });
 /** Recording block — null when no recording cap is active for this device. */
 var CameraRecordingStatusSchema = object({
-	mode: _enum([
-		"off",
-		"continuous",
-		"events"
-	]),
+	mode: RecordingStorageModeSchema,
 	active: boolean(),
 	storageBytes: number()
 });
@@ -82143,11 +82157,10 @@ DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceI
 var RecordingStatusSchema = object({
 	deviceId: number(),
 	enabled: boolean(),
-	activeMode: _enum([
-		"off",
-		"continuous",
-		"events"
-	]),
+	/** THE derived storage mode, from the one definition
+	*  (`deriveRecordingMode`) — never a second enum. A duplicated list is how
+	*  `on-device-decision` could have reached the recorder and not the status. */
+	activeMode: RecordingStorageModeSchema,
 	nodeId: string(),
 	storageBytes: number()
 });
@@ -96796,6 +96809,16 @@ var dreameChildSchema = object({
 	navigationDisabledEntryIds: array(string()).optional(),
 	/** Privacy PIN set at pairing — required to wake a coded camera (camera child only). */
 	navigationAccessCode: string().optional(),
+	/**
+	* ms-epoch of the ONE-SHOT recording seed (camera child only, D380).
+	*
+	* A MARK, never the value: it says this camera was seeded, which stays true
+	* after the operator switches recording off — and an operator's `off` is
+	* byte-identical to a camera that was never seeded (`enabled: false,
+	* bands: []`), so nothing but this field can tell the two apart. The
+	* authority for what is recorded remains `RecordingConfig` (D62).
+	*/
+	recordingSeededAt: number().optional(),
 	mapShowNoGo: boolean().optional(),
 	mapShowVirtualWalls: boolean().optional(),
 	mapShowObstacles: boolean().optional(),
@@ -97846,6 +97869,51 @@ var DreameNetworkLinkMonitor = class {
 	}
 };
 //#endregion
+//#region src/devices/dreame-recording-seed.ts
+/**
+* THE config the provider seeds: recording ON, decided by the device.
+*
+* No bands (the mode carries none, D380) and no profiles/retention: those are
+* cluster-wide defaults the recorder already resolves, and pinning them here
+* would be the provider deciding storage policy for a camera it does not own.
+*/
+var DEVICE_DECISION_SEED_CONFIG = Object.freeze({
+	enabled: true,
+	deviceDecision: true,
+	bands: []
+});
+/**
+* Seed `on-device-decision` recording for this camera, once, ever.
+*
+* Never throws: it runs on the activation path and a camera that fails to be
+* seeded must still come up. Every branch that does not write says why — a
+* silent skip here is indistinguishable from the feature not existing.
+*/
+async function seedDeviceDecisionRecording(deps) {
+	const { deviceId, logger } = deps;
+	if (deps.alreadySeeded) return "already-seeded";
+	try {
+		await deps.writeConfig(DEVICE_DECISION_SEED_CONFIG);
+	} catch (err) {
+		logger.warn("robot camera: could not seed on-device-decision recording — retried at the next start", {
+			tags: { deviceId },
+			meta: { error: errMsg(err) }
+		});
+		return "failed";
+	}
+	try {
+		await deps.markSeeded();
+	} catch (err) {
+		logger.warn("robot camera: recording seeded but the one-shot mark could not be persisted — a restart may seed it again and override an operator who switched it off", {
+			tags: { deviceId },
+			meta: { error: errMsg(err) }
+		});
+		return "seeded";
+	}
+	logger.info("robot camera: seeded on-device-decision recording (once, at first start)", { tags: { deviceId } });
+	return "seeded";
+}
+//#endregion
 //#region src/devices/dreame-recording-signal.ts
 /** Vacuum lifecycle states during which the camera asks to be recorded. */
 var ACTIVE_STATES = new Set(["cleaning", "returning"]);
@@ -143560,6 +143628,28 @@ var DreameCameraDevice = class extends DreameChildDevice {
 		this.networkLink.start();
 		this.registerStreamCatalogCap();
 		this.registerRecordingSignalCap();
+		this.seedRecordingConfig();
+	}
+	/**
+	* Seed `on-device-decision` recording the FIRST time this camera comes up.
+	*
+	* Gated on the durable mark and NOT on the current config: an operator who
+	* switched recording off leaves a config that is byte-identical to one that
+	* was never seeded, so reading the value would re-enable it at every restart.
+	* The value stays the recorder's (D62) — this writes a default through the
+	* same cap method an operator uses and keeps no copy of it.
+	*/
+	async seedRecordingConfig() {
+		await seedDeviceDecisionRecording({
+			deviceId: this.id,
+			alreadySeeded: this.config.get("recordingSeededAt") !== void 0,
+			writeConfig: (config) => this.ctx.api.recording.setDeviceConfig.mutate({
+				deviceId: this.id,
+				config
+			}),
+			markSeeded: () => this.config.set("recordingSeededAt", Date.now()),
+			logger: this.ctx.logger
+		});
 	}
 	/**
 	* The camera's own "record me" LEVEL, derived from the vacuum lifecycle

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-provider-dreame",
-  "version": "0.2.75",
+  "version": "0.2.76",
   "description": "Dreame robot-vacuum / lawn-mower device-provider addon for CamStack — wraps the @apocaliss92/nodedreame Dreamehome cloud client",
   "keywords": [
     "camstack",