@camstack/addon-provider-reolink 1.2.182 → 1.2.184

package/dist/addon.mjs

@@ -10,6 +10,7 @@ import * as crypto$7 from "crypto";
 import crypto$1, { createHash as createHash$1, randomUUID } from "crypto";
 import { execFile, spawn } from "child_process";
 import { createServer } from "node:http";
+import "node:zlib";
 import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { join as join$1 } from "node:path";
 import { PassThrough } from "stream";
@@ -27,7 +28,7 @@ import { URL as URL$1 } from "url";
 import { spawn as spawn$1 } from "node:child_process";
 import os, { tmpdir } from "node:os";
 import { createReadStream } from "node:fs";
-//#region ../types/dist/event-category-DaIZi00R.mjs
+//#region ../types/dist/event-category-C4hVnRo8.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -246,7 +247,17 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["RecordingStopped"] = "recording.stopped";
 	EventCategory["RecordingError"] = "recording.error";
 	EventCategory["RecordingHealthDegraded"] = "recording.health.degraded";
+	/** Recording enabled but no segment finalized for the NC stall window. */
+	EventCategory["RecordingHealthStalled"] = "recording.health.stalled";
+	/** Recovery from {@link RecordingHealthStalled}. */
+	EventCategory["RecordingHealthOk"] = "recording.health.ok";
 	EventCategory["RecordingStorageCritical"] = "recording.storage.critical";
+	/** Free space on a storage location crossed the warn bar. */
+	EventCategory["StorageLocationLow"] = "storage.location.low";
+	/** Free space at/under the critical bar, or capacity probe failed (`null`). */
+	EventCategory["StorageLocationCritical"] = "storage.location.critical";
+	/** Recovery from low/critical on a storage location. */
+	EventCategory["StorageLocationOk"] = "storage.location.ok";
 	EventCategory["RecordingSegmentWritten"] = "recording.segment.written";
 	EventCategory["RecordingPolicyFallback"] = "recording.policy.fallback";
 	EventCategory["RecordingRetentionCompleted"] = "recording.retention.completed";
@@ -5405,7 +5416,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-r3RWkGVx.mjs
+//#region ../types/dist/sleep-vWTnHq9G.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -8010,6 +8021,21 @@ var ProfileRtspEntrySchema = object({
 	codec: string().optional(),
 	resolution: CamStreamResolutionSchema.optional()
 });
+/**
+* The model weight formats a catalog entry can ship. Schema-free on purpose:
+* `types/models.ts` builds Zod schemas from it, but a runner-closure consumer
+* (the model downloader in `@camstack/system`) needs only the list and must
+* reach it through `@camstack/types/addon` without building the cap schema
+* graph (D28).
+*/
+var MODEL_FORMATS = [
+	"onnx",
+	"coreml",
+	"openvino",
+	"tflite",
+	"pt",
+	"gguf"
+];
 object({
 	field: string().min(1),
 	on: literal("advance")
@@ -8608,7 +8634,7 @@ var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
 	return DeviceRole;
 }({});
 //#endregion
-//#region ../types/dist/composition-Bzr7GwgP.mjs
+//#region ../types/dist/composition-C-WpVYTX.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -8660,7 +8686,7 @@ var BASE = `https://github.com/jellyfin/jellyfin-ffmpeg/releases/download/v${FFM
 function portable(target) {
 	return `${BASE}/jellyfin-ffmpeg_${FFMPEG_RELEASE}_portable_${target}-gpl.tar.xz`;
 }
-portable("linux64"), portable("linuxarm64"), portable("macarm64"), portable("mac64");
+portable("linux64"), portable("linuxarm64"), portable("macarm64"), portable("mac64"), `${BASE}${FFMPEG_RELEASE}`;
 /**
 * THE table "which boolean of this device type counts as HIGH", and the
 * pure evaluator of its EDGE.
@@ -9463,6 +9489,16 @@ var CompositionSchema = object({
 		seen.add(feature.cap);
 	});
 });
+var NodeColorIdSchema = _enum([
+	"node-a",
+	"node-b",
+	"node-c",
+	"node-d",
+	"node-e",
+	"node-f",
+	"node-g",
+	"node-h"
+]);
 new Set([
 	"track",
 	"face",
@@ -12394,14 +12430,6 @@ var MASK_SUPPLY_STEP_IDS = ["segmentation"];
 	...CROP_SUPPLY_STEP_IDS,
 	...MASK_SUPPLY_STEP_IDS
 ];
-var MODEL_FORMATS = [
-	"onnx",
-	"coreml",
-	"openvino",
-	"tflite",
-	"pt",
-	"gguf"
-];
 /**
 * Multi-file format payload.
 *
@@ -14225,7 +14253,14 @@ var BrokerProviderInfoSchema = object({
 	/** Broker kinds this provider can create, with a display label. */
 	kinds: array(object({
 		kind: string(),
-		label: string()
+		label: string(),
+		/**
+		* Relative hub path to start an interactive account link (OAuth popup).
+		* May include `{{brokerId}}`; admin-ui substitutes and appends `?popup=1`.
+		*/
+		interactiveConnectPath: string().min(1).optional(),
+		/** Relative hub path to disconnect the linked account (same popup pattern). */
+		interactiveDisconnectPath: string().min(1).optional()
 	}))
 });
 var ListInputSchema = object({ 
@@ -19176,14 +19211,14 @@ var LlmProfileSchema = object({
 /** ConfigUISchema tree passed through untyped on the wire (the
 *  notification-output `ConfigSchemaPassthrough` precedent at
 *  notification-output.cap.ts:151); the exported TS type re-tightens it. */
-var ConfigSchemaPassthrough$1 = unknown();
+var ConfigSchemaPassthrough$3 = unknown();
 var LlmProfileKindDescriptorSchema = object({
 	kind: LlmProfileKindSchema,
 	label: string(),
 	icon: string(),
 	/** Stamped by each provider so the concat-fanned catalog stays routable. */
 	addonId: string(),
-	configSchema: ConfigSchemaPassthrough$1
+	configSchema: ConfigSchemaPassthrough$3
 });
 var LlmDefaultSelectorSchema = union([object({ consumer: string() }), object({ purpose: _enum(["text", "vision"]) })]);
 var LlmDefaultSchema = object({
@@ -20325,7 +20360,7 @@ var TargetKindCapsSchema = object({
 * the union is large and not meant for runtime validation here; the exported
 * `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
 */
-var ConfigSchemaPassthrough = unknown();
+var ConfigSchemaPassthrough$2 = unknown();
 var TargetKindSchema = object({
 	kind: string(),
 	label: string(),
@@ -20362,7 +20397,7 @@ var TargetKindSchema = object({
 	* its raster path, which is the safe default for an unknown image.
 	*/
 	iconMediaType: string().optional(),
-	configSchema: ConfigSchemaPassthrough,
+	configSchema: ConfigSchemaPassthrough$2,
 	/**
 	* The config keys that decide WHERE this kind's secrets are sent (server,
 	* base URL, instance, chat, recipient). A save that changes any of them
@@ -21319,6 +21354,12 @@ var NcSystemEventKindSchema = _enum([
 	"node-updating",
 	"node-inference-unavailable",
 	"detection-blind",
+	"recording-stalled",
+	"recording-healthy",
+	"recording-degraded",
+	"storage-location-low",
+	"storage-location-critical",
+	"storage-location-ok",
 	"addon-crash-loop",
 	"addon-update-available",
 	"server-update-available",
@@ -23699,6 +23740,61 @@ var OauthIntegrationDescriptorSchema = object({
 });
 method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" });
 /**
+* `oidc-connections` — CRUD for IdP rows under `auth-oidc` (D828 sibling).
+*
+* One hub-only singleton (`auth-oidc`). The Settings UI is a DataTable +
+* ItemFormDialog; there is no `editable-array` in `globalSettingsSchema`.
+* Operator-chosen `id` is the URL slug (`/addon/auth-oidc/<id>/…`) and is
+* immutable after create.
+*/
+var ConfigSchemaPassthrough$1 = unknown();
+var OidcConnectionSchema = object({
+	id: string().min(1),
+	displayName: string(),
+	icon: string(),
+	issuerUrl: string(),
+	clientId: string(),
+	/** Client id + secret present — never the secret value. */
+	configured: boolean(),
+	/**
+	* Values for the connection form schema. `clientSecret` is a keychain
+	* {@link SecretFieldView} or `null` / `''`, never plaintext (D789).
+	*/
+	formValues: record(string(), unknown()).optional()
+});
+/**
+* Patch one connection. Omitted or empty `clientSecret` keeps the stored
+* secret (D787). `{ $secretClear: true }` clears it. `id` is never renamed.
+*/
+var OidcConnectionUpdateInputSchema = object({
+	id: string().min(1),
+	displayName: string().min(1),
+	icon: string().optional(),
+	issuerUrl: string().optional(),
+	clientId: string().optional(),
+	clientSecret: union([string(), object({ $secretClear: literal(true) })]).optional(),
+	redirectUri: string().optional(),
+	scopes: string().optional(),
+	usernameClaim: _enum([
+		"preferred_username",
+		"email",
+		"sub"
+	]).optional()
+});
+method(object({}), ConfigSchemaPassthrough$1, { auth: "admin" }), method(object({}), array(OidcConnectionSchema).readonly(), { auth: "admin" }), method(object({
+	id: string().min(1).regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "id must be a lowercase slug"),
+	displayName: string().min(1)
+}), object({ id: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(OidcConnectionUpdateInputSchema, object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ id: string().min(1) }), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * What started a camera's onboard motion (D672). `camera` is the camera's own
 * firmware; `sensor` is a device the operator ATTACHED to it. Absent on the
 * wire means the camera: only the camera-sensors bridge ever says `sensor`.
@@ -25055,24 +25151,69 @@ var RetrainFrameListSchema = object({
 	/** What the page pre-selects — the native key frame when one survives. */
 	autoPickMediaId: number().int().optional()
 });
+/** Exclusive partition of a corpus copy's annotation progress (design §4.2). */
+var RetrainFrameWorkStateSchema = _enum([
+	"unannotated",
+	"annotated",
+	"complete"
+]);
+/**
+* Filters for paginated corpus list, KPI, and matching export (design §4.4).
+* Every narrowing field is ANDed; omitted fields impose no constraint.
+*/
+var RetrainCorpusFilterSchema = object({
+	workState: RetrainFrameWorkStateSchema.optional(),
+	deviceIds: array(number()).max(500).optional(),
+	/** When set, only frames in this named collection. */
+	collectionId: string().optional(),
+	/** Frames that carry at least one saved annotation in one of these classes. */
+	classes: array(RetrainMacroClassSchema).optional(),
+	page: number().int().positive().default(1),
+	pageSize: number().int().positive().max(100).default(50)
+});
+var RetrainCorpusPageSchema = object({
+	frames: array(RetrainFrameSchema.extend({ workState: RetrainFrameWorkStateSchema })).readonly(),
+	total: number().int().nonnegative(),
+	page: number().int().positive(),
+	pageSize: number().int().positive()
+});
+var RetrainCorpusKpiCameraRowSchema = object({
+	deviceId: number(),
+	unannotated: number().int().nonnegative(),
+	annotated: number().int().nonnegative(),
+	complete: number().int().nonnegative(),
+	/** This camera's `complete` count divided by corpus `total`, in `[0,1]`.
+	*  `null` when the corpus is empty (no ratio). */
+	pctOfCorpus: number().min(0).max(1).nullable()
+});
+var RetrainCorpusKpiSchema = object({
+	total: number().int().nonnegative(),
+	unannotated: number().int().nonnegative(),
+	annotated: number().int().nonnegative(),
+	complete: number().int().nonnegative(),
+	cameras: array(RetrainCorpusKpiCameraRowSchema).readonly()
+});
 /**
 * Which frames an annotated export carries. Every field narrows; an empty
-* filter is every annotated copy. A dataset VERSION is a frozen `frameIds`
-* list owned by whoever trains (the training orchestrator), so `frameIds` is
-* the primitive a version export uses; `batchId` re-selects what an earlier
-* export carried (`exportedInBatch`).
+* filter is every annotated copy. `frameIds` is the primitive a job or
+* download uses; `batchId` re-selects what an earlier export carried
+* (`exportedInBatch`). Frozen dataset versions were removed — live selection
+* resolves to `frameIds` at plan/start.
 */
 var RetrainExportFilterSchema = object({
 	deviceIds: array(number()).optional(),
 	frameIds: array(string()).max(2e4).optional(),
 	/** Only frames in at least one of these named collections. */
 	collectionIds: array(string()).max(200).optional(),
-	/** Exactly the frames of this dataset version (and its completeOnly). An
-	*  unknown id selects nothing. */
-	datasetVersionId: string().optional(),
+	/** Single collection (Frames filter bar). ANDed with `collectionIds` when both set. */
+	collectionId: string().optional(),
 	batchId: string().optional(),
 	/** Only frames the operator marked complete (all subjects boxed). */
-	completeOnly: boolean().optional()
+	completeOnly: boolean().optional(),
+	/** Exclusive work-state partition (`workStateOf`); same as the corpus list. */
+	workState: RetrainFrameWorkStateSchema.optional(),
+	/** Frames with at least one saved annotation in one of these classes. */
+	classes: array(RetrainMacroClassSchema).optional()
 });
 /**
 * `frames`: the full frame copies, boxes in `annotations.json`.
@@ -25272,8 +25413,7 @@ var RetrainDatasetStatsSchema = object({
 		completeFrames: number().int()
 	})).readonly()
 });
-/** An immutable dataset version, without its frame list. */
-var RetrainDatasetVersionSchema = object({
+object({
 	id: string(),
 	name: string(),
 	createdAt: number(),
@@ -25281,22 +25421,33 @@ var RetrainDatasetVersionSchema = object({
 	layout: RetrainExportLayoutSchema,
 	completeOnly: boolean(),
 	frameCount: number().int(),
-	/** sha256 of what the frames taught when the version was frozen. */
 	annotationHash: string(),
-	/** The export manifest schema the version was cut under. */
 	manifestSchema: string(),
 	stats: RetrainDatasetStatsSchema
 });
-var CreateRetrainDatasetVersionResultSchema = discriminatedUnion("kind", [object({
-	kind: literal("created"),
-	version: RetrainDatasetVersionSchema
+/**
+* Live training corpus criteria — same shape as `TrainingCorpusSelection` on
+* the training cap. Resolved here so plan/start and the annotated export share
+* one definition of "the frames" (`buildRetrainExportPlan`).
+*/
+var RetrainTrainingCorpusSelectionSchema = object({
+	collectionIds: array(string()).min(1),
+	workState: _enum([
+		"complete",
+		"annotated_or_complete",
+		"any_annotated"
+	]).default("complete")
+});
+var RetrainTrainingCorpusResolveResultSchema = discriminatedUnion("kind", [object({
+	kind: literal("resolved"),
+	frameIds: array(string()).max(2e4).readonly(),
+	stats: RetrainDatasetStatsSchema,
+	annotationHash: string(),
+	layout: RetrainExportLayoutSchema
 }), object({
 	kind: literal("refused"),
-	reason: _enum([
-		"empty-name",
-		"duplicate-name",
-		"no-frames"
-	])
+	reason: _enum(["unknown-collection", "no-frames"]),
+	detail: string()
 })]);
 /** The outcome of a lifecycle move owned by the retrain page. */
 var RetrainTransitionResultSchema = object({
@@ -26003,6 +26154,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), array(RetrainTrackSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
+}), method(RetrainCorpusFilterSchema, RetrainCorpusPageSchema, {
+	kind: "query",
+	auth: "admin"
+}), method(object({}), RetrainCorpusKpiSchema, {
+	kind: "query",
+	auth: "admin"
 }), method(object({ trackId: string() }), RetrainFrameListSchema, {
 	kind: "query",
 	auth: "admin"
@@ -26098,36 +26255,6 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: 12e4
-}), method(object({
-	selection: RetrainDatasetSelectionSchema,
-	completeOnly: boolean().optional()
-}), RetrainDatasetStatsSchema, {
-	kind: "query",
-	auth: "admin"
-}), method(object({
-	name: string().max(120),
-	selection: RetrainDatasetSelectionSchema,
-	layout: RetrainExportLayoutSchema,
-	completeOnly: boolean()
-}), CreateRetrainDatasetVersionResultSchema, {
-	kind: "mutation",
-	auth: "admin",
-	timeoutMs: 12e4
-}), method(object({}), array(RetrainDatasetVersionSchema).readonly(), {
-	kind: "query",
-	auth: "admin"
-}), method(object({ id: string() }), object({ deleted: boolean() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ id: string() }), object({
-	found: boolean(),
-	annotationHash: string(),
-	matches: boolean(),
-	missingFrames: number().int()
-}), {
-	kind: "query",
-	auth: "admin",
-	timeoutMs: 12e4
 }), method(object({}), array(RetrainAssistProfileSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
@@ -26154,6 +26281,10 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), method(object({}), array(RetrainCollectionSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
+}), method(RetrainTrainingCorpusSelectionSchema, RetrainTrainingCorpusResolveResultSchema, {
+	kind: "query",
+	auth: "admin",
+	timeoutMs: 6e4
 }), method(object({
 	id: string(),
 	name: string().max(120)
@@ -26770,11 +26901,14 @@ var HardwareClassIdSchema = _enum([
 	"intel-n-series",
 	"apple-m-base",
 	"apple-m-pro",
+	"amd-phoenix",
 	"unknown"
 ]);
 var AcceleratorKindSchema = _enum([
 	"intel-npu",
 	"intel-igpu",
+	"amd-igpu",
+	"amd-npu",
 	"x86-cpu",
 	"arm-cpu",
 	"apple-ane",
@@ -28704,6 +28838,8 @@ var AgentPipelineSettingsSchema = object({
 	* address is wrong (multi-homed host, NAT, custom interface).
 	*/
 	reachableHost: string().optional(),
+	/** Hub-persisted UI colour (`--color-node-*` theme tokens). */
+	color: NodeColorIdSchema.optional(),
 	/**
 	* Multi-device inference opt-in (Phase 4). Per-node map deviceKey → {enabled,
 	* weight, steps}. Absent / all-disabled ⇒ the node's single default
@@ -29253,8 +29389,9 @@ method(object({
 	auth: "admin"
 }), method(object({
 	agentNodeId: string(),
-	reachableHost: string().nullable()
-}), object({ success: literal(true) }), {
+	reachableHost: string().nullable().optional(),
+	color: NodeColorIdSchema.nullable().optional()
+}).refine((v) => v.reachableHost !== void 0 || v.color !== void 0, { message: "reachableHost or color required" }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -32852,7 +32989,7 @@ var CustomActionInputSchema = object({
 	action: string().min(1),
 	input: unknown()
 });
-method(_void(), array(AddonListItemSchema).readonly()), method(object({
+method(object({ nodeId: string().optional() }).optional(), array(AddonListItemSchema).readonly()), method(object({
 	addonId: string(),
 	limit: number().min(1).max(500).default(100),
 	level: LogLevelSchema$2.optional()
@@ -33322,6 +33459,17 @@ var BatteryStatusSchema = object({
 	*/
 	lastContactAt: number().optional(),
 	/**
+	* Ms epoch of the last COMPLETE scheduled refresh — every fact the provider
+	* holds for the device (level, charging, link, device info, state slices) and
+	* its cached snapshot, read together. Absent = never since this slice was
+	* born. Unlike `lastUpdated` (any write, even a push of one field) this is
+	* the staleness an operator can trust: the provider owns the device fact and
+	* so owns the window on its age (D224, D847). Not a clock in the
+	* runtime-state-durability sense: it moves once per window and must survive
+	* a restart, or every restart would owe the camera a wake.
+	*/
+	lastFullRefreshAt: number().optional(),
+	/**
 	* True when the source is a BINARY low-battery indicator (HA
 	* `binary_sensor` device_class=battery / `LOW_BAT`) that has no real
 	* charge level — `percentage` is then a coarse stand-in (100 = normal,
@@ -38399,6 +38547,7 @@ var OsdNamedTemplateSchema = object({
 });
 /** Where a slot's value comes from. */
 var OsdSourceSchema = discriminatedUnion("kind", [
+	object({ kind: literal("none") }),
 	object({
 		kind: literal("static"),
 		text: string().max(64)
@@ -38525,6 +38674,13 @@ method(object({ deviceId: number().int() }), object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number().int(),
+	slotId: string().min(1),
+	enabled: boolean()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	sourceDeviceId: number().int(),
 	targetDeviceId: number().int()
@@ -38956,7 +39112,15 @@ var GpuInfoSchema = object({
 	name: string(),
 	memoryMB: number().optional()
 });
-var NpuInfoSchema = object({ type: _enum(["apple-ane", "intel-npu"]) });
+var NpuInfoSchema = object({
+	type: _enum([
+		"apple-ane",
+		"intel-npu",
+		"amd-xdna"
+	]),
+	name: string().optional(),
+	generation: _enum(["xdna1", "xdna2"]).optional()
+});
 var CoralInfoSchema = object({
 	type: literal("coral-edgetpu"),
 	bus: string().optional()
@@ -44203,9 +44367,11 @@ var zoneRulesCapability = {
 * once is what makes a second provider (RunPod, a local NVIDIA node) a new
 * manifest entry and nothing else.
 *
-* Collection, routed by the `addonId` in every single-row input (the `llm` /
-* `notification-output` posture); `describe` concat-fans across providers.
-* Every method is `admin`: these spend money.
+* Collection of provider **types** (addons). Each addon owns zero or more
+* **entries** (credentials + defaults). Concat-fans: `describe`,
+* `describeTypes`, `listEntries`, `listJobs`. Single-row work is keyed by
+* `entryId`; callers also pass the owning `addonId` as the collection
+* selector (broker posture). Every method is `admin`: these spend money.
 *
 * Every cloud object a provider creates is tagged with the orchestrator's
 * `jobKey`, so a retried submit finds the job it already started instead of
@@ -44229,8 +44395,8 @@ var TrainingRegionOptionSchema = object({
 	priceMultiplier: number().positive()
 });
 /**
-* The provider's per-account settings, as the orchestrator reads them. They
-* live in the PROVIDER addon's settings (operator decision 2026-10-08: they
+* The provider's per-entry settings, as the orchestrator reads them. They
+* live on the PROVIDER addon's entry (operator decision 2026-10-08: they
 * depend on the user's account), never hard-coded in the orchestrator.
 */
 var TrainingProviderDefaultsSchema = object({
@@ -44241,9 +44407,44 @@ var TrainingProviderDefaultsSchema = object({
 	/** Hours a FAILED job's cloud dataset is kept for debugging; 0 = delete at once. */
 	failedDatasetGraceHours: number().nonnegative()
 });
+/**
+* Entry form schema for a provider type — same seam as notification
+* `TargetKind.configSchema` (`z.unknown()` at the wire; callers tighten to
+* {@link ConfigUISchema}). Drives `ConfigFormBuilder` on Training → Providers.
+*/
+var ConfigSchemaPassthrough = unknown();
+/** One creatable provider type, for the Add-entry dialog. */
+var TrainingProviderTypeSchema = object({
+	typeId: string(),
+	label: string(),
+	/** Path under the addon package (e.g. `assets/training-modal/icon.svg`). */
+	iconAsset: string(),
+	/** Owning `training-provider` addon — collection selector for createEntry. */
+	addonId: string(),
+	/**
+	* Fields for one entry of this type (credentials + defaults). Absent on a
+	* type that only needs a name. Password fields are keychain-backed on the
+	* provider addon (`secretStatePaths`), not D634 plaintext.
+	*/
+	configSchema: ConfigSchemaPassthrough.optional()
+});
+/** One configured account / workspace under a provider type. */
+var TrainingProviderEntrySchema = object({
+	entryId: string(),
+	typeId: string(),
+	name: string(),
+	addonId: string(),
+	/** Credentials are present — never the values. */
+	configured: boolean()
+});
 var TrainingProviderDescriptorSchema = object({
 	addonId: string(),
-	/** `modal`, `runpod`, `fake`, … */
+	entryId: string(),
+	typeId: string(),
+	/** Operator-chosen entry name. */
+	name: string(),
+	iconAsset: string(),
+	/** `modal`, `runpod`, `fake`, … — same as typeId for current providers. */
 	kind: string(),
 	label: string(),
 	gpuTypes: array(TrainingGpuOptionSchema).readonly(),
@@ -44255,7 +44456,30 @@ var TrainingProviderDescriptorSchema = object({
 	dataResidencyNote: string(),
 	/** Credentials are present — never the values. */
 	configured: boolean(),
-	defaults: TrainingProviderDefaultsSchema
+	defaults: TrainingProviderDefaultsSchema,
+	/**
+	* Values for {@link TrainingProviderTypeSchema}'s `configSchema` — password
+	* fields are keychain {@link SecretFieldView} or `null` / `''` (create),
+	* never plaintext. Same hydrate contract as settings forms (D789).
+	*/
+	formValues: record(string(), unknown()).optional()
+});
+/**
+* Patch one entry's name, credentials and defaults. Pin with owning `{ addonId }`.
+* An omitted or empty `tokenSecret` means KEEP the stored secret (D787).
+* `{ $secretClear: true }` clears it.
+*/
+var TrainingProviderUpdateEntryInputSchema = object({
+	entryId: string().min(1),
+	name: string().min(1),
+	tokenId: string().optional(),
+	tokenSecret: union([string(), object({ $secretClear: literal(true) })]).optional(),
+	environment: string().optional(),
+	gpuType: string().optional(),
+	region: string().optional(),
+	costCapUsd: number().nonnegative().optional(),
+	maxRuntimeSec: number().int().positive().optional(),
+	failedDatasetGraceHours: number().nonnegative().optional()
 });
 var TrainingCredentialCheckSchema = object({
 	ok: boolean(),
@@ -44307,20 +44531,33 @@ var TrainerSourceRefSchema = object({
 	/** A commit sha (never a branch) — the job must be reproducible. */
 	revision: string().regex(/^[0-9a-f]{7,64}$/)
 });
+/** Cloud job identity — route with the owning addon's `addonId` selector. */
 var JobRef = {
-	addonId: string(),
+	entryId: string().min(1),
 	jobKey: string().uuid()
 };
 var TrainingLogLineSchema = object({
 	ts: number(),
 	text: string()
 });
-method(object({}), array(TrainingProviderDescriptorSchema).readonly(), { auth: "admin" }), method(object({ addonId: string() }), TrainingCredentialCheckSchema, {
+method(object({}), array(TrainingProviderDescriptorSchema).readonly(), { auth: "admin" }), method(object({}), array(TrainingProviderTypeSchema).readonly(), { auth: "admin" }), method(object({}), array(TrainingProviderEntrySchema).readonly(), { auth: "admin" }), method(object({
+	typeId: string().min(1),
+	name: string().min(1)
+}), object({ entryId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ entryId: string().min(1) }), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(TrainingProviderUpdateEntryInputSchema, object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ entryId: string().min(1) }), TrainingCredentialCheckSchema, {
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: 3e4
 }), method(object({
-	addonId: string(),
+	entryId: string().min(1),
 	gpuType: string(),
 	region: string(),
 	datasetBytes: number().int().nonnegative(),
@@ -44386,7 +44623,7 @@ method(object({}), array(TrainingProviderDescriptorSchema).readonly(), { auth: "
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: 5 * 6e4
-}), method(object({ addonId: string() }), array(ProviderJobStatusSchema).readonly(), {
+}), method(object({ entryId: string().min(1).optional() }), array(ProviderJobStatusSchema).readonly(), {
 	auth: "admin",
 	timeoutMs: 2 * 6e4
 });
@@ -44396,20 +44633,31 @@ method(object({}), array(TrainingProviderDescriptorSchema).readonly(), { auth: "
 *
 * It owns what every provider must agree on, written once:
 *
-* - **Dataset versions.** Taken over from pipeline-analytics (D796): the rows
-*   live here (D808); pipeline-analytics still CUTS a version (it owns the corpus and
-*   the export plan) and reaches this store through the five row methods
-*   below, so the Retrain page and the export did not change.
 * - **Jobs.** A persisted state machine, a reconcile loop against the
 *   provider, a cost guard, a daily orphan sweep and the retention rules.
 * - **The return flow.** Verified artefacts → Model Studio
 *   (`custom-model-registry.importModelBundle`) → canary on cameras →
 *   rollback. Nothing is ever registered automatically.
 *
+* Plan/start takes a live {@link TrainingCorpusSelection} (collections +
+* work-state rule); frame ids are resolved via pipeline-analytics at that
+* moment and snapshotted on the job. No frozen dataset version.
+*
 * Every method is `admin`.
 */
-/** A version WITH its frame list — what the export and a job read. */
-var TrainingDatasetVersionRowSchema = RetrainDatasetVersionSchema.omit({ frameCount: true }).extend({ frameIds: array(string()).max(2e4).readonly() });
+/**
+* Live corpus criteria for plan/start (design §5.2). Default is complete-only.
+* Frame ids are resolved at plan/start — never a frozen version id.
+*/
+var TrainingCorpusSelectionSchema = object({
+	collectionIds: array(string()).min(1),
+	/** Default complete-only for v1 */
+	workState: _enum([
+		"complete",
+		"annotated_or_complete",
+		"any_annotated"
+	]).default("complete")
+});
 /** A base model a detector job can fine-tune, and the baseline it is judged against. */
 var TrainingBaseModelSchema = object({
 	modelId: string(),
@@ -44427,9 +44675,13 @@ var TrainingPresetSchema = _enum([
 	"thorough"
 ]);
 var TrainingJobRequestSchema = object({
-	datasetVersionId: string().min(1),
-	/** The `training-provider` addon that runs it. */
-	addonId: string().min(1),
+	/** Live collection + work-state criteria; resolved at plan/start. */
+	selection: TrainingCorpusSelectionSchema,
+	/**
+	* The provider **entry** that runs it (credentials + defaults).
+	* Resolve to an owning addon via `training-provider.describe` / `listEntries`.
+	*/
+	entryId: string().min(1),
 	gpuType: string().min(1),
 	region: string(),
 	baseModelId: string().min(1),
@@ -44488,6 +44740,7 @@ var TrainingJobPlanSchema = object({
 * result lives after the operator acted on it.
 */
 var TrainingJobStateSchema = _enum([
+	"queued",
 	"uploading",
 	"submitted",
 	"starting",
@@ -44541,6 +44794,11 @@ var TrainingJobSchema = object({
 	createdAt: number(),
 	updatedAt: number(),
 	state: TrainingJobStateSchema,
+	/**
+	* Shared by every job enqueued together via `startJobBatch`.
+	* `null` for a lone `startJob`. The engine advances queued siblings by this id.
+	*/
+	batchId: string().nullable().default(null),
 	stage: TrainingStageSchema.nullable(),
 	failure: object({
 		reason: TrainingFailureReasonSchema,
@@ -44552,6 +44810,12 @@ var TrainingJobSchema = object({
 	maxRuntimeSec: number().int().positive(),
 	trainer: TrainerSourceRefSchema,
 	datasetLayout: RetrainExportLayoutSchema,
+	/** Frame count snapshotted when the job started (audit; equals `frameIds.length`). */
+	frameCount: number().int().nonnegative(),
+	/** Resolved frame ids at start — the archive ships exactly these. */
+	frameIds: array(string()).max(2e4).readonly(),
+	/** Hash of what those frames taught at start (trainer `dataset.annotationHash`). */
+	annotationHash: string(),
 	dataset: object({
 		bytes: number().int(),
 		sha256: string(),
@@ -44593,13 +44857,7 @@ var TrainingJobSchema = object({
 	canary: TrainingCanarySchema.nullable()
 });
 var IdInput = object({ id: string().min(1) });
-method(TrainingDatasetVersionRowSchema, object({ stored: boolean() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(IdInput, TrainingDatasetVersionRowSchema.nullable(), { auth: "admin" }), method(object({}), array(RetrainDatasetVersionSchema).readonly(), { auth: "admin" }), method(object({ name: string() }), object({ id: string().nullable() }), { auth: "admin" }), method(IdInput, object({ removed: boolean() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({}), array(TrainingBaseModelSchema).readonly(), { auth: "admin" }), method(TrainingJobRequestSchema, TrainingJobPlanSchema, {
+method(object({}), array(TrainingBaseModelSchema).readonly(), { auth: "admin" }), method(TrainingJobRequestSchema, TrainingJobPlanSchema, {
 	auth: "admin",
 	timeoutMs: 6e4
 }), method(TrainingJobRequestSchema.extend({
@@ -44618,6 +44876,24 @@ method(TrainingDatasetVersionRowSchema, object({ stored: boolean() }), {
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: 12e4
+}), method(TrainingJobRequestSchema.omit({ baseModelId: true }).extend({
+	baseModelIds: array(string().min(1)).min(1),
+	name: string().min(1).max(120),
+	maxCostUsd: number().positive(),
+	maxRuntimeSec: number().int().positive(),
+	idempotencyKey: string().min(8).max(80)
+}), discriminatedUnion("kind", [object({
+	kind: literal("started"),
+	batchId: string(),
+	jobs: array(TrainingJobSchema).min(1).readonly()
+}), object({
+	kind: literal("refused"),
+	reason: TrainingRefusalReasonSchema,
+	detail: string()
+})]), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
 }), method(object({}), array(TrainingJobSchema).readonly(), { auth: "admin" }), method(IdInput, TrainingJobSchema.nullable(), { auth: "admin" }), method(IdInput, TrainingJobSchema, {
 	kind: "mutation",
 	auth: "admin",
@@ -46228,17 +46504,6 @@ var BaseDeviceProvider = class extends BaseAddon {
 		return toDeviceSummary(device, this.addonId);
 	}
 };
-/**
-* Default silence budget before a sleeping battery camera is called gone.
-*
-* Sized off the mechanism that produces contact, not off taste: a battery cam
-* on this deployment surfaces a firmware push (battery level, sleep/wake, or a
-* motion email) on the order of hours even with no visitors, and the snapshot
-* wrapper's own battery window is 1 hour. Six hours is therefore several
-* missed opportunities, not one — so a single quiet night does not raise a
-* fault, and a genuinely flat camera is named well inside a day.
-*/
-var BATTERY_UNREACHABLE_AFTER_MS = 360 * 6e4;
 DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
 new Set(Object.values(DeviceType));
 Object.freeze({
@@ -50202,6 +50467,36 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"oidcConnections.connectionFormSchema": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"oidcConnections.createConnection": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"oidcConnections.deleteConnection": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"oidcConnections.listConnections": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"oidcConnections.updateConnection": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"osd.getStatus": {
 		capName: "osd",
 		capScope: "device",
@@ -50274,6 +50569,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"osdManager.setSlotCameraEnabled": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"osdManager.upsertTemplate": {
 		capName: "osd-manager",
 		capScope: "system",
@@ -50412,12 +50713,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.createRetrainDatasetVersion": {
-		capName: "pipeline-analytics",
-		capScope: "device",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineAnalytics.deleteDeviceEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -50430,12 +50725,6 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
-	"pipelineAnalytics.deleteRetrainDatasetVersion": {
-		capName: "pipeline-analytics",
-		capScope: "device",
-		addonId: null,
-		access: "delete"
-	},
 	"pipelineAnalytics.deleteTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -50538,6 +50827,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getRetrainCorpusKpi": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getRetrainExportUrl": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -50658,7 +50953,7 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineAnalytics.listRetrainDatasetVersions": {
+	"pipelineAnalytics.listRetrainCorpusPage": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
@@ -50712,12 +51007,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.previewRetrainDataset": {
-		capName: "pipeline-analytics",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineAnalytics.proposeRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -50796,6 +51085,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.resolveRetrainTrainingCorpus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.restageRetrainTrack": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -50856,12 +51151,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.verifyRetrainDatasetVersion": {
-		capName: "pipeline-analytics",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineAnalytics.wipeAllAnalytics": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -53256,18 +53545,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"training.findDatasetVersionIdByName": {
-		capName: "training",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"training.getDatasetVersion": {
-		capName: "training",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"training.getJob": {
 		capName: "training",
 		capScope: "system",
@@ -53286,12 +53563,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"training.listDatasetVersions": {
-		capName: "training",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"training.listJobs": {
 		capName: "training",
 		capScope: "system",
@@ -53304,54 +53575,66 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"training.putDatasetVersion": {
+	"training.registerResult": {
 		capName: "training",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"training.registerResult": {
+	"training.rollbackCanary": {
 		capName: "training",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"training.removeDatasetVersion": {
+	"training.startJob": {
 		capName: "training",
 		capScope: "system",
 		addonId: null,
-		access: "delete"
+		access: "create"
 	},
-	"training.rollbackCanary": {
+	"training.startJobBatch": {
 		capName: "training",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"training.startJob": {
-		capName: "training",
+	"trainingProvider.cancelJob": {
+		capName: "training-provider",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"trainingProvider.cancelJob": {
+	"trainingProvider.cleanupJob": {
 		capName: "training-provider",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"trainingProvider.cleanupJob": {
+	"trainingProvider.createEntry": {
 		capName: "training-provider",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"trainingProvider.deleteEntry": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"trainingProvider.describe": {
 		capName: "training-provider",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"trainingProvider.describeTypes": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"trainingProvider.estimateJob": {
 		capName: "training-provider",
 		capScope: "system",
@@ -53364,6 +53647,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"trainingProvider.listEntries": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"trainingProvider.listJobEvents": {
 		capName: "training-provider",
 		capScope: "system",
@@ -53394,6 +53683,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"trainingProvider.updateEntry": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"trainingProvider.uploadDataset": {
 		capName: "training-provider",
 		capScope: "system",
@@ -56752,6 +57047,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"osdManager.setSlotCameraEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"petFeeder.callPet": [{
 		name: "deviceId",
 		form: "single",
@@ -56972,6 +57272,11 @@ Object.freeze({
 		form: "array",
 		optional: false
 	}],
+	"pipelineAnalytics.listRetrainCorpusPage": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineAnalytics.listRetrainStaging": [{
 		name: "deviceIds",
 		form: "array",
@@ -58081,6 +58386,7 @@ Object.freeze({
 });
 Object.freeze({
 	"broker": "broker",
+	"calendar-source": "calendar",
 	"device-export": "device-export",
 	"llm": "ai",
 	"mesh-network": "mesh",
@@ -58205,6 +58511,9 @@ new Map(Object.entries({
 	"stream-online": "device-events",
 	"stream-offline": "device-events",
 	"detection-blind": "device-events",
+	"recording-stalled": "device-events",
+	"recording-healthy": "device-events",
+	"recording-degraded": "device-events",
 	"node-online": "system",
 	"node-offline": "system",
 	"node-restarting": "system",
@@ -58218,6 +58527,9 @@ new Map(Object.entries({
 	"wrapper-update-available": "system",
 	"backup-completed": "system",
 	"export-completed": "system",
+	"storage-location-low": "system",
+	"storage-location-critical": "system",
+	"storage-location-ok": "system",
 	"alarm-triggered": "alarm",
 	"alarm-armed": "alarm",
 	"alarm-disarmed": "alarm",
@@ -58279,6 +58591,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Detecting nothing",
 		kinds: ["detection-blind"]
 	},
+	{
+		id: "recording",
+		family: "device-events",
+		label: "Recording",
+		kinds: [
+			"recording-stalled",
+			"recording-healthy",
+			"recording-degraded"
+		]
+	},
 	{
 		id: "nodes",
 		family: "system",
@@ -58319,6 +58641,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Backups & exports",
 		kinds: ["backup-completed", "export-completed"]
 	},
+	{
+		id: "storage",
+		family: "system",
+		label: "Storage locations",
+		kinds: [
+			"storage-location-low",
+			"storage-location-critical",
+			"storage-location-ok"
+		]
+	},
 	{
 		id: "alarm",
 		family: "alarm",
@@ -58401,6 +58733,9 @@ var DEVICE_EVENTS = [
 	"stream-online",
 	"stream-offline",
 	"detection-blind",
+	"recording-stalled",
+	"recording-healthy",
+	"recording-degraded",
 	...ALARM
 ];
 /** Every kind a summary may speak about — the two summarisable families. */
@@ -58568,6 +58903,11 @@ var STATE_SUMMARY_VARS = [
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
 	([...RULE_TEXT], [...UPDATES]),
 	([...RULE_TEXT], [...PACKAGE_UPDATES]),
 	([...RULE_TEXT], [...PACKAGE_UPDATES]),
@@ -71239,7 +71579,7 @@ var require_snapshot_utils = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 //#region ../../node_modules/undici/lib/mock/snapshot-recorder.js
 var require_snapshot_recorder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var { writeFile: writeFile$1, readFile: readFile$1, mkdir: mkdir$2 } = __require("node:fs/promises");
-	var { dirname: dirname$1, resolve } = __require("node:path");
+	var { dirname: dirname$2, resolve: resolve$1 } = __require("node:path");
 	var { setTimeout: setTimeout$1, clearTimeout: clearTimeout$1 } = __require("node:timers");
 	var { InvalidArgumentError, UndiciError } = require_errors$1();
 	var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -71504,7 +71844,7 @@ var require_snapshot_recorder = /* @__PURE__ */ __commonJSMin(((exports, module)
 			const path = filePath || this.#snapshotPath;
 			if (!path) throw new InvalidArgumentError("Snapshot path is required");
 			try {
-				const data = await readFile$1(resolve(path), "utf8");
+				const data = await readFile$1(resolve$1(path), "utf8");
 				const parsed = JSON.parse(data);
 				if (Array.isArray(parsed)) {
 					this.#snapshots.clear();
@@ -71524,8 +71864,8 @@ var require_snapshot_recorder = /* @__PURE__ */ __commonJSMin(((exports, module)
 		async saveSnapshots(filePath) {
 			const path = filePath || this.#snapshotPath;
 			if (!path) throw new InvalidArgumentError("Snapshot path is required");
-			const resolvedPath = resolve(path);
-			await mkdir$2(dirname$1(resolvedPath), { recursive: true });
+			const resolvedPath = resolve$1(path);
+			await mkdir$2(dirname$2(resolvedPath), { recursive: true });
 			const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
 				hash,
 				snapshot
@@ -160162,6 +160502,7 @@ function buildInitialStatus2(config, enabled) {
 		lastErrorMessage: void 0
 	};
 }
+process.platform, process.env["SystemRoot"];
 /**
 * The spawn a one-shot ffmpeg site uses: the spec's seam when one is injected,
 * else the node's PINNED binary (D540), else `null` — and the site refuses by
@@ -160734,6 +161075,13 @@ var reolinkCameraSchema = object({
 	*/
 	clipCatalogForcedWake: boolean().optional(),
 	/**
+	* Battery cameras only: the window, in minutes, in which the camera refreshes
+	* ALL its metadata and its cached snapshot exactly once (D847). Absent means
+	* the default (60); `0` turns the scheduled refresh off for this camera; a
+	* value is clamped to 15..240 (below the 6 h presence budget).
+	*/
+	batteryRefreshMinutes: number().int().min(0).max(240).optional(),
+	/**
 	* Per-AI-class sensitivity overrides — pushed via
 	* `setAiDetection(aiType, sensitivity)` (cmdId=343). Reolink
 	* range 0..100 — same scale the reolink_aio CGI exposes
@@ -166991,14 +167339,266 @@ function deriveChargingSource(adapterStatus, chargeStatus) {
 function reportsPowerSource(info) {
 	return info.adapterStatus !== void 0 || info.chargeStatus !== void 0;
 }
+/** The settings key, per device. */
+var BATTERY_REFRESH_MINUTES_KEY = "batteryRefreshMinutes";
+/** How often the in-memory check runs. Costs nothing: no I/O unless it fires. */
+var BATTERY_REFRESH_TICK_MS = 6e4;
+/** The least time between two attempts in one window. */
+var RETRY_BACKOFF_MS = 10 * 6e4;
+var MAX_WAKE_LEAD_MS = 5 * 6e4;
+var STAGGER_SLOTS = 60;
+/** The operator's window in ms, or `0` for off. Out-of-range values clamp. */
+function resolveBatteryRefreshIntervalMs(configured) {
+	if (typeof configured !== "number" || !Number.isFinite(configured)) return 60 * 6e4;
+	if (configured <= 0) return 0;
+	return Math.min(240, Math.max(15, Math.round(configured))) * 6e4;
+}
+/** Deterministic per-device offset so a fleet's windows do not align. */
+function staggerOffsetMs(deviceId, intervalMs) {
+	const slot = Math.abs(Math.trunc(deviceId)) % STAGGER_SLOTS;
+	return Math.floor(intervalMs / STAGGER_SLOTS * slot);
+}
+/** Which window a wall-clock instant falls in. */
+function windowIndex(at, intervalMs, offsetMs) {
+	return Math.floor((at - offsetMs) / intervalMs);
+}
+/** How long before a window's end the wake is allowed to fire. */
+function wakeLeadMs(intervalMs) {
+	return Math.min(MAX_WAKE_LEAD_MS, Math.floor(intervalMs / 10));
+}
+function decideBatteryRefresh(input) {
+	if (input.intervalMs <= 0) return {
+		kind: "skip",
+		reason: "off"
+	};
+	const current = windowIndex(input.nowMs, input.intervalMs, input.offsetMs);
+	if ((typeof input.lastFullRefreshAt === "number" && input.lastFullRefreshAt > 0 ? windowIndex(input.lastFullRefreshAt, input.intervalMs, input.offsetMs) : Number.NEGATIVE_INFINITY) >= current) return {
+		kind: "skip",
+		reason: "done"
+	};
+	if (input.attemptsInWindow >= 2) return {
+		kind: "skip",
+		reason: "attempts-exhausted"
+	};
+	if (input.lastAttemptAt !== void 0 && input.attemptsInWindow > 0 && input.nowMs - input.lastAttemptAt < 6e5) return {
+		kind: "skip",
+		reason: "backoff"
+	};
+	if (input.awake) return { kind: "refresh-awake" };
+	const windowEnd = input.offsetMs + (current + 1) * input.intervalMs;
+	if (input.nowMs < windowEnd - wakeLeadMs(input.intervalMs)) return {
+		kind: "skip",
+		reason: "asleep-before-deadline"
+	};
+	return { kind: "wake-then-refresh" };
+}
+var BatteryHourlyRefresh = class {
+	deps;
+	inFlight = null;
+	attemptWindow = Number.NEGATIVE_INFINITY;
+	attempts = 0;
+	lastAttemptAt;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/**
+	* The periodic check. Resolves `true` when a refresh landed in this call.
+	* Never throws.
+	*/
+	async tick() {
+		return this.consider("tick");
+	}
+	/**
+	* The camera was just observed coming up (event, sleep poll, hub summary, a
+	* confirmed wake). Resolves `true` when this call refreshed everything, so
+	* the caller can skip the parts of its own fan-out the refresh already did.
+	*/
+	async noteAwake() {
+		return this.consider("wake-transition");
+	}
+	async consider(trigger) {
+		if (this.inFlight !== null) return this.inFlight;
+		const nowMs = this.deps.now();
+		const intervalMs = this.deps.intervalMs();
+		const offsetMs = intervalMs > 0 ? staggerOffsetMs(this.deps.deviceId, intervalMs) : 0;
+		const window = intervalMs > 0 ? windowIndex(nowMs, intervalMs, offsetMs) : 0;
+		if (window !== this.attemptWindow) {
+			this.attemptWindow = window;
+			this.attempts = 0;
+			this.lastAttemptAt = void 0;
+		}
+		const decision = decideBatteryRefresh({
+			nowMs,
+			intervalMs,
+			offsetMs,
+			lastFullRefreshAt: this.deps.lastFullRefreshAt(),
+			awake: trigger === "wake-transition" || this.deps.isAwake(),
+			attemptsInWindow: this.attempts,
+			lastAttemptAt: this.lastAttemptAt
+		});
+		if (decision.kind === "skip") {
+			this.logSkip(decision.reason, trigger);
+			return false;
+		}
+		this.attempts += 1;
+		this.lastAttemptAt = nowMs;
+		const run = this.run(decision.kind, trigger).finally(() => {
+			this.inFlight = null;
+		});
+		this.inFlight = run;
+		return run;
+	}
+	async run(kind, trigger) {
+		const { logger, deviceId } = this.deps;
+		try {
+			if (kind === "wake-then-refresh") {
+				logger.info("battery hourly refresh: not awake in the window — waking once", {
+					tags: { deviceId },
+					meta: { attempt: this.attempts }
+				});
+				if (!await this.deps.wake()) {
+					logger.warn("battery hourly refresh: the wake did not bring the camera up", {
+						tags: { deviceId },
+						meta: {
+							attempt: this.attempts,
+							retryAfterMs: RETRY_BACKOFF_MS
+						}
+					});
+					return false;
+				}
+				if (this.windowSatisfied()) return true;
+			} else logger.info("battery hourly refresh: camera is awake — refreshing now, no wake", {
+				tags: { deviceId },
+				meta: {
+					trigger,
+					attempt: this.attempts
+				}
+			});
+			const outcome = await this.deps.refreshAll();
+			if (outcome.failed.length > 0) {
+				logger.warn("battery hourly refresh incomplete — not stamped, retried at the next chance", {
+					tags: { deviceId },
+					meta: {
+						failed: outcome.failed,
+						attempt: this.attempts,
+						retryAfterMs: RETRY_BACKOFF_MS
+					}
+				});
+				return false;
+			}
+			const at = this.deps.now();
+			this.deps.stamp(at);
+			logger.info("battery hourly refresh complete", {
+				tags: { deviceId },
+				meta: {
+					kind,
+					trigger,
+					at
+				}
+			});
+			return true;
+		} catch (err) {
+			logger.warn("battery hourly refresh failed — retried at the next chance", {
+				tags: { deviceId },
+				meta: {
+					error: err instanceof Error ? err.message : String(err),
+					attempt: this.attempts,
+					retryAfterMs: RETRY_BACKOFF_MS
+				}
+			});
+			return false;
+		}
+	}
+	windowSatisfied() {
+		const intervalMs = this.deps.intervalMs();
+		if (intervalMs <= 0) return false;
+		const offsetMs = staggerOffsetMs(this.deps.deviceId, intervalMs);
+		const last = this.deps.lastFullRefreshAt();
+		if (typeof last !== "number" || last <= 0) return false;
+		return windowIndex(last, intervalMs, offsetMs) >= windowIndex(this.deps.now(), intervalMs, offsetMs);
+	}
+	logSkip(reason, trigger) {
+		if (reason === "backoff" || reason === "attempts-exhausted") {
+			this.deps.logger.info("battery hourly refresh skipped", {
+				tags: { deviceId: this.deps.deviceId },
+				meta: {
+					reason,
+					trigger,
+					attempts: this.attempts
+				}
+			});
+			return;
+		}
+		this.deps.logger.debug("battery hourly refresh not due", {
+			tags: { deviceId: this.deps.deviceId },
+			meta: {
+				reason,
+				trigger
+			}
+		});
+	}
+};
+//#endregion
+//#region src/battery-refresh-settings.ts
+var BATTERY_REFRESH_SECTION_ID = "battery-refresh";
+var BATTERY_REFRESH_MINUTES_DESCRIPTION = `Once per window this camera refreshes everything CamStack knows about it — battery level and charging, signal, device info, every state panel and the cached snapshot. If the camera is awake at some point in the window (a motion event, a live view, anything that woke it) it is refreshed then and not woken again; if the whole window passes with the camera asleep, it is woken ONCE near the end of the window, refreshed, and left to go back to sleep. A camera that does not answer is retried at most twice per window. 15–240 minutes, default 60; 0 turns the scheduled refresh off (the battery level then ages until the camera next wakes by itself).`;
+/** Battery cameras only: a mains camera keeps its facts fresh on its own socket. */
+function buildBatteryRefreshDeviceSection(input) {
+	if (!input.isBattery) return [];
+	return [{
+		id: BATTERY_REFRESH_SECTION_ID,
+		tab: "general",
+		title: "Scheduled refresh",
+		description: "How often this battery camera is guaranteed to have been read, so a battery level never goes stale unseen.",
+		columns: 1,
+		fields: [{
+			type: "number",
+			key: BATTERY_REFRESH_MINUTES_KEY,
+			label: "Refresh window (min)",
+			description: BATTERY_REFRESH_MINUTES_DESCRIPTION,
+			default: 60,
+			min: 0,
+			max: 240,
+			step: 5
+		}]
+	}];
+}
 //#endregion
-//#region src/battery-contact-expiry.ts
-function shouldWakeForContact(input) {
-	if (input.hubChild) return false;
-	if (!input.sleeping) return false;
-	const last = input.lastContactAt;
-	if (typeof last !== "number" || last <= 0) return false;
-	return input.nowMs - last + input.tickMs >= input.unreachableAfterMs;
+//#region src/battery-snapshot-refresh.ts
+/** The wrapper may run on another node; a stale frame is hours old, skew is seconds. */
+var CLOCK_SKEW_TOLERANCE_MS = 6e4;
+async function refreshSnapshotCacheOnce(input) {
+	const { deviceId, api, logger } = input;
+	const startedAt = input.now();
+	if (await api.getSnapshot({
+		deviceId,
+		force: true
+	}) === null) {
+		logger.warn("battery hourly refresh: the snapshot came back empty", { tags: { deviceId } });
+		return false;
+	}
+	let rows;
+	try {
+		rows = await api.getSnapshotOverview({ deviceIds: [deviceId] });
+	} catch (err) {
+		logger.debug("battery hourly refresh: snapshot overview unreadable — counting the image", {
+			tags: { deviceId },
+			meta: { error: err instanceof Error ? err.message : String(err) }
+		});
+		return true;
+	}
+	const capturedAt = rows.find((row) => row.deviceId === deviceId)?.lastCapturedAt ?? null;
+	if (capturedAt === null || capturedAt < startedAt - CLOCK_SKEW_TOLERANCE_MS) {
+		logger.warn("battery hourly refresh: the snapshot cache did not move (a stale frame was served)", {
+			tags: { deviceId },
+			meta: {
+				capturedAt,
+				startedAt
+			}
+		});
+		return false;
+	}
+	return true;
 }
 //#endregion
 //#region src/log-channels.ts
@@ -171001,7 +171601,6 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*  passively checks sleep state, and short-circuits if sleeping. */
 	batteryUpdateTimer = null;
 	/** Single-flight gate so two interval fires can't overlap. */
-	batteryUpdateInFlight = null;
 	/** Aux accessory references registered by spawned children
 	*  (siren / floodlight / pir). The parent's centralised align
 	*  method iterates these to refresh their slices on a single
@@ -171339,7 +171938,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* snapshot also drives the dispatch's known-good baseline.
 	*/
 	async refreshParentSettingsSnapshot(slices, reason = "background") {
-		if (this.isBattery && this.sleeping && reason !== "post-write") {
+		if (this.isBattery && this.sleeping && reason !== "post-write" && reason !== "scheduled") {
 			this.ctx.logger.info("refreshParentSettingsSnapshot skipped — battery cam is sleeping", { tags: {
 				deviceId: this.id,
 				reason
@@ -172285,7 +172884,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				tags: { deviceId: this.id },
 				meta: { reason }
 			});
-			return;
+			return false;
 		}
 		let api;
 		try {
@@ -172295,17 +172894,19 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				tags: { deviceId: this.id },
 				meta: { error: err instanceof Error ? err.message : String(err) }
 			});
-			return;
+			return false;
 		}
 		try {
 			const info = await api.getBatteryInfo(this.getChannel());
 			this.updateBatteryCache(info);
 			await this.refreshNetworkLinkFromApi(api, "battery");
+			return true;
 		} catch (err) {
 			this.ctx.logger.debug("battery refresh failed", {
 				tags: { deviceId: this.id },
 				meta: { error: err instanceof Error ? err.message : String(err) }
 			});
+			return false;
 		}
 	}
 	/**
@@ -173551,6 +174152,18 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* proactive gate lets it through because `sleeping` is false here.
 	* Mirrors the reference's `updateBatteryAndSnapshot`.
 	*/
+	/** The scheduled refresh's snapshot step: true only when the cache really moved. */
+	refreshSnapshotCache() {
+		return refreshSnapshotCacheOnce({
+			deviceId: this.id,
+			logger: this.ctx.logger,
+			now: () => Date.now(),
+			api: {
+				getSnapshot: (input) => this.ctx.api.snapshot.getSnapshot.query(input),
+				getSnapshotOverview: (input) => this.ctx.api.snapshot.getSnapshotOverview.query({ deviceIds: [...input.deviceIds] })
+			}
+		});
+	}
 	async warmSnapshotOnWake() {
 		try {
 			await this.ctx.api.snapshot.getSnapshot.query({
@@ -175986,119 +176599,84 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			this.alignAuxTimer = null;
 		}
 	}
-	/** Run one cycle of the battery-cam periodic refresh. Single-flight
-	*  via `batteryUpdateInFlight`. Never throws. */
-	async runBatteryUpdate() {
-		if (this.batteryUpdateInFlight) return this.batteryUpdateInFlight;
-		const cycle = (async () => {
+	batteryRefresh = null;
+	getBatteryRefresh() {
+		if (this.batteryRefresh === null) this.batteryRefresh = new BatteryHourlyRefresh({
+			deviceId: this.id,
+			logger: this.ctx.logger,
+			now: () => Date.now(),
+			isAwake: () => !this.sleeping,
+			intervalMs: () => resolveBatteryRefreshIntervalMs(this.config.get("batteryRefreshMinutes")),
+			lastFullRefreshAt: () => this.state.battery.lastFullRefreshAt,
+			wake: async () => {
+				if (!this.canProactivelyWake("scheduled-refresh")) return false;
+				this.markWakeIssued();
+				return this.wakeIfSleeping();
+			},
+			refreshAll: () => this.refreshEverythingNow(),
+			stamp: (at) => {
+				this.state.battery.lastFullRefreshAt = at;
+			}
+		});
+		return this.batteryRefresh;
+	}
+	/**
+	* Every fact and the snapshot, read while the camera is up. SERIALIZED (one
+	* Baichuan round-trip at a time on the single BCUDP stream), and each step
+	* names itself in `failed` instead of throwing, so one dead read neither
+	* hides the others nor stamps the window as done.
+	*/
+	async refreshEverythingNow() {
+		const failed = [];
+		const step = async (name, run) => {
 			try {
-				if (this.isBattery && this.sleeping) {
-					if (shouldWakeForContact({
-						nowMs: Date.now(),
-						lastContactAt: this.state.battery.lastContactAt,
-						sleeping: true,
-						hubChild: this.isHubChild(),
-						unreachableAfterMs: 216e5,
-						tickMs: ReolinkCamera.BATTERY_UPDATE_INTERVAL_MS
-					})) {
-						await this.wakeForContactRefresh();
-						return;
-					}
-					this.ctx.logger.debug("battery-update: cam sleeping — skipping cycle without connecting", { tags: { deviceId: this.id } });
-					return;
-				}
-				let api;
-				try {
-					api = await this.ensureApi();
-				} catch (err) {
-					this.ctx.logger.debug("battery-update: ensureApi failed — skipping cycle", {
-						tags: { deviceId: this.id },
-						meta: { error: err instanceof Error ? err.message : String(err) }
-					});
-					return;
-				}
-				let sleeping = false;
-				try {
-					sleeping = api.getSleepStatus({ channel: this.getChannel() }).state === "sleeping";
-				} catch (err) {
-					this.ctx.logger.debug("battery-update: getSleepStatus threw — skipping cycle", {
-						tags: { deviceId: this.id },
-						meta: { error: err instanceof Error ? err.message : String(err) }
-					});
-					return;
-				}
-				if (sleeping) {
-					this.ctx.logger.debug("battery-update: cam sleeping — skipping periodic refresh", { tags: { deviceId: this.id } });
-					return;
-				}
-				this.ctx.logger.info("battery-update: cam awake — running periodic refresh", {
+				if (await run() === false) failed.push(name);
+			} catch (err) {
+				failed.push(name);
+				this.ctx.logger.debug("battery hourly refresh: step threw", {
 					tags: { deviceId: this.id },
 					meta: {
-						isHubChild: this.isHubChild(),
-						auxAccessoryCount: this.auxAccessoryRefs.size
+						step: name,
+						error: err instanceof Error ? err.message : String(err)
 					}
 				});
-				await this.refreshBatteryFromApi("periodic").catch(() => {});
-				await this.alignAuxDevicesState("periodic").catch(() => {});
-				await this.refreshParentSettingsSnapshot().catch(() => {});
-			} finally {
-				this.batteryUpdateInFlight = null;
 			}
-		})();
-		this.batteryUpdateInFlight = cycle;
-		return cycle;
+		};
+		await step("battery", () => this.refreshBatteryFromApi("demand"));
+		await step("device-info", async () => {
+			await this.populateMetadataFromFirmware(await this.ensureApi());
+		});
+		await step("cap-slices", async () => {
+			await this.warmCapSlicesOnWake({ force: true });
+		});
+		await step("aux-accessories", () => this.alignAuxDevicesState("wake"));
+		await step("settings-snapshot", () => this.refreshParentSettingsSnapshot(void 0, "scheduled"));
+		await step("snapshot", () => this.refreshSnapshotCache());
+		return { failed };
 	}
 	/**
-	* D355: wake a standalone battery camera ONCE because its last passive
-	* contact is about to expire, and refresh every slice while it is up.
-	* Bounded by `canProactivelyWake` (the shared cooldown) and by the fact
-	* that a wake that answers resets the silence. A wake that fails is left
-	* alone: the silence then reaches the budget and `deriveBatteryPresence`
-	* says `unreachable` — for the first time on evidence.
+	* Run one scheduled-refresh check. Never throws; costs nothing unless a
+	* refresh is due (see {@link decideBatteryRefresh}).
 	*/
-	async wakeForContactRefresh() {
-		if (!this.canProactivelyWake("contact-expiry")) return;
-		this.markWakeIssued();
-		const lastContactAt = this.state.battery.lastContactAt ?? 0;
-		const silenceMs = Date.now() - lastContactAt;
-		this.ctx.logger.info("battery contact expiring — waking once to refresh every slice (D355)", {
-			tags: { deviceId: this.id },
-			meta: {
-				silenceMs,
-				budgetMs: BATTERY_UNREACHABLE_AFTER_MS
-			}
-		});
-		try {
-			await this.ensureApi();
-		} catch (err) {
-			this.ctx.logger.warn("battery contact wake FAILED — silence continues and the camera will read unreachable at the budget", {
-				tags: { deviceId: this.id },
-				meta: {
-					silenceMs,
-					error: err instanceof Error ? err.message : String(err)
-				}
-			});
-			return;
-		}
-		await this.refreshBatteryFromApi("demand").catch(() => {});
-		await this.warmCapSlicesOnWake().catch(() => {});
-		await this.alignAuxDevicesState("wake").catch(() => {});
-		await this.warmSnapshotOnWake().catch(() => {});
+	async runBatteryUpdate() {
+		if (!this.isBattery) return;
+		await this.getBatteryRefresh().tick();
 	}
-	/** Arm the periodic battery-cam refresh timer. No-op for wired cams
-	*  (their state is kept fresh by the 10 s aux-align poll and push
-	*  events). Idempotent. */
+	/** Arm the scheduled-refresh check. No-op for wired cams (their state is
+	*  kept fresh by the 10 s aux-align poll and push events). Idempotent. */
 	startBatteryUpdatePolling() {
 		if (this.batteryUpdateTimer) return;
 		if (!this.isBattery) return;
 		this.batteryUpdateTimer = setInterval(() => {
 			this.runBatteryUpdate().catch(() => {});
-		}, ReolinkCamera.BATTERY_UPDATE_INTERVAL_MS);
+		}, BATTERY_REFRESH_TICK_MS);
 		if (typeof this.batteryUpdateTimer.unref === "function") this.batteryUpdateTimer.unref();
-		this.ctx.logger.info("battery-update: periodic refresh armed", {
+		this.ctx.logger.info("battery-update: scheduled full refresh armed", {
 			tags: { deviceId: this.id },
 			meta: {
-				intervalMs: ReolinkCamera.BATTERY_UPDATE_INTERVAL_MS,
+				tickMs: BATTERY_REFRESH_TICK_MS,
+				intervalMs: resolveBatteryRefreshIntervalMs(this.config.get("batteryRefreshMinutes")),
+				lastFullRefreshAt: this.state.battery.lastFullRefreshAt ?? null,
 				isHubChild: this.isHubChild()
 			}
 		});
@@ -176194,22 +176772,18 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				meta: { error: err instanceof Error ? err.message : String(err) }
 			});
 		}
-		await this.warmCapSlicesOnWake();
-		await this.warmSnapshotOnWake();
-		await this.alignAuxDevicesState("wake");
-		await this.refreshParentSettingsSnapshot();
+		if (!(this.isBattery ? await this.getBatteryRefresh().noteAwake().catch(() => false) : false)) {
+			await this.warmCapSlicesOnWake();
+			await this.warmSnapshotOnWake();
+			await this.alignAuxDevicesState("wake");
+			await this.refreshParentSettingsSnapshot();
+		}
 		await this.refreshClipCatalogOnWake();
 	}
 	static PING_INTERVAL_MS = 3e4;
 	static PING_MAX_FAILURES = 3;
 	static EVENT_CHECK_INTERVAL_MS = 6e4;
 	static EVENT_STALE_THRESHOLD_MS = 10 * 6e4;
-	/** Battery-cam periodic refresh cadence. The timer fires on this
-	*  interval, passively checks sleep state, and only runs the
-	*  refresh when the cam is already awake — so it never forces a
-	*  wake. Mirrors the reference's `batteryUpdateIntervalMinutes`
-	*  default (60 minutes). */
-	static BATTERY_UPDATE_INTERVAL_MS = 60 * 6e4;
 	/**
 	* Arm the connection-liveness ping watchdog and the event-watchdog.
 	* Battery cams skip the ping watchdog — they keep `setIdleDisconnect=true`
@@ -177393,7 +177967,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				...buildClipRefreshDeviceSection({
 					isHubChild: this.isHubChild(),
 					isBattery: this.isBattery
-				})
+				}),
+				...buildBatteryRefreshDeviceSection({ isBattery: this.isBattery })
 			]
 		};
 		const emailSnap = cache?.emailConfigSnapshot;
@@ -177414,6 +177989,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			emailScheduleEnabled: emailSnap?.taskEnabled ?? false,
 			clipCatalogRefreshMinutes: this.config.get("clipCatalogRefreshMinutes"),
 			clipCatalogForcedWake: this.config.get("clipCatalogForcedWake") ?? false,
+			batteryRefreshMinutes: this.config.get("batteryRefreshMinutes"),
 			debugGeneral: this.config.get("debugGeneral") ?? false,
 			debugSocketLogs: this.config.get("debugSocketLogs") ?? [],
 			motionEnabled: this.config.get("motionEnabled") ?? motionSnap.enabled ?? true,