@camstack/addon-provider-reolink 1.2.146 → 1.2.148

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./chunk-CNf5ZN-e.mjs";
-import { A as splitAnnexBToNalPayloads, C as extractSpsFromAnnexB, D as md5StrModern, E as isH265Irap, M as talkTraceLog, N as traceLog, O as normalizeDebugOptions, S as extractPpsFromAnnexB, T as getH265NalType, _ as convertToAnnexB, a as BC_MAGIC, b as deriveAesKey, c as BaichuanVideoStream, d as __require$1, f as aesDecrypt, g as bcHeaderHasPayloadOffset, h as bcEncrypt, i as BC_CLASS_MODERN_24, j as splitAnnexBToNalPayloads2, k as recordingsTraceLog, l as BcMediaAnnexBDecoder, m as bcDecrypt, n as BC_CLASS_LEGACY, o as BC_MAGIC_REV, p as aesEncrypt, r as BC_CLASS_MODERN_20, t as BC_CLASS_FILE_DOWNLOAD, v as convertToAnnexB2, w as extractVpsFromAnnexB, x as eventTraceLog, y as debugLog } from "./chunk-4KBXJ7U3-CCQfaWmi.mjs";
+import { A as splitAnnexBToNalPayloads, C as extractSpsFromAnnexB, D as md5StrModern, E as isH265Irap, M as talkTraceLog, N as traceLog, O as normalizeDebugOptions, S as extractPpsFromAnnexB, T as getH265NalType, _ as convertToAnnexB, a as BC_MAGIC, b as deriveAesKey, c as BaichuanVideoStream, d as __require$1, f as aesDecrypt, g as bcHeaderHasPayloadOffset, h as bcEncrypt, i as BC_CLASS_MODERN_24, j as splitAnnexBToNalPayloads2, k as recordingsTraceLog, l as BcMediaAnnexBDecoder, m as bcDecrypt, n as BC_CLASS_LEGACY, o as BC_MAGIC_REV, p as aesEncrypt, r as BC_CLASS_MODERN_20, t as BC_CLASS_FILE_DOWNLOAD, v as convertToAnnexB2, w as extractVpsFromAnnexB, x as eventTraceLog, y as debugLog } from "./chunk-ZBACPERX-cDJK1KXE.mjs";
 import { createHash, randomBytes } from "node:crypto";
 import { EventEmitter } from "events";
 import * as fs2 from "fs";
@@ -5385,7 +5385,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-7AN_Txmu.mjs
+//#region ../types/dist/sleep-CaB_hL5g.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -7432,6 +7432,8 @@ var EVENT_OWNER_TYPES = [
 * nothing failing until a caller asked.
 */
 var EventOwnerTypeSchema = _enum(EVENT_OWNER_TYPES);
