@camstack/types 1.2.155 → 1.2.157

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-b8kBSOTT.js");
-const require_sleep = require("./sleep-QEBby1J6.js");
+const require_sleep = require("./sleep-BGiOgxye.js");
 const require_canonical_hash = require("./canonical-hash-DNV8S5ET.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -2041,7 +2041,22 @@ var RecordingTriggersSchema = zod.z.object({
 	* il livello: un contatto trovato già aperto al riavvio del runner non fa
 	* registrare.
 	*/
-	sensorDeviceIds: zod.z.array(zod.z.number().int().positive()).min(1).max(16).refine(noDuplicates, { message: "sensorDeviceIds must not repeat a device" }).optional()
+	sensorDeviceIds: zod.z.array(zod.z.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: zod.z.boolean().optional()
 });
 /**
 * Mode of a single recording band — the recorder per-band vocabulary.
@@ -7644,6 +7659,8 @@ var streamBrokerCapability = {
 			label: zod.z.string().optional(),
 			deviceFeatures: zod.z.array(zod.z.string()).optional(),
 			autoEligible: zod.z.boolean().optional(),
+			/** The slot the publisher says this stream IS — see `CameraStreamSchema.profileHint`. */
+			profileHint: require_sleep.CamProfileSchema.optional(),
 			metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
 			/** Required when kind === 'derived' — the source camStreamId the
 			*  derived broker reads its encoded plane from.
@@ -32989,6 +33006,79 @@ var recordingExportCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/recording-signal.cap.ts
+/**
+* A camera's own "record me NOW" LEVEL — a signal the device raises while
+* something it knows about is happening (a robot vacuum cleaning, a machine
+* running, a gate open) and lowers when it stops.
+*
+* It is a level, not an edge. The sensor triggers the recorder already listens
+* to (`SOURCE_CAP_ACTIVE_FIELD`) fire on a rising edge and record for a fixed
+* post-buffer; a cleaning lasts forty minutes, and forty minutes of "this is
+* still happening" cannot be expressed as an edge plus a post-buffer without
+* either re-triggering on a timer (polling — D224 forbids the consumer keeping
+* the fact fresh) or picking a post-buffer long enough to cover every job,
+* which records the dock for that long after every short one. So the recorder
+* reads the LEVEL: it records for as long as `active` is true, plus the band's
+* own post-buffer once it falls.
+*
+* Who owns the fact: the PROVIDER of the device, which already reads the state
+* the signal is derived from (the vacuum's lifecycle state, for Dreame). It
+* writes this slice on every change; consumers subscribe to the kernel's
+* `DeviceStateChanged` for it and read it back through
+* `deviceState.getCapSlice` to reconcile — never a second copy, never a poll
+* against the device (D224, D8/D11).
+*
+* Deliberately NOT a `binary` sensor on the camera: a binary sensor is exported
+* to Home Assistant, HomeKit and the sensor picker as a thing an operator can
+* bind, and "the camera wants to record" is not a room sensor. It is a fact
+* about the camera, on the camera.
+*/
+var RecordingSignalStatusSchema = zod.z.object({
+	/** True while the device asks to be recorded. */
+	active: zod.z.boolean(),
+	/**
+	* Why, in the provider's own vocabulary (a vacuum's `cleaning` / `docked`,
+	* …). Free text for the log line and the UI badge; the recorder never
+	* branches on it.
+	*/
+	reason: zod.z.string(),
+	/** Ms epoch of the last `active` transition. 0 if never observed. */
+	lastChangedAt: zod.z.number()
+});
+/** The runtime-state slice: the status plus the clock every slice carries. */
+var RecordingSignalRuntimeStateSchema = RecordingSignalStatusSchema.extend({ lastFetchedAt: zod.z.number() });
+var recordingSignalCapability = {
+	name: "recording-signal",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [require_sleep.DeviceType.Camera],
+	methods: { 
+	/** The current level, straight from the slice the provider keeps fresh. */
+getStatus: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), RecordingSignalStatusSchema) },
+	status: {
+		schema: RecordingSignalStatusSchema,
+		kind: "push",
+		empty: {
+			active: false,
+			reason: "unknown",
+			lastChangedAt: 0
+		}
+	},
+	runtimeState: RecordingSignalRuntimeStateSchema,
+	/**
+	* Runtime-state durability: **session** — a restored `active: true` from
+	* before a restart is exactly the stale level the recorder's reconcile bound
+	* exists to end, and the provider re-derives the true level on activation
+	* anyway. Nothing is lost by forgetting it; a lie is avoided.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session"
+};
+//#endregion
 //#region src/capabilities/scene-monitor.cap.ts
 /**
 * scene-monitor — device-scoped reference-region state cap. An operator marks
@@ -33521,6 +33611,8 @@ var CamStreamDescriptorSchema = zod.z.object({
 	deviceFeatures: zod.z.array(zod.z.string()).optional(),
 	/** Eligible for automatic profile assignment. Absent = `true`. */
 	autoEligible: zod.z.boolean().optional(),
