@camstack/addon-provider-wyze 0.2.51 → 0.2.53

package/dist/addon.js

@@ -8050,6 +8050,20 @@ var RelocateJobSchema = object({
 	* in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
 	*/
 	rowsReconciled: number().int().nonnegative().optional(),
+	/**
+	* Rows this run FORGOT because the file they name is not on disk.
+	*
+	* The mover derived the path from the row's own fields and `stat`ed it; an
+	* ENOENT there is a per-path confirmation that the segment is gone (D296),
+	* and the durable row is dropped through the same channel eviction uses. It
+	* is reported for the same reason `rowsReconciled` is: this is a durable
+	* mutation nobody asked for, and a migration that quietly erases hour rows is
+	* the same failure as one that quietly skips them (D295).
+	*
+	* The production drain of 2026-08-30 would have reported 11 074 here — the
+	* ledger claimed 5.65 GB of footage that no longer existed.
+	*/
+	rowsForgotten: number().int().nonnegative().optional(),
 	startedAt: number(),
 	finishedAt: number().nullable(),
 	error: string().nullable()
@@ -8413,6 +8427,91 @@ var RelocateResidueSchema = object({
 	segments: number().int().nonnegative(),
 	bytes: number().int().nonnegative()
 }).nullable();
+/**
+* Ask one location whether its durable hour rows describe the disk — the walk
+* (D319).
+*
+* `apply` DEFAULTS TO FALSE and that default is the product: the operator's
+* missing tool is the question, and the dry run is how they sanity-check the
+* destructive run before authorising it.
+*/
+var LedgerWalkInputSchema = object({
+	locationId: string().min(1),
+	/** Forget the confirmed-absent rows, rather than only counting them. */
+	apply: boolean().optional(),
+	/** Narrow to one camera. */
+	deviceId: number().int().positive().optional(),
+	/** Narrow to these recording profiles; empty/absent = every profile. */
+	profiles: array(string().min(1)).optional()
+});
+/** Why a whole walk did nothing. Every one leaves the ledger untouched. */
+var LedgerWalkRefusalSchema = _enum([
+	"location-unknown",
+	"source-writable",
+	"no-ledger",
+	"archive-unreadable",
+	"anchor-absent",
+	"anchor-unreadable",
+	"anchor-moved"
+]);
+_enum([
+	"live-tail",
+	"listing-error",
+	"path-mismatch",
+	"durable-refused"
+]);
+/** Every skip reason, always present, always a number — so a reason that never
+*  fired reports as zero rather than absent and the report shape is constant
+*  between passes. Spelled out rather than `z.record` for exactly that. */
+var LedgerWalkSkipCountsSchema = object({
+	"live-tail": number().int().nonnegative(),
+	"listing-error": number().int().nonnegative(),
+	"path-mismatch": number().int().nonnegative(),
+	"durable-refused": number().int().nonnegative()
+});
+/** One camera's share of a walk, so a report names cameras and not rows. */
+var LedgerWalkDeviceReportSchema = object({
+	deviceId: number().int(),
+	hoursWalked: number().int().nonnegative(),
+	hoursMissing: number().int().nonnegative(),
+	ghostSegments: number().int().nonnegative(),
+	ghostBytes: number().int().nonnegative(),
+	forgottenSegments: number().int().nonnegative(),
+	orphanFiles: number().int().nonnegative()
+});
+/**
+* What one walk claimed, listed, found and (only when armed) forgot.
+*
+* `archiveSegments` is the **M** and `segmentsClaimed` the **N** (D295), so a
+* walk that saw a fraction of the location is visible in its own report rather
+* than in the absence of one.
+*/
+var LedgerWalkReportSchema = object({
+	locationId: string(),
+	applied: boolean(),
+	refused: LedgerWalkRefusalSchema.nullable(),
+	archiveSegments: number().int().nonnegative().nullable(),
+	archiveBytes: number().int().nonnegative().nullable(),
+	hoursClaimed: number().int().nonnegative(),
+	hoursWalked: number().int().nonnegative(),
+	hoursMissing: number().int().nonnegative(),
+	/** `readdir` calls issued — the cost, stated in the unit that is paid. */
+	listings: number().int().nonnegative(),
+	segmentsClaimed: number().int().nonnegative(),
+	ghostSegments: number().int().nonnegative(),
+	ghostBytes: number().int().nonnegative(),
+	ghostHoursWhole: number().int().nonnegative(),
+	forgottenSegments: number().int().nonnegative(),
+	forgottenBytes: number().int().nonnegative(),
+	/** Files under a claimed hour that no durable row names. Never deleted. */
+	orphanFiles: number().int().nonnegative(),
+	orphanSample: array(string()).readonly(),
+	hoursSkipped: number().int().nonnegative(),
+	skippedByReason: LedgerWalkSkipCountsSchema,
+	/** The walk stopped at its per-pass hour bound with claims unwalked. */
+	bounded: boolean(),
+	byDevice: array(LedgerWalkDeviceReportSchema).readonly()
+});
 /** How many rows a media pass would still act on against a given target — the
 *  media lane's denominator AND its residue, from ONE derivation so the two can
 *  never disagree. `null` = the count could not be taken. */
@@ -19045,13 +19144,15 @@ var ListGroupsPageSchema = object({
 	groups: array(AnalyticsGroupRecordSchema).readonly(),
 	nextCursor: string().nullable()
 });
+var KEY_EVENTS_DEFAULT_LIMIT = 50;
+var KEY_EVENTS_MAX_LIMIT = 200;
 var KeyEventQueryInput = object({
 	deviceId: number(),
 	/** Window lower bound (track firstSeen ≥ since). */
 	since: number(),
 	/** Window upper bound (track firstSeen ≤ until). */
 	until: number(),
-	limit: number().int().min(1).max(200).default(50),
+	limit: number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
 	/** Drop tracks scoring below this importance. */
 	minImportance: number().min(0).max(1).optional(),
 	/** Restrict to a single class (e.g. 'person'). */
@@ -19073,6 +19174,32 @@ var KeyEventSchema = object({
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
+/** `getKeyEvents`' window and filters, asked of a SET of cameras at once. */
+var KeyEventBatchQueryInput = object({
+	deviceIds: array(number()).min(1).max(200),
+	since: number(),
+	until: number(),
+	/** Applied PER CAMERA, exactly as `getKeyEvents.limit` is — never a total
+	*  across the set, which would let a busy camera starve a quiet one of its
+	*  rows and change what the merged feed contains. */
+	limit: number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
+	minImportance: number().min(0).max(1).optional(),
+	classFilter: string().optional()
+});
+/**
+* One camera's key events in a batch answer.
+*
+* The row exists for every requested id. `getKeyEvents` degrades to `[]` on
+* error rather than throwing, so a camera whose store read failed and one with
+* no events in the window were ALREADY indistinguishable per camera — the
+* batch does not make that worse, and the row keeps the deviceId the single
+* method's output never carried (the caller used to stamp it from the fan-out
+* key, which only worked because there was one query per camera).
+*/
+var KeyEventsForDeviceSchema = object({
+	deviceId: number(),
+	events: array(KeyEventSchema).readonly()
+});
 object({
 	trackId: string(),
 	className: string(),
@@ -19144,6 +19271,50 @@ var EventStoreFootprintSchema = object({
 	totalBytes: number().int(),
 	devices: array(EventStoreDeviceFootprintSchema).readonly()
 });
+/** Event-media footprint for one {@link MediaFileKind}. */
+var EventMediaKindFootprintSchema = object({
+	kind: MediaFileKindEnum,
+	/** Media rows of this kind. */
+	rows: number().int(),
+	/** Bytes on disk held by those rows. */
+	bytes: number().int()
+});
+/**
+* The media footprint broken down by KIND — the axis a deletion decision
+* actually turns on.
+*
+* A byte total says how much there is; it cannot say what is safe to remove.
+* The deletable set (the periodic `snapshot` filmstrip, the surplus per-edge
+* motion stills) and the keep set (`firstFrame`, rolling `lastFrame`,
+* `thumbnail`/`thumbnailSmall`, `keyFrame`/`keyFrameSmall`, the face/plate
+* buffers, gallery media, the CLIP `crop`) are distinguished by `kind` and by
+* nothing else, so sizing a deletion means summing per kind.
+*
+* ## Why `unaccounted*` exists
+*
+* `kinds` is enumerated from {@link MediaFileKindEnum} — the closed set the
+* writers use — and summed one kind at a time. `totalRows` / `totalBytes` come
+* from a SEPARATE unfiltered aggregate over the same rows, never from adding
+* `kinds` up. A row whose stored `kind` is not in the enum (written by a
+* retired code path, or by a version that knew a kind this one does not) would
+* otherwise vanish from the total silently, and an operator would delete
+* against a denominator smaller than the disk.
+*
+* `unaccountedRows` / `unaccountedBytes` are the difference. They are normally
+* zero; a non-zero value is a real finding and must be shown, not rounded away.
+*/
+var EventMediaKindBreakdownSchema = object({
+	/** Every media row in scope, from one unfiltered aggregate. */
+	totalRows: number().int(),
+	/** Every media byte in scope, from that same aggregate. */
+	totalBytes: number().int(),
+	/** Per-kind footprint, ordered by bytes descending. */
+	kinds: array(EventMediaKindFootprintSchema).readonly(),
+	/** `totalRows` minus the summed `kinds` rows — see the schema note. */
+	unaccountedRows: number().int(),
+	/** `totalBytes` minus the summed `kinds` bytes — see the schema note. */
+	unaccountedBytes: number().int()
+});
 /** Per-kind counts returned by the event-prune / device-delete mutations. */
 var EventPruneCountsSchema = object({
 	motion: number().int(),
@@ -19298,7 +19469,7 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	until: number().optional(),
 	kinds: array(string()).optional(),
 	limit: number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT)
-}), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(object({
+}), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(KeyEventBatchQueryInput, array(KeyEventsForDeviceSchema).readonly()), method(object({
 	deviceId: number(),
 	since: number(),
 	until: number(),
@@ -19347,6 +19518,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), TrackFlagsSchema, { kind: "mutation" }), method(object({}), EventStoreFootprintSchema, {
 	kind: "query",
 	auth: "admin"
+}), method(object({ deviceId: number().int().optional() }), EventMediaKindBreakdownSchema, {
+	kind: "query",
+	auth: "admin"
 }), method(object({
 	olderThanMs: number(),
 	reason: OpsLogReasonSchema.optional()
@@ -21402,6 +21576,20 @@ method(object({
 	error: string().optional()
 }), { auth: "admin" }), method(_void(), array(ProviderListEntrySchema).readonly()), method(object({
 	providerId: string(),
+	/**
+	* The location this config is an UNSAVED edit of, when there is one.
+	*
+	* `listLocations` replaces every declared secret with the redaction
+	* sentinel, so the edit modal's form state holds the sentinel for any
+	* credential the operator did not retype — and posting that here
+	* without a way to resolve it makes the provider try to authenticate
+	* as `__camstack_redacted__` and report the operator's own working
+	* password as wrong. Given this id, the orchestrator restores each
+	* sentinel from the stored config (same rule as `upsertLocation`)
+	* before dispatching. Omitted by the "Add location" wizard, where
+	* every value was typed just now and nothing is stored yet.
+	*/
+	locationId: string().optional(),
 	config: record(string(), unknown())
 }), object({
 	ok: boolean(),
@@ -28760,6 +28948,9 @@ method(object({
 }), method(RelocateResidueInputSchema, RelocateResidueSchema, {
 	kind: "query",
 	auth: "admin"
+}), method(LedgerWalkInputSchema, LedgerWalkReportSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
@@ -29151,6 +29342,25 @@ var SceneMonitorStatusSchema = object({
 	monitors: array(SceneMonitorSchema),
 	lastFetchedAt: number()
 });
+/**
+* One camera's row in a `listScenesBatch` answer.
+*
+* `status` is NULLABLE and the nullability is the whole point. `scene-monitor`
+* is a `defaultActive` wrapper, so every camera is asked; a camera whose
+* provider is absent (pipeline-analytics not deployed, the post-processing node
+* down) cannot answer, and that is not the same fact as a camera with no scenes
+* configured. Fanned out per camera the difference was visible — one query
+* errored while the others resolved — and a batch that returned only the rows
+* it managed would have destroyed it, silently, by making an unreachable camera
+* indistinguishable from one that answered `monitors: []`.
+*
+* So: EVERY requested deviceId gets a row. `status: null` means "this camera
+* could not be read"; `status.monitors: []` means "read, and it has none".
+*/
+var SceneMonitorStatusForDeviceSchema = object({
+	deviceId: number(),
+	status: SceneMonitorStatusSchema.nullable()
+});
 var sceneMonitorCapability = {
 	name: "scene-monitor",
 	scope: "device",
@@ -29160,6 +29370,22 @@ var sceneMonitorCapability = {
 	deviceTypes: [DeviceType.Camera],
 	methods: {
 		listScenes: method(object({ deviceId: number() }), SceneMonitorStatusSchema),
+		/**
+		* The same answer, for a SET of cameras, in one round trip.
+		*
+		* `/scenes` renders every camera and re-reads them on a 30s safety-net
+		* poll behind the push slice. Fanned out client-side that was one query
+		* per camera — 29 round trips through the browser, the hub and the
+		* post-analysis runner every 30 seconds to read an in-memory map the
+		* owner had already merged. The work is unchanged (`statusFor` per
+		* device, all in-process at the owner); what collapses is the transport.
+		*
+		* A camera that cannot answer still gets a row, with `status: null` —
+		* see {@link SceneMonitorStatusForDeviceSchema}. Never fewer rows than
+		* ids: a caller that asked for twenty-nine and got twenty-seven cannot
+		* tell which two are missing, or that any are.
+		*/
+		listScenesBatch: method(object({ deviceIds: array(number()).min(1).max(200) }), array(SceneMonitorStatusForDeviceSchema).readonly()),
 		createScene: method(object({
 			deviceId: number(),
 			label: string(),
@@ -30995,6 +31221,27 @@ var CameraOccupancySnapshotSchema = object({
 	stationaryObjects: array(StationaryObjectSchema).readonly().optional()
 });
 /**
+* One camera's row in a `getCurrentSnapshotBatch` answer.
+*
+* THREE outcomes, and the single-camera method could only express two of them
+* because `snapshot: null` was already spoken for:
+*
+*  - `read: 'read'`, `snapshot` present — the live occupancy reading.
+*  - `read: 'read'`, `snapshot: null`   — read, and this camera has no reading
+*    yet: no frame since boot, and no parked-object registry to hydrate from.
+*  - `read: 'unreadable'`               — the owner could not answer for this
+*    camera. `snapshot` is null, and it does NOT mean "nothing parked here".
+*
+* Collapsing the last two is the failure this field exists to prevent: a
+* hydration that threw would otherwise render as an empty Stationary section,
+* which is a definite claim about a camera nobody could read.
+*/
+var CameraOccupancySnapshotForDeviceSchema = object({
+	deviceId: number(),
+	read: _enum(["read", "unreadable"]),
+	snapshot: CameraOccupancySnapshotSchema.nullable()
+});
+/**
 * Time-series resolution. The history methods return one bucket per
 * step over the requested range. Smaller resolutions cost more
 * memory + bandwidth; bound to discrete steps so caller cannot ask
@@ -31051,6 +31298,20 @@ var zoneAnalyticsCapability = {
 		*  (no inference result emitted since boot or since binding was
 		*  activated). */
 		getCurrentSnapshot: method(object({ deviceId: number() }), CameraOccupancySnapshotSchema.nullable()),
+		/**
+		* The same snapshot, for a SET of cameras, in one round trip.
+		*
+		* The Events page's Stationary section polls this every 15s for every
+		* selected camera. Fanned out client-side that is one query per camera to
+		* read a `Map.get` at the owner — the answer costs nothing, the round trip
+		* costs everything. Batched, N transports become one and the per-device
+		* work is unchanged.
+		*
+		* Every requested deviceId gets a row, tagged `read` — see
+		* {@link CameraOccupancySnapshotForDeviceSchema}. A camera the owner could
+		* not answer for is `'unreadable'`, never an empty reading.
+		*/
+		getCurrentSnapshotBatch: method(object({ deviceIds: array(number()).min(1).max(200) }), array(CameraOccupancySnapshotForDeviceSchema).readonly()),
 		/** Time-series object count inside one zone. `className` optional —
 		*  omit to count every class in the zone. */
 		getZoneHistory: method(object({
@@ -35448,6 +35709,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getEventMediaFootprintByKind": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getEventStoreFootprint": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -35466,6 +35733,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getKeyEventsBatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -36642,6 +36915,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.reconcileLedgerAgainstDisk": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.refreshStorageLocationsForMigration": {
 		capName: "recording",
 		capScope: "system",
@@ -36768,6 +37047,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"sceneMonitor.listScenesBatch": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.recheckNow": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -38124,6 +38409,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"zoneAnalytics.getCurrentSnapshotBatch": {
+		capName: "zone-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"zoneAnalytics.getUnzonedHistory": {
 		capName: "zone-analytics",
 		capScope: "device",
@@ -39113,6 +39404,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getEventMediaFootprintByKind": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"pipelineAnalytics.getGroup": [{
 		name: "deviceId",
 		form: "single",
@@ -39123,6 +39419,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getKeyEventsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"pipelineAnalytics.getMotionEvents": [{
 		name: "deviceId",
 		form: "single",
@@ -39563,6 +39864,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.reconcileLedgerAgainstDisk": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"recording.relocateFootage": [{
 		name: "deviceId",
 		form: "single",
@@ -39628,6 +39934,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"sceneMonitor.listScenesBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"sceneMonitor.recheckNow": [{
 		name: "deviceId",
 		form: "single",
@@ -39889,6 +40200,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"zoneAnalytics.getCurrentSnapshotBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"zoneAnalytics.getUnzonedHistory": [{
 		name: "deviceId",
 		form: "single",

package/dist/addon.mjs

@@ -8029,6 +8029,20 @@ var RelocateJobSchema = object({
 	* in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
 	*/
 	rowsReconciled: number().int().nonnegative().optional(),
+	/**
+	* Rows this run FORGOT because the file they name is not on disk.
+	*
+	* The mover derived the path from the row's own fields and `stat`ed it; an
+	* ENOENT there is a per-path confirmation that the segment is gone (D296),
+	* and the durable row is dropped through the same channel eviction uses. It
+	* is reported for the same reason `rowsReconciled` is: this is a durable
+	* mutation nobody asked for, and a migration that quietly erases hour rows is
+	* the same failure as one that quietly skips them (D295).
+	*
+	* The production drain of 2026-08-30 would have reported 11 074 here — the
+	* ledger claimed 5.65 GB of footage that no longer existed.
+	*/
+	rowsForgotten: number().int().nonnegative().optional(),
 	startedAt: number(),
 	finishedAt: number().nullable(),
 	error: string().nullable()
@@ -8392,6 +8406,91 @@ var RelocateResidueSchema = object({
 	segments: number().int().nonnegative(),
 	bytes: number().int().nonnegative()
 }).nullable();
+/**
+* Ask one location whether its durable hour rows describe the disk — the walk
+* (D319).
+*
+* `apply` DEFAULTS TO FALSE and that default is the product: the operator's
+* missing tool is the question, and the dry run is how they sanity-check the
+* destructive run before authorising it.
+*/
+var LedgerWalkInputSchema = object({
+	locationId: string().min(1),
+	/** Forget the confirmed-absent rows, rather than only counting them. */
+	apply: boolean().optional(),
+	/** Narrow to one camera. */
+	deviceId: number().int().positive().optional(),
+	/** Narrow to these recording profiles; empty/absent = every profile. */
+	profiles: array(string().min(1)).optional()
+});
+/** Why a whole walk did nothing. Every one leaves the ledger untouched. */
+var LedgerWalkRefusalSchema = _enum([
+	"location-unknown",
+	"source-writable",
+	"no-ledger",
+	"archive-unreadable",
+	"anchor-absent",
+	"anchor-unreadable",
+	"anchor-moved"
+]);
+_enum([
+	"live-tail",
+	"listing-error",
+	"path-mismatch",
+	"durable-refused"
+]);
+/** Every skip reason, always present, always a number — so a reason that never
+*  fired reports as zero rather than absent and the report shape is constant
+*  between passes. Spelled out rather than `z.record` for exactly that. */
+var LedgerWalkSkipCountsSchema = object({
+	"live-tail": number().int().nonnegative(),
+	"listing-error": number().int().nonnegative(),
+	"path-mismatch": number().int().nonnegative(),
+	"durable-refused": number().int().nonnegative()
+});
+/** One camera's share of a walk, so a report names cameras and not rows. */
+var LedgerWalkDeviceReportSchema = object({
+	deviceId: number().int(),
+	hoursWalked: number().int().nonnegative(),
+	hoursMissing: number().int().nonnegative(),
+	ghostSegments: number().int().nonnegative(),
+	ghostBytes: number().int().nonnegative(),
+	forgottenSegments: number().int().nonnegative(),
+	orphanFiles: number().int().nonnegative()
+});
+/**
+* What one walk claimed, listed, found and (only when armed) forgot.
+*
+* `archiveSegments` is the **M** and `segmentsClaimed` the **N** (D295), so a
+* walk that saw a fraction of the location is visible in its own report rather
+* than in the absence of one.
+*/
+var LedgerWalkReportSchema = object({
+	locationId: string(),
+	applied: boolean(),
+	refused: LedgerWalkRefusalSchema.nullable(),
+	archiveSegments: number().int().nonnegative().nullable(),
+	archiveBytes: number().int().nonnegative().nullable(),
+	hoursClaimed: number().int().nonnegative(),
+	hoursWalked: number().int().nonnegative(),
+	hoursMissing: number().int().nonnegative(),
+	/** `readdir` calls issued — the cost, stated in the unit that is paid. */
+	listings: number().int().nonnegative(),
+	segmentsClaimed: number().int().nonnegative(),
+	ghostSegments: number().int().nonnegative(),
+	ghostBytes: number().int().nonnegative(),
+	ghostHoursWhole: number().int().nonnegative(),
+	forgottenSegments: number().int().nonnegative(),
+	forgottenBytes: number().int().nonnegative(),
+	/** Files under a claimed hour that no durable row names. Never deleted. */
+	orphanFiles: number().int().nonnegative(),
+	orphanSample: array(string()).readonly(),
+	hoursSkipped: number().int().nonnegative(),
+	skippedByReason: LedgerWalkSkipCountsSchema,
+	/** The walk stopped at its per-pass hour bound with claims unwalked. */
+	bounded: boolean(),
+	byDevice: array(LedgerWalkDeviceReportSchema).readonly()
+});
 /** How many rows a media pass would still act on against a given target — the
 *  media lane's denominator AND its residue, from ONE derivation so the two can
 *  never disagree. `null` = the count could not be taken. */
@@ -19024,13 +19123,15 @@ var ListGroupsPageSchema = object({
 	groups: array(AnalyticsGroupRecordSchema).readonly(),
 	nextCursor: string().nullable()
 });
+var KEY_EVENTS_DEFAULT_LIMIT = 50;
+var KEY_EVENTS_MAX_LIMIT = 200;
 var KeyEventQueryInput = object({
 	deviceId: number(),
 	/** Window lower bound (track firstSeen ≥ since). */
 	since: number(),
 	/** Window upper bound (track firstSeen ≤ until). */
 	until: number(),
-	limit: number().int().min(1).max(200).default(50),
+	limit: number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
 	/** Drop tracks scoring below this importance. */
 	minImportance: number().min(0).max(1).optional(),
 	/** Restrict to a single class (e.g. 'person'). */
@@ -19052,6 +19153,32 @@ var KeyEventSchema = object({
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
+/** `getKeyEvents`' window and filters, asked of a SET of cameras at once. */
+var KeyEventBatchQueryInput = object({
+	deviceIds: array(number()).min(1).max(200),
+	since: number(),
+	until: number(),
+	/** Applied PER CAMERA, exactly as `getKeyEvents.limit` is — never a total
+	*  across the set, which would let a busy camera starve a quiet one of its
+	*  rows and change what the merged feed contains. */
+	limit: number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
+	minImportance: number().min(0).max(1).optional(),
+	classFilter: string().optional()
+});
+/**
+* One camera's key events in a batch answer.
+*
+* The row exists for every requested id. `getKeyEvents` degrades to `[]` on
+* error rather than throwing, so a camera whose store read failed and one with
+* no events in the window were ALREADY indistinguishable per camera — the
+* batch does not make that worse, and the row keeps the deviceId the single
+* method's output never carried (the caller used to stamp it from the fan-out
+* key, which only worked because there was one query per camera).
+*/
+var KeyEventsForDeviceSchema = object({
+	deviceId: number(),
+	events: array(KeyEventSchema).readonly()
+});
 object({
 	trackId: string(),
 	className: string(),
@@ -19123,6 +19250,50 @@ var EventStoreFootprintSchema = object({
 	totalBytes: number().int(),
 	devices: array(EventStoreDeviceFootprintSchema).readonly()
 });
+/** Event-media footprint for one {@link MediaFileKind}. */
+var EventMediaKindFootprintSchema = object({
+	kind: MediaFileKindEnum,
+	/** Media rows of this kind. */
+	rows: number().int(),
+	/** Bytes on disk held by those rows. */
+	bytes: number().int()
+});
+/**
+* The media footprint broken down by KIND — the axis a deletion decision
+* actually turns on.
+*
+* A byte total says how much there is; it cannot say what is safe to remove.
+* The deletable set (the periodic `snapshot` filmstrip, the surplus per-edge
+* motion stills) and the keep set (`firstFrame`, rolling `lastFrame`,
+* `thumbnail`/`thumbnailSmall`, `keyFrame`/`keyFrameSmall`, the face/plate
+* buffers, gallery media, the CLIP `crop`) are distinguished by `kind` and by
+* nothing else, so sizing a deletion means summing per kind.
+*
+* ## Why `unaccounted*` exists
+*
+* `kinds` is enumerated from {@link MediaFileKindEnum} — the closed set the
+* writers use — and summed one kind at a time. `totalRows` / `totalBytes` come
+* from a SEPARATE unfiltered aggregate over the same rows, never from adding
+* `kinds` up. A row whose stored `kind` is not in the enum (written by a
+* retired code path, or by a version that knew a kind this one does not) would
+* otherwise vanish from the total silently, and an operator would delete
+* against a denominator smaller than the disk.
+*
+* `unaccountedRows` / `unaccountedBytes` are the difference. They are normally
+* zero; a non-zero value is a real finding and must be shown, not rounded away.
+*/
+var EventMediaKindBreakdownSchema = object({
+	/** Every media row in scope, from one unfiltered aggregate. */
+	totalRows: number().int(),
+	/** Every media byte in scope, from that same aggregate. */
+	totalBytes: number().int(),
+	/** Per-kind footprint, ordered by bytes descending. */
+	kinds: array(EventMediaKindFootprintSchema).readonly(),
+	/** `totalRows` minus the summed `kinds` rows — see the schema note. */
+	unaccountedRows: number().int(),
+	/** `totalBytes` minus the summed `kinds` bytes — see the schema note. */
+	unaccountedBytes: number().int()
+});
 /** Per-kind counts returned by the event-prune / device-delete mutations. */
 var EventPruneCountsSchema = object({
 	motion: number().int(),
@@ -19277,7 +19448,7 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	until: number().optional(),
 	kinds: array(string()).optional(),
 	limit: number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT)
-}), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(object({
+}), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(KeyEventBatchQueryInput, array(KeyEventsForDeviceSchema).readonly()), method(object({
 	deviceId: number(),
 	since: number(),
 	until: number(),
@@ -19326,6 +19497,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), TrackFlagsSchema, { kind: "mutation" }), method(object({}), EventStoreFootprintSchema, {
 	kind: "query",
 	auth: "admin"
+}), method(object({ deviceId: number().int().optional() }), EventMediaKindBreakdownSchema, {
+	kind: "query",
+	auth: "admin"
 }), method(object({
 	olderThanMs: number(),
 	reason: OpsLogReasonSchema.optional()
@@ -21381,6 +21555,20 @@ method(object({
 	error: string().optional()
 }), { auth: "admin" }), method(_void(), array(ProviderListEntrySchema).readonly()), method(object({
 	providerId: string(),
+	/**
+	* The location this config is an UNSAVED edit of, when there is one.
+	*
+	* `listLocations` replaces every declared secret with the redaction
+	* sentinel, so the edit modal's form state holds the sentinel for any
+	* credential the operator did not retype — and posting that here
+	* without a way to resolve it makes the provider try to authenticate
+	* as `__camstack_redacted__` and report the operator's own working
+	* password as wrong. Given this id, the orchestrator restores each
+	* sentinel from the stored config (same rule as `upsertLocation`)
+	* before dispatching. Omitted by the "Add location" wizard, where
+	* every value was typed just now and nothing is stored yet.
+	*/
+	locationId: string().optional(),
 	config: record(string(), unknown())
 }), object({
 	ok: boolean(),
@@ -28739,6 +28927,9 @@ method(object({
 }), method(RelocateResidueInputSchema, RelocateResidueSchema, {
 	kind: "query",
 	auth: "admin"
+}), method(LedgerWalkInputSchema, LedgerWalkReportSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
@@ -29130,6 +29321,25 @@ var SceneMonitorStatusSchema = object({
 	monitors: array(SceneMonitorSchema),
 	lastFetchedAt: number()
 });
+/**
+* One camera's row in a `listScenesBatch` answer.
+*
+* `status` is NULLABLE and the nullability is the whole point. `scene-monitor`
+* is a `defaultActive` wrapper, so every camera is asked; a camera whose
+* provider is absent (pipeline-analytics not deployed, the post-processing node
+* down) cannot answer, and that is not the same fact as a camera with no scenes
+* configured. Fanned out per camera the difference was visible — one query
+* errored while the others resolved — and a batch that returned only the rows
+* it managed would have destroyed it, silently, by making an unreachable camera
+* indistinguishable from one that answered `monitors: []`.
+*
+* So: EVERY requested deviceId gets a row. `status: null` means "this camera
+* could not be read"; `status.monitors: []` means "read, and it has none".
+*/
+var SceneMonitorStatusForDeviceSchema = object({
+	deviceId: number(),
+	status: SceneMonitorStatusSchema.nullable()
+});
 var sceneMonitorCapability = {
 	name: "scene-monitor",
 	scope: "device",
@@ -29139,6 +29349,22 @@ var sceneMonitorCapability = {
 	deviceTypes: [DeviceType.Camera],
 	methods: {
 		listScenes: method(object({ deviceId: number() }), SceneMonitorStatusSchema),
+		/**
+		* The same answer, for a SET of cameras, in one round trip.
+		*
+		* `/scenes` renders every camera and re-reads them on a 30s safety-net
+		* poll behind the push slice. Fanned out client-side that was one query
+		* per camera — 29 round trips through the browser, the hub and the
+		* post-analysis runner every 30 seconds to read an in-memory map the
+		* owner had already merged. The work is unchanged (`statusFor` per
+		* device, all in-process at the owner); what collapses is the transport.
+		*
+		* A camera that cannot answer still gets a row, with `status: null` —
+		* see {@link SceneMonitorStatusForDeviceSchema}. Never fewer rows than
+		* ids: a caller that asked for twenty-nine and got twenty-seven cannot
+		* tell which two are missing, or that any are.
+		*/
+		listScenesBatch: method(object({ deviceIds: array(number()).min(1).max(200) }), array(SceneMonitorStatusForDeviceSchema).readonly()),
 		createScene: method(object({
 			deviceId: number(),
 			label: string(),
@@ -30974,6 +31200,27 @@ var CameraOccupancySnapshotSchema = object({
 	stationaryObjects: array(StationaryObjectSchema).readonly().optional()
 });
 /**
+* One camera's row in a `getCurrentSnapshotBatch` answer.
+*
+* THREE outcomes, and the single-camera method could only express two of them
+* because `snapshot: null` was already spoken for:
+*
+*  - `read: 'read'`, `snapshot` present — the live occupancy reading.
+*  - `read: 'read'`, `snapshot: null`   — read, and this camera has no reading
+*    yet: no frame since boot, and no parked-object registry to hydrate from.
+*  - `read: 'unreadable'`               — the owner could not answer for this
+*    camera. `snapshot` is null, and it does NOT mean "nothing parked here".
+*
+* Collapsing the last two is the failure this field exists to prevent: a
+* hydration that threw would otherwise render as an empty Stationary section,
+* which is a definite claim about a camera nobody could read.
+*/
+var CameraOccupancySnapshotForDeviceSchema = object({
+	deviceId: number(),
+	read: _enum(["read", "unreadable"]),
+	snapshot: CameraOccupancySnapshotSchema.nullable()
+});
+/**
 * Time-series resolution. The history methods return one bucket per
 * step over the requested range. Smaller resolutions cost more
 * memory + bandwidth; bound to discrete steps so caller cannot ask
@@ -31030,6 +31277,20 @@ var zoneAnalyticsCapability = {
 		*  (no inference result emitted since boot or since binding was
 		*  activated). */
 		getCurrentSnapshot: method(object({ deviceId: number() }), CameraOccupancySnapshotSchema.nullable()),
+		/**
+		* The same snapshot, for a SET of cameras, in one round trip.
+		*
+		* The Events page's Stationary section polls this every 15s for every
+		* selected camera. Fanned out client-side that is one query per camera to
+		* read a `Map.get` at the owner — the answer costs nothing, the round trip
+		* costs everything. Batched, N transports become one and the per-device
+		* work is unchanged.
+		*
+		* Every requested deviceId gets a row, tagged `read` — see
+		* {@link CameraOccupancySnapshotForDeviceSchema}. A camera the owner could
+		* not answer for is `'unreadable'`, never an empty reading.
+		*/
+		getCurrentSnapshotBatch: method(object({ deviceIds: array(number()).min(1).max(200) }), array(CameraOccupancySnapshotForDeviceSchema).readonly()),
 		/** Time-series object count inside one zone. `className` optional —
 		*  omit to count every class in the zone. */
 		getZoneHistory: method(object({
@@ -35427,6 +35688,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getEventMediaFootprintByKind": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getEventStoreFootprint": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -35445,6 +35712,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getKeyEventsBatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -36621,6 +36894,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.reconcileLedgerAgainstDisk": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.refreshStorageLocationsForMigration": {
 		capName: "recording",
 		capScope: "system",
@@ -36747,6 +37026,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"sceneMonitor.listScenesBatch": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.recheckNow": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -38103,6 +38388,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"zoneAnalytics.getCurrentSnapshotBatch": {
+		capName: "zone-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"zoneAnalytics.getUnzonedHistory": {
 		capName: "zone-analytics",
 		capScope: "device",
@@ -39092,6 +39383,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getEventMediaFootprintByKind": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"pipelineAnalytics.getGroup": [{
 		name: "deviceId",
 		form: "single",
@@ -39102,6 +39398,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getKeyEventsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"pipelineAnalytics.getMotionEvents": [{
 		name: "deviceId",
 		form: "single",
@@ -39542,6 +39843,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.reconcileLedgerAgainstDisk": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"recording.relocateFootage": [{
 		name: "deviceId",
 		form: "single",
@@ -39607,6 +39913,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"sceneMonitor.listScenesBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"sceneMonitor.recheckNow": [{
 		name: "deviceId",
 		form: "single",
@@ -39868,6 +40179,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"zoneAnalytics.getCurrentSnapshotBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"zoneAnalytics.getUnzonedHistory": [{
 		name: "deviceId",
 		form: "single",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-provider-wyze",
-  "version": "0.2.51",
+  "version": "0.2.53",
   "description": "Wyze camera device-provider addon for CamStack — wraps the @apocaliss92/wyze-bridge-js P2P/DTLS client, feeding the stream-broker via the pull-rfc4571 lazy-publish path (a structural twin of addon-provider-reolink)",
   "keywords": [
     "camstack",