@camstack/types 1.2.158 → 1.2.160

package/dist/addon.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-BGiOgxye.js");
+const require_sleep = require("./sleep-DDIFZGbc.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-zAv7pMUz.mjs";
-import { D as adminUiCapability, E as DeviceType, G as scopeKey, H as ReadinessTimeoutError, M as expandCapMethods, R as nodePin, S as DEVICE_CHILDREN_BATCH_MAX, V as ReadinessRegistry, _t as DATAPLANE_SECRET_HEADER, a as asJsonObject, b as deviceOpsCapability, bt as BaseAddon, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, wt as emitReadiness, x as viewerUiCapability, xt as normalizeAddonInitResult, yt as DisposerChain, z as readNodePin } from "./sleep-IaOr7P-z.mjs";
+import { D as adminUiCapability, E as DeviceType, G as scopeKey, H as ReadinessTimeoutError, M as expandCapMethods, R as nodePin, S as DEVICE_CHILDREN_BATCH_MAX, V as ReadinessRegistry, _t as DATAPLANE_SECRET_HEADER, a as asJsonObject, b as deviceOpsCapability, bt as BaseAddon, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, wt as emitReadiness, x as viewerUiCapability, xt as normalizeAddonInitResult, yt as DisposerChain, z as readNodePin } from "./sleep-Cfij6Jj9.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/capabilities/pipeline-orchestrator.cap.d.ts

@@ -320,11 +320,14 @@ declare const CameraAudioStatusSchema: z.ZodObject<{
     nodeId: z.ZodString;
     enabled: z.ZodBoolean;
 }, z.core.$strip>;
-/** Recording mode enum (matches recording cap). */
+/** Recording mode — THE one definition, shared with the `recording` cap. A
+ *  copy of the list is how `on-device-decision` could have reached the recorder
+ *  and not this status block. */
 declare const CameraRecordingModeSchema: z.ZodEnum<{
     off: "off";
     events: "events";
     continuous: "continuous";
+    "on-device-decision": "on-device-decision";
 }>;
 /** Recording block — null when no recording cap is active for this device. */
 declare const CameraRecordingStatusSchema: z.ZodObject<{
@@ -332,6 +335,7 @@ declare const CameraRecordingStatusSchema: z.ZodObject<{
         off: "off";
         events: "events";
         continuous: "continuous";
+        "on-device-decision": "on-device-decision";
     }>;
     active: z.ZodBoolean;
     storageBytes: z.ZodNumber;
@@ -501,6 +505,7 @@ declare const CameraStatusSchema: z.ZodObject<{
             off: "off";
             events: "events";
             continuous: "continuous";
+            "on-device-decision": "on-device-decision";
         }>;
         active: z.ZodBoolean;
         storageBytes: z.ZodNumber;
@@ -1470,6 +1475,7 @@ export declare const pipelineOrchestratorCapability: {
                     off: "off";
                     events: "events";
                     continuous: "continuous";
+                    "on-device-decision": "on-device-decision";
                 }>;
                 active: z.ZodBoolean;
                 storageBytes: z.ZodNumber;
@@ -1605,6 +1611,7 @@ export declare const pipelineOrchestratorCapability: {
                     off: "off";
                     events: "events";
                     continuous: "continuous";
+                    "on-device-decision": "on-device-decision";
                 }>;
                 active: z.ZodBoolean;
                 storageBytes: z.ZodNumber;

package/dist/capabilities/recording.cap.d.ts

@@ -17,6 +17,7 @@ export declare const RecordingStatusSchema: z.ZodObject<{
         off: "off";
         events: "events";
         continuous: "continuous";
+        "on-device-decision": "on-device-decision";
     }>;
     nodeId: z.ZodString;
     storageBytes: z.ZodNumber;
@@ -338,6 +339,7 @@ export declare const recordingCapability: {
                 off: "off";
                 events: "events";
                 continuous: "continuous";
+                "on-device-decision": "on-device-decision";
             }>;
             nodeId: z.ZodString;
             storageBytes: z.ZodNumber;
@@ -462,6 +464,7 @@ export declare const recordingCapability: {
                 off: "off";
                 events: "events";
                 continuous: "continuous";
+                "on-device-decision": "on-device-decision";
             }>>;
             profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 high: "high";
@@ -486,11 +489,11 @@ export declare const recordingCapability: {
                         animal: "animal";
                     }>>>;
                     sensorDeviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                    deviceSignal: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>;
                 preBufferSec: z.ZodOptional<z.ZodNumber>;
                 postBufferSec: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>>;
+            deviceDecision: z.ZodOptional<z.ZodBoolean>;
             retention: z.ZodOptional<z.ZodObject<{
                 maxAgeDays: z.ZodOptional<z.ZodNumber>;
                 maxSizeGb: z.ZodOptional<z.ZodNumber>;
@@ -564,6 +567,7 @@ export declare const recordingCapability: {
                     off: "off";
                     events: "events";
                     continuous: "continuous";
+                    "on-device-decision": "on-device-decision";
                 }>>;
                 profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                     high: "high";
@@ -588,11 +592,11 @@ export declare const recordingCapability: {
                             animal: "animal";
                         }>>>;
                         sensorDeviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                        deviceSignal: z.ZodOptional<z.ZodBoolean>;
                     }, z.core.$strip>>;
                     preBufferSec: z.ZodOptional<z.ZodNumber>;
                     postBufferSec: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>>;
+                deviceDecision: z.ZodOptional<z.ZodBoolean>;
                 retention: z.ZodOptional<z.ZodObject<{
                     maxAgeDays: z.ZodOptional<z.ZodNumber>;
                     maxSizeGb: z.ZodOptional<z.ZodNumber>;
@@ -604,6 +608,7 @@ export declare const recordingCapability: {
                 off: "off";
                 events: "events";
                 continuous: "continuous";
+                "on-device-decision": "on-device-decision";
             }>>;
             profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 high: "high";
@@ -628,11 +633,11 @@ export declare const recordingCapability: {
                         animal: "animal";
                     }>>>;
                     sensorDeviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                    deviceSignal: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>;
                 preBufferSec: z.ZodOptional<z.ZodNumber>;
                 postBufferSec: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>>;
+            deviceDecision: z.ZodOptional<z.ZodBoolean>;
             retention: z.ZodOptional<z.ZodObject<{
                 maxAgeDays: z.ZodOptional<z.ZodNumber>;
                 maxSizeGb: z.ZodOptional<z.ZodNumber>;
@@ -649,6 +654,7 @@ export declare const recordingCapability: {
                 off: "off";
                 events: "events";
                 continuous: "continuous";
+                "on-device-decision": "on-device-decision";
             }>;
             nodeId: z.ZodString;
             storageBytes: z.ZodNumber;

package/dist/generated/device-scoped-caps.d.ts

@@ -5,7 +5,7 @@
  * can answer "may a rule actuate this?" without importing the schema barrel
  * (~144MB RSS per runner, D28).
  *
- * Coverage: 82 device-scoped capabilities.
+ * Coverage: 83 device-scoped capabilities.
  */
 export declare const DEVICE_SCOPED_CAPS: ReadonlySet<string>;
 /**

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-BGiOgxye.js");
+const require_sleep = require("./sleep-DDIFZGbc.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");
@@ -1228,21 +1228,21 @@ function schemaDeclaresAnyField(schema) {
 	for (const section of sectionsOf(schema)) if (fieldsOf(section).length > 0) return true;
 	return false;
 }
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sectionsOf(schema) {
-	if (!isRecord$2(schema)) return [];
+	if (!isRecord$3(schema)) return [];
 	const sections = schema["sections"];
 	return Array.isArray(sections) ? sections : [];
 }
 function fieldsOf(node) {
-	if (!isRecord$2(node)) return [];
+	if (!isRecord$3(node)) return [];
 	const fields = node["fields"];
 	return Array.isArray(fields) ? fields : [];
 }
 function walkField(field, out) {
-	if (!isRecord$2(field)) return;
+	if (!isRecord$3(field)) return;
 	const type = field["type"];
 	const key = field["key"];
 	if ((type === "password" || field["secret"] === true) && typeof key === "string" && key.length > 0) out.add(key);
@@ -1327,12 +1327,12 @@ function toStreamSourceEntry(stream) {
 function isString(v) {
 	return typeof v === "string";
 }
-function isRecord$1(v) {
+function isRecord$2(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function parseStreamEntry(v) {
 	if (isString(v) && v.trim()) return { url: v };
-	if (isRecord$1(v) && isString(v["url"]) && v["url"].trim()) return {
+	if (isRecord$2(v) && isString(v["url"]) && v["url"].trim()) return {
 		url: v["url"],
 		label: isString(v["label"]) ? v["label"] : void 0
 	};
@@ -1972,17 +1972,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 = zod.z.enum([
 	"off",
 	"events",
-	"continuous"
+	"continuous",
+	"on-device-decision"
 ]);
 /**
 * Le macro classi che possono aprire una finestra di registrazione — le stesse
@@ -2041,22 +2053,7 @@ 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(),
-	/**
-	* 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()
+	sensorDeviceIds: zod.z.array(zod.z.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.
@@ -2086,6 +2083,24 @@ var RecordingBandSchema = zod.z.object({
 	end: zod.z.string().regex(HHMM),
 	mode: RecordingBandModeSchema,
 	triggers: RecordingBandTriggersSchema.optional(),
+	/**
+	* RETIRED (D381). A band no longer carries a pre-buffer of its own.
+	*
+	* It was the retroactive KEEP bound — which already-written segments survive
+	* a trigger — and it had to be at least as wide as the widest pre-roll the
+	* broker could serve, or the gate would delete the seconds the ring had just
+	* handed the writer. That "at least as wide as" is the tell: it was a second
+	* expression of the broker's retention, in different units, in a different
+	* addon, with an invariant the operator had to maintain by hand. The keep
+	* bound is now derived from the one prebuffer ceiling and there is nothing
+	* left to configure here.
+	*
+	* The key survives in the SHAPE so a config written before that record still
+	* parses and can be migrated deliberately — `RecordingBandSchema` is not
+	* strict, so simply deleting it would strip an operator's value in silence on
+	* the next save (the failure D380 came one commit from shipping). Nothing
+	* reads it: {@link stripRetiredBandPreBufferSec} removes it on load.
+	*/
 	preBufferSec: zod.z.number().min(0).optional(),
 	postBufferSec: zod.z.number().min(0).optional()
 });
@@ -2103,29 +2118,56 @@ var RecordingBandSchema = zod.z.object({
 * `postBufferSec` must therefore exceed one segment length plus the attach
 * latency (ffmpeg spawn + RTSP dial), or the window closes before the first
 * segment is ever finalized and the camera records nothing anyway. At the 10 s
-* default segment length, 30 s leaves room for two full segments. `preBufferSec`
-* is retroactive only — it costs nothing at record time, it merely keeps
-* already-written segments.
-*
-* ## Why `preBufferSec` is 15 and not one segment length
-*
-* It has to cover the broker's RECORDING pre-roll, which is media handed to the
-* writer from BEFORE the trigger (D192/D193). If this bound were narrower, the
-* keep gate would delete the very seconds the ring just supplied — two
-* authorities disagreeing about the same footage, which is the failure D191 was
-* written against. It is therefore set to `RECORDING_PRE_ROLL_MAX_MS` (15 s),
-* the widest window the broker can be configured to serve, so an operator
-* raising the cluster pre-roll can never walk past the gate silently. The
-* addon-side guard is
-* `packages/addon-pipeline/src/recorder/addon/__tests__/band-decision.spec.ts`.
-*
-* An EXPLICIT `0` is left alone: that is an operator statement, not an omission,
-* and it is excluded from that invariant by name.
-*/
-var DEFAULT_EVENTS_BAND_BUFFER_SEC = {
-	preBufferSec: 15,
-	postBufferSec: 30
-};
+* default segment length, 30 s leaves room for two full segments.
+*
+* ## There is no `preBufferSec` here any more (D381)
+*
+* There used to be, at 15 s, and its whole justification was that it had to
+* cover the widest pre-roll the broker could serve. A number whose only
+* correct value is another subsystem's ceiling is not a setting; it is that
+* ceiling, restated where it can drift. The keep bound is derived from the
+* prebuffer ceiling directly now, in `band-decision.ts`, so an operator
+* raising the prebuffer cannot walk past the gate at all rather than merely
+* being warned not to.
+*/
+var DEFAULT_EVENTS_BAND_BUFFER_SEC = { postBufferSec: 30 };
+/**
+* Drop the RETIRED band `preBufferSec` from a persisted recording config.
+*
+* Explicit, and it reports what it removed, because the alternative is a
+* silent strip: `RecordingBandSchema` is a plain `z.object`, so the key
+* survives a parse and disappears on the next save with no line anywhere. An
+* operator who had typed a number would find it gone and nothing would say
+* when or why.
+*
+* Nothing is carried forward: the value it held was always required to be at
+* least the broker's widest pre-roll, and the gate is now derived from exactly
+* that ceiling. Every configuration that was legal therefore keeps a keep-gate
+* at least as wide as the one it had — including an explicit `0`, which widens.
+* That is deliberate and it is the only behaviour change: a band that kept
+* nothing before its trigger now keeps up to the prebuffer ceiling of
+* already-written footage, which is media that exists either way.
+*/
+function stripRetiredBandPreBufferSec(config) {
+	const strippedBands = [];
+	const bands = config.bands.map((band, index) => {
+		if (band.preBufferSec === void 0) return band;
+		strippedBands.push(index);
+		const { preBufferSec: _retired, ...rest } = band;
+		return rest;
+	});
+	if (strippedBands.length === 0) return {
+		config,
+		strippedBands
+	};
+	return {
+		config: {
+			...config,
+			bands
+		},
+		strippedBands
+	};
+}
 /**
 * Adjacent recorded ranges closer than this belong to the SAME videoclip visit.
 *
@@ -2187,8 +2229,29 @@ var RecordingConfigSchema = zod.z.object({
 	* "off" is the absence of a covering band, never a band value.
 	*/
 	bands: zod.z.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: zod.z.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"]
+});
 /**
 * Derive the {@link RecordingStorageModeSchema} summary from the authoritative
 * bands: `continuous` when any band records continuously, `events` when a band
@@ -2201,7 +2264,9 @@ var RecordingConfigSchema = zod.z.object({
 * bug this field was added to fix.
 */
 function deriveRecordingMode(config) {
-	if (!config.enabled || config.bands.length === 0) return "off";
+	if (!config.enabled) return "off";
+	if (config.deviceDecision === true) return "on-device-decision";
+	if (config.bands.length === 0) return "off";
 	if (config.bands.some((band) => band.mode === "continuous")) return "continuous";
 	return "events";
 }
@@ -2229,6 +2294,85 @@ function resolveRecordingProfiles(assigned, override) {
 	const preferred = assigned.filter((profile) => DEFAULT_RECORDING_PROFILES.includes(profile));
 	return preferred.length > 0 ? preferred : [...assigned];
 }
+/** Trigger keys that survive D380 — a band carrying one of these is a real band. */
+var SURVIVING_TRIGGER_KEYS = [
+	"motion",
+	"audioThresholdDbfs",
+	"objectClasses",
+	"sensorDeviceIds"
+];
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function listensToLegacySignal(band) {
+	return isRecord$1(band) && isRecord$1(band.triggers) && band.triggers.deviceSignal === true;
+}
+function hasSurvivingTrigger(band) {
+	const triggers = band.triggers;
+	if (!isRecord$1(triggers)) return false;
+	return SURVIVING_TRIGGER_KEYS.some((key) => triggers[key] !== void 0);
+}
+function withoutLegacySignal(band) {
+	const triggers = band.triggers;
+	if (!isRecord$1(triggers)) return band;
+	const { deviceSignal: _retired, ...rest } = triggers;
+	return {
+		...band,
+		triggers: rest
+	};
+}
+/**
+* Turn a config stored under D371 (`bands[].triggers.deviceSignal: true`) into
+* a D380 one (`deviceDecision: true`, no bands). Pure, total and IDEMPOTENT —
+* a row with no legacy key comes back as the SAME reference, `migrated: false`.
+*
+* ## Why the schema cannot be left to do this
+*
+* `RecordingTriggersSchema` is a non-strict `z.object`, so the retired key is
+* SILENTLY STRIPPED on read. The camera whose only trigger it was would parse
+* cleanly into an `events` band that lists nothing — "enabled, and records
+* nothing, forever", the exact shape `eventsBandCanEverDemand` exists to shout
+* about, reached without a single line in the log. On the reference hub that is
+* camera 4374, the one camera an operator had configured by hand.
+*
+* `enabled` is carried through untouched: a camera the operator had switched
+* OFF comes out of a migration still off (D62).
+*/
+function migrateLegacyDeviceSignalConfig(raw) {
+	const unchanged = {
+		value: raw,
+		migrated: false,
+		strippedOnly: false
+	};
+	if (!isRecord$1(raw) || !Array.isArray(raw.bands)) return unchanged;
+	if (!raw.bands.some(listensToLegacySignal)) return unchanged;
+	const kept = [];
+	for (const band of raw.bands) {
+		if (!listensToLegacySignal(band) || !isRecord$1(band)) {
+			kept.push(band);
+			continue;
+		}
+		if (hasSurvivingTrigger(band)) kept.push(withoutLegacySignal(band));
+	}
+	if (kept.length > 0) return {
+		value: {
+			...raw,
+			bands: kept
+		},
+		migrated: false,
+		strippedOnly: true
+	};
+	const { mode: _derived, ...rest } = raw;
+	return {
+		value: {
+			...rest,
+			bands: [],
+			deviceDecision: true
+		},
+		migrated: true,
+		strippedOnly: false
+	};
+}
 //#endregion
 //#region src/interfaces/relocate.ts
 /**
@@ -21503,12 +21647,10 @@ var CameraAudioStatusSchema = zod.z.object({
 	nodeId: zod.z.string(),
 	enabled: zod.z.boolean()
 });
-/** Recording mode enum (matches recording cap). */
-var CameraRecordingModeSchema = zod.z.enum([
-	"off",
-	"continuous",
-	"events"
-]);
+/** Recording mode — THE one definition, shared with the `recording` cap. A
+*  copy of the list is how `on-device-decision` could have reached the recorder
+*  and not this status block. */
+var CameraRecordingModeSchema = RecordingStorageModeSchema;
 /** Recording block — null when no recording cap is active for this device. */
 var CameraRecordingStatusSchema = zod.z.object({
 	mode: CameraRecordingModeSchema,
@@ -32115,11 +32257,10 @@ var rebootCapability = {
 var RecordingStatusSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	enabled: zod.z.boolean(),
-	activeMode: zod.z.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: zod.z.string(),
 	storageBytes: zod.z.number()
 });
@@ -55284,6 +55425,7 @@ exports.meshNetworkCapability = meshNetworkCapability;
 exports.method = require_sleep.method;
 exports.methodAccessForHttpMethod = methodAccessForHttpMethod;
 exports.metricsProviderCapability = metricsProviderCapability;
+exports.migrateLegacyDeviceSignalConfig = migrateLegacyDeviceSignalConfig;
 exports.modelConvertCapability = modelConvertCapability;
 exports.modelDistributorCapability = modelDistributorCapability;
 exports.modelFormatForRuntime = modelFormatForRuntime;
@@ -55431,6 +55573,7 @@ exports.streamCatalogCapability = streamCatalogCapability;
 exports.streamParamsCapability = streamParamsCapability;
 exports.streamPixels = streamPixels;
 exports.streamQualityLabel = streamQualityLabel;
+exports.stripRetiredBandPreBufferSec = stripRetiredBandPreBufferSec;
 exports.subKindsOf = subKindsOf;
 exports.summarisePrivacyAudio = summarisePrivacyAudio;
 exports.summarizeEffectiveScope = summarizeEffectiveScope;