+	/** The slot the publisher says this stream IS — see `CameraStreamSchema.profileHint`. */
+	profileHint: require_sleep.CamProfileSchema.optional(),
 	/** Transport-specific opaque metadata (e.g. rfc4571 SDP). */
 	metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
@@ -36622,6 +36714,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	pressureSensor: pressureSensorCapability,
 	privacyMask: privacyMaskCapability,
 	ptzAutotrack: ptzAutotrackCapability,
+	recordingSignal: recordingSignalCapability,
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
 	smoke: smokeCapability,
@@ -37474,6 +37567,53 @@ var BaseDeviceProvider = class extends require_sleep.BaseAddon {
 		const ids = [...this._permanentRestoreFailures.keys()].join(", ");
 		return `${this._permanentRestoreFailures.size} device(s) permanently failed restore (deviceIds: ${ids}) — restart the ${this.providerName} provider to retry`;
 	}
+	/**
+	* A top-level persisted row with NO configuration is a leftover, not a
+	* device — quarantine it instead of dialling it.
+	*
+	* Device 614 was deleted, resurrected as a config-less shell by a write
+	* already in flight (D376), and then dialled at every single boot: eight
+	* `Failed to restore device — bounded retry scheduled` lines in one day,
+	* each one the same Zod refusal on `host` and `password`. The bound was
+	* real, but it is a bound PER PROCESS, and the runner restarts — so nothing
+	* about the row ever stopped costing attempts and log lines.
+	*
+	* No retry can add a configuration that is not there. The row is reported
+	* once, with its `deviceId`, and set aside.
+	*
+	* Top-level only: an accessory child legitimately carries an empty blob (it
+	* lives off its parent), and a hub-adopted child with an emptied blob is
+	* repaired by `healSavedConfig` from its parent instead. Providers that
+	* genuinely create configuration-free top-level devices turn this off.
+	*/
+	quarantineConfiglessTopLevelRestores = true;
+	isUnrestorableShell(saved) {
+		if (!this.quarantineConfiglessTopLevelRestores) return false;
+		if (saved.parentDeviceId !== null) return false;
+		const config = saved.config;
+		if (config === void 0) return false;
+		return Object.keys(config).length === 0;
+	}
+	quarantineShell(saved) {
+		this._permanentRestoreFailures.set(saved.id, {
+			deviceId: saved.id,
+			stableId: saved.stableId,
+			type: saved.type,
+			attempts: 0,
+			lastError: "persisted row has no configuration",
+			failedAt: Date.now()
+		});
+		this.ctx.logger.error("Persisted device row has NO configuration — quarantined: not restored, not retried. Remove it (deviceManager.removeDevice) or re-add the device.", {
+			tags: {
+				deviceId: saved.id,
+				stableId: saved.stableId
+			},
+			meta: {
+				type: saved.type,
+				provider: this.providerName
+			}
+		});
+	}
 	cancelRestoreRetries() {
 		this._restoreRetryScheduler?.cancel();
 		this._restoreRetryScheduler = null;
@@ -37658,6 +37798,10 @@ var BaseDeviceProvider = class extends require_sleep.BaseAddon {
 				});
 				return;
 			}
+			if (this.isUnrestorableShell(saved)) {
+				this.quarantineShell(saved);
+				return;
+			}
 			try {
 				await attemptRestore(saved);
 			} catch (err) {
@@ -39439,6 +39583,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"ptz",
 	"ptz-autotrack",
 	"recording",
+	"recording-signal",
 	"scene-monitor",
 	"script-runner",
 	"smoke",
@@ -39574,6 +39719,7 @@ var CAPABILITY_NAMES = {
 	reboot: "reboot",
 	recording: "recording",
 	recordingExport: "recording-export",
+	recordingSignal: "recording-signal",
 	sceneMonitor: "scene-monitor",
 	scriptRunner: "script-runner",
 	serverManagement: "server-management",
@@ -40082,6 +40228,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "recordingExport",
 		name: "recording-export"
 	},
+	{
+		key: "recordingSignal",
+		name: "recording-signal"
+	},
 	{
 		key: "sceneMonitor",
 		name: "scene-monitor"
@@ -40358,6 +40508,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	rebootCapability,
 	recordingCapability,
 	recordingExportCapability,
+	recordingSignalCapability,
 	sceneMonitorCapability,
 	scriptRunnerCapability,
 	serverManagementCapability,
@@ -45037,6 +45188,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recordingSignal.getStatus": {
+		capName: "recording-signal",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.captureReference": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -46611,6 +46768,7 @@ var KNOWN_CAP_NAMES = [
 	"reboot",
 	"recording",
 	"recording-export",
+	"recording-signal",
 	"scene-monitor",
 	"script-runner",
 	"server-management",
@@ -46686,6 +46844,7 @@ var DEVICE_CAP_NAMES = [
 	"ptz",
 	"ptz-autotrack",
 	"reboot",
+	"recording-signal",
 	"scene-monitor",
 	"script-runner",
 	"snapshot",
@@ -48294,6 +48453,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"recordingSignal.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"sceneMonitor.captureReference": [{
 		name: "deviceId",
 		form: "single",
@@ -48808,7 +48972,7 @@ function getCapsByProviderKind(kind) {
 //#region src/generated/runtime-state-durability.ts
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 66 caps: 35 `restored`, 31 `session`.
+* `runtimeState`. 67 caps: 35 `restored`, 32 `session`.
 *
 * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
 * with `durability: 'session'` has one and has decided not to keep it.
@@ -49010,6 +49174,10 @@ var RUNTIME_STATE_POLICY = {
 		durability: "session",
 		volatileFields: []
 	},
+	"recording-signal": {
+		durability: "session",
+		volatileFields: []
+	},
 	"scene-monitor": {
 		durability: "session",
 		volatileFields: []
@@ -54587,6 +54755,8 @@ exports.RecordingRebalancePlanSchema = RecordingRebalancePlanSchema;
 exports.RecordingRebalanceSkipReasonSchema = RecordingRebalanceSkipReasonSchema;
 exports.RecordingRebalanceSkipSchema = RecordingRebalanceSkipSchema;
 exports.RecordingRetentionSchema = RecordingRetentionSchema;
+exports.RecordingSignalRuntimeStateSchema = RecordingSignalRuntimeStateSchema;
+exports.RecordingSignalStatusSchema = RecordingSignalStatusSchema;
 exports.RecordingStatusSchema = RecordingStatusSchema;
 exports.RecordingStorageModeSchema = RecordingStorageModeSchema;
 exports.RecordingStorageUsageSchema = RecordingStorageUsageSchema;
@@ -55190,6 +55360,7 @@ exports.readinessKey = require_sleep.readinessKey;
 exports.rebootCapability = rebootCapability;
 exports.recordingCapability = recordingCapability;
 exports.recordingExportCapability = recordingExportCapability;
+exports.recordingSignalCapability = recordingSignalCapability;
 exports.rectsToCells = rectsToCells;
 exports.reducePoints = reducePoints;
 exports.requiresPython = requiresPython;