+/** The same list as a Zod enum, for the cap input that carries it. */
+var MediaPresenceOwnerKindSchema = _enum([...EVENT_OWNER_TYPES, "track"]);
 new Set(EVENT_OWNER_TYPES);
 var EncodeProfileSchema = object({
 	video: object({
@@ -14977,8 +14979,6 @@ method(object({
 	deviceId: number(),
 	capName: string(),
 	wrapperAddonId: string(),
-	/** The `ClipSource.source` id to toggle. Absent = all of the addon's. */
-	sourceId: string().optional(),
 	active: boolean()
 }), _void(), {
 	kind: "mutation",
@@ -22007,7 +22007,11 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	ownerType: EventOwnerTypeSchema,
 	eventId: number().int(),
 	deviceId: number()
-}), array(MediaFileInfoSchema).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), method(object({}), WipeObjectEmbeddingsResultSchema, {
+}), array(MediaFileInfoSchema).readonly()), method(object({
+	deviceId: number(),
+	ownerKind: MediaPresenceOwnerKindSchema,
+	ownerIds: array(string()).max(5e3)
+}), array(string()).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), method(object({}), WipeObjectEmbeddingsResultSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
@@ -25105,6 +25109,24 @@ method(VectorDeclareIndexInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
 }), method(VectorStatsInputSchema, VectorStatsResultSchema, { auth: "admin" });
+_enum([
+	"queue-full",
+	"camera-backoff",
+	"sleeping",
+	"camera-refused",
+	"no-keyframe",
+	"no-catalog-row",
+	"unsupported",
+	"unknown-device",
+	"uid-missing"
+]);
+_enum(["deferred", "final"]);
+/** The camera's / provider's own words. Kept verbatim, never parsed. */
+var CLIP_STILL_REASON_HEADER = "x-camstack-reason";
+/** One {@link ClipStillRefusalCodeSchema} token, alone. */
+var CLIP_STILL_REASON_CODE_HEADER = "x-camstack-reason-code";
+/** One {@link ClipStillDispositionSchema} token, alone. */
+var CLIP_STILL_DISPOSITION_HEADER = "x-camstack-disposition";
 var ClipSchema = object({
 	/** Opaque, provider-namespaced id. The default provider encodes the time
 	*  window so `getClipPlayback` is self-contained (no event re-query). */
@@ -25255,7 +25277,25 @@ var ClipSchema = object({
 	*/
 	playable: boolean().optional(),
 	/** Why {@link playable} is false, verbatim (`no-file-for-window`). */
-	unplayableReason: string().optional()
+	unplayableReason: string().optional(),
+	/**
+	* This clip is STILL BEING WRITTEN, so {@link ClipSchema.timeRange}`.endMs`
+	* is not its end.
+	*
+	* Absent — the common case — means the row is closed and its `endMs` is the
+	* end of the recording. Present and `true` means the source told us the file
+	* has no end yet, and the `endMs` we carry is whatever the camera's index
+	* entry happened to hold: on a Reolink E1 Outdoor PoE (592, measured
+	* 2026-09-20) the newest file `…_192927_000000_…_0.mp4` reported an `endTime`
+	* of 19:29:56 and STILL reported it eight minutes later, while the file went
+	* on growing. A surface that drew 29 s there was lying about a clip that
+	* plays for minutes, on the one row the operator looks at first.
+	*
+	* `endMs` is deliberately still a number: it is the best bound anything has
+	* for a mint window or a byte fetch, and every consumer already requires it.
+	* This flag says what it is WORTH, and a duration is not drawn from it.
+	*/
+	inProgress: boolean().optional()
 });
 var ClipPlaybackSchema = object({
 	/**
@@ -25338,59 +25378,17 @@ var ClipSourceSchema = object({
 	* alternative — a `native:reolink:* → provider-reolink` table inside the
 	* widget — is a second authority on provider identity living in the one
 	* package with no business knowing it, wrong the day a third source appears
-	* (D557). One addon may serve SEVERAL sources: `addon-provider-reolink`
-	* answers a hub child with both `native:reolink:onboard` and
-	* `native:reolink:hub`, which is why the per-device switch is keyed by
-	* SOURCE and not by this (D555).
+	* (D557). One addon may serve SEVERAL sources, which is why the per-device
+	* switch is keyed by SOURCE and not by this (D555) — `addon-provider-reolink`
+	* served a hub child two of them until the two views were measured to be one
+	* store read twice (D555) and then read ONE way (D565).
 	*
 	* Optional for version skew only. The collection dispatcher stamps it from
 	* the registry, so a row that travelled through the fan-out carries the
 	* authoritative id whatever the provider filled in.
 	*/
 	addonId: string().optional(),
-	/**
-	* Which API this source resolved to FOR THIS CAMERA, when it has a choice.
-	*
-	* A source may cover one store through more than one surface — the Reolink
-	* provider reads a hub child through the parent's event log and a standalone
-	* through its own file list, because that is what each camera answers. The
-	* CHOICE is the provider's, made from what the camera is, and is never a row
-	* the operator has to understand; but it is REPORTED, because a source that
-	* silently reads a different API on two cameras and then behaves differently
-	* is the thing nobody can debug later. Absent when the source has only one
-	* way to read its store.
-	*/
-	via: string().optional(),
-	availability: ClipSourceAvailabilitySchema,
-	/**
-	* The operator switched this source OFF for this camera.
-	*
-	* Deliberately NOT a member of {@link ClipSourceAvailabilitySchema}'s
-	* vocabulary. That enum models what the source CAN do — a sleeping camera, an
-	* unmounted card, an index that disagrees with its own calendar — and a
-	* switched-off source could answer perfectly well; the operator decided it
-	* should not. Folding the choice in is how `disabled` and `broken` stop being
-	* distinguishable, which is the D62 rule this repo has already paid for twice:
-	* an off switch is REPORTED off (`CameraStatus.switchedOff`, the same word),
-	* and disabled must never look like broken. It is also what lets every
-	* exhaustive consumer of the availability enum keep compiling.
-	*
-	* A switched-off source contributes NO clips (`listClips` never calls it) and
-	* its row carries no `catalogAsOf`: nothing confirms a catalog it is not
-	* allowed to serve, and a frozen age that can only grow draws a stalling
-	* source rather than an off switch.
-	*
-	* The row survives BECAUSE it is the control the operator switches the source
-	* back on from — D554 decision 4's rule ("a source that cannot answer
-	* produces a ROW, not an absence") applied to the one case D556 carved out of
-	* it, and D557's own kept property ("a source is never hidden, only its
-	* rows"). Absent means on.
-	*
-	* A provider never sets this — like {@link ClipSourceSchema.addonId} it is
-	* stamped by the collection dispatcher, which holds the registry's projection
-	* of the persisted authority (D556) and is the only place that knows it.
-	*/
-	switchedOff: boolean().optional()
+	availability: ClipSourceAvailabilitySchema
 });
 var videoclipsCapability = {
 	name: "videoclips",
@@ -25444,22 +25442,40 @@ var videoclipsCapability = {
 			limit: number().int().positive().optional(),
 			/**
 			* WHICH provider to ask — the `addonId` a {@link ClipSourceSchema} row
-			* carries, never a source id and never a list.
+			* carries, never a source id and never a list. **Required** (D554 amended).
 			*
-			* Absent means the device's BOUND provider, which is CamStack on every
-			* camera today because that is what `deviceManager.getBindings`
-			* answers with. A provider the device is not bound to is refused by
-			* name rather than answered by another one (D552's
-			* `rejectUnresolvedAddonPin` rule).
+			* A provider the device is not bound to is refused by name rather than
+			* answered by another one (D552's `rejectUnresolvedAddonPin` rule).
+			*
+			* It was optional, documented as "absent means the device's BOUND
+			* provider, which is CamStack on every camera". No code implemented
+			* that. Measured on the live hub 2026-09-20 — device 592, bound to
+			* `recorder` AND `provider-reolink` — a bare call with `limit: 3`
+			* answered SIX rows, three from each source, merged newest-first:
+			* `device-collection-dispatch.ts` simply left the fan-out un-narrowed,
+			* so absence bought the union this method exists not to be, and
+			* `limit` meant `limit × sources`.
+			*
+			* There is nothing to restore the default to. `getBindings` answers a
+			* collection cap with a DERIVED, PLURAL set (D554 amended, step 0);
+			* `setWrapperActive` — the singleton authority that could name one —
+			* throws for a collection cap by design. Naming CamStack here instead
+			* would privilege one addon by id inside a surface whose premise is
+			* that sources are peers, and would be wrong on the first camera with
+			* no recorder binding. So absence is REFUSED, in the schema, where the
+			* generated types make it unomittable rather than merely discouraged.
+			*
+			* The default belongs to the SURFACE, which has the `listSources` rows
+			* and can say which one it picked (D569 § 1–3; the viewer already
+			* always sends this).
 			*
 			* It replaced `sources?: string[]`, a VIEW filter over source ids that
 			* assumed the answer was a fan-out over everything a camera has. The
-			* operator settled otherwise on 2026-09-20 — *"il get videoclips
-			* prendere un provider opzionale, di default va su camstack"*,
-			* *"l'utilizzatore è uno solo"* — so the list is asked of one provider
-			* at a time and there is nothing to filter out of it.
+			* operator settled otherwise on 2026-09-20 — *"l'utilizzatore è uno
+			* solo"* — so the list is asked of one provider at a time and there is
+			* nothing to filter out of it.
 			*/
-			provider: string().optional()
+			provider: string().min(1)
 		}), array(ClipSchema).readonly(), {
 			kind: "query",
 			auth: "protected"
@@ -41437,6 +41453,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.ownersWithMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.pauseForStorageMigration": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -45337,6 +45359,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.ownersWithMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.proposeRetrainAnnotations": [{
 		name: "deviceId",
 		form: "single",
@@ -69356,11 +69383,11 @@ var require_yazl = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 }));
 //#endregion
-//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-W55OUIVZ.js
+//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-UIQ527B6.js
 var import_undici = require_undici();
 var import_yazl = /* @__PURE__ */ __toESM(require_yazl(), 1);
 var formatterCache = /* @__PURE__ */ new Map();
-function formatterFor$1(timeZone) {
+function formatterFor$2(timeZone) {
 	const cached = formatterCache.get(timeZone);
 	if (cached) return cached;
 	const fmt = new Intl.DateTimeFormat("en-US", {
@@ -69385,7 +69412,7 @@ function wallClockParts(d, timeZone) {
 		minute: d.getMinutes(),
 		second: d.getSeconds()
 	};
-	const parts = formatterFor$1(timeZone).formatToParts(d);
+	const parts = formatterFor$2(timeZone).formatToParts(d);
 	const pick = (type) => {
 		const p = parts.find((x) => x.type === type);
 		return Number.parseInt(p?.value ?? "", 10);
@@ -75842,7 +75869,7 @@ var require_lz4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	};
 }));
 //#endregion
-//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-BHO5QGTT.js
+//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-5PJ6XPBF.js
 var import_fxp = require_fxp();
 var import_lz4 = /* @__PURE__ */ __toESM(require_lz4(), 1);
 function encodeHeader(h) {
@@ -83946,6 +83973,128 @@ function patchMotionSensitivityListXml(currentXml, bands) {
 	const fragment = encodeMotionSensitivityListXml(bands);
 	return currentXml.replace(/<sensitivityInfoList[\s\S]*?(?:\/>|<\/sensitivityInfoList>)/, fragment);
 }
+var ADTS_SAMPLES_PER_FRAME = 1024;
+var ADTS_SAMPLE_RATES = [
+	96e3,
+	88200,
+	64e3,
+	48e3,
+	44100,
+	32e3,
+	24e3,
+	22050,
+	16e3,
+	12e3,
+	11025,
+	8e3,
+	7350,
+	null,
+	null,
+	null
+];
+var ADTS_PROFILES = [
+	"Main",
+	"LC",
+	"SSR",
+	"LTP"
+];
+var parseAdtsHeader = (frame) => {
+	if (frame.length < 7) return null;
+	const b0 = frame[0];
+	const b1 = frame[1];
+	if (b0 !== 255 || (b1 & 240) !== 240) return null;
+	const b2 = frame[2];
+	const b3 = frame[3];
+	const b4 = frame[4];
+	const b5 = frame[5];
+	const profile = b2 >> 6 & 3;
+	const sampleRateIndex = b2 >> 2 & 15;
+	const channelConfig = (b2 & 1) << 2 | b3 >> 6 & 3;
+	const frameLength = (b3 & 3) << 11 | b4 << 3 | b5 >> 5 & 7;
+	if (frameLength < 7) return null;
+	return {
+		profile,
+		profileName: ADTS_PROFILES[profile] ?? "unknown",
+		sampleRate: ADTS_SAMPLE_RATES[sampleRateIndex] ?? null,
+		channels: channelConfig > 0 ? channelConfig : null,
+		frameLength
+	};
+};
+var buildRecordingAudioTrack = (params) => {
+	const { codec, frames } = params;
+	if (codec == null || frames.length === 0) return null;
+	const data = frames.length === 1 ? frames[0] : Buffer.concat([...frames]);
+	if (codec === "Adpcm") return {
+		codec,
+		format: "adpcm",
+		data,
+		frames: frames.length,
+		bytes: data.length,
+		sampleRate: null,
+		channels: null,
+		durationSeconds: null
+	};
+	const head = parseAdtsHeader(frames[0]);
+	if (head == null) return {
+		codec,
+		format: "unknown",
+		data,
+		frames: frames.length,
+		bytes: data.length,
+		sampleRate: null,
+		channels: null,
+		durationSeconds: null
+	};
+	const durationSeconds = head.sampleRate != null && head.sampleRate > 0 ? frames.length * ADTS_SAMPLES_PER_FRAME / head.sampleRate : null;
+	return {
+		codec,
+		format: "adts",
+		data,
+		frames: frames.length,
+		bytes: data.length,
+		sampleRate: head.sampleRate,
+		channels: head.channels,
+		durationSeconds
+	};
+};
+var roundRecordingFps = (fps) => {
+	if (fps > 14 && fps < 16) return 15;
+	if (fps > 23 && fps < 26) return 25;
+	if (fps > 29 && fps < 31) return 30;
+	return Math.round(fps * 100) / 100;
+};
+var estimateVideoTiming = (params) => {
+	const { timestampsUs } = params;
+	const infoFps = params.infoFps != null && params.infoFps > 0 ? params.infoFps : null;
+	const accessUnits = timestampsUs.length;
+	if (accessUnits >= 2) {
+		const spanUs = timestampsUs[accessUnits - 1] - timestampsUs[0];
+		if (spanUs > 0) {
+			const durationSeconds = spanUs / 1e6;
+			return {
+				accessUnits,
+				fps: roundRecordingFps((accessUnits - 1) / durationSeconds),
+				durationSeconds,
+				infoFps,
+				fpsSource: "timestamps"
+			};
+		}
+	}
+	if (infoFps != null) return {
+		accessUnits,
+		fps: infoFps,
+		durationSeconds: accessUnits > 0 ? accessUnits / infoFps : null,
+		infoFps,
+		fpsSource: "infoFps"
+	};
+	return {
+		accessUnits,
+		fps: null,
+		durationSeconds: null,
+		infoFps,
+		fpsSource: "unknown"
+	};
+};
 var buildDetectionClasses = (parsed, recordType) => {
 	const classes = [];
 	const flags = parsed?.flags;
@@ -88860,7 +89009,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 			return;
 		}
 		entry.startInFlight = (async () => {
-			const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-GFJX465B-D_s-iWc1.mjs");
+			const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-FOE2DBVZ-94yIU75L.mjs");
 			const sessionKey = `live:object-detections:ch${entry.channel}:${entry.profile}`;
 			const dedicated = await this.createDedicatedSession(sessionKey);
 			const stream = new BaichuanVideoStream2({
@@ -91973,25 +92122,46 @@ ${stderr}`));
 	async downloadRecordingDemuxed(params) {
 		const raw = await this.downloadRecording(params);
 		const frames = [];
+		const timestampsUs = [];
+		const audioFrames = [];
 		const decoder = new BcMediaAnnexBDecoder({
 			strict: false,
 			logger: this.logger,
-			onVideoAccessUnit: ({ annexB }) => {
+			onVideoAccessUnit: ({ annexB, microseconds }) => {
 				frames.push(annexB);
+				timestampsUs.push(microseconds);
+			},
+			onAudioFrame: ({ data }) => {
+				audioFrames.push(data);
 			}
 		});
 		decoder.push(raw);
 		const stats = decoder.getStats();
+		const audio = buildRecordingAudioTrack({
+			codec: stats.audioType,
+			frames: audioFrames
+		});
+		const timing = estimateVideoTiming({
+			timestampsUs,
+			infoFps: stats.infos[0]?.fps ?? null
+		});
+		if (audio == null) this.logger?.debug?.(`[downloadRecordingDemuxed] no audio packet in ${stats.packets} BcMedia packets (${stats.bytesIn} bytes) for ${params.fileName}`);
 		return {
 			annexB: Buffer.concat(frames),
 			videoType: stats.videoType,
+			audio,
 			stats: {
 				bytesIn: stats.bytesIn,
 				bytesOut: stats.bytesOut,
 				packets: stats.packets,
 				videoPackets: stats.videoPackets,
 				audioPackets: stats.audioPackets,
-				keyframes: stats.keyframes
+				audioBytes: stats.audioBytesOut,
+				keyframes: stats.keyframes,
+				fps: timing.fps,
+				durationSeconds: timing.durationSeconds,
+				infoFps: timing.infoFps,
+				fpsSource: timing.fpsSource
 			}
 		};
 	}
@@ -92037,28 +92207,12 @@ ${stderr}`));
 		decoder.push(raw);
 		const decoderStats = decoder.getStats();
 		const videoCodec = decoderStats.videoType ?? "H264";
-		let fps;
-		let durationSeconds;
-		if (videoFrames.length >= 2) {
-			const firstTs = videoFrames[0].microseconds;
-			const durationUs = videoFrames[videoFrames.length - 1].microseconds - firstTs;
-			if (durationUs > 0) {
-				durationSeconds = durationUs / 1e6;
-				fps = (videoFrames.length - 1) / durationSeconds;
-			} else {
-				const infoFps = decoderStats.infos[0]?.fps;
-				fps = infoFps && infoFps > 0 ? infoFps : 15;
-				durationSeconds = videoFrames.length / fps;
-			}
-		} else {
-			const infoFps = decoderStats.infos[0]?.fps;
-			fps = infoFps && infoFps > 0 ? infoFps : 15;
-			durationSeconds = videoFrames.length / fps;
-		}
-		if (fps > 14 && fps < 16) fps = 15;
-		else if (fps > 23 && fps < 26) fps = 25;
-		else if (fps > 29 && fps < 31) fps = 30;
-		else fps = Math.round(fps * 100) / 100;
+		const timing = estimateVideoTiming({
+			timestampsUs: videoFrames.map((f) => f.microseconds),
+			infoFps: decoderStats.infos[0]?.fps ?? null
+		});
+		const fps = timing.fps ?? 15;
+		const durationSeconds = timing.durationSeconds ?? videoFrames.length / fps;
 		const videoData = Buffer.concat(videoFrames.map((f) => f.annexB));
 		const audioData = audioFrames.length > 0 ? Buffer.concat(audioFrames) : null;
 		const hasAudio = audioData != null && audioData.length > 0;
@@ -95011,7 +95165,7 @@ ${xml}`);
 	* @returns Test results for all stream types and profiles
 	*/
 	async testChannelStreams(channel, logger) {
-		const { testChannelStreams } = await import("./DiagnosticsTools-DZ5RWXSM-9NV95vRN.mjs");
+		const { testChannelStreams } = await import("./DiagnosticsTools-ZC7I7QM6-9NV95vRN.mjs");
 		return await testChannelStreams({
 			api: this,
 			channel: this.normalizeChannel(channel),
@@ -95027,7 +95181,7 @@ ${xml}`);
 	* @returns Complete diagnostics for all channels and streams
 	*/
 	async collectMultifocalDiagnostics(logger) {
-		const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-DZ5RWXSM-9NV95vRN.mjs");
+		const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-ZC7I7QM6-9NV95vRN.mjs");
 		return await collectMultifocalDiagnostics({
 			api: this,
 			logger
@@ -144089,7 +144243,7 @@ function buildAacAudioSpecificConfigHex(params) {
 	if (!Number.isFinite(audioObjectType) || audioObjectType <= 0 || audioObjectType > 31) return;
 	return ((audioObjectType & 31) << 11 | (samplingFreqIndex & 15) << 7 | (channels & 15) << 3).toString(16).padStart(4, "0");
 }
-function parseAdtsHeader(adtsFrame) {
+function parseAdtsHeader2(adtsFrame) {
 	if (adtsFrame.length < 7) return null;
 	if (adtsFrame[0] !== 255 || (adtsFrame[1] & 240) !== 240) return null;
 	const protectionAbsent = (adtsFrame[1] & 1) === 1;
@@ -144194,7 +144348,7 @@ function packetizeH265(nal, rtp, opts, markerOnLast, isLastNal) {
 	return out;
 }
 function packetizeAacAdtsFrame(adts, rtp) {
-	const parsed = parseAdtsHeader(adts);
+	const parsed = parseAdtsHeader2(adts);
 	if (!parsed) return { packets: [] };
 	const raw = adts.subarray(parsed.headerLength);
 	if (!raw.length) return { packets: [] };
@@ -145844,7 +145998,7 @@ async function createRfc4571TcpServerInternal(options) {
 			}, isCompositeStream ? Math.min(1e4, keyframeTimeoutMs) : 5e3);
 			const onAudio = (frame) => {
 				sawAnyAudio = true;
-				const parsed = parseAdtsHeader(frame);
+				const parsed = parseAdtsHeader2(frame);
 				if (!parsed) {
 					if (debugLogsLeft-- > 0) {
 						const head = frame.subarray(0, Math.min(16, frame.length)).toString("hex");
@@ -147027,6 +147181,23 @@ var reolinkCameraSchema = object({
 	motionEnabled: boolean().optional(),
 	motionSensitivity: number().int().min(1).max(50).optional(),
 	/**
+	* Per-device clip-catalog refresh interval, in minutes — the OVERRIDE half
+	* of the cascade whose global default lives in the addon store under the
+	* same key. Absent means "use the global", which is the same thing a reset
+	* means (`resolveClipCatalogRefreshMinutes`, D562). `0` turns the timer off
+	* for this camera. What the timer DOES with it differs by topology and the
+	* field description says both: a free read on a hub child and on mains, and
+	* stale-marking only on a standalone battery camera.
+	*/
+	clipCatalogRefreshMinutes: number().int().min(0).max(1440).optional(),
+	/**
+	* Let the clip timer WAKE this standalone battery camera. Off by default and
+	* per device only — a 15-minute forced timer is 96 wakes/day against a
+	* natural rate of 1–20 clips/day on this fleet (D562). Inert on every other
+	* topology, which is why it is one switch and not a second meaning.
+	*/
+	clipCatalogForcedWake: boolean().optional(),
+	/**
 	* Per-AI-class sensitivity overrides — pushed via
 	* `setAiDetection(aiType, sensitivity)` (cmdId=343). Reolink
 	* range 0..100 — same scale the reolink_aio CGI exposes
@@ -147571,6 +147742,20 @@ var ClipCatalogCache = class ClipCatalogCache {
 		}
 		return null;
 	}
+	/**
+	* Every day key this device holds a listing for, in no particular order.
+	*
+	* It is what lets an availability probe say WHEN a catalog was last
+	* confirmed without listing anything: a camera nobody may wake reports the
+	* age of what is held, and a source with nothing held says so rather than
+	* claiming to be current.
+	*/
+	daysHeld(deviceId) {
+		const out = [];
+		const prefix = `${deviceId}|`;
+		for (const key of this.slots.keys()) if (key.startsWith(prefix)) out.push(key.slice(prefix.length));
+		return out;
+	}
 	/** Every row held for a device, in no particular order. The prefetch sorts. */
 	allRows(deviceId) {
 		const out = [];
@@ -147624,6 +147809,57 @@ var ClipCatalogCache = class ClipCatalogCache {
 	}
 };
 //#endregion
+//#region src/clips/clip-still-refusal.ts
+/** "You are in the queue." */
+function deferStill(code, reason, retryAfterMs) {
+	return {
+		ok: false,
+		code,
+		disposition: "deferred",
+		reason,
+		retryAfterMs
+	};
+}
+/** "This will not happen." */
+function refuseStill(code, reason) {
+	return {
+		ok: false,
+		code,
+		disposition: "final",
+		reason
+	};
+}
+/**
+* The queue's own refusal — the only failure that is about the LANE rather
+* than about the camera, and therefore the only one that is deferred.
+*
+* It carries its own `retryAfterMs` because the queue is the only thing that
+* knows it: the depth it is holding, or the exact instant a host's backoff
+* closes.
+*/
+var ThumbQueueRefusedError = class extends Error {
+	code;
+	retryAfterMs;
+	constructor(code, message, retryAfterMs) {
+		super(message);
+		this.name = "ThumbQueueRefusedError";
+		this.code = code;
+		this.retryAfterMs = retryAfterMs;
+	}
+};
+/**
+* A thrown value from the queue, as a wire answer — or `null` when it was not
+* the queue at all.
+*
+* `null` is not a default: it is what makes the caller name `camera-refused`
+* explicitly, instead of a socket close quietly inheriting "come back later"
+* and a tile retrying four times against a camera that is not there.
+*/
+function queueRefusal(err) {
+	if (!(err instanceof ThumbQueueRefusedError)) return null;
+	return deferStill(err.code, err.message, err.retryAfterMs);
+}
+//#endregion
 //#region src/clips/clip-data-plane.ts
 /**
 * The addon's two data-plane handlers — the still and the bytes.
@@ -147645,6 +147881,19 @@ var ClipCatalogCache = class ClipCatalogCache {
 * which. Waiting instead would hold a request open behind a camera that is
 * asleep for the night.
 *
+* **And it says whether to COME BACK.** Those reasons are two kinds of answer:
+* `queue-full` and `camera-backoff` mean the still is still coming, the rest
+* mean it will not. The branch that refused decides — nothing here maps a code
+* to a disposition, and no client parses one out of the prose — and the answer
+* travels as its own headers (`x-camstack-reason-code`,
+* `x-camstack-disposition`, plus `retry-after` on a deferred one) beside the
+* prose, which stays verbatim because a `camera-refused` is only ever
+* explained by the camera's own words.
+*
+* A response with no disposition header is read as FINAL by every surface,
+* which is exactly how this route behaved before: an older addon under a newer
+* admin UI keeps the old behaviour instead of gaining a retry loop.
+*
 * ## Why Range is hand-rolled here
 *
 * One file, one path, no root mapping — and `createReadStream().pipe(res)`
@@ -147687,26 +147936,45 @@ function createClipThumbHandler(deps) {
 		try {
 			minted = await deps.mint(deviceId, clipKey);
 		} catch (err) {
-			minted = {
-				ok: false,
-				reason: err instanceof Error ? err.message : String(err)
-			};
+			minted = refuseStill("camera-refused", err instanceof Error ? err.message : String(err));
 		}
 		if (!minted.ok) {
-			deps.logger.debug("videoclips: thumbnail not minted", {
-				tags: { deviceId },
-				meta: {
-					clipKey,
-					reason: minted.reason
-				}
-			});
-			res.writeHead(204, { "x-camstack-reason": minted.reason.slice(0, 500) });
-			res.end();
+			writeRefusal(res, minted, deviceId, deps.logger, clipKey);
 			return;
 		}
 		writeJpeg(res, minted.bytes, req.method === "HEAD");
 	};
 }
+/**
+* The 204, with everything the tile needs to decide what to draw next.
+*
+* A FINAL refusal is work that was dropped, so it is warned, per camera. A
+* DEFERRED one dropped nothing — the still is queued behind another — and
+* warning it would put 43 lines on the log for one 60-tile page against a
+* 16-deep lane, which is how a real drop stops being visible.
+*/
+function writeRefusal(res, refusal, deviceId, logger, clipKey) {
+	const line = "videoclips: thumbnail not minted";
+	const extras = {
+		tags: { deviceId },
+		meta: {
+			clipKey,
+			code: refusal.code,
+			disposition: refusal.disposition,
+			reason: refusal.reason
+		}
+	};
+	if (refusal.disposition === "final") logger.warn(line, extras);
+	else logger.debug(line, extras);
+	const retryAfterMs = refusal.disposition === "deferred" ? refusal.retryAfterMs : void 0;
+	res.writeHead(204, {
+		[CLIP_STILL_REASON_HEADER]: refusal.reason.slice(0, 500),
+		[CLIP_STILL_REASON_CODE_HEADER]: refusal.code,
+		[CLIP_STILL_DISPOSITION_HEADER]: refusal.disposition,
+		...retryAfterMs === void 0 ? {} : { "retry-after": String(Math.max(1, Math.ceil(retryAfterMs / 1e3))) }
+	});
+	res.end();
+}
 function writeJpeg(res, bytes, headOnly) {
 	res.writeHead(200, {
 		"content-type": "image/jpeg",
@@ -147825,21 +148093,73 @@ function createClipPlaybackHandler(deps) {
 //#region src/clips/clip-mux.ts
 /** A clip that has not transferred by here is not going to. */
 var CLIP_MUX_TIMEOUT_MS = 6e4;
+/**
+* Decide what to do with the track the download returned.
+*
+* The gate is `format === 'adts'` and NOT `audio !== null`: an `adpcm` or
+* `unknown` track stream-copied into MP4 produces a file whose audio track is
+* garbage, which is worse than a clip that is honestly silent. A track that
+* arrived with no frames is no track — counting it would promise sound the
+* file does not have.
+*/
+function decideClipAudio(audio) {
+	if (audio === null) return {
+		kind: "silent",
+		reason: "no-audio-track",
+		format: null
+	};
+	if (audio.frames === 0 || audio.bytes === 0) return {
+		kind: "silent",
+		reason: "no-audio-track",
+		format: audio.format
+	};
+	if (audio.format !== "adts") return {
+		kind: "silent",
+		reason: "audio-not-copyable",
+		format: audio.format
+	};
+	return {
+		kind: "copy",
+		format: "adts",
+		data: audio.data
+	};
+}
+function usableFps(fps) {
+	if (fps === null || fps === void 0) return null;
+	return Number.isFinite(fps) && fps > 0 ? fps : null;
+}
 function buildClipMuxArgs(input) {
+	const demuxer = input.videoType === "H265" ? "hevc" : "h264";
+	const fps = usableFps(input.fps);
 	return [
 		"-hide_banner",
 		"-loglevel",
 		"error",
 		"-nostdin",
 		"-y",
+		...fps !== null ? ["-r", String(fps)] : [],
 		"-f",
-		input.videoType === "H265" ? "hevc" : "h264",
+		demuxer,
 		"-i",
 		input.inputPath,
-		"-c",
+		...input.audio !== void 0 ? [
+			"-f",
+			"aac",
+			"-i",
+			input.audio.path
+		] : [],
+		"-c:v",
 		"copy",
+		...input.audio !== void 0 ? [
+			"-c:a",
+			"copy",
+			"-bsf:a",
+			"aac_adtstoasc"
+		] : [],
 		"-movflags",
 		"+faststart",
+		"-f",
+		"mp4",
 		input.outputPath
 	];
 }
@@ -147926,6 +148246,85 @@ function describeMuxFailure(run) {
 	if (run.code !== 0) return `mux-failed (exit ${String(run.code)}): ${run.stderr.slice(0, 300)}`;
 	return null;
 }
+//#endregion
+//#region src/clips/clip-truncation.ts
+/**
+* The window a TRUNCATED fetch is retried on: the library's own default, the
+* one this repo shipped for its whole life. A retry exists to answer "was that
+* the window or the camera?", so it must be the conservative number and not a
+* second short one.
+*/
+var CLIP_IDLE_WINDOW_RETRY_MS = 2e3;
+/**
+* Did this pass deliver the clip the row describes?
+*
+* Only a SHORTFALL is a defect. A decode that runs longer than the row is
+* routine — the row's stamps are whole seconds and its twins differ by up to
+* four — and calling it truncated would refuse a clip that is more complete
+* than the catalog knew.
+*/
+function judgeClipDuration(input) {
+	if (input.inProgress === true) return {
+		kind: "unknown",
+		reason: "clip-open"
+	};
+	if (input.decodedSeconds === null || !Number.isFinite(input.decodedSeconds)) return {
+		kind: "unknown",
+		reason: "duration-unmeasured"
+	};
+	if (!Number.isFinite(input.expectedMs) || input.expectedMs <= 0) return {
+		kind: "unknown",
+		reason: "row-window-unknown"
+	};
+	const expectedSeconds = input.expectedMs / 1e3;
+	const decodedSeconds = input.decodedSeconds;
+	const shortfallSeconds = expectedSeconds - decodedSeconds;
+	if (shortfallSeconds > 1.5) return {
+		kind: "short",
+		expectedSeconds,
+		decodedSeconds,
+		shortfallSeconds
+	};
+	return {
+		kind: "complete",
+		expectedSeconds,
+		decodedSeconds
+	};
+}
+//#endregion
+//#region src/clips/clip-thumb-queue.ts
+/**
+* The provider's OWN CoverPreview lane — two queues, one in flight per host.
+*
+* The library already serialises CoverPreview: one in flight per api instance,
+* a 50-deep FIFO that throws past that, and a process-wide host-keyed backoff
+* that doubles on a 400. What a FIFO cannot express is PRIORITY, and the two
+* kinds of mint this feature has are not equal — an operator staring at a tile
+* must not wait behind twenty prefetches for clips nobody opened.
+*
+* So the provider keeps two queues of its own, hands the library at most ONE
+* CoverPreview per host at a time, drains `interactive` before `prefetch`, and
+* re-checks between every prefetch mint (D549 16).
+*
+* ## Two things it refuses to do
+*
+* **Wait when the queue is full.** A request past the bound is REFUSED with
+* `queue-full`, so the route can answer 204 with a reason. A request held open
+* behind forty-nine others is a spinner the operator cannot cancel, and the
+* camera will have rolled the clip over before it is served.
+*
+* **Let a prefetch probe a sulking host.** While a host's 400 backoff is open
+* a prefetch is skipped entirely; only an interactive request may probe it,
+* because only an interactive request has somebody waiting for the answer.
+*
+* The backoff mirrors the library's (1 s doubling to 30 s) rather than
+* replacing it: this one decides whether to ASK at all, the library's decides
+* how long to wait once asked.
+*/
+/** How long one waiting mint is worth, as a retry hint. Coarse on purpose:
+*  the client floors it with its own backoff and caps its own attempts, so a
+*  wrong hint can neither cause a hammer nor a hang. */
+var THUMB_DRAIN_HINT_PER_WAITER_MS = 1e3;
 var THUMB_BACKOFF_INITIAL_MS = 1e3;
 var THUMB_BACKOFF_MAX_MS = 3e4;
 /**
@@ -147946,6 +148345,28 @@ var ClipThumbQueue = class {
 		const state = this.hosts.get(host);
 		return state !== void 0 && state.backoffUntilMs > this.now();
 	}
+	/**
+	* Is this host busy with, or owed, operator-facing work?
+	*
+	* The periodic catalog refresh asks before it spends the host's one lane:
+	* an operator staring at a tile must never wait behind a timer, and a host
+	* whose 400 backoff is open must not be probed by anything that has nobody
+	* waiting for the answer — the same rule that already keeps a PREFETCH off
+	* a sulking host.
+	*
+	* Either a mint is in flight or the host is sulking. There is deliberately
+	* no third clause for "an interactive request is queued": a queued request
+	* means a mint is running, so `running` already covers it, and a clause
+	* that can never be the reason for the answer is a leftover that reads as
+	* verification. The lane is one per host, so a PREFETCH holding it defers
+	* the refresh too — which is right: the refresh is the lowest-priority
+	* thing on this host.
+	*/
+	busy(host) {
+		const state = this.hosts.get(host);
+		if (state === void 0) return false;
+		return state.backoffUntilMs > this.now() || state.running;
+	}
 	backoffUntil(host) {
 		return this.hosts.get(host)?.backoffUntilMs ?? 0;
 	}
@@ -147968,8 +148389,8 @@ var ClipThumbQueue = class {
 	*/
 	async submit(job) {
 		const state = this.stateFor(job.host);
-		if (job.lane === "prefetch" && state.backoffUntilMs > this.now()) throw new Error(`camera-backoff: host ${job.host} refused a CoverPreview recently; prefetch skipped until the backoff closes (only an interactive request probes it)`);
-		if (state.waiting.length >= 16) throw new Error(`queue-full: ${state.waiting.length} thumbnail mints already waiting for host ${job.host}`);
+		if (job.lane === "prefetch" && state.backoffUntilMs > this.now()) throw new ThumbQueueRefusedError("camera-backoff", `camera-backoff: host ${job.host} refused a CoverPreview recently; prefetch skipped until the backoff closes (only an interactive request probes it)`, state.backoffUntilMs - this.now());
+		if (state.waiting.length >= 16) throw new ThumbQueueRefusedError("queue-full", `queue-full: ${state.waiting.length} thumbnail mints already waiting for host ${job.host}`, state.waiting.length * THUMB_DRAIN_HINT_PER_WAITER_MS);
 		return new Promise((resolve, reject) => {
 			state.waiting.push({
 				lane: job.lane,
@@ -147989,7 +148410,7 @@ var ClipThumbQueue = class {
 		if (next === void 0) return;
 		state.waiting.splice(pick, 1);
 		if (next.lane === "prefetch" && state.backoffUntilMs > this.now()) {
-			next.reject(/* @__PURE__ */ new Error(`camera-backoff: host ${host} is backing off; prefetch skipped`));
+			next.reject(new ThumbQueueRefusedError("camera-backoff", `camera-backoff: host ${host} is backing off; prefetch skipped`, state.backoffUntilMs - this.now()));
 			this.drain(host);
 			return;
 		}
@@ -148042,12 +148463,13 @@ var ClipThumbQueue = class {
 * exactly — 29 events, 28 inside the 20 listed files, and all 20 files
 * carrying an event. They are two VIEWS of one store.
 *
-* So the operator collapsed them (2026-09-20): one source, which picks the
-* best API for what the camera IS. Which view it resolved to is REPORTED
-* (`ClipSource.via`, and the listing log line) — a source that silently reads
-* a different API on two cameras and then behaves differently is the thing
-* nobody can debug later — but it is never a row the operator has to
-* understand.
+* So the operator collapsed them (2026-09-20): one source, which picked the
+* best API for what the camera IS, and REPORTED the pick on `ClipSource.via`.
+* Later the same day the pick went too (D565): `FileInfoList` is the catalog
+* on every topology, so `via` had one value and is gone. What is left is one
+* source reading one API — and `clipKeyFor` below is still keyed off
+* `(channel, fileName)` rather than the source, which is now simply true
+* rather than a concession.
 */
 var CLIP_SOURCE_ONBOARD = "native:reolink:onboard";
 /** Every source this provider can name. Order is the picker's order. */
@@ -148098,10 +148520,10 @@ function parseClipId(clipId) {
 }
 /**
 * The on-disk key for a clip's derived artifacts (its thumbnail, its muxed
-* MP4). Derived from `(channel, fileName)` and NOT from the source: the two
-* views of a hub child's store are two views of the SAME file, so a thumbnail
-* minted for the files view is the same picture the events view wants and
-* minting it twice would cost the camera a second CoverPreview.
+* MP4). Derived from `(channel, fileName)` and NOT from the source: a
+* thumbnail belongs to the FILE, so any surface that names the same file
+* finds the same picture and the camera is never asked for a second
+* CoverPreview of it.
 *
 * A hash rather than the encoded name because a hub `<Id>` is a full path and
 * the encoded form is long enough to hit a file-name limit.
@@ -148250,7 +148672,7 @@ function startOf(file) {
 	return file.startTime?.getTime() ?? 0;
 }
 var partsCache = /* @__PURE__ */ new Map();
-function formatterFor(timeZone) {
+function formatterFor$1(timeZone) {
 	const cached = partsCache.get(timeZone);
 	if (cached !== void 0) return cached;
 	const made = new Intl.DateTimeFormat("en-US", {
@@ -148267,7 +148689,7 @@ function formatterFor(timeZone) {
 	return made;
 }
 function partsAt(epochMs, timeZone) {
-	const parts = formatterFor(timeZone).formatToParts(new Date(epochMs));
+	const parts = formatterFor$1(timeZone).formatToParts(new Date(epochMs));
 	const read = (type) => {
 		const found = parts.find((p) => p.type === type);
 		return found === void 0 ? 0 : Number(found.value);
@@ -148338,36 +148760,6 @@ function enumerateWallClockDays(sinceMs, untilMs, timeZone) {
 //#endregion
 //#region src/clips/clip-catalog.ts
 /**
-* Reading a Reolink camera's own clip catalog: the cheap question, the day
-* index, then one day's files.
-*
-* ## The order is the point
-*
-* 1. **Is there a card at all?** `getHddInfoList` (cmd 102). 640 answers
-*    `mount 0, capacity 0` — no SD card — and searching it is 400s and wasted
-*    wake budget. "The cheap question comes first" (D549 4 / D54).
-* 2. **Which days hold footage?** `getDayRecords` (cmd 142) once per month.
-*    The per-day listing loop of the earlier plan is deleted, not kept as a
-*    fallback (D549 8): 19 days in 50 ms beats 30 searches.
-* 3. **What is in one day?** `FileInfoList` (cmd 14/15/16), sub AND main, then
-*    twinned (D549 14b). A clip IS a file: its name is its id, its bytes
-*    (cmd 5) and its still (cmd 298) are addressed from it (D549 10).
-*
-* This is the API a STANDALONE camera's one source resolves to — a standalone
-* answers `findEventLog` with an empty body. A hub child resolves to the event
-* view instead (`clip-event-catalog.ts`), and still uses this reader for the
-* day's files, which is what an event's window is joined against (D555).
-*
-* ## What an empty answer means
-*
-* A day the CALENDAR names and the INDEX answers with nothing is a defect on
-* the camera, measured on 618: the calendar marks 3–20 September, days 6–20
-* list zero files on both streams, on both filters, on a hand-built window,
-* with 177 GB free. The reader reports `indexEmpty` for that day so the
-* provider can say `index-empty` — never "no clips", which would be a lie
-* about a card that is full of them (D549 18).
-*/
-/**
 * Locate the disk record structurally.
 *
 * The library's declared `HddInfoListConfig` and the captured wire disagree —
@@ -148452,6 +148844,30 @@ function monthsBetween(sinceMs, untilMs, timeZone) {
 	}
 	return out;
 }
+/**
+* Is this file still being written?
+*
+* A Reolink recording is named `<prefix>_DST<date>_<start>_<end>_<hex>_<hex>`,
+* and while it is open the camera writes the END stamp as `000000` and the
+* size as `0` — measured on 592, 2026-09-20:
+* `RecS03_DST20260920_192927_000000_2B1E808_0.mp4`. Its `<endTime>` block is
+* FROZEN at whatever the index entry held when it was created (19:29:56, read
+* three times over fifteen minutes while the file grew), so a duration drawn
+* from it is a lie about the one row the operator sees first.
+*
+* BOTH signals are required. A recording that happens to end at midnight is
+* named `_000000_` and is closed; its bytes are what separate the two. Nothing
+* on the wire distinguishes them otherwise, and a false positive here would
+* replace a correct duration with `Recording…` for ever. Re-measured
+* read-only the same evening: of 355 sub and 355 main files on that camera's
+* day, zero carried a `_000000_` segment and zero carried a size of 0.
+*/
+function isFileStillBeingWritten(file) {
+	if (file.sizeBytes !== void 0 && file.sizeBytes > 0) return false;
+	return OPEN_END_STAMP.test(file.fileName);
+}
+/** The end-stamp field of an open recording, between its own separators. */
+var OPEN_END_STAMP = /_000000_/;
 function handleOf(file) {
 	const id = file.id;
 	return id !== void 0 && id !== "" ? id : file.fileName;
@@ -148492,139 +148908,123 @@ async function listDayRows(api, input) {
 				...pair.sub.sizeBytes !== void 0 ? { subBytes: pair.sub.sizeBytes } : {},
 				...pair.main !== void 0 ? { mainFileName: handleOf(pair.main) } : {},
 				...pair.main?.sizeBytes !== void 0 ? { mainBytes: pair.main.sizeBytes } : {},
+				...pair.main?.startTime !== void 0 ? { mainStartMs: pair.main.startTime.getTime() } : {},
 				supportSub: pair.sub.supportSub !== false,
-				nativeTypes: parseNativeTypes(pair.sub.recordType)
+				nativeTypes: parseNativeTypes(pair.sub.recordType),
+				...isFileStillBeingWritten(pair.sub) ? { inProgress: true } : {}
 			};
 		}),
 		indexEmpty: subs.length === 0,
 		...mainSearchFailed !== void 0 ? { mainSearchFailed } : {}
 	};
 }
-//#endregion
-//#region src/clips/clip-event-catalog.ts
-/**
-* The HUB events view — the API a HUB CHILD's one source resolves to (D549 19,
-* D555).
-*
-* On a hub child the catalog is the EVENT list, not the file list: 29 events
-* in 293 ms against 20 files in 503 ms, and it is the ONLY class source there
-* because a hub child's files come back with `recordType none`. The file view
-* reads the SAME store from the other side — the hub's uid addresses no
-* catalog at all while the child's addresses all of it, and cmd 5 serves
-* identical bytes either way. Two views, one store. They were two SOURCES for
-* a few hours; the operator collapsed them once that measurement landed, so
-* this module is now one of the two ways the single source reads itself, and
-* the file reader is the other (`clip-catalog.ts`).
-*
-* ## An event is not a promise of a clip
-*
-* A row whose `hasRecFile` is false has nothing to play, and both of the wrong
-* things are easy: dropping it under-reports a camera's events, and showing it
-* as playable fails on click. It is listed with `playable: false` and a
-* reason, which is what `ClipSchema.unplayableReason` exists for.
-*
-* **How often that bites is a per-camera fact.** Measured 2026-09-20 over 20
-* days: 3628 → 222 rows with 0 orphans, 3629 → 1 059 rows with 0 orphans, and
-* the orphans D549 19 describes are on 3825 — the child whose uid was never
-* persisted, which this provider cannot address at all today. So one camera's
-* events are all playable and another's are all not, and a surface built for
-* either extreme is wrong on the other.
-*
-* ## Where the file comes from
-*
-* `findEventLog` rows carry no file name — they name events, not files. So the
-* file is resolved by WINDOW CONTAINMENT against the day's `FileInfoList`
-* rows, which the `onboard` reader already fetches: an event whose
-* `[start, end]` lies inside a file's `[start − 3 s, end + 3 s]`. 28 of 29 on
-* the measured day; the one that did not is a real orphan (the hub refused its
-* CoverPreview too), not a join bug.
-*
-* Deliberately NOT used here: `searchAlarmVideos` (272/273/274). It does carry
-* a `fileName`, and its containment is measured at 1271/1271 — but it is
-* clamped to ONE camera-local day (an 18→19 September window silently answered
-* 462 windows all dated the 18th) where `searchEventLog` spans the whole
-* window in one open, and D549 19 chose the event list on the measured timing.
-* Its place is the per-window label upgrade for a clip's DETAIL (D549 20), and
-* that is a separate slice.
-*
-* ## `devices` is the selector; `chnbits` is inert
-*
-* Measured: `chnbits: 3` answered exactly the same 9 rows as the default, and
-* OMITTING `devices` is refused outright by the library ("no devices to
-* search") rather than answered emptily — a hub that has pushed nothing yet is
-* a refusal, not an empty result. This module always passes `devices`, never
-* sends `chnbits`, and never derives one from the other. With one child named,
-* foreign rows in the reply were 0; the uid filter below is belt and braces.
-*/
-/**
-* Every event for ONE child in the window, newest first, in ONE call.
-*
-* The event list is multi-day by construction — a per-day loop would pay the
-* open/close for each day and answer the same rows. The bound the caller owes
-* is on the WINDOW, and it has a number behind it: measured on one hub child,
-* ONE day is 267 ms and 20 days is 3.6–5.4 s. A day-range default is therefore
-* a UI decision, not a free one.
-*/
-async function listEventRows(api, input) {
-	const entries = await api.searchEventLog({
-		devices: [{ uid: input.uid }],
-		start: new Date(input.since),
-		end: new Date(input.until),
-		timeZone: input.timeZone
+/**
+* Every alarm window of ONE camera-local day.
+*
+* The one-day clamp is the firmware's, not ours: an 18→19 September ask
+* answered 462 windows all dated the 18th. The caller owns the iteration, and
+* this is asked from inside the day loop the listing already runs.
+*/
+async function readAlarmWindows(api, input) {
+	const { startMs, endMs } = dayBounds(input.day, input.timeZone);
+	return await api.searchAlarmVideos({
+		channel: input.channel,
+		start: new Date(startMs),
+		end: new Date(endMs),
+		streamType: 1,
+		timeZone: input.timeZone,
+		...input.uid !== void 0 ? { uid: input.uid } : {}
 	});
-	const rows = [];
-	for (const entry of entries) {
-		if (entry.uid !== input.uid) continue;
-		const startMs = entry.startTime?.getTime();
-		if (startMs === void 0 || !Number.isFinite(startMs)) continue;
-		rows.push({
-			channel: input.channel,
-			startMs,
-			endMs: entry.endTime?.getTime() ?? startMs,
-			nativeTypes: [...entry.alarmTypes],
-			hasRecFile: entry.hasRecFile
-		});
+}
+/** The camera declined to class this file: `none`, or no `recordType` at all. */
+function fileCarriesNoClass(nativeTypes) {
+	return nativeTypes.every((type) => type === "none");
+}
+/**
+* Should this day's labels be asked for separately?
+*
+* Only when NOTHING in the day carried a class. One file saying `md` is proof
+* that this camera writes `recordType`, and then the free answer is the
+* answer — paying 8–9 s to restate it is the cheap-question rule inverted.
+*/
+function dayNeedsAlarmLabels(rows) {
+	return rows.length > 0 && rows.every((row) => fileCarriesNoClass(row.nativeTypes));
+}
+/**
+* Attach each window's `alarmType`s to the file whose START it names.
+*
+* A row the camera already classed is returned untouched: the file's own
+* `recordType` is the authority wherever it exists, and a per-window answer
+* must not narrow it. A window that names no listed file contributes nothing
+* and is COUNTED — it is never attached to the nearest neighbour, which is how
+* a surface ends up showing one recording's class on another's row.
+*/
+function joinAlarmLabels(rows, windows, timeZone) {
+	const byStamp = /* @__PURE__ */ new Map();
+	for (const window of windows) {
+		const key = window.fileName.slice(-STAMP_LENGTH);
+		const existing = byStamp.get(key);
+		const target = existing ?? [];
+		if (existing === void 0) byStamp.set(key, target);
+		for (const type of window.alarmTypes) if (type !== "" && !target.includes(type)) target.push(type);
 	}
-	return rows.toSorted((a, b) => b.startMs - a.startMs);
+	const claimed = /* @__PURE__ */ new Set();
+	let matched = 0;
+	return {
+		rows: rows.map((row) => {
+			if (!fileCarriesNoClass(row.nativeTypes)) return row;
+			const subKey = alarmJoinKey(row.startMs, timeZone);
+			const mainKey = row.mainStartMs !== void 0 ? alarmJoinKey(row.mainStartMs, timeZone) : void 0;
+			const key = byStamp.has(subKey) ? subKey : mainKey !== void 0 && byStamp.has(mainKey) ? mainKey : void 0;
+			if (key === void 0) return row;
+			const types = byStamp.get(key);
+			if (types === void 0 || types.length === 0) return row;
+			claimed.add(key);
+			matched += 1;
+			return {
+				...row,
+				nativeTypes: [...types]
+			};
+		}),
+		matched,
+		unmatchedWindows: byStamp.size - claimed.size
+	};
 }
-function joinEventsToFiles(events, files) {
-	return events.map((event) => {
-		if (!event.hasRecFile) return {
-			...event,
-			clipKey: eventKey(event),
-			playable: false,
-			unplayableReason: "no-rec-file"
-		};
-		const file = files.find((candidate) => event.startMs >= candidate.startMs - 3e3 && event.endMs <= candidate.endMs + 3e3);
-		if (file === void 0) return {
-			...event,
-			clipKey: eventKey(event),
-			playable: false,
-			unplayableReason: "no-file-for-window"
-		};
-		return {
-			...event,
-			clipKey: file.clipKey,
-			fileName: file.subFileName,
-			playable: true
-		};
+/** `YYYYMMDDHHMMSS` — 14 digits. */
+var STAMP_LENGTH = 14;
+var FORMATTER_BY_ZONE = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+	const cached = FORMATTER_BY_ZONE.get(timeZone);
+	if (cached !== void 0) return cached;
+	const made = new Intl.DateTimeFormat("en-CA", {
+		timeZone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: false
 	});
+	FORMATTER_BY_ZONE.set(timeZone, made);
+	return made;
 }
-/** A key for a row with no file — stable, and its OWN. */
-function eventKey(event) {
-	return clipKeyFor(event.channel, `event:${event.startMs}-${event.endMs}`);
+/**
+* The 14-digit tail of the short name a window carries — the file's start in
+* the CAMERA's wall clock. Never a UTC stamp: 00:30 Rome on the 17th is 22:30
+* UTC on the 16th, and a UTC key would file it under the wrong day and join it
+* to nothing.
+*/
+function alarmJoinKey(atMs, timeZone) {
+	const parts = new Map(formatterFor(timeZone).formatToParts(new Date(atMs)).map((part) => [part.type, part.value]));
+	return `${parts.get("year") ?? ""}${parts.get("month") ?? ""}${parts.get("day") ?? ""}${normaliseHour(parts.get("hour"))}${parts.get("minute") ?? ""}${parts.get("second") ?? ""}`;
+}
+/** `hourCycle: h23` still renders midnight as `24` in some ICU builds. */
+function normaliseHour(hour) {
+	return hour === "24" ? "00" : hour ?? "";
 }
 //#endregion
 //#region src/clips/reolink-videoclips-provider.ts
-/**
-* Which API the ONE source resolved to for a camera — reported on
-* `ClipSource.via` and on the listing log line.
-*
-* The CHOICE is made from what the camera is (`viaFor`); naming it is what
-* makes "why do these two cameras behave differently" answerable at all.
-*/
-var CATALOG_VIA_EVENTS = "events";
-var CATALOG_VIA_FILES = "files";
 function createReolinkVideoclipsProvider(deps) {
 	/** Last known availability per `deviceId|source`, written by every read. */
 	const health = /* @__PURE__ */ new Map();
@@ -148748,7 +149148,7 @@ function createReolinkVideoclipsProvider(deps) {
 							error: result.mainSearchFailed
 						}
 					});
-					return result.rows;
+					return await labelDay(device, api, day, result.rows);
 				});
 				if (entry.clips.length === 0) emptyDays.push(day);
 				rows.push(...entry.clips);
@@ -148776,11 +149176,7 @@ function createReolinkVideoclipsProvider(deps) {
 					days: emptyDays
 				}
 			});
-			noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, {
-				state: "index-empty",
-				reason: `The camera’s calendar marks ${emptyDays.length} day(s) with footage that its own index lists no files for: ${emptyDays.join(", ")}.`,
-				catalogAsOf: deps.now()
-			});
+			noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, indexEmpty(emptyDays));
 		} else noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, {
 			state: "ok",
 			catalogAsOf: deps.now()
@@ -148788,140 +149184,55 @@ function createReolinkVideoclipsProvider(deps) {
 		return rows;
 	};
 	/**
-	* Read the HUB's event view for one child.
+	* Give a day's rows a class when the FILES carried none.
 	*
-	* ONE `searchEventLog` open for the whole window — the event list is
-	* multi-day by construction, so a per-day loop would pay the open/close per
-	* day for the same rows. The bound is the WINDOW, and it has a number
-	* behind it: 59 events over 3 children and 3 days took 2 372 ms, 1 886
-	* events over 20 days took 11 908 ms. The elapsed time and the row count
-	* are logged per camera so "why is this camera slow" is answerable.
+	* The gate is what the day actually said, never what the camera is: a hub
+	* child's files are `recordType: none` on every row (measured), a
+	* standalone's carry `md,people,dog_cat,sched`, and a camera that changes
+	* firmware changes which of those it is without this code learning a new
+	* topology. The cheap question comes first (D54) — on 592 an alarm search
+	* costs 8.2–9.5 s for 1 271 windows to restate labels already on the row.
 	*
-	* The day's FILE rows come from the `onboard` reader, cache-backed, because
-	* `findEventLog` names events and not files: the join is by window
-	* containment. Losing the file list costs PLAYABILITY, not the events — the
-	* rows still list, each saying why it cannot play.
+	* A refusal costs the LABELS and nothing else. Losing the day because its
+	* class could not be read would be the upgrade destroying the thing it
+	* upgrades — the same rule the MAIN search already lives by.
 	*/
-	const readHubEvents = async (device, since, until) => {
+	const labelDay = async (device, api, day, rows) => {
 		const tags = { deviceId: device.deviceId };
-		if (!device.isHubChild) return [];
-		const uid = device.uid;
-		if (uid === void 0) {
-			deps.logger.warn("videoclips: no uid for this camera — the hub cannot be asked about it", {
-				tags,
-				meta: {
-					branch: "uid-missing",
-					via: CATALOG_VIA_EVENTS
-				}
-			});
-			noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, {
-				state: "unreachable",
-				reason: UID_MISSING_REASON
-			});
-			return [];
-		}
-		let api;
-		try {
-			api = await device.getApi();
-		} catch (err) {
-			const reason = err instanceof Error ? err.message : String(err);
-			deps.logger.warn("videoclips: could not reach the hub", {
-				tags,
-				meta: {
-					branch: "camera-refused",
-					via: CATALOG_VIA_EVENTS,
-					error: reason
-				}
-			});
-			noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, {
-				state: "unreachable",
-				reason
-			});
-			return [];
-		}
+		if (!dayNeedsAlarmLabels(rows)) return rows;
 		const startedAt = deps.now();
-		let events = [];
-		let joined = [];
+		let windows;
 		try {
-			const rows = await listEventRows(api, {
-				uid,
+			windows = await readAlarmWindows(api, {
 				channel: device.channel,
+				uid: device.uid,
 				timeZone: device.timeZone,
-				since,
-				until
+				day
 			});
-			events = rows;
-			joined = joinEventsToFiles(rows, await readOnboard(device, since, until).catch(() => []));
 		} catch (err) {
-			const reason = err instanceof Error ? err.message : String(err);
-			deps.logger.warn("videoclips: the hub event log refused", {
+			deps.logger.warn("videoclips: the label search refused — the day lists without classes", {
 				tags,
 				meta: {
 					branch: "camera-refused",
-					via: CATALOG_VIA_EVENTS,
-					error: reason
+					day,
+					error: err instanceof Error ? err.message : String(err)
 				}
 			});
-			noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, {
-				state: "unreachable",
-				reason
-			});
-			return [];
+			return rows;
 		}
-		const unplayable = joined.filter((row) => !row.playable).length;
-		deps.logger.info("videoclips: read the hub event log", {
+		const joined = joinAlarmLabels(rows, windows, device.timeZone);
+		deps.logger.info("videoclips: read the classes a day of files does not carry", {
 			tags,
 			meta: {
-				via: CATALOG_VIA_EVENTS,
-				events: events.length,
-				unplayable,
-				elapsedMs: deps.now() - startedAt,
-				windowDays: Math.max(1, Math.round((until - since) / 864e5))
+				day,
+				windows: windows.length,
+				rows: rows.length,
+				labelled: joined.matched,
+				unmatchedWindows: joined.unmatchedWindows,
+				elapsedMs: deps.now() - startedAt
 			}
 		});
-		noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, {
-			state: "ok",
-			catalogAsOf: deps.now()
-		});
-		return joined;
-	};
-	/**
-	* An events-view row as a `Clip`.
-	*
-	* The id carries the event WINDOW as well as the file, because a file holds
-	* 1–13 windows and two events of one recording must not collapse into one
-	* row. A row with nothing to play carries `playable: false` and its reason,
-	* and offers no thumbnail mint — the hub refused the CoverPreview for
-	* exactly that orphan event, so an offer here would be a tile that spins and
-	* then fails.
-	*/
-	const toEventClip = async (device, row, catalogAsOf) => {
-		const classification = classifyNativeTypes(row.nativeTypes);
-		const still = await deps.hasVouchedThumbnail(device.deviceId, row.clipKey) ? { thumbnail: deps.thumbnailUrl(device.deviceId, row.clipKey) } : row.playable ? { thumbnailMint: deps.thumbnailMintUrl(device.deviceId, row.clipKey) } : { thumbnailUnavailable: { reason: "no-keyframe" } };
-		return {
-			id: mintClipId({
-				source: CLIP_SOURCE_ONBOARD,
-				channel: row.channel,
-				fileName: row.fileName ?? `event:${row.startMs}-${row.endMs}`,
-				window: {
-					startMs: row.startMs,
-					endMs: row.endMs
-				}
-			}),
-			source: CLIP_SOURCE_ONBOARD,
-			kind: classification.kind,
-			timeRange: {
-				startMs: row.startMs,
-				endMs: row.endMs
-			},
-			...classification.labels.length > 0 ? { labels: [...classification.labels] } : {},
-			...classification.behaviours.length > 0 ? { behaviours: [...classification.behaviours] } : {},
-			...classification.nativeTypes.length > 0 ? { nativeTypes: [...classification.nativeTypes] } : {},
-			...still,
-			...catalogAsOf !== void 0 ? { catalogAsOf } : {},
-			playable: row.playable,
-			...row.unplayableReason !== void 0 ? { unplayableReason: row.unplayableReason } : {}
-		};
+		return joined.rows;
 	};
 	const toClip = async (device, source, row, catalogAsOf) => {
 		rowsByKey.set(`${device.deviceId}|${row.clipKey}`, row);
@@ -148940,6 +149251,7 @@ function createReolinkVideoclipsProvider(deps) {
 				startMs: row.startMs,
 				endMs: row.endMs
 			},
+			...row.inProgress === true ? { inProgress: true } : {},
 			...classification.labels.length > 0 ? { labels: [...classification.labels] } : {},
 			...classification.behaviours.length > 0 ? { behaviours: [...classification.behaviours] } : {},
 			...classification.nativeTypes.length > 0 ? { nativeTypes: [...classification.nativeTypes] } : {},
@@ -148970,36 +149282,26 @@ function createReolinkVideoclipsProvider(deps) {
 		listSources: async ({ deviceId }) => {
 			const device = await deps.resolveDevice(deviceId);
 			if (device === null) return [];
-			const via = viaFor(device);
 			return [{
 				source: CLIP_SOURCE_ONBOARD,
 				addonId: REOLINK_ADDON_ID,
 				label: "Camera storage",
-				via,
-				availability: await resolveAvailability(device, via)
+				availability: await resolveAvailability(device)
 			}];
 		},
 		listClips: async ({ deviceId, since, until, limit }) => {
 			const device = await deps.resolveDevice(deviceId);
 			if (device === null) return [];
 			const tags = { deviceId };
-			const via = viaFor(device);
-			const ordered = (via === "events" ? await (async () => {
-				const events = await readHubEvents(device, since, until);
-				const asOf = health.get(healthKey(deviceId, CLIP_SOURCE_ONBOARD))?.availability.catalogAsOf;
-				return await Promise.all(events.map((row) => toEventClip(device, row, asOf)));
-			})() : await (async () => {
-				const rows = await readOnboard(device, since, until);
-				const asOf = health.get(healthKey(deviceId, CLIP_SOURCE_ONBOARD))?.availability.catalogAsOf;
-				return await Promise.all(rows.toSorted((a, b) => b.startMs - a.startMs).map((row) => toClip(device, CLIP_SOURCE_ONBOARD, row, asOf)));
-			})()).toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
+			const rows = await readOnboard(device, since, until);
+			const asOf = health.get(healthKey(deviceId, CLIP_SOURCE_ONBOARD))?.availability.catalogAsOf;
+			const ordered = (await Promise.all(rows.toSorted((a, b) => b.startMs - a.startMs).map((row) => toClip(device, CLIP_SOURCE_ONBOARD, row, asOf)))).toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
 			const capped = limit !== void 0 ? ordered.slice(0, limit) : ordered;
 			const vouched = capped.filter((c) => c.thumbnail !== void 0).length;
 			deps.logger.info("videoclips: listed a Reolink catalog", {
 				tags,
 				meta: {
 					source: CLIP_SOURCE_ONBOARD,
-					via,
 					clips: capped.length,
 					truncated: limit !== void 0 && ordered.length > limit,
 					unplayable: capped.filter((c) => c.playable === false).length,
@@ -149008,6 +149310,18 @@ function createReolinkVideoclipsProvider(deps) {
 					availability: health.get(healthKey(deviceId, CLIP_SOURCE_ONBOARD))?.availability.state
 				}
 			});
+			const availability = health.get(healthKey(deviceId, CLIP_SOURCE_ONBOARD))?.availability;
+			if (capped.length === 0 && availability !== void 0 && availability.state !== "ok") {
+				deps.logger.warn("videoclips: nothing to list, and the source cannot answer", {
+					tags,
+					meta: {
+						branch: "refused-empty",
+						state: availability.state,
+						reason: availability.reason ?? null
+					}
+				});
+				throw new Error(`videoclips: device ${deviceId} listed no clips, and that is not an empty day — the source is "${availability.state}"` + (availability.reason !== void 0 ? `: ${availability.reason}` : "."));
+			}
 			return capped;
 		},
 		getClipPlayback: async ({ deviceId, clipId, profile }) => {
@@ -149016,7 +149330,6 @@ function createReolinkVideoclipsProvider(deps) {
 			const device = await deps.resolveDevice(deviceId);
 			if (device === null) throw new Error(`videoclips: device ${deviceId} is not a Reolink camera`);
 			if (device.isBattery && device.sleeping && !device.isHubChild) throw new Error(`videoclips: device ${deviceId} is a standalone battery camera and is sleeping — fetching a clip would wake it. Use "Wake and refresh" first.`);
-			if (parsed.fileName.startsWith("event:")) throw new Error(`videoclips: clip ${clipId} is an event with no recording file (no-rec-file) — the hub listed the event, not a clip.`);
 			const row = rowsByKey.get(`${deviceId}|${clipKeyFor(parsed.channel, parsed.fileName)}`) ?? null;
 			const wantsMain = profile === "high" && row?.mainFileName !== void 0;
 			const fileName = wantsMain ? row?.mainFileName ?? parsed.fileName : parsed.fileName;
@@ -149035,46 +149348,350 @@ function createReolinkVideoclipsProvider(deps) {
 		}
 	};
 	/**
-	* Which API this camera's ONE source reads.
-	*
-	* From what the camera IS, never from a stored preference and never from a
-	* row the operator ticked: a hub child is served by its parent's event log
-	* (faster, and the only class source there), a standalone by its own file
-	* list (a standalone answers `findEventLog` with an empty body). Pure, so
-	* the choice is the same on every call and the reported `via` cannot drift
-	* from the API that actually ran.
-	*/
-	function viaFor(device) {
-		return device.isHubChild ? CATALOG_VIA_EVENTS : CATALOG_VIA_FILES;
-	}
-	async function resolveAvailability(device, via) {
+	* What a source is saying right now — MEASURED, never defaulted.
+	*
+	* A listing that already ran is the better answer and wins: `listClips`
+	* asked the whole window and this probe asks one day, so re-deciding from
+	* the narrower question would throw away 618's other nineteen empty days.
+	* With nothing established, the probe runs — and `ok` is only ever returned
+	* because something was really read.
+	*
+	* ## What it costs, per call, and why
+	*
+	* This used to answer `ok` after at most one storage command, and `ok` is
+	* the one state whose list may be read as complete. On the live hub, on the
+	* cold runners a deploy had just produced, that default made 640 (no SD
+	* card) and 618 (an index that lists nothing for days its own calendar
+	* marks) both answer `ok` and then an empty list — the exact lie this line
+	* of work exists to end. So `listSources` pays for its answer:
+	*
+	* - **a standalone battery camera: NOTHING, ever.** No `getApi`, no command,
+	*   not even the cheap one — on UDP the login IS the wake. `sleeping`, with
+	*   the age of whatever is cached. The gate is `isBattery`, never the
+	*   BELIEF `sleeping`: that belief is `state.battery.sleeping ?? false`, so
+	*   a slice that has not restored reads as awake, and a probe on it is a
+	*   wake nobody asked for.
+	* - **a hub child: one `getDayRecords` through the parent's existing socket**
+	*   (65 ms measured on 3628). The child never hears it; the storage question
+	*   is the HUB's and is not asked.
+	* - **a mains standalone: `getHddInfoList` (ms) + `getDayRecords`
+	*   (38 ms–1.9 s) + ONE day listing of the NEWEST day the calendar claims**
+	*   (0.3–6 s, and cache-backed — `serveAndRevalidate`, so a day already
+	*   listed costs nothing and a day listed here is free for the `listClips`
+	*   that follows). The day listing is what distinguishes `index-empty` from
+	*   `ok`, and nothing cheaper can: `no-storage` is the cheap question and it
+	*   comes first precisely so a camera with no card never pays the rest.
+	*
+	* The calendar is read for the CURRENT month only. A picker asks "can this
+	* source answer", not "what does it hold since April", and the measured
+	* defect (618) is in the month the operator is looking at.
+	*/
+	async function resolveAvailability(device) {
 		const known = health.get(healthKey(device.deviceId, CLIP_SOURCE_ONBOARD))?.availability;
 		if (known !== void 0) return known;
-		if (via === "events") return uidIsMissing(device) ? {
-			state: "unreachable",
-			reason: UID_MISSING_REASON
-		} : { state: "ok" };
-		if (device.isBattery && device.sleeping && !device.isHubChild) return {
-			state: "sleeping",
-			reason: "A read would wake this camera. Nothing has been listed yet."
+		const availability = await probeAvailability(device);
+		noteHealth(device.deviceId, CLIP_SOURCE_ONBOARD, availability);
+		return availability;
+	}
+	async function probeAvailability(device) {
+		const tags = { deviceId: device.deviceId };
+		if (device.isBattery && !device.isHubChild) {
+			const asOf = newestCachedAsOf(device.deviceId);
+			deps.logger.warn("videoclips: not probing a standalone battery camera — login is the wake", {
+				tags,
+				meta: {
+					branch: "sleeping",
+					believedSleeping: device.sleeping,
+					confirmedAt: asOf
+				}
+			});
+			return {
+				state: "sleeping",
+				reason: asOf === void 0 ? "A read would wake this standalone battery camera. Nothing has been confirmed yet." : "A read would wake this standalone battery camera; showing the catalog as last confirmed.",
+				...asOf !== void 0 ? { catalogAsOf: asOf } : {}
+			};
+		}
+		if (uidIsMissing(device)) {
+			deps.logger.warn("videoclips: no uid for this camera — its catalog cannot be addressed", {
+				tags,
+				meta: {
+					branch: "uid-missing",
+					probe: true
+				}
+			});
+			return {
+				state: "unreachable",
+				reason: UID_MISSING_REASON
+			};
+		}
+		let api;
+		try {
+			api = await device.getApi();
+		} catch (err) {
+			return unreachableFrom(device, "camera-refused", err);
+		}
+		if (!device.isHubChild) {
+			const storage = await readStorageState(api);
+			if (storage.state === "absent") {
+				deps.logger.info("videoclips: no SD card mounted — nothing to list", {
+					tags,
+					meta: {
+						branch: "no-storage",
+						probe: true
+					}
+				});
+				return {
+					state: "no-storage",
+					reason: "The camera reports no mounted storage (HddInfo mount 0)."
+				};
+			}
+			if (storage.state === "unknown") {
+				deps.logger.warn("videoclips: the storage question was not answered", {
+					tags,
+					meta: {
+						branch: "camera-refused",
+						probe: true,
+						error: storage.reason ?? null
+					}
+				});
+				return {
+					state: "unreachable",
+					reason: storage.reason ?? "The camera did not answer the storage question (HddInfo unreadable)."
+				};
+			}
+		}
+		const today = wallClockDayKey(deps.now(), device.timeZone);
+		let calendar;
+		try {
+			calendar = await readDayIndex(api, {
+				channel: device.channel,
+				uid: device.uid,
+				months: [{
+					year: Number(today.slice(0, 4)),
+					month: Number(today.slice(5, 7))
+				}]
+			});
+		} catch (err) {
+			return unreachableFrom(device, "camera-refused", err);
+		}
+		const claimed = [...calendar].toSorted().toReversed();
+		if (claimed.length === 0) return {
+			state: "ok",
+			catalogAsOf: deps.now()
 		};
-		if (uidIsMissing(device)) return {
+		const newest = claimed[0];
+		if (newest === void 0) return {
+			state: "ok",
+			catalogAsOf: deps.now()
+		};
+		try {
+			await deps.cache.serveAndRevalidate(device.deviceId, newest, { closed: newest !== today }, async () => (await listDayRows(api, {
+				channel: device.channel,
+				uid: device.uid,
+				timeZone: device.timeZone,
+				day: newest
+			})).rows);
+		} catch (err) {
+			return unreachableFrom(device, "camera-refused", err);
+		}
+		const emptyClaimed = claimed.filter((day) => deps.cache.peek(device.deviceId, day)?.clips.length === 0);
+		if (emptyClaimed.length > 0) {
+			deps.logger.warn("videoclips: the calendar marks days the index will not list", {
+				tags,
+				meta: {
+					branch: "index-empty",
+					probe: true,
+					days: emptyClaimed
+				}
+			});
+			return indexEmpty(emptyClaimed);
+		}
+		return {
+			state: "ok",
+			catalogAsOf: deps.now()
+		};
+	}
+	function unreachableFrom(device, branch, err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		deps.logger.warn("videoclips: the source could not be probed", {
+			tags: { deviceId: device.deviceId },
+			meta: {
+				branch,
+				probe: true,
+				error: reason
+			}
+		});
+		return {
 			state: "unreachable",
-			reason: UID_MISSING_REASON
+			reason
 		};
+	}
+	/** When any day of this device's catalog was last confirmed, newest first. */
+	function newestCachedAsOf(deviceId) {
+		let newest;
+		for (const day of deps.cache.daysHeld(deviceId)) {
+			const asOf = deps.cache.peek(deviceId, day)?.catalogAsOf;
+			if (asOf !== void 0 && (newest === void 0 || asOf > newest)) newest = asOf;
+		}
+		return newest;
+	}
+	/** The one wording for "the camera's calendar and its own index disagree". */
+	function indexEmpty(days) {
+		return {
+			state: "index-empty",
+			reason: `The camera’s calendar marks ${days.length} day(s) with footage that its own index lists no files for: ${days.join(", ")}.`,
+			catalogAsOf: deps.now()
+		};
+	}
+}
+//#endregion
+//#region src/clips/clip-refresh.ts
+/** The settings key, global default and per-device override (D562). */
+var CLIP_CATALOG_REFRESH_MINUTES_KEY = "clipCatalogRefreshMinutes";
+/** The settings key, per device only, OFF by default (D562). */
+var CLIP_CATALOG_FORCED_WAKE_KEY = "clipCatalogForcedWake";
+/** A day. Past this the catalog's own TTLs are the thing doing the work. */
+var CLIP_CATALOG_REFRESH_MINUTES_MAX = 1440;
+/**
+* How much of the catalog one refresh confirms.
+*
+* A day. The listing cost is per DAY (0.3–6 s on a standalone, 267 ms for one
+* child-day on the hub) and a 20-day window measured 3.6–5.4 s per child, so a
+* timer that re-confirmed everything would spend the whole budget re-reading
+* days that cannot change. Older days are immutable and the cache holds them
+* under their own 24 h TTL.
+*/
+var CLIP_CATALOG_REFRESH_WINDOW_MS = 1440 * 6e4;
+/**
+* The mode for one camera. Pure, and decided from what the camera IS — never
+* from a belief about whether it is asleep right now: the gate has to hold for
+* a camera whose sleep slice has not restored, which reads "awake" and is how
+* a picker draw once logged into 640 (D561).
+*/
+function resolveClipRefreshMode(topology) {
+	if (topology.isHubChild) return "via-hub";
+	if (!topology.isBattery) return "direct";
+	return topology.forcedWake ? "forced-wake" : "mark-stale";
+}
+/**
+* The refresh interval for one camera: the per-device override on top of the
+* global default, with **reset == unset == the default**.
+*
+* Never throws on a bad blob. An invalid value at either level resolves to the
+* level above it, so a store written by an older release cannot stop the timer
+* — the same cascade `stationary-settings.ts` uses, for the same reason.
+*/
+function resolveClipCatalogRefreshMinutes(globalValue, deviceValue) {
+	return asRefreshMinutes(deviceValue) ?? asRefreshMinutes(globalValue) ?? 30;
+}
+function asRefreshMinutes(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return null;
+	const rounded = Math.round(value);
+	if (rounded === 0) return 0;
+	if (rounded < 5) return null;
+	if (rounded > 1440) return null;
+	return rounded;
+}
+/** Is the operator's forced-wake switch on for this camera? */
+function resolveClipCatalogForcedWake(value) {
+	return value === true;
+}
+/**
+* The timer. `tick()` is the whole surface, so a test drives it from COLD and
+* the scheduler owns no clock of its own — the addon supplies the interval.
+*/
+var ClipCatalogRefreshScheduler = class {
+	deps;
+	/** Last time an interval was SPENT on a camera, successful or not. */
+	lastRunAt = /* @__PURE__ */ new Map();
+	/** Cameras whose refresh has not come back yet. */
+	inFlight = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async tick() {
+		const now = this.deps.now();
+		const due = this.deps.listTargets().filter((target) => this.isDue(target, now));
+		for (const target of due) await this.run(target, now);
+	}
+	isDue(target, now) {
+		if (target.intervalMinutes <= 0) return false;
+		if (this.inFlight.has(target.deviceId)) return false;
+		const last = this.lastRunAt.get(target.deviceId);
+		if (last === void 0) return true;
+		return now - last >= target.intervalMinutes * 6e4;
+	}
+	async run(target, now) {
+		const tags = { deviceId: target.deviceId };
+		const mode = resolveClipRefreshMode(target);
+		if (this.deps.hostBusy(target.hostKey)) {
+			this.deps.logger.warn("videoclips: catalog refresh deferred — the host is serving a read", {
+				tags,
+				meta: {
+					branch: "deferred-interactive",
+					mode,
+					host: target.hostKey
+				}
+			});
+			return;
+		}
+		if (mode === "mark-stale") {
+			this.deps.markStale(target.deviceId);
+			this.lastRunAt.set(target.deviceId, now);
+			this.deps.logger.info("videoclips: catalog marked stale — a timer cannot read a standalone battery camera", {
+				tags,
+				meta: {
+					branch: "mark-stale",
+					mode,
+					refreshesOn: "onWakeTransition",
+					intervalMinutes: target.intervalMinutes
+				}
+			});
+			return;
+		}
+		this.lastRunAt.set(target.deviceId, now);
+		this.inFlight.add(target.deviceId);
 		try {
-			if ((await readStorageState(await device.getApi())).state === "absent") return {
-				state: "no-storage",
-				reason: "The camera reports no mounted storage (HddInfo mount 0)."
-			};
-			return { state: "ok" };
+			if (mode === "forced-wake") try {
+				await this.deps.wake(target.deviceId);
+			} catch (err) {
+				this.deps.markStale(target.deviceId);
+				this.deps.logger.warn("videoclips: the authorised wake did not bring the camera up — catalog left stale", {
+					tags,
+					meta: {
+						branch: "forced-wake-failed",
+						mode,
+						error: errMessage$1(err)
+					}
+				});
+				return;
+			}
+			await this.deps.refresh(target.deviceId);
+			this.deps.logger.info("videoclips: catalog refreshed", {
+				tags,
+				meta: {
+					branch: "refreshed",
+					mode,
+					elapsedMs: this.deps.now() - now
+				}
+			});
 		} catch (err) {
-			return {
-				state: "unreachable",
-				reason: err instanceof Error ? err.message : String(err)
-			};
+			this.deps.markStale(target.deviceId);
+			this.deps.logger.warn("videoclips: catalog refresh failed — the catalog stays as it was", {
+				tags,
+				meta: {
+					branch: "refresh-failed",
+					mode,
+					error: errMessage$1(err)
+				}
+			});
+		} finally {
+			this.inFlight.delete(target.deviceId);
 		}
 	}
+};
+function errMessage$1(err) {
+	return err instanceof Error ? err.message : String(err);
 }
 function createClipService(deps) {
 	const now = deps.now ?? (() => Date.now());
@@ -149105,23 +149722,11 @@ function createClipService(deps) {
 	};
 	const mintThumbnail = async (deviceId, clipKey, lane) => {
 		const device = await deps.resolveDevice(deviceId);
-		if (device === null) return {
-			ok: false,
-			reason: `unknown-device: ${deviceId} is not a Reolink camera here`
-		};
-		if (device.isBattery && device.sleeping && !device.isHubChild) return {
-			ok: false,
-			reason: "sleeping: a still would wake this standalone battery camera"
-		};
-		if (uidIsMissing(device)) return {
-			ok: false,
-			reason: UID_MISSING_REASON
-		};
+		if (device === null) return refuseStill("unknown-device", `unknown-device: ${deviceId} is not a Reolink camera here`);
+		if (device.isBattery && device.sleeping && !device.isHubChild) return refuseStill("sleeping", "sleeping: a still would wake this standalone battery camera");
+		if (uidIsMissing(device)) return refuseStill("uid-missing", UID_MISSING_REASON);
 		const row = rowFor(deviceId, clipKey);
-		if (row === null) return {
-			ok: false,
-			reason: "no-catalog-row: list this day before asking for its stills"
-		};
+		if (row === null) return refuseStill("no-catalog-row", "no-catalog-row: list this day before asking for its stills");
 		try {
 			const bytes = await queue.submit({
 				host: device.hostKey,
@@ -149138,10 +149743,7 @@ function createClipService(deps) {
 					});
 				}
 			});
-			if (bytes.byteLength === 0) return {
-				ok: false,
-				reason: "no-keyframe: the camera returned an empty frame"
-			};
+			if (bytes.byteLength === 0) return refuseStill("no-keyframe", "no-keyframe: the camera returned an empty frame");
 			await thumbs.put(deviceId, clipKey, bytes);
 			return {
 				ok: true,
@@ -149149,6 +149751,19 @@ function createClipService(deps) {
 			};
 		} catch (err) {
 			const reason = err instanceof Error ? err.message : String(err);
+			const deferred = queueRefusal(err);
+			if (deferred !== null) {
+				deps.logger.debug("videoclips: a thumbnail mint was deferred", {
+					tags: { deviceId },
+					meta: {
+						clipKey,
+						lane,
+						code: deferred.code,
+						retryAfterMs: deferred.retryAfterMs
+					}
+				});
+				return deferred;
+			}
 			deps.logger.warn("videoclips: a thumbnail mint refused", {
 				tags: { deviceId },
 				meta: {
@@ -149158,11 +149773,97 @@ function createClipService(deps) {
 					error: reason
 				}
 			});
-			return {
-				ok: false,
-				reason
+			return refuseStill("camera-refused", reason);
+		}
+	};
+	/**
+	* ONE clip's bytes, on the short window, with the fetch PROVED (D568).
+	*
+	* Completion is an idle window because nothing on the wire ends a cmd 5
+	* transfer, and that window is short. What makes it safe is not the window,
+	* it is the decoded duration judged against the row that asked for it.
+	*/
+	const fetchVerifiedClipBytes = async (device, row, clipKey) => {
+		const deviceId = device.deviceId;
+		const api = await device.getApi();
+		const fetchPass = (idleTimeoutMs) => fetchClipBytes({
+			download: () => api.downloadRecordingDemuxed({
+				channel: device.channel,
+				...device.uid !== void 0 ? { uid: device.uid } : {},
+				fileName: row.subFileName,
+				idleTimeoutMs
+			}),
+			sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+		});
+		const judge = (pass) => judgeClipDuration({
+			expectedMs: row.endMs - row.startMs,
+			decodedSeconds: pass.stats.durationSeconds,
+			...row.inProgress === true ? { inProgress: true } : {}
+		});
+		const first = await fetchPass(300);
+		const firstVerdict = judge(first);
+		if (firstVerdict.kind === "unknown") {
+			const line = {
+				tags: { deviceId },
+				meta: {
+					clipKey,
+					branch: "completeness-unverified",
+					reason: firstVerdict.reason,
+					idleTimeoutMs: 300,
+					expectedMs: row.endMs - row.startMs,
+					decodedSeconds: first.stats.durationSeconds
+				}
 			};
+			if (firstVerdict.reason === "clip-open") deps.logger.debug("videoclips: an open clip cannot be checked for truncation", line);
+			else deps.logger.warn("videoclips: a clip fetch could not be checked for truncation", line);
+			return first;
+		}
+		if (firstVerdict.kind === "complete") return first;
+		deps.logger.warn("videoclips: a clip fetch came back truncated", {
+			tags: { deviceId },
+			meta: {
+				clipKey,
+				branch: "truncated-fetch",
+				idleTimeoutMs: 300,
+				expectedSeconds: firstVerdict.expectedSeconds,
+				decodedSeconds: firstVerdict.decodedSeconds,
+				shortfallSeconds: firstVerdict.shortfallSeconds,
+				bytes: first.annexB.byteLength,
+				keyframes: first.stats.keyframes
+			}
+		});
+		const retry = await fetchPass(CLIP_IDLE_WINDOW_RETRY_MS);
+		const keepRetry = (retry.stats.durationSeconds ?? 0) >= (first.stats.durationSeconds ?? 0);
+		const kept = keepRetry ? retry : first;
+		const verdict = keepRetry ? judge(retry) : firstVerdict;
+		const keptWindowMs = keepRetry ? CLIP_IDLE_WINDOW_RETRY_MS : 300;
+		if (verdict.kind === "short") {
+			deps.logger.warn("videoclips: a clip is still short after the long window", {
+				tags: { deviceId },
+				meta: {
+					clipKey,
+					branch: "truncated-after-retry",
+					idleTimeoutMs: keptWindowMs,
+					retriedOnMs: CLIP_IDLE_WINDOW_RETRY_MS,
+					expectedSeconds: verdict.expectedSeconds,
+					decodedSeconds: verdict.decodedSeconds,
+					shortfallSeconds: verdict.shortfallSeconds,
+					bytes: kept.annexB.byteLength
+				}
+			});
+			return kept;
 		}
+		deps.logger.info("videoclips: a truncated clip fetch landed whole on the long window", {
+			tags: { deviceId },
+			meta: {
+				clipKey,
+				branch: "truncation-recovered",
+				idleTimeoutMs: keptWindowMs,
+				decodedSeconds: verdict.kind === "complete" ? verdict.decodedSeconds : null,
+				bytes: kept.annexB.byteLength
+			}
+		});
+		return kept;
 	};
 	const prepareClip = async (deviceId, clipKey) => {
 		const ready = await media.pathIfPresent(deviceId, clipKey);
@@ -149200,25 +149901,44 @@ function createClipService(deps) {
 			});
 			return null;
 		}
-		const fileName = row.subFileName;
-		const api = await device.getApi();
-		const downloaded = await fetchClipBytes({
-			download: () => api.downloadRecordingDemuxed({
-				channel: device.channel,
-				...device.uid !== void 0 ? { uid: device.uid } : {},
-				fileName
-			}),
-			sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+		const downloaded = await fetchVerifiedClipBytes(device, row, clipKey);
+		const audio = decideClipAudio(downloaded.audio);
+		if (audio.kind === "silent") deps.logger.warn("videoclips: serving a clip with no sound", {
+			tags: { deviceId },
+			meta: {
+				clipKey,
+				branch: audio.reason,
+				audioFormat: audio.format,
+				audioPackets: downloaded.stats.audioPackets,
+				audioBytes: downloaded.stats.audioBytes
+			}
+		});
+		if (downloaded.stats.fpsSource !== "timestamps") deps.logger.warn("videoclips: no measured frame rate for this clip", {
+			tags: { deviceId },
+			meta: {
+				clipKey,
+				branch: "fps-unmeasured",
+				fpsSource: downloaded.stats.fpsSource,
+				fps: downloaded.stats.fps,
+				infoFps: downloaded.stats.infoFps
+			}
 		});
 		const scratch = await mkdtemp(join$1(tmpdir(), "camstack-clip-mux-"));
 		try {
 			const rawPath = join$1(scratch, "clip.h264");
+			const audioPath = join$1(scratch, "clip.aac");
 			const outPath = join$1(scratch, "clip.mp4");
 			await writeFile(rawPath, downloaded.annexB);
+			if (audio.kind === "copy") await writeFile(audioPath, audio.data);
 			const failure = describeMuxFailure(await muxRunner(buildClipMuxArgs({
 				inputPath: rawPath,
 				outputPath: outPath,
-				videoType: downloaded.videoType
+				videoType: downloaded.videoType,
+				fps: downloaded.stats.fps,
+				...audio.kind === "copy" ? { audio: {
+					path: audioPath,
+					format: audio.format
+				} } : {}
 			})));
 			if (failure !== null) {
 				deps.logger.warn("videoclips: the clip mux failed", {
@@ -149240,21 +149960,32 @@ function createClipService(deps) {
 			});
 		}
 	};
-	return {
-		provider: createReolinkVideoclipsProvider({
-			now,
-			cache,
-			resolveDevice: deps.resolveDevice,
-			hasVouchedThumbnail: (deviceId, clipKey) => thumbs.has(deviceId, clipKey),
-			thumbnailUrl: (deviceId, clipKey) => `/addon/${REOLINK_ADDON_ID}/${CLIP_THUMB_PREFIX}/${deviceId}/${clipKey}`,
-			thumbnailMintUrl: (deviceId, clipKey) => `/addon/${REOLINK_ADDON_ID}/${CLIP_THUMB_PREFIX}/${deviceId}/${clipKey}`,
-			preparePlayback: async ({ device, clipKey, profile }) => ({
-				playbackUrl: `/addon/${REOLINK_ADDON_ID}/${CLIP_MEDIA_PREFIX}/${device.deviceId}/${clipKey}.mp4`,
-				served: profile === "high" ? "high" : "low"
-			}),
-			logger: deps.logger
+	const provider = createReolinkVideoclipsProvider({
+		now,
+		cache,
+		resolveDevice: deps.resolveDevice,
+		hasVouchedThumbnail: (deviceId, clipKey) => thumbs.has(deviceId, clipKey),
+		thumbnailUrl: (deviceId, clipKey) => `/addon/${REOLINK_ADDON_ID}/${CLIP_THUMB_PREFIX}/${deviceId}/${clipKey}`,
+		thumbnailMintUrl: (deviceId, clipKey) => `/addon/${REOLINK_ADDON_ID}/${CLIP_THUMB_PREFIX}/${deviceId}/${clipKey}`,
+		preparePlayback: async ({ device, clipKey, profile }) => ({
+			playbackUrl: `/addon/${REOLINK_ADDON_ID}/${CLIP_MEDIA_PREFIX}/${device.deviceId}/${clipKey}.mp4`,
+			served: profile === "high" ? "high" : "low"
 		}),
+		logger: deps.logger
+	});
+	return {
+		provider,
 		cache,
+		refreshCatalog: async (deviceId) => {
+			const until = now();
+			await provider.listClips({
+				deviceId,
+				since: until - CLIP_CATALOG_REFRESH_WINDOW_MS,
+				until,
+				provider: REOLINK_ADDON_ID
+			});
+		},
+		hostBusy: (hostKey) => queue.busy(hostKey),
 		thumbPrefix: CLIP_THUMB_PREFIX,
 		mediaPrefix: CLIP_MEDIA_PREFIX,
 		thumbHandler: createClipThumbHandler({
@@ -149279,6 +150010,79 @@ function createClipService(deps) {
 	};
 }
 //#endregion
+//#region src/clips/clip-refresh-settings.ts
+/** The section id, so the addon's declaration and this schema cannot drift. */
+var CLIP_REFRESH_SECTION_ID = "clip-catalog-refresh";
+/**
+* The one sentence the interval must always carry.
+*
+* It does TWO different things depending on what the camera is, and a knob
+* that silently means two things on two cameras is how this repo has shipped
+* settings nobody could reason about. So the difference is in the operator's
+* own text, at both levels, not only in a record.
+*/
+var CLIP_CATALOG_REFRESH_MINUTES_DESCRIPTION = "How often CamStack re-reads what a Reolink camera holds on its own storage. It costs almost nothing on a camera it can reach: a hub child is read through the hub on the session that is already open (measured 65 ms, and the camera itself never hears it), and a mains camera is read on its own socket. On a STANDALONE BATTERY camera the timer cannot read anything at all — logging in is what wakes such a camera — so there it only marks the catalog as ageing, and the real re-read happens the next time the camera wakes up for its own reasons (motion, a stream, something you did). Set 0 to switch the timer off.";
+var CLIP_CATALOG_FORCED_WAKE_DESCRIPTION = "Let the refresh timer WAKE this camera. Off unless you mean it: on a standalone battery camera every read is a login and every login is a wake, so a 15-minute timer is 96 wakes a day (24 at 60 minutes) against the 1–20 clips a day these cameras actually record — five to a hundred times their normal wake count, and the battery pays for all of it. One interval buys exactly one wake, successful or not. It has no effect on a hub child or a mains camera, which are never woken by this timer.";
+/**
+* The addon-level (global) default. Per-camera overrides live on the device,
+* under the SAME key, and a device that sets nothing — or resets — resolves to
+* this value (`resolveClipCatalogRefreshMinutes`).
+*/
+function buildClipRefreshSettingsSchema() {
+	return { sections: [{
+		id: CLIP_REFRESH_SECTION_ID,
+		title: "Clip catalog refresh",
+		description: "The default for every Reolink camera. Each camera can override it in its own Recording settings; a camera that overrides nothing uses this value.",
+		columns: 1,
+		fields: [{
+			type: "number",
+			key: CLIP_CATALOG_REFRESH_MINUTES_KEY,
+			label: "Refresh interval (min)",
+			description: CLIP_CATALOG_REFRESH_MINUTES_DESCRIPTION,
+			default: 30,
+			min: 0,
+			max: CLIP_CATALOG_REFRESH_MINUTES_MAX,
+			step: 5
+		}]
+	}] };
+}
+/**
+* The per-camera section: the interval override, and — only where it can mean
+* anything — the forced wake.
+*
+* `forcedWake` is a plain persisted switch on purpose. It is NOT a
+* `device-action-button` and there is no custom action behind it, so nothing
+* that dispatches device actions (a schedule, an automation, a rule) can spend
+* a battery camera's wakes; the only way to turn it on is an operator editing
+* this camera's settings.
+*/
+function buildClipRefreshDeviceSection(input) {
+	const forcedWakeApplies = input.isBattery && !input.isHubChild;
+	return [{
+		id: CLIP_REFRESH_SECTION_ID,
+		tab: "recording",
+		title: "Clip catalog refresh",
+		description: "How often this camera’s own clip list is re-read. Leave the interval empty to use the default from the Reolink addon settings.",
+		columns: 1,
+		fields: [{
+			type: "number",
+			key: CLIP_CATALOG_REFRESH_MINUTES_KEY,
+			label: "Refresh interval (min)",
+			description: CLIP_CATALOG_REFRESH_MINUTES_DESCRIPTION,
+			min: 0,
+			max: CLIP_CATALOG_REFRESH_MINUTES_MAX,
+			step: 5
+		}, ...forcedWakeApplies ? [{
+			type: "boolean",
+			key: CLIP_CATALOG_FORCED_WAKE_KEY,
+			label: "Wake this camera to refresh",
+			description: CLIP_CATALOG_FORCED_WAKE_DESCRIPTION,
+			default: false,
+			style: "switch"
+		}] : []]
+	}];
+}
+//#endregion
 //#region src/intercom-failure-report.ts
 /**
 * Per-camera talk-back counters, published through `failure-contribution`.
@@ -154356,6 +155160,73 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* provider still treats a missing `uid` as a dropped branch rather than as
 	* an empty catalog.
 	*/
+	/**
+	* Re-read this camera's clip catalog. Set by the addon for every camera it
+	* owns; `null` until it is wired (a redeploy re-registers the device, and
+	* the addon re-wires on `DeviceRegistered` AND `DeviceMetaChanged` — the
+	* same fan-out the email-push resolver needed, for the same reason).
+	*/
+	clipCatalogRefresher = null;
+	setClipCatalogRefresher(refresh) {
+		this.clipCatalogRefresher = refresh;
+	}
+	/**
+	* This camera's OVERRIDE of the clip-refresh interval, or `undefined` when
+	* it overrides nothing — which is what a reset leaves behind too, and is
+	* why the resolver takes `unknown` rather than a number (D562).
+	*/
+	getClipCatalogRefreshMinutes() {
+		return this.config.get("clipCatalogRefreshMinutes");
+	}
+	/** Whether the operator authorised the clip timer to wake this camera. */
+	getClipCatalogForcedWake() {
+		return this.config.get("clipCatalogForcedWake");
+	}
+	/**
+	* The clip refresh the TIMER cannot do.
+	*
+	* On a standalone battery camera a catalog read is a login and a login is
+	* the wake, so the periodic refresh only marks the catalog stale (D562).
+	* This is the other half: the moment the camera confirmed itself awake for
+	* its own reasons — a camera event, a stream, an operator action — is a free
+	* read, and it is the same moment that already warms the stream catalog and
+	* every settings slice. Called from `onWakeTransition`, best-effort, last:
+	* a clip listing must never delay the live-stream catalog the operator is
+	* waiting for.
+	*/
+	async refreshClipCatalogOnWake() {
+		const refresh = this.clipCatalogRefresher;
+		if (refresh === null) {
+			this.ctx.logger.debug("onWakeTransition: no clip catalog refresher wired", {
+				tags: { deviceId: this.id },
+				meta: { branch: "clip-refresher-unwired" }
+			});
+			return;
+		}
+		try {
+			await refresh();
+		} catch (err) {
+			this.ctx.logger.warn("onWakeTransition: the clip catalog refresh failed", {
+				tags: { deviceId: this.id },
+				meta: {
+					branch: "clip-refresh-failed",
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+		}
+	}
+	/**
+	* Wake this camera because the OPERATOR authorised the clip timer to
+	* (`clipCatalogForcedWake`, off by default — D562).
+	*
+	* The only path from the timer to a battery camera's radio, and it is the
+	* same forced wake `wakeIfSleeping` already drives for a config button.
+	* Throws when the camera did not come up, so the scheduler can say so and
+	* leave the catalog stale rather than stamping it fresh.
+	*/
+	async wakeForClipCatalogRefresh() {
+		if (!await this.wakeIfSleeping()) throw new Error(`ReolinkCamera ${this.id}: the authorised clip-refresh wake did not bring the camera up`);
+	}
 	getClipDeviceRef() {
 		const uid = this.config.get("uid");
 		return {
@@ -158616,6 +159487,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		await this.warmSnapshotOnWake();
 		await this.alignAuxDevicesState("wake");
 		await this.refreshParentSettingsSnapshot();
+		await this.refreshClipCatalogOnWake();
 	}
 	static PING_INTERVAL_MS = 3e4;
 	static PING_MAX_FAILURES = 3;
@@ -159801,7 +160673,11 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				}),
 				...this.buildSessionsTabSections(),
 				...this.buildEmailPushSection(),
-				...this.buildEmailTabSections()
+				...this.buildEmailTabSections(),
+				...buildClipRefreshDeviceSection({
+					isHubChild: this.isHubChild(),
+					isBattery: this.isBattery
+				})
 			]
 		};
 		const emailSnap = cache?.emailConfigSnapshot;
@@ -159820,6 +160696,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			emailRecipient3: emailSnap?.recipients?.[2] ?? "",
 			emailSendNickname: emailSnap?.sendNickname ?? this.name,
 			emailScheduleEnabled: emailSnap?.taskEnabled ?? false,
+			clipCatalogRefreshMinutes: this.config.get("clipCatalogRefreshMinutes"),
+			clipCatalogForcedWake: this.config.get("clipCatalogForcedWake") ?? false,
 			debugGeneral: this.config.get("debugGeneral") ?? false,
 			debugSocketLogs: this.config.get("debugSocketLogs") ?? [],
 			motionEnabled: this.config.get("motionEnabled") ?? motionSnap.enabled ?? true,
@@ -163093,6 +163971,10 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 		throw new Error(`Reolink: ${reason}`);
 	}
 	async onShutdown() {
+		if (this.clipRefreshTimer) {
+			clearInterval(this.clipRefreshTimer);
+			this.clipRefreshTimer = null;
+		}
 		this.logChannels?.stop();
 		await this.emailPushServer?.stop().catch(() => {});
 		await this.autodetectCache.dispose();
@@ -163103,6 +163985,7 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 	* logged inside the server and leaves it stopped until the next edit.
 	*/
 	async onConfigChanged() {
+		await this.refreshClipRefreshGlobalStore();
 		await this.emailPushServer?.restart().catch((err) => {
 			this.ctx.logger.warn("email-push: restart after settings change failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
@@ -163122,7 +164005,7 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 	* for core to select from.
 	*/
 	globalSettingsSchema() {
-		return buildEmailPushSettingsSchema(listLanHosts()[0] ?? "127.0.0.1");
+		return { sections: [...buildEmailPushSettingsSchema(listLanHosts()[0] ?? "127.0.0.1").sections, ...buildClipRefreshSettingsSchema().sections] };
 	}
 	/**
 	* Both email-push sections ARE this integration's configuration — one SMTP
@@ -163169,6 +164052,9 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 			capability: videoclipsCapability,
 			provider: this.clipService.provider
 		});
+		await this.refreshClipRefreshGlobalStore();
+		this.startClipCatalogRefresh(this.clipService);
+		this.wireClipCatalogRefreshers();
 		await this.serveClipPlanes(this.clipService);
 		this.ensureEmailPushServer().start().catch((err) => {
 			this.ctx.logger.warn("email-push: SMTP intake failed to start at init", { meta: { error: err instanceof Error ? err.message : String(err) } });
@@ -163181,6 +164067,7 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 			if (dev instanceof ReolinkCamera) {
 				const server = this.ensureEmailPushServer();
 				dev.setEmailPushParamsResolver(() => server.buildCameraSetupParams(dev));
+				this.wireClipCatalogRefreshers();
 				this.ctx.logger.debug("email-push: resolver wired", {
 					tags: { deviceId: data.deviceId },
 					meta: { via }
@@ -163194,6 +164081,102 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 	}
 	/** The clip catalog, its thumbnail cache and its two routes (D549). */
 	clipService = null;
+	clipRefreshTimer = null;
+	/**
+	* The addon store as the refresh timer last saw it.
+	*
+	* `listTargets` is synchronous on purpose — a tick that awaited a settings
+	* read per camera would be a store round-trip per camera per tick — so the
+	* global half of the cascade is mirrored here and refreshed at init and on
+	* every `onConfigChanged`. An empty mirror resolves to the DEFAULT, never to
+	* "off": a settings read that has not happened yet must not switch the timer
+	* off for the whole fleet.
+	*/
+	clipRefreshGlobalStore = {};
+	/**
+	* Give every camera the wake-side refresh.
+	*
+	* Idempotent, and re-run on both device lifecycle events for the reason the
+	* email-push resolver documents: an addon-only redeploy re-registers a
+	* device the hub already knows, which emits `DeviceMetaChanged` and NOT
+	* `DeviceRegistered`, and subscribing to one left every battery camera
+	* unwired.
+	*/
+	wireClipCatalogRefreshers() {
+		const service = this.clipService;
+		if (service === null) return;
+		for (const camera of this.listReolinkCameras()) {
+			const deviceId = camera.getClipDeviceRef().deviceId;
+			camera.setClipCatalogRefresher(async () => {
+				await service.refreshCatalog(deviceId);
+			});
+		}
+	}
+	/** Re-read the global half of the clip-refresh cascade. */
+	async refreshClipRefreshGlobalStore() {
+		try {
+			this.clipRefreshGlobalStore = await this.resolveGlobalStore();
+		} catch (err) {
+			this.ctx.logger.warn("videoclips: could not read the clip refresh default — keeping the last", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
+	/**
+	* Arm the clip-catalog refresh.
+	*
+	* The scheduler owns no clock: it is ticked, so its rules are testable from
+	* COLD (`clip-refresh.spec.ts` — the discipline D561 cost us). The tick
+	* cadence is the FLOOR of what any camera can be configured to, not the
+	* interval itself; each camera's own interval is decided inside the tick
+	* from the cascade, so changing a setting takes effect without re-arming.
+	*/
+	startClipCatalogRefresh(service) {
+		const scheduler = new ClipCatalogRefreshScheduler({
+			now: () => Date.now(),
+			listTargets: () => this.clipRefreshTargets(),
+			refresh: async (deviceId) => {
+				await service.refreshCatalog(deviceId);
+			},
+			markStale: (deviceId) => {
+				service.cache.markStale(deviceId);
+			},
+			wake: async (deviceId) => {
+				const device = this.ctx.kernel.deviceRegistry?.getById(deviceId);
+				if (!(device instanceof ReolinkCamera)) throw new Error(`clip refresh: device ${String(deviceId)} is not a Reolink camera here`);
+				await device.wakeForClipCatalogRefresh();
+			},
+			hostBusy: (hostKey) => service.hostBusy(hostKey),
+			logger: this.ctx.logger
+		});
+		this.clipRefreshTimer = setInterval(() => {
+			scheduler.tick().catch((err) => {
+				this.ctx.logger.warn("videoclips: the catalog refresh tick failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			});
+		}, 5 * 6e4);
+		if (typeof this.clipRefreshTimer.unref === "function") this.clipRefreshTimer.unref();
+	}
+	/**
+	* Every Reolink CAMERA this process owns, with its cascade resolved.
+	*
+	* Cameras only — the Home Hub (639) is `type: hub` and never binds
+	* `videoclips` (`deviceTypes: [Camera]`); its catalog IS its children's and
+	* is refreshed per child, on its one session. Accessories are not cameras.
+	*/
+	clipRefreshTargets() {
+		const globalMinutes = this.clipRefreshGlobalStore[CLIP_CATALOG_REFRESH_MINUTES_KEY];
+		const out = [];
+		for (const device of this.listReolinkCameras()) {
+			const ref = device.getClipDeviceRef();
+			out.push({
+				deviceId: ref.deviceId,
+				hostKey: ref.hostKey,
+				isHubChild: ref.isHubChild,
+				isBattery: ref.isBattery,
+				forcedWake: resolveClipCatalogForcedWake(device.getClipCatalogForcedWake()),
+				intervalMinutes: resolveClipCatalogRefreshMinutes(globalMinutes, device.getClipCatalogRefreshMinutes())
+			});
+		}
+		return out;
+	}
 	/**
 	* Host the thumbnail and media planes, and never let a host without the
 	* facility take the addon down with it — a data plane is an enhancement to