@camstack/addon-provider-reolink 1.2.163 → 1.2.164

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_chunk_OSVYEFMM = require("./chunk-OSVYEFMM-Czx77gto.js");
+const require_chunk_XAKOGDFB = require("./chunk-XAKOGDFB-CEh96Ccz.js");
 let node_crypto = require("node:crypto");
 let events = require("events");
 let fs = require("fs");
@@ -5391,7 +5391,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-COWaSCAi.mjs
+//#region ../types/dist/sleep-PEo0-Fz9.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6527,6 +6527,24 @@ function normalizeAddonInitResult(result) {
 	if (Array.isArray(result)) return { providers: result };
 	return result;
 }
+/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
+var PeerBytesTicketSchema = object({
+	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
+	url: string().min(1),
+	/**
+	* The HOST node this URL means something on — the hub or a named agent,
+	* never a runner. {@link AddonPeerBytes.open} compares it to its own and
+	* refuses `cross-node` by name when they differ, without dialling.
+	*/
+	hostNodeId: string().min(1),
+	expiresAtMs: number().int().nonnegative(),
+	/**
+	* What the producer DECLARED the body to be, when it knows — `null` when it
+	* does not. Never `0` for unknown (D393): a consumer sizing a bound off this
+	* must be able to tell "the producer did not say" from "the body is empty".
+	*/
+	declaredBytes: number().int().nonnegative().nullable()
+});
 /** Shared Zod schemas used across streaming capabilities. */
 var CamProfileSchema = _enum([
 	"high",
@@ -7607,24 +7625,6 @@ object({
 		unreachable: number()
 	})
 });
-/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
-var PeerBytesTicketSchema = object({
-	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
-	url: string().min(1),
-	/**
-	* The HOST node this URL means something on — the hub or a named agent,
-	* never a runner. {@link AddonPeerBytes.open} compares it to its own and
-	* refuses `cross-node` by name when they differ, without dialling.
-	*/
-	hostNodeId: string().min(1),
-	expiresAtMs: number().int().nonnegative(),
-	/**
-	* What the producer DECLARED the body to be, when it knows — `null` when it
-	* does not. Never `0` for unknown (D393): a consumer sizing a bound off this
-	* must be able to tell "the producer did not say" from "the body is empty".
-	*/
-	declaredBytes: number().int().nonnegative().nullable()
-});
 /**
 * Adoption job — the background form of `device-adoption.adopt`.
 *
@@ -7736,7 +7736,7 @@ var AdoptionJobSchema = object({
 * component's original options — detection to the detection-pipeline wrapper
 * binding, audio analysis to its own, recording to `RecordingConfig.enabled`
 * (which was always first-class; the switch was a veneer over
-* `recording.setDeviceConfig`), notifications to a notification-center
+* `recordingArchive.setDeviceConfig`), notifications to a notification-center
 * per-device setting, the two camera planes to their own components.
 *
 * What survives is {@link composeSwitchedOff}: `CameraStatus.switchedOff`, the
@@ -7762,7 +7762,7 @@ var AdoptionJobSchema = object({
 * | `stream-broker` | `deviceManager.setDisabled` | `StreamBrokerManager.reconcileAllCatalogs` releases the brokers; `ensureBroker` refuses re-creation |
 * | `object-detection` | `deviceManager.setWrapperActive('detection-pipeline')` | `PipelineSettingsStore.resolvePipelineForDevice` returns `{ steps: [], audio: null }` |
 * | `audio-analysis` | `deviceManager.setWrapperActive('audio-analysis')` | `AudioSubscriptionController.subscribeAudioStream` returns `null` before opening the stream |
-* | `recording` | `recording.setDeviceConfig` → `RecordingConfig.enabled` | `band-decision.shouldRecord` returns false; the controller detaches the device |
+* | `recording` | `recordingArchive.setDeviceConfig` → `RecordingConfig.enabled` | `band-decision.shouldRecord` returns false; the controller detaches the device |
 * | `notifications` | `notificationRules.setDeviceMuted` | `NotificationCenter.evaluateAndEnqueue` returns before any rule is evaluated |
 * | `privacy-mask` | `privacyMask.setMask({ enabled })` → the CAMERA | the camera blanks the masked regions itself; every stream and recording carries the black boxes |
 * | `device-audio` | `privacyMask.setAudioEnabled` → the CAMERA | the camera stops encoding an audio track at all; every consumer sees silent video |
@@ -12192,87 +12192,6 @@ method(ListInputSchema, array(BrokerInfoSchema$1)), method(GetInputSchema, Broke
 	auth: "admin"
 }), method(GetStateInputSchema, unknown().nullable()), method(_void(), RegistryStatusSchema);
 DeviceType.Camera;
-/**
-* The signals a device can emit to WAKE its own stream.
-*
-* A camera whose stream is built on demand sleeps until something asks for it,
-* and "something" cannot be a consumer that is merely attached — a Frigate-style
-* puller holds a session open for ever, and treating that as demand would keep
-* a battery camera awake for ever, which is the whole thing the battery is for
-* (D173). So the wake has to come from the CAMERA: an event it noticed by
-* itself, with no stream running.
-*
-* ## The vocabulary is the PROVIDER'S, not ours
-*
-* Like `consumables`, this cap declares no vocabulary of its own. A provider
-* names each signal with a `code` it chooses and a `label` an operator reads.
-* Reolink offers motion and camera-native detection; another provider may offer
-* a tamper, a doorbell press, a PIR, or something no camera in this fleet has
-* yet. A fixed enum here would mean every new signal is a framework release.
-*
-* It is deliberately NOT derived from the caps a device already binds. Whether
-* a camera CAN push firmware motion is expressed by `motionSources` containing
-* `'onboard'`, and whether it does AI on-camera by the `native-object-detection`
-* binding — but both answer "what drives the detection pipeline", which is a
-* different question from "what may wake a sleeping stream". A camera can do
-* the first and not be trusted with the second, and the operator picks per
-* camera. Two questions, two authorities.
-*
-* ## Availability is not permission
-*
-* `listSignals` says what the device CAN emit. Whether a given signal actually
-* wakes the stream is the operator's per-camera choice, held by the broker
-* alongside the cooldown — see the stream-broker cap's wake settings. A
-* provider declaring a signal is not a provider enabling it.
-*/
-/** One signal a device can emit. */
-var StreamSignalSchema = object({
-	/** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
-	code: string().min(1),
-	/** What an operator reads in the picker. The provider's own wording. */
-	label: string().min(1),
-	/**
-	* Whether the provider recommends this signal ON when a camera is first set
-	* up. A provider knows which of its signals are cheap and reliable; an
-	* operator should not have to discover that by trial. Reolink recommends
-	* both of its own.
-	*/
-	recommended: boolean()
-});
-var StreamSignalsStatusSchema = object({
-	signals: array(StreamSignalSchema),
-	lastFetchedAt: number()
-});
-var streamSignalsCapability = {
-	name: "stream-signals",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: Object.values(DeviceType),
-	runtimeState: StreamSignalsStatusSchema,
-	/**
-	* Runtime-state durability: **session** — mirrored in RAM, never written.
-	*
-	* The slice holds what the DEVICE says it can emit. That is a probed fact,
-	* not an operator choice: the provider re-declares it on every registration,
-	* so losing it loses nothing and persisting it would freeze an answer the
-	* camera is entitled to change. Measured the same day on the sibling case —
-	* `native-object-detection.supportedClasses` was persisted, and a firmware
-	* class the camera really detected stayed missing for the life of the row
-	* because the fix could not reach it.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	methods: { 
-	/**
-	* What this device can emit. Empty is a valid and common answer — most
-	* cameras have nothing to offer here, and an empty list is what makes the
-	* broker's picker show nothing rather than a false choice.
-	*/
-listSignals: method(_void(), array(StreamSignalSchema).readonly()) }
-};
 /** Stream delivery format. (Relocated from the retired `streaming-engine` cap.) */
 var StreamFormatSchema = _enum([
 	"webrtc",
@@ -13738,6 +13657,210 @@ method(object({ codec: string() }), boolean()), method(_void(), object({
 });
 DeviceType.Camera;
 /**
+* device-admin-link — "this device has a management page of its own, and here
+* is its address".
+*
+* ## Why this is not a `deviceConfig` cap
+*
+* There is nothing to edit. A `deviceConfig` cap (D14) exists so the framework
+* can DERIVE a settings form from `getOptions` + `getStatus` and route a flat
+* patch back through a setter; it costs a `builderId` reducer in
+* `device-config-contribution.ts` and a `*-config-schema.ts` beside it, and it
+* renders a form section. This cap answers ONE question with ONE read and
+* renders a button. Nothing about it is a form, so it carries no `deviceConfig`
+* block, no `settings`, no `runtimeState` and no reducer — exactly like
+* `reboot`, the other pure-RPC device-native cap.
+*
+* ## Absent, and the difference between "no page" and "we cannot say"
+*
+* The two are answered at DIFFERENT layers, on purpose:
+*
+*  - **"We cannot say"** → the provider never registers the cap for that
+*    device. A VeSync humidifier, a Petkit feeder, a Dreame vacuum and a Dreo
+*    fan are reached only through a vendor cloud; there is no address to hand
+*    out and no page to open. A Tuya plug, a Wyze camera and a Gree air
+*    conditioner DO have a LAN IP, and still have no HTTP management page
+*    behind it. None of them register, so `deviceManager.getBindings` never
+*    lists the cap and no surface asks.
+*  - **"This device has no page, and I know that"** → the provider registers
+*    and `getAdminLink` returns `null`. This is the answer for a device whose
+*    sibling DOES have a page: a Reolink battery camera reached over UDP by
+*    `uid` with a blank `host`, an Ecowitt gateway configured in `listener`
+*    transport, a Home Assistant broker authenticated by supervisor token
+*    (which carries no `baseUrl` at all).
+*
+* Both draw NOTHING. A button that opens a browser error is worse than no
+* button, and D62 is the same rule from the other side: an off switch is
+* reported off, never made to look broken. There is no third state where the
+* UI renders a disabled button "because the device might have a page".
+*
+* ## The URL never carries credentials
+*
+* Not in userinfo, not in a query string. Every provider builds through
+* `buildDeviceAdminUrl` (`device-admin-link-url.ts`), which takes host, port,
+* scheme and path as separate arguments — there is no parameter a secret could
+* arrive in — and re-checks its own output for the `scheme://user:pass@` shape
+* that `scripts/check-no-credential-urls-in-fixtures.ts` bans from recorded
+* output. `scripts/check-admin-link-builder-is-the-only-url-source.ts` is what
+* keeps providers from hand-rolling one anyway.
+*
+* This matters here more than anywhere else in the repo, because every provider
+* that knows a device's host knows its PASSWORD too: `{ host, port, username,
+* password }` sit in one object on Hikvision, Amcrest, Reolink and ONVIF alike,
+* and `http://admin:hunter2@192.168.50.139/` is a URL a browser accepts. The
+* camera's own page will ask for its own login. That is correct, and pre-
+* filling it is the operator's business, not ours.
+*
+* ## It is a LAN fact
+*
+* The URL addresses the device where the NODE can see it. It is not proxied,
+* not made reachable from outside, and not sent anywhere. A surface renders it
+* as a link the operator's own browser follows, on the operator's own network,
+* or renders nothing.
+*/
+/**
+* Whose page is it. The distinction is for the OPERATOR, who needs to know
+* before clicking whether he is about to land on a camera's own web server or
+* inside Home Assistant.
+*/
+var AdminLinkTargetEnum = _enum(["device", "integration"]);
+var DeviceAdminLinkSchema = object({
+	/**
+	* Absolute `http(s)://` URL. Built by `buildDeviceAdminUrl` and therefore
+	* free of userinfo and of any credential-shaped query key.
+	*/
+	url: string(),
+	/**
+	* What the surface calls it — "Web UI", "Home Assistant", "UniFi controller".
+	* The PROVIDER names it, because only the provider knows what the page is;
+	* a UI that invented the label from the addon id would call the Home
+	* Assistant device page "Provider Homeassistant".
+	*/
+	label: string(),
+	target: AdminLinkTargetEnum,
+	/**
+	* Host the URL points at, without scheme, port or path — for the tooltip, so
+	* an operator can see WHERE the button goes before he follows it. Redundant
+	* with `url` by construction; carried separately so no surface has to parse
+	* a URL to show it.
+	*/
+	host: string()
+});
+var deviceAdminLinkCapability = {
+	name: "device-admin-link",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	methods: { 
+	/**
+	* The device's management page, or `null` when this device has none.
+	*
+	* `auth: 'admin'` deliberately. This is administration, not actuation —
+	* the same bucket as `reboot` and `camera-credentials`, and explicitly NOT
+	* the actuation set `scripts/check-actuation-not-admin.ts` protects (D403).
+	* The URL is also a statement about the LAN, which a household member with
+	* a `view` grant on a light has no reason to be handed.
+	*
+	* The surfaces gate on the QUERY, never on a role they guessed: a caller
+	* without the right loses the query and draws nothing, which is the same
+	* thing a device with no page draws. There is no path on which a button
+	* appears and then fails — the D403 failure mode, from the other end.
+	*/
+getAdminLink: method(object({ deviceId: number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" }) }
+};
+/**
+* Query keys that may never appear on an admin link. A credential smuggled as
+* `?password=` is the same leak as userinfo, in a form the userinfo check
+* cannot see: it survives copy-paste, referrer headers and proxy logs
+* identically.
+*/
+var CREDENTIAL_QUERY_KEYS = [
+	"password",
+	"passwd",
+	"pwd",
+	"pass",
+	"user",
+	"username",
+	"usr",
+	"login",
+	"token",
+	"access_token",
+	"auth",
+	"authorization",
+	"apikey",
+	"api_key",
+	"secret",
+	"credential",
+	"credentials",
+	"session",
+	"sessionid",
+	"key"
+];
+/**
+* The same userinfo shape `scripts/check-no-credential-urls-in-fixtures.ts`
+* scans recorded fixtures for, applied to what we are about to EMIT. Kept
+* structurally identical on purpose: a URL this function returns is a URL that
+* guard would pass.
+*/
+var CREDENTIAL_URL = /[a-z][a-z0-9+.-]*:\/\/[^/\s:@'"]+:[^/\s:@'"]+@/i;
+/** A host that is safe to place in an authority component verbatim. */
+var PLAIN_HOST = /^[a-zA-Z0-9._-]+$/;
+/** A bracketed IPv6 literal, the only other authority form we emit. */
+var IPV6_HOST = /^\[[0-9a-fA-F:.]+\]$/;
+function defaultPortFor(scheme) {
+	return scheme === "https" ? 443 : 80;
+}
+/**
+* Build the admin-page URL, or refuse by name.
+*
+* The refusal is never thrown: a provider answering "no page for this device"
+* is an ordinary answer (`getAdminLink` → `null`), and a throw here would turn
+* a missing host on one device into a failed query for the whole surface.
+*/
+function buildDeviceAdminUrl(parts) {
+	const host = parts.host.trim();
+	if (host.length === 0) return {
+		ok: false,
+		reason: "empty-host"
+	};
+	if (host.includes("@")) return {
+		ok: false,
+		reason: "host-carries-userinfo"
+	};
+	if (!PLAIN_HOST.test(host) && !IPV6_HOST.test(host)) return {
+		ok: false,
+		reason: "host-not-plain"
+	};
+	if (parts.port !== null) {
+		if (!Number.isInteger(parts.port) || parts.port < 1 || parts.port > 65535) return {
+			ok: false,
+			reason: "port-out-of-range"
+		};
+	}
+	if (!parts.path.startsWith("/")) return {
+		ok: false,
+		reason: "path-not-absolute"
+	};
+	const query = parts.query ?? {};
+	for (const key of Object.keys(query)) if (CREDENTIAL_QUERY_KEYS.includes(key.toLowerCase())) return {
+		ok: false,
+		reason: "credential-query-key"
+	};
+	const authority = parts.port === null || parts.port === defaultPortFor(parts.scheme) ? host : `${host}:${String(parts.port)}`;
+	const search = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) search.append(key, value);
+	const suffix = search.size > 0 ? `?${search.toString()}` : "";
+	const url = `${parts.scheme}://${authority}${parts.path}${suffix}`;
+	if (CREDENTIAL_URL.test(url)) return {
+		ok: false,
+		reason: "userinfo-in-result"
+	};
+	return {
+		ok: true,
+		url
+	};
+}
+/**
 * Identity envelope for a device's upstream-system metadata.
 *
 * Two jobs:
@@ -14172,210 +14295,6 @@ method(object({ integrationId: string() }), object({ filters: array(AdoptionFilt
 	auth: "admin"
 });
 /**
-* device-admin-link — "this device has a management page of its own, and here
-* is its address".
-*
-* ## Why this is not a `deviceConfig` cap
-*
-* There is nothing to edit. A `deviceConfig` cap (D14) exists so the framework
-* can DERIVE a settings form from `getOptions` + `getStatus` and route a flat
-* patch back through a setter; it costs a `builderId` reducer in
-* `device-config-contribution.ts` and a `*-config-schema.ts` beside it, and it
-* renders a form section. This cap answers ONE question with ONE read and
-* renders a button. Nothing about it is a form, so it carries no `deviceConfig`
-* block, no `settings`, no `runtimeState` and no reducer — exactly like
-* `reboot`, the other pure-RPC device-native cap.
-*
-* ## Absent, and the difference between "no page" and "we cannot say"
-*
-* The two are answered at DIFFERENT layers, on purpose:
-*
-*  - **"We cannot say"** → the provider never registers the cap for that
-*    device. A VeSync humidifier, a Petkit feeder, a Dreame vacuum and a Dreo
-*    fan are reached only through a vendor cloud; there is no address to hand
-*    out and no page to open. A Tuya plug, a Wyze camera and a Gree air
-*    conditioner DO have a LAN IP, and still have no HTTP management page
-*    behind it. None of them register, so `deviceManager.getBindings` never
-*    lists the cap and no surface asks.
-*  - **"This device has no page, and I know that"** → the provider registers
-*    and `getAdminLink` returns `null`. This is the answer for a device whose
-*    sibling DOES have a page: a Reolink battery camera reached over UDP by
-*    `uid` with a blank `host`, an Ecowitt gateway configured in `listener`
-*    transport, a Home Assistant broker authenticated by supervisor token
-*    (which carries no `baseUrl` at all).
-*
-* Both draw NOTHING. A button that opens a browser error is worse than no
-* button, and D62 is the same rule from the other side: an off switch is
-* reported off, never made to look broken. There is no third state where the
-* UI renders a disabled button "because the device might have a page".
-*
-* ## The URL never carries credentials
-*
-* Not in userinfo, not in a query string. Every provider builds through
-* `buildDeviceAdminUrl` (`device-admin-link-url.ts`), which takes host, port,
-* scheme and path as separate arguments — there is no parameter a secret could
-* arrive in — and re-checks its own output for the `scheme://user:pass@` shape
-* that `scripts/check-no-credential-urls-in-fixtures.ts` bans from recorded
-* output. `scripts/check-admin-link-builder-is-the-only-url-source.ts` is what
-* keeps providers from hand-rolling one anyway.
-*
-* This matters here more than anywhere else in the repo, because every provider
-* that knows a device's host knows its PASSWORD too: `{ host, port, username,
-* password }` sit in one object on Hikvision, Amcrest, Reolink and ONVIF alike,
-* and `http://admin:hunter2@192.168.50.139/` is a URL a browser accepts. The
-* camera's own page will ask for its own login. That is correct, and pre-
-* filling it is the operator's business, not ours.
-*
-* ## It is a LAN fact
-*
-* The URL addresses the device where the NODE can see it. It is not proxied,
-* not made reachable from outside, and not sent anywhere. A surface renders it
-* as a link the operator's own browser follows, on the operator's own network,
-* or renders nothing.
-*/
-/**
-* Whose page is it. The distinction is for the OPERATOR, who needs to know
-* before clicking whether he is about to land on a camera's own web server or
-* inside Home Assistant.
-*/
-var AdminLinkTargetEnum = _enum(["device", "integration"]);
-var DeviceAdminLinkSchema = object({
-	/**
-	* Absolute `http(s)://` URL. Built by `buildDeviceAdminUrl` and therefore
-	* free of userinfo and of any credential-shaped query key.
-	*/
-	url: string(),
-	/**
-	* What the surface calls it — "Web UI", "Home Assistant", "UniFi controller".
-	* The PROVIDER names it, because only the provider knows what the page is;
-	* a UI that invented the label from the addon id would call the Home
-	* Assistant device page "Provider Homeassistant".
-	*/
-	label: string(),
-	target: AdminLinkTargetEnum,
-	/**
-	* Host the URL points at, without scheme, port or path — for the tooltip, so
-	* an operator can see WHERE the button goes before he follows it. Redundant
-	* with `url` by construction; carried separately so no surface has to parse
-	* a URL to show it.
-	*/
-	host: string()
-});
-var deviceAdminLinkCapability = {
-	name: "device-admin-link",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	methods: { 
-	/**
-	* The device's management page, or `null` when this device has none.
-	*
-	* `auth: 'admin'` deliberately. This is administration, not actuation —
-	* the same bucket as `reboot` and `camera-credentials`, and explicitly NOT
-	* the actuation set `scripts/check-actuation-not-admin.ts` protects (D403).
-	* The URL is also a statement about the LAN, which a household member with
-	* a `view` grant on a light has no reason to be handed.
-	*
-	* The surfaces gate on the QUERY, never on a role they guessed: a caller
-	* without the right loses the query and draws nothing, which is the same
-	* thing a device with no page draws. There is no path on which a button
-	* appears and then fails — the D403 failure mode, from the other end.
-	*/
-getAdminLink: method(object({ deviceId: number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" }) }
-};
-/**
-* Query keys that may never appear on an admin link. A credential smuggled as
-* `?password=` is the same leak as userinfo, in a form the userinfo check
-* cannot see: it survives copy-paste, referrer headers and proxy logs
-* identically.
-*/
-var CREDENTIAL_QUERY_KEYS = [
-	"password",
-	"passwd",
-	"pwd",
-	"pass",
-	"user",
-	"username",
-	"usr",
-	"login",
-	"token",
-	"access_token",
-	"auth",
-	"authorization",
-	"apikey",
-	"api_key",
-	"secret",
-	"credential",
-	"credentials",
-	"session",
-	"sessionid",
-	"key"
-];
-/**
-* The same userinfo shape `scripts/check-no-credential-urls-in-fixtures.ts`
-* scans recorded fixtures for, applied to what we are about to EMIT. Kept
-* structurally identical on purpose: a URL this function returns is a URL that
-* guard would pass.
-*/
-var CREDENTIAL_URL = /[a-z][a-z0-9+.-]*:\/\/[^/\s:@'"]+:[^/\s:@'"]+@/i;
-/** A host that is safe to place in an authority component verbatim. */
-var PLAIN_HOST = /^[a-zA-Z0-9._-]+$/;
-/** A bracketed IPv6 literal, the only other authority form we emit. */
-var IPV6_HOST = /^\[[0-9a-fA-F:.]+\]$/;
-function defaultPortFor(scheme) {
-	return scheme === "https" ? 443 : 80;
-}
-/**
-* Build the admin-page URL, or refuse by name.
-*
-* The refusal is never thrown: a provider answering "no page for this device"
-* is an ordinary answer (`getAdminLink` → `null`), and a throw here would turn
-* a missing host on one device into a failed query for the whole surface.
-*/
-function buildDeviceAdminUrl(parts) {
-	const host = parts.host.trim();
-	if (host.length === 0) return {
-		ok: false,
-		reason: "empty-host"
-	};
-	if (host.includes("@")) return {
-		ok: false,
-		reason: "host-carries-userinfo"
-	};
-	if (!PLAIN_HOST.test(host) && !IPV6_HOST.test(host)) return {
-		ok: false,
-		reason: "host-not-plain"
-	};
-	if (parts.port !== null) {
-		if (!Number.isInteger(parts.port) || parts.port < 1 || parts.port > 65535) return {
-			ok: false,
-			reason: "port-out-of-range"
-		};
-	}
-	if (!parts.path.startsWith("/")) return {
-		ok: false,
-		reason: "path-not-absolute"
-	};
-	const query = parts.query ?? {};
-	for (const key of Object.keys(query)) if (CREDENTIAL_QUERY_KEYS.includes(key.toLowerCase())) return {
-		ok: false,
-		reason: "credential-query-key"
-	};
-	const authority = parts.port === null || parts.port === defaultPortFor(parts.scheme) ? host : `${host}:${String(parts.port)}`;
-	const search = new URLSearchParams();
-	for (const [key, value] of Object.entries(query)) search.append(key, value);
-	const suffix = search.size > 0 ? `?${search.toString()}` : "";
-	const url = `${parts.scheme}://${authority}${parts.path}${suffix}`;
-	if (CREDENTIAL_URL.test(url)) return {
-		ok: false,
-		reason: "userinfo-in-result"
-	};
-	return {
-		ok: true,
-		url
-	};
-}
-/**
 * `device-export` — collection cap for addons that export camstack
 * devices to external ecosystems (HomeAssistant via MQTT discovery,
 * HomeKit/HAP, Alexa Smart Home, …).
@@ -24798,6 +24717,87 @@ method(_void(), ProviderInfoSchema, { auth: "admin" }), method(object({ config:
 	kind: "mutation",
 	auth: "admin"
 });
+/**
+* The signals a device can emit to WAKE its own stream.
+*
+* A camera whose stream is built on demand sleeps until something asks for it,
+* and "something" cannot be a consumer that is merely attached — a Frigate-style
+* puller holds a session open for ever, and treating that as demand would keep
+* a battery camera awake for ever, which is the whole thing the battery is for
+* (D173). So the wake has to come from the CAMERA: an event it noticed by
+* itself, with no stream running.
+*
+* ## The vocabulary is the PROVIDER'S, not ours
+*
+* Like `consumables`, this cap declares no vocabulary of its own. A provider
+* names each signal with a `code` it chooses and a `label` an operator reads.
+* Reolink offers motion and camera-native detection; another provider may offer
+* a tamper, a doorbell press, a PIR, or something no camera in this fleet has
+* yet. A fixed enum here would mean every new signal is a framework release.
+*
+* It is deliberately NOT derived from the caps a device already binds. Whether
+* a camera CAN push firmware motion is expressed by `motionSources` containing
+* `'onboard'`, and whether it does AI on-camera by the `native-object-detection`
+* binding — but both answer "what drives the detection pipeline", which is a
+* different question from "what may wake a sleeping stream". A camera can do
+* the first and not be trusted with the second, and the operator picks per
+* camera. Two questions, two authorities.
+*
+* ## Availability is not permission
+*
+* `listSignals` says what the device CAN emit. Whether a given signal actually
+* wakes the stream is the operator's per-camera choice, held by the broker
+* alongside the cooldown — see the stream-broker cap's wake settings. A
+* provider declaring a signal is not a provider enabling it.
+*/
+/** One signal a device can emit. */
+var StreamSignalSchema = object({
+	/** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
+	code: string().min(1),
+	/** What an operator reads in the picker. The provider's own wording. */
+	label: string().min(1),
+	/**
+	* Whether the provider recommends this signal ON when a camera is first set
+	* up. A provider knows which of its signals are cheap and reliable; an
+	* operator should not have to discover that by trial. Reolink recommends
+	* both of its own.
+	*/
+	recommended: boolean()
+});
+var StreamSignalsStatusSchema = object({
+	signals: array(StreamSignalSchema),
+	lastFetchedAt: number()
+});
+var streamSignalsCapability = {
+	name: "stream-signals",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: Object.values(DeviceType),
+	runtimeState: StreamSignalsStatusSchema,
+	/**
+	* Runtime-state durability: **session** — mirrored in RAM, never written.
+	*
+	* The slice holds what the DEVICE says it can emit. That is a probed fact,
+	* not an operator choice: the provider re-declares it on every registration,
+	* so losing it loses nothing and persisting it would freeze an answer the
+	* camera is entitled to change. Measured the same day on the sibling case —
+	* `native-object-detection.supportedClasses` was persisted, and a firmware
+	* class the camera really detected stayed missing for the life of the row
+	* because the fix could not reach it.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	methods: { 
+	/**
+	* What this device can emit. Empty is a valid and common answer — most
+	* cameras have nothing to offer here, and an empty list is what makes the
+	* broker's picker show nothing rather than a false choice.
+	*/
+listSignals: method(_void(), array(StreamSignalSchema).readonly()) }
+};
 /** Profile-exported FormBuilder schema. Shape is ConfigUISchema at the UI. */
 var ProfileSettingsSchemaBridge = unknown().nullable();
 var ProfileSettingsBagSchema = record(string(), unknown());
@@ -25838,27 +25838,74 @@ var ClipStreamDialSchema = object({
 	audioReason: ClipStreamAudioReasonSchema.optional()
 });
 /**
-* The playback rates a clip can be DELIVERED at, ascending, always with `1`.
+* The playback rates the broker can pace over media it HOLDS, ascending,
+* always with `1` — and the WIDEST ladder there is. It is the domain the
+* broker's `clampPlaybackRate` is derived from, at both ends.
 *
 * These are the BROKER's: it re-paces frames it has already demuxed — the
 * `MonotonicClock` divides source elapsed time by the factor and the pacer
-* pushes that much faster — so the domain is the recorded one, {0} ∪ [0.25, 4],
-* and this is the discrete ladder drawn from it. `1.5` is in it because a
-* re-pacer has no reason to refuse it.
-*
-* `8` and `16` are deliberately NOT here. They are the CAMERA's own
-* `<playSpeed>` (Reolink cmd-5 replay), a different mechanism, still unwired
-* (D597, D600) — a rate change there costs a new dial and a new stream, and
-* the camera's 8x would need a resample the clip audio path has no decoder
-* for. Offering them today accepts a rate and delivers 1x, which is the whole
-* defect this list exists to end (D612). When `playSpeed` IS wired its rates
-* join THIS array — a second list elsewhere is the second authority D62
-* forbids.
-*
-* Every entry must survive the broker's `clampPlaybackRate` unchanged: a set
-* that offers what the clamp then moves is the same lie one step later.
+* pushes that much faster. `1.5` is in it because a re-pacer has no reason to
+* refuse it.
+*
+* **`8` is here since D621, and it is the pacer's, not a camera's.** D620
+* measured the thing that was assumed for a year and was never true: a
+* Reolink `<playSpeed>` does not time-compress anything. At 1, 2, 4 and 8 the
+* transfer is byte-identical — same 947 472 bytes, same 594 access units,
+* same 39.855 s presentation span, same 624 AAC frames — and only the wall
+* clock moves. It buys SUPPLY, never speed. So there was never a second
+* mechanism to wire for 8×: there is one, this one, and what it needs is
+* media in hand and a clamp that does not move the number.
+*
+* **`16` is deliberately NOT here, and will not join by widening this array.**
+* The camera's `playSpeed 16` is not a rate at all but an I-frame-only MODE —
+* measured on 592: 10 access units for a whole 36.3 s sub clip, 20 for the
+* main twin at a 2 025 ms median spacing, and no audio track. That is
+* different CONTENT, a stream of its own, and the honest broker-side twin of
+* it would be a pacer that DROPS whole GOPs rather than one that pushes 16×
+* the bitrate at a live WebRTC track. Neither exists. A `16` in this array
+* today would be a rate accepted and delivered at 8 — D612's defect, which
+* this list exists to end, one number further along.
+*
+* Every entry must survive the broker's `clampPlaybackRate` unchanged. Since
+* D621 that is structural rather than a discipline: the clamp reads this
+* array's own ends. What still has to be proved behaviourally — and is, in
+* the broker's `clip-stream-feeder.spec` — is that the PACER really empties a
+* clip `rate` times faster, because a clamp agreeing with a ladder is a
+* constant compared against itself.
+*
+* Narrower ladders exist for transports whose SUPPLY is bounded; they are
+* subsets of this one ({@link CLIP_STREAM_SOURCE_RATES},
+* {@link CLIP_REALTIME_SOURCE_RATES}).
 */
 var CLIP_BROKER_PACED_RATES = [
+	.25,
+	.5,
+	1,
+	1.5,
+	2,
+	4,
+	8
+];
+/**
+* The rates a provider-STREAMED clip can be delivered at — a subset of
+* {@link CLIP_BROKER_PACED_RATES}, and frozen below it on purpose (D621).
+*
+* A `stream` clip's media does not exist yet: it arrives on a socket from the
+* camera while the pacer consumes it. The pacer takes `rate` seconds of media
+* per second of wall clock, so the ceiling is whatever the SOURCE supplies,
+* and that is a measurement per vendor rather than a preference.
+*
+* Reolink, the one provider on this envelope, was measured on 592
+* (2026-09-23, D620): with the `<ReplaySeek>` that 0.11.1 sends before every
+* replay, a sub clip arrives at **1.2×** and a main twin at **1.37×**. The
+* ladder below is therefore ALREADY beyond this transport above 1 — the D612
+* defect returned through a door nobody opened — and D620 fixed the repair
+* order: the supply first, the ladder after. So this array does not move with
+* the broker's, and it does not gain `8`; what it gains, when the library
+* forwards a `<playSpeed>` large enough to feed the rate being paced over it,
+* is the right to be widened on a measurement rather than shortened on one.
+*/
+var CLIP_STREAM_SOURCE_RATES = [
 	.25,
 	.5,
 	1,
@@ -26343,7 +26390,7 @@ var CLIP_PLAYBACK_OPTIONS = {
 		seek: "forward",
 		stepBack: false,
 		scrub: false,
-		rates: CLIP_BROKER_PACED_RATES
+		rates: CLIP_STREAM_SOURCE_RATES
 	},
 	/**
 	* A `stream` whose SOURCE runs at realtime — a Hikvision RTSP replay.
@@ -27727,6 +27774,143 @@ DeviceType.Camera, method(object({ deviceId: number() }), CameraCredentialsSchem
 	auth: "admin"
 });
 /**
+* camera-grid-layout — the geometry of a COMPOSITE camera, on the camera's own
+* page.
+*
+* ## Why this is a capability and not an addon settings schema
+*
+* It was one, and it did not render. The addon declared the editor as a
+* `type: 'widget'` field inside its own `deviceSettingsSchema()`; the hub
+* returned that section correctly and `ConfigFormField` renders `type:'widget'`
+* perfectly well — and nothing ever asked camera-grid for it. The Cluster →
+* Pipeline → Device Overrides page interrogates a HAND-WRITTEN list of four
+* addons (`PIPELINE_CLUSTER_DEVICE_ADDONS`), whose own comment says an addon
+* not on it "falls off silently".
+*
+* Adding a fifth name to that list would have been the wrong fix twice over:
+* that page is per-camera DETECTION tuning, and a grid's geometry belongs
+* beside PTZ and motion zones on the camera itself. The device page is
+* BINDING-driven (D12), so the way in is a capability bound to the device —
+* and this cap carries its section the way `recording` does, by RETURNING it
+* from `getDeviceSettingsContribution`.
+*
+* Seven other widgets are still declared the other way, through a
+* `deviceConfig.ui` block the framework derives a section from. That route
+* gives the addon no say in where its own panel lands and no way to decline
+* for a device the panel does not suit, which is why this one does not use it.
+*
+* ## Why one addon may implement it
+*
+* It is a device-scoped NATIVE cap, registered by the grid camera device
+* itself. Nothing else declares a composite camera, so nothing else has a
+* layout — and the device-scoped route means the widget asks THE camera, not
+* "the camera-grid addon", which is what let the old custom-action pair be
+* reached only by a caller that already knew the addon id.
+*
+* ## The tab
+*
+* `streaming`, not a top-tab of its own. A grid's geometry IS what its stream
+* is, so the Streaming tab is where it belongs; a `grid` top-tab would need an
+* entry in `WELL_KNOWN_TAB_MAP` or the device page renders the raw id as the
+* label (measured on the robot camera, 2026-09-06 — a tab called "navigation"
+* next to "PTZ").
+*/
+/** A rectangle in normalized [0,1] coordinates of whatever contains it. */
+var GridNormalizedRectSchema = object({
+	x: number().min(0).max(1),
+	y: number().min(0).max(1),
+	width: number().gt(0).max(1),
+	height: number().gt(0).max(1)
+});
+/**
+* One source camera, the part of its picture taken, and where that part lands.
+*
+* Both rectangles are NORMALIZED (D519): a source camera can change resolution
+* — a profile switch, a firmware update, a substream that comes back different
+* — and a stored PIXEL rectangle would quietly start cutting the wrong region,
+* which is the class of bug nobody files.
+*/
+var GridLayoutCellSchema = object({
+	deviceId: number().int().positive(),
+	/** The part of the SOURCE taken, normalized against the source. */
+	source: GridNormalizedRectSchema,
+	/** Where it lands, normalized against the CANVAS. */
+	cell: GridNormalizedRectSchema
+});
+/**
+* Which profiles this grid can actually compose, and why not.
+*
+* A grid's `high` composes its sources' `high` and its `low` their `low`, so a
+* profile is on offer only when EVERY source can serve it. The refusal NAMES
+* the sources, because "this grid has no low" is not a finding — "615 has no
+* low" is, and it is the one an operator can act on.
+*/
+var GridProfileOfferSchema = object({
+	profile: _enum([
+		"high",
+		"mid",
+		"low"
+	]),
+	offered: boolean(),
+	/** Sources that cannot serve it. Empty when it is offered, or when there are no cells. */
+	missingSources: array(number().int().positive()),
+	/**
+	* The canvas this profile composes onto, `WxH`, or empty when it is not
+	* offered. DERIVED from the cells and the sources' own size at this profile —
+	* it is reported because nothing else in the system would ever say what the
+	* grid came out as, and because it is the number an operator would otherwise
+	* expect to type.
+	*/
+	canvas: string(),
+	/**
+	* Whether this profile is PUBLISHED, of the ones the grid could serve.
+	*
+	* A grid's `high` is composed of its sources' `high`, so on a 4K fleet it is
+	* a 4K canvas built from 4K decodes — something to opt into, not something a
+	* viewer's adaptive should be handed by climbing to the top rung it can see.
+	* Default is `mid` + `low`.
+	*/
+	published: boolean()
+});
+var GridLayoutViewSchema = object({
+	/** The persisted grid row this camera was declared from. */
+	instanceId: string(),
+	deviceId: number().int().nonnegative(),
+	name: string(),
+	/**
+	* NO canvas size. A grid's resolution is not authored: each profile derives
+	* its own from the cells and its sources' dimensions. The two numbers that
+	* used to be here were a text field that silently decided both how much the
+	* composite cost and how sharp it was — see `profiles[].canvas` for what it
+	* came out as.
+	*/
+	fps: number().int(),
+	cells: array(GridLayoutCellSchema),
+	/** What the catalog will publish, and what it refuses to. Read-only. */
+	profiles: array(GridProfileOfferSchema)
+});
+var GridLayoutPatchSchema = object({
+	deviceId: number().int().nonnegative(),
+	name: string().min(1).max(160).optional(),
+	fps: number().int().min(1).max(60).optional(),
+	/** Which profiles to publish. See `GridProfileOffer.published`. */
+	publishedProfiles: array(_enum([
+		"high",
+		"mid",
+		"low"
+	])).max(3).optional(),
+	/**
+	* The whole cell list at once. A per-cell patch would need an ordering the
+	* editor does not have, and a half-applied layout is a picture nobody asked
+	* for.
+	*/
+	cells: array(GridLayoutCellSchema).max(16)
+});
+DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), GridLayoutViewSchema.nullable(), { auth: "admin" }), method(GridLayoutPatchSchema, GridLayoutViewSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * Carbon-monoxide alarm sensor. Drives Home Assistant `binary_sensor`
 * entries with `device_class: carbon_monoxide`. Push-driven.
 */
@@ -28529,511 +28713,6 @@ var dayNightCapability = {
 	volatileStateFields: ["lastFetchedAt"]
 };
 /**
-* Vendor-neutral **onboard** recording + storage cap — what the CAMERA
-* writes to the CAMERA's own card, on the camera's own schedule.
-*
-* This is NOT `recording.cap.ts`. That one is CamStack's recorder: our
-* footage ledger, our storage locations, our retention. This one has a
-* different authority — the camera's firmware — and per D62 it stores
-* nothing of its own. Every value here is read from the camera and every
-* write goes back to the camera; there is no CamStack-side mirror that
-* could disagree with the device.
-*
-* ## One shape, two firmwares
-*
-* Measured 2026-09-22 against the live fleet:
-*
-* | fact | Hikvision (ISAPI) | Reolink (Baichuan) |
-* | --- | --- | --- |
-* | storage | `ContentMgmt/Storage` `<hdd>` rows: status, capacity, freeSpace (MB) | `getHddInfoList` (cmd 102): `mount`, `format`, `capacity` GB + `capacityM` MB remainder |
-* | tracks | several (101 **and** 103 on both 1436 and 3833), each with its own schedule | one per channel |
-* | schedule | per track, 7 `ScheduleAction` blocks: DayOfWeek + TimeOfDay range + ONE `ActionRecordingMode` | per trigger type, a 168-char weekly HOUR mask |
-* | triggers | `CMR`, `MOTION` | `Normal`, `MD`, `people`, `vehicle`, `dog_cat`, `crossline`, `intrude`, `loitering` |
-* | pre-record | `PreRecordTimeSeconds` | `preRecordTime` |
-* | post-record | `PostRecordTimeSeconds` | `recordDelayTime` |
-* | overwrite | per track `LoopEnable` | `cycle`, with `cycleList` enumerating the accepted values |
-* | segment length | not exposed on V5.7.1 | `packageTime` (minutes) |
-*
-* The two schedule models look different and are the same thing in
-* different coordinates: both answer "for this trigger, during which
-* weekly windows does the camera record". {@link RecordWindow} is that
-* question in one shape — Hikvision's ranges map straight onto it,
-* Reolink's mask expands into hour-aligned windows.
-*
-* ## Union, not intersection
-*
-* **The same fields exist on every camera.** What differs per device is
-* which VALUES that device accepts, and that is what {@link
-* RecordingOnboardOptions} reports — a `{ readable, writable, reason }`
-* per field plus the schedule's own limits. A control a camera cannot
-* honour is rendered DISABLED WITH ITS REASON, never missing and never
-* dead: disabled must not look like broken.
-*
-* ## Refusal by name
-*
-* A write a camera cannot honour is refused with a sentence the operator
-* can read — never accepted and dropped. Both providers refuse through
-* {@link describeOnboardRefusal}, so the vocabulary is one function and
-* one test, not two hand-written vendor opinions.
-*
-* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
-* `getOptions` advertises per-camera availability, `getStatus` (auto-
-* injected from `status`) reports the live values, and a single
-* `setSettings` mutation applies a partial change. No hand-written
-* settings-contribution methods.
-*/
-/**
-* What makes the camera start recording during a window.
-*
-* The union of both vendors' vocabularies. `continuous` is Hikvision's
-* `CMR` and Reolink's `Normal`; `motion` is `MOTION` / `MD`. The
-* object-class triggers are Reolink-only today and the smart-event ones
-* (`lineCrossing`, `intrusion`, `loitering`) are Reolink-only on the
-* firmwares measured — a camera that cannot record on a trigger simply
-* does not list it in `options.schedule.triggers`, and a window naming
-* it is REFUSED, not dropped.
-*/
-var RecordTriggerSchema = _enum([
-	"continuous",
-	"motion",
-	"person",
-	"vehicle",
-	"animal",
-	"lineCrossing",
-	"intrusion",
-	"loitering",
-	"alarmInput"
-]);
-/**
-* One weekly recording window: "on `day`, from `startMinute` to
-* `endMinute`, record on `trigger`".
-*
-* `day` is 0 = Monday … 6 = Sunday (ISO order, which is also the order
-* both firmwares enumerate). Minutes are local camera time since
-* midnight; `endMinute` may be 1440, meaning end of day — that is
-* Hikvision's literal `24:00` and Reolink's 24th mask slot, and
-* collapsing it to 0 would turn a whole-day window into an empty one.
-*/
-var RecordWindowSchema = object({
-	trigger: RecordTriggerSchema,
-	day: number().int().min(0).max(6),
-	startMinute: number().int().min(0).max(1439),
-	endMinute: number().int().min(1).max(1440)
-});
-/** Status of one physical volume, as the camera itself describes it. */
-var OnboardStorageVolumeSchema = object({
-	/** The camera's own id for the volume (`hdd/id`, Reolink `HddInfo/number`). */
-	id: string(),
-	/** The camera's own name for it, when it gives one (`hddName`). */
-	label: string().optional(),
-	status: _enum([
-		"ok",
-		"unformatted",
-		"error",
-		"offline",
-		"unknown"
-	]),
-	/**
-	* Total size in MB, or **null when the camera did not say**.
-	*
-	* Never 0 for an unreadable value: a measurement that failed is not a
-	* measurement (D393), and a card whose size is unknown must not be
-	* rendered as a card of size zero.
-	*/
-	capacityMb: number().nullable(),
-	/**
-	* Free space in MB, or null when unknown.
-	*
-	* **Not a proxy for "has footage".** Measured 2026-09-22: 1436 and
-	* 1439 both report exactly 11776 MB free — the fixed reserve a looping
-	* card converges on once it has wrapped. At loop steady state the
-	* number is identical whether the camera recorded yesterday or stopped
-	* a month ago.
-	*/
-	freeMb: number().nullable(),
-	/** True when the camera reports the volume writable (`property` RW). */
-	writable: boolean().optional()
-});
-/**
-* What the camera is doing with its own storage, right now.
-*
-* Every scalar is nullable and **null means the camera did not answer**,
-* never a default. A form that seeds `0` from an unanswered read invites
-* the operator to save that 0 back onto the camera.
-*/
-var RecordingOnboardStatusSchema = object({
-	storage: discriminatedUnion("kind", [
-		object({
-			kind: literal("present"),
-			volumes: array(OnboardStorageVolumeSchema)
-		}),
-		object({
-			kind: literal("absent"),
-			reason: string()
-		}),
-		object({
-			kind: literal("unknown"),
-			reason: string()
-		})
-	]),
-	tracks: array(object({
-		id: string(),
-		enabled: boolean(),
-		isVideo: boolean(),
-		/** From the camera's own track description. Null when it does not say. */
-		codec: string().nullable(),
-		resolution: string().nullable(),
-		/** Per-track overwrite flag, where the firmware keeps it per track. */
-		overwriteWhenFull: boolean().nullable()
-	})),
-	/**
-	* The track the write path targets — the enabled VIDEO one. Null when
-	* no track could be identified, which is itself a refusal reason.
-	*/
-	primaryTrackId: string().nullable(),
-	/** Master "record to the card at all" switch. */
-	enabled: boolean().nullable(),
-	overwriteWhenFull: boolean().nullable(),
-	preRecordSec: number().nullable(),
-	postRecordSec: number().nullable(),
-	/** Length of one recorded file, in minutes. */
-	segmentMinutes: number().nullable(),
-	/** The primary track's weekly windows, flattened. */
-	windows: array(RecordWindowSchema),
-	/**
-	* How many windows the camera described that CamStack could NOT read —
-	* an unrecognised trigger, an unparseable clock, a weekday it does not
-	* name.
-	*
-	* A dropped window is work the reader threw away, and a schedule that
-	* silently shows fewer rows than the camera holds is how an operator
-	* saves back a schedule shorter than the one they were looking at
-	* (D391). Non-zero means the window list is INCOMPLETE and a write
-	* that replaces it would delete what was not shown — which is why a
-	* provider reporting a non-zero count also reports the schedule as not
-	* writable.
-	*/
-	unreadableWindows: number(),
-	/**
-	* The camera is scheduled to record and has NO usable storage.
-	*
-	* A first-class fact because it is the fleet's most common silent
-	* defect: measured 2026-09-22, 1441 and 3831 are both motion-recording
-	* to a card that is not there. Neither the schedule nor the storage
-	* read says anything wrong on its own; only the pair does.
-	*/
-	recordingToNowhere: boolean(),
-	lastFetchedAt: number()
-});
-/** Numeric range descriptor — `{ min, max, step }` per the getOptions convention. */
-var RangeSchema = object({
-	min: number(),
-	max: number(),
-	step: number()
-});
-/**
-* The values a camera actually takes for a numeric field, when they are a SET
-* rather than a range.
-*
-* `{min,max,step}` cannot say what these two firmwares do. Measured on 1436
-* (I91DN) on 2026-09-22 by writing each value and reading it back:
-*
-* - pre-record: `0, 5, 10, 15, 20, 25, 30` and `2147483647` (INT32_MAX, the
-*   camera's "no limit" — `-1` and `4294967295` both land on it);
-* - post-record: `5, 10, 30, 60, 120, 300, 600`.
-*
-* Neither is expressible as a step: the first has a sentinel two billion away
-* from its neighbours, the second doubles and then jumps. A range that tried
-* would forbid values the camera takes AND permit values it silently replaces
-* with 5 — wrong in both directions at once.
-*
-* `sentinel` names the member that is not a duration, so a surface can render
-* "no limit" instead of `2147483647` seconds.
-*/
-var AllowedValuesSchema = object({
-	values: array(number()).min(1),
-	sentinel: object({
-		value: number(),
-		meaning: _enum(["no-limit", "disabled"])
-	}).optional()
-});
-/**
-* Per-field availability on ONE camera.
-*
-* The field exists on every camera — this says whether this one can be
-* read and whether it can be written, and `reason` says why not when
-* either is false. The UI renders the control DISABLED with the reason
-* rather than hiding it, so a limitation is legible instead of looking
-* like a missing feature.
-*/
-var OnboardFieldSupportSchema = object({
-	readable: boolean(),
-	writable: boolean(),
-	/** Required whenever `readable` or `writable` is false. */
-	reason: string().optional()
-});
-/** What this camera's schedule model can express. */
-var OnboardScheduleSupportSchema = object({
-	support: OnboardFieldSupportSchema,
-	/**
-	* The smallest time step the camera can express, in minutes.
-	*
-	* Hikvision takes arbitrary minutes (`00:05:00`–`23:57:00` observed on
-	* 1436's track 103). Reolink's schedule is a 7×24 HOUR mask, so 60. A
-	* window whose edges are not a multiple of this is REFUSED rather than
-	* quietly rounded — rounding is how an operator's 06:30 becomes 06:00
-	* and nothing says so.
-	*/
-	granularityMinutes: number(),
-	/** Triggers this camera can record on. A window naming another is refused. */
-	triggers: array(RecordTriggerSchema),
-	/**
-	* False when the camera stores ONE trigger per time range, so two
-	* windows overlapping on the same day cannot carry different triggers.
-	* True on Reolink, whose mask is per-trigger and independent.
-	*/
-	supportsOverlappingTriggers: boolean()
-});
-var RecordingOnboardOptionsSchema = object({
-	enabled: OnboardFieldSupportSchema,
-	overwriteWhenFull: OnboardFieldSupportSchema,
-	preRecordSec: OnboardFieldSupportSchema,
-	preRecordSecRange: RangeSchema.optional(),
-	/** Preferred over the range when the camera takes a SET, not a span. */
-	preRecordSecAllowed: AllowedValuesSchema.optional(),
-	postRecordSec: OnboardFieldSupportSchema,
-	postRecordSecRange: RangeSchema.optional(),
-	/** Preferred over the range when the camera takes a SET, not a span. */
-	postRecordSecAllowed: AllowedValuesSchema.optional(),
-	segmentMinutes: OnboardFieldSupportSchema,
-	segmentMinutesRange: RangeSchema.optional(),
-	/** Preferred over the range when the camera takes a SET, not a span. */
-	segmentMinutesAllowed: AllowedValuesSchema.optional(),
-	schedule: OnboardScheduleSupportSchema
-});
-/**
-* A partial change. Every field optional.
-*
-* Unlike the other `deviceConfig` caps, a provider here does **NOT**
-* silently ignore a field it cannot support — it refuses, by name,
-* through {@link describeOnboardRefusal}. Silence on a recording setting
-* is the failure D62 exists to prevent: the operator believes the camera
-* is recording the way the form says, and it is not.
-*/
-var RecordingOnboardPatchSchema = object({
-	enabled: boolean().optional(),
-	overwriteWhenFull: boolean().optional(),
-	preRecordSec: number().optional(),
-	postRecordSec: number().optional(),
-	segmentMinutes: number().optional(),
-	/** The complete new window set for the primary track — not a delta. */
-	windows: array(RecordWindowSchema).optional()
-});
-var recordingOnboardCapability = {
-	name: "recording-onboard",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.Camera],
-	deviceConfig: { ui: {
-		kind: "derived-form",
-		builderId: "recording-onboard",
-		tab: "recording"
-	} },
-	methods: {
-		getOptions: method(object({ deviceId: number() }), RecordingOnboardOptionsSchema),
-		setSettings: method(object({
-			deviceId: number(),
-			settings: RecordingOnboardPatchSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	status: {
-		schema: RecordingOnboardStatusSchema,
-		kind: "poll"
-	},
-	runtimeState: RecordingOnboardStatusSchema,
-	/**
-	* Runtime-state durability: **restored** — operator-set camera-side
-	* recording config; mutation-driven, and the storage half is the last
-	* thing the camera said about its own card.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored",
-	/** Clock fields: written, but excluded from the compare that decides
-	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"]
-};
-/**
-* Day-of-week names in the cap's index order (0 = Monday), for messages
-* an operator reads and for Hikvision's `<DayOfWeek>` element.
-*/
-var DAY_NAMES = [
-	"Monday",
-	"Tuesday",
-	"Wednesday",
-	"Thursday",
-	"Friday",
-	"Saturday",
-	"Sunday"
-];
-/**
-* Does `patch` ask this camera for something it cannot do?
-*
-* Returns the operator-readable reason, or `null` when every field in
-* the patch is within what `options` says this camera accepts. A
-* provider calls this BEFORE touching the camera and throws the string:
-* refusing is the point, and refusing identically on both vendors is why
-* this is one function.
-*
-* The order of checks is the order an operator would read them: the
-* scalar knobs first, then the schedule, because a schedule complaint is
-* longer and a scalar one is usually the real problem.
-*/
-function describeOnboardRefusal(options, patch) {
-	if (patch.enabled !== void 0 && !options.enabled.writable) return unwritable("the master recording switch", options.enabled.reason);
-	if (patch.overwriteWhenFull !== void 0 && !options.overwriteWhenFull.writable) return unwritable("overwrite-when-full", options.overwriteWhenFull.reason);
-	const preRefusal = refuseNumeric("pre-record seconds", patch.preRecordSec, options.preRecordSec, options.preRecordSecRange, options.preRecordSecAllowed);
-	if (preRefusal) return preRefusal;
-	const postRefusal = refuseNumeric("post-record seconds", patch.postRecordSec, options.postRecordSec, options.postRecordSecRange, options.postRecordSecAllowed);
-	if (postRefusal) return postRefusal;
-	const segmentRefusal = refuseNumeric("segment length (minutes)", patch.segmentMinutes, options.segmentMinutes, options.segmentMinutesRange, options.segmentMinutesAllowed);
-	if (segmentRefusal) return segmentRefusal;
-	if (patch.windows !== void 0) {
-		const scheduleRefusal = refuseSchedule(options, patch.windows);
-		if (scheduleRefusal) return scheduleRefusal;
-	}
-	return null;
-}
-function unwritable(what, reason) {
-	return reason ? `this camera cannot change ${what}: ${reason}` : `this camera cannot change ${what}`;
-}
-function refuseNumeric(what, value, support, range, allowed) {
-	if (value === void 0) return null;
-	if (!support.writable) return unwritable(what, support.reason);
-	if (!Number.isFinite(value)) return `${what} must be a number, got ${String(value)}`;
-	if (allowed) {
-		if (allowed.values.includes(value)) return null;
-		const say = (v) => allowed.sentinel !== void 0 && v === allowed.sentinel.value ? allowed.sentinel.meaning === "no-limit" ? "no limit" : "off" : String(v);
-		return `this camera accepts ${what} only as ${allowed.values.map(say).join(", ")}; ${say(value)} is not one of them`;
-	}
-	if (!range) return null;
-	if (value < range.min || value > range.max) return `this camera accepts ${what} between ${String(range.min)} and ${String(range.max)}; ${String(value)} is outside that`;
-	if (range.step > 0 && (value - range.min) % range.step !== 0) return `this camera accepts ${what} in steps of ${String(range.step)} from ${String(range.min)}; ${String(value)} is not one of them`;
-	return null;
-}
-function refuseSchedule(options, windows) {
-	const schedule = options.schedule;
-	if (!schedule.support.writable) return unwritable("the recording schedule", schedule.support.reason);
-	const allowed = new Set(schedule.triggers);
-	for (const window of windows) {
-		if (!allowed.has(window.trigger)) {
-			const offer = schedule.triggers.length > 0 ? schedule.triggers.join(", ") : "none";
-			return `this camera cannot record on "${window.trigger}"; it records on: ${offer}`;
-		}
-		if (window.endMinute <= window.startMinute) return `a window on ${dayName(window.day)} ends at or before it starts (${String(window.startMinute)} → ${String(window.endMinute)})`;
-		const step = schedule.granularityMinutes;
-		if (step > 1 && (window.startMinute % step !== 0 || window.endMinute % step !== 0)) return `this camera's schedule only moves in ${String(step)}-minute steps; the ${dayName(window.day)} window ${formatMinutes(window.startMinute)}–${formatMinutes(window.endMinute)} is not aligned to them`;
-	}
-	if (!schedule.supportsOverlappingTriggers) {
-		const clash = findOverlapWithDifferentTrigger(windows);
-		if (clash) return `this camera stores one trigger per time range, so "${clash.a.trigger}" and "${clash.b.trigger}" cannot both cover ${dayName(clash.a.day)} ${formatMinutes(Math.max(clash.a.startMinute, clash.b.startMinute))}–${formatMinutes(Math.min(clash.a.endMinute, clash.b.endMinute))}`;
-	}
-	return null;
-}
-function findOverlapWithDifferentTrigger(windows) {
-	for (let i = 0; i < windows.length; i += 1) for (let j = i + 1; j < windows.length; j += 1) {
-		const a = windows[i];
-		const b = windows[j];
-		if (!a || !b) continue;
-		if (a.day !== b.day) continue;
-		if (a.trigger === b.trigger) continue;
-		if (a.startMinute < b.endMinute && b.startMinute < a.endMinute) return {
-			a,
-			b
-		};
-	}
-	return null;
-}
-function dayName(day) {
-	return DAY_NAMES[day] ?? `day ${String(day)}`;
-}
-/** `510` → `08:30`. For messages, not for the wire. */
-function formatMinutes(minute) {
-	const hour = Math.floor(minute / 60);
-	const rest = minute % 60;
-	return `${String(hour).padStart(2, "0")}:${String(rest).padStart(2, "0")}`;
-}
-/**
-* Index of the mask character covering `day` at `hour`.
-*
-* **Layout: day-major, Monday first** — `day * 24 + hour`.
-*
-* This is an ASSUMPTION, and it is recorded as one because the fleet
-* cannot currently confirm it: every `valueTable` on every Reolink
-* measured on 2026-09-22 is uniform (all `1` or all `0`), and a uniform
-* mask reads identically under either layout. To settle it, set a single
-* hour on one day from the Reolink app and re-read `getRecordSchedule`.
-* Until then, a NON-uniform mask is reported as windows under this
-* layout and the day labels may be transposed; a uniform one is exact.
-*/
-function weeklyMaskIndex(day, hour) {
-	return day * 24 + hour;
-}
-/**
-* Expand one trigger's weekly hour mask into windows, merging adjacent
-* set hours into one window per run so a full day is ONE window rather
-* than twenty-four.
-*
-* A mask of the wrong length yields no windows: a truncated table is not
-* a schedule of fewer days, it is an answer we did not understand.
-*/
-function weeklyMaskToWindows(mask, trigger) {
-	if (mask.length !== 168) return [];
-	const out = [];
-	for (let day = 0; day < 7; day += 1) {
-		let runStart = null;
-		for (let hour = 0; hour <= 24; hour += 1) {
-			const set = hour < 24 && mask[weeklyMaskIndex(day, hour)] === "1";
-			if (set && runStart === null) runStart = hour;
-			else if (!set && runStart !== null) {
-				out.push({
-					trigger,
-					day,
-					startMinute: runStart * 60,
-					endMinute: hour * 60
-				});
-				runStart = null;
-			}
-		}
-	}
-	return out;
-}
-/**
-* Collapse this trigger's windows back into a weekly hour mask.
-*
-* Windows for other triggers are ignored — the mask is per trigger. A
-* window that is not hour-aligned is REFUSED upstream by
-* {@link describeOnboardRefusal}; this function rounds nothing, it
-* simply sets every hour the window fully or partly covers, so a caller
-* that skipped the refusal cannot silently lose coverage.
-*/
-function windowsToWeeklyMask(windows, trigger) {
-	const slots = new Array(168).fill("0");
-	for (const window of windows) {
-		if (window.trigger !== trigger) continue;
-		if (window.day < 0 || window.day >= 7) continue;
-		const firstHour = Math.floor(window.startMinute / 60);
-		const lastHour = Math.ceil(window.endMinute / 60);
-		for (let hour = firstHour; hour < lastHour && hour < 24; hour += 1) slots[weeklyMaskIndex(window.day, hour)] = "1";
-	}
-	return slots.join("");
-}
-/**
 * Generic device-level status snapshot. Auto-registered by `BaseDevice`
 * for every device, regardless of provider — the kernel needs a uniform
 * cap-keyed slice for the basic device flags every consumer expects to
@@ -29252,30 +28931,6 @@ var eventEmitterCapability = {
 	*/
 	durability: "session"
 };
-var EventItemSchema = object({
-	id: string(),
-	type: string(),
-	timestamp: number(),
-	label: string().optional(),
-	thumbnailUrl: string().optional(),
-	clipUrl: string().optional(),
-	metadata: record(string(), unknown()).optional()
-});
-DeviceType.Camera, method(object({
-	deviceId: number(),
-	from: number().optional(),
-	to: number().optional(),
-	limit: number().optional()
-}), array(EventItemSchema)), method(object({
-	deviceId: number(),
-	eventId: string()
-}), object({
-	base64: string(),
-	contentType: string()
-}).nullable()), method(object({
-	deviceId: number(),
-	eventId: string()
-}), string().nullable());
 var IdentitySchema = object({
 	id: string(),
 	name: string(),
@@ -31528,143 +31183,6 @@ var motionTriggerCapability = {
 	durability: "session"
 };
 /**
-* camera-grid-layout — the geometry of a COMPOSITE camera, on the camera's own
-* page.
-*
-* ## Why this is a capability and not an addon settings schema
-*
-* It was one, and it did not render. The addon declared the editor as a
-* `type: 'widget'` field inside its own `deviceSettingsSchema()`; the hub
-* returned that section correctly and `ConfigFormField` renders `type:'widget'`
-* perfectly well — and nothing ever asked camera-grid for it. The Cluster →
-* Pipeline → Device Overrides page interrogates a HAND-WRITTEN list of four
-* addons (`PIPELINE_CLUSTER_DEVICE_ADDONS`), whose own comment says an addon
-* not on it "falls off silently".
-*
-* Adding a fifth name to that list would have been the wrong fix twice over:
-* that page is per-camera DETECTION tuning, and a grid's geometry belongs
-* beside PTZ and motion zones on the camera itself. The device page is
-* BINDING-driven (D12), so the way in is a capability bound to the device —
-* and this cap carries its section the way `recording` does, by RETURNING it
-* from `getDeviceSettingsContribution`.
-*
-* Seven other widgets are still declared the other way, through a
-* `deviceConfig.ui` block the framework derives a section from. That route
-* gives the addon no say in where its own panel lands and no way to decline
-* for a device the panel does not suit, which is why this one does not use it.
-*
-* ## Why one addon may implement it
-*
-* It is a device-scoped NATIVE cap, registered by the grid camera device
-* itself. Nothing else declares a composite camera, so nothing else has a
-* layout — and the device-scoped route means the widget asks THE camera, not
-* "the camera-grid addon", which is what let the old custom-action pair be
-* reached only by a caller that already knew the addon id.
-*
-* ## The tab
-*
-* `streaming`, not a top-tab of its own. A grid's geometry IS what its stream
-* is, so the Streaming tab is where it belongs; a `grid` top-tab would need an
-* entry in `WELL_KNOWN_TAB_MAP` or the device page renders the raw id as the
-* label (measured on the robot camera, 2026-09-06 — a tab called "navigation"
-* next to "PTZ").
-*/
-/** A rectangle in normalized [0,1] coordinates of whatever contains it. */
-var GridNormalizedRectSchema = object({
-	x: number().min(0).max(1),
-	y: number().min(0).max(1),
-	width: number().gt(0).max(1),
-	height: number().gt(0).max(1)
-});
-/**
-* One source camera, the part of its picture taken, and where that part lands.
-*
-* Both rectangles are NORMALIZED (D519): a source camera can change resolution
-* — a profile switch, a firmware update, a substream that comes back different
-* — and a stored PIXEL rectangle would quietly start cutting the wrong region,
-* which is the class of bug nobody files.
-*/
-var GridLayoutCellSchema = object({
-	deviceId: number().int().positive(),
-	/** The part of the SOURCE taken, normalized against the source. */
-	source: GridNormalizedRectSchema,
-	/** Where it lands, normalized against the CANVAS. */
-	cell: GridNormalizedRectSchema
-});
-/**
-* Which profiles this grid can actually compose, and why not.
-*
-* A grid's `high` composes its sources' `high` and its `low` their `low`, so a
-* profile is on offer only when EVERY source can serve it. The refusal NAMES
-* the sources, because "this grid has no low" is not a finding — "615 has no
-* low" is, and it is the one an operator can act on.
-*/
-var GridProfileOfferSchema = object({
-	profile: _enum([
-		"high",
-		"mid",
-		"low"
-	]),
-	offered: boolean(),
-	/** Sources that cannot serve it. Empty when it is offered, or when there are no cells. */
-	missingSources: array(number().int().positive()),
-	/**
-	* The canvas this profile composes onto, `WxH`, or empty when it is not
-	* offered. DERIVED from the cells and the sources' own size at this profile —
-	* it is reported because nothing else in the system would ever say what the
-	* grid came out as, and because it is the number an operator would otherwise
-	* expect to type.
-	*/
-	canvas: string(),
-	/**
-	* Whether this profile is PUBLISHED, of the ones the grid could serve.
-	*
-	* A grid's `high` is composed of its sources' `high`, so on a 4K fleet it is
-	* a 4K canvas built from 4K decodes — something to opt into, not something a
-	* viewer's adaptive should be handed by climbing to the top rung it can see.
-	* Default is `mid` + `low`.
-	*/
-	published: boolean()
-});
-var GridLayoutViewSchema = object({
-	/** The persisted grid row this camera was declared from. */
-	instanceId: string(),
-	deviceId: number().int().nonnegative(),
-	name: string(),
-	/**
-	* NO canvas size. A grid's resolution is not authored: each profile derives
-	* its own from the cells and its sources' dimensions. The two numbers that
-	* used to be here were a text field that silently decided both how much the
-	* composite cost and how sharp it was — see `profiles[].canvas` for what it
-	* came out as.
-	*/
-	fps: number().int(),
-	cells: array(GridLayoutCellSchema),
-	/** What the catalog will publish, and what it refuses to. Read-only. */
-	profiles: array(GridProfileOfferSchema)
-});
-var GridLayoutPatchSchema = object({
-	deviceId: number().int().nonnegative(),
-	name: string().min(1).max(160).optional(),
-	fps: number().int().min(1).max(60).optional(),
-	/** Which profiles to publish. See `GridProfileOffer.published`. */
-	publishedProfiles: array(_enum([
-		"high",
-		"mid",
-		"low"
-	])).max(3).optional(),
-	/**
-	* The whole cell list at once. A per-cell patch would need an ordering the
-	* editor does not have, and a half-applied layout is a picture nobody asked
-	* for.
-	*/
-	cells: array(GridLayoutCellSchema).max(16)
-});
-DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), GridLayoutViewSchema.nullable(), { auth: "admin" }), method(GridLayoutPatchSchema, GridLayoutViewSchema, {
-	kind: "mutation",
-	auth: "admin"
-});
-/**
 * Motion-zones share the same MaskShape vocabulary as privacy-mask — the
 * on-camera motion-detection mask is a single `grid` region (a row-major
 * boolean cell lattice the camera's onboard VMD evaluates). Composing it as
@@ -34184,37 +33702,37 @@ var rebootCapability = {
 		auth: "admin"
 	}) }
 };
-/**
-* `recording` cap — footage availability + HLS playback manifests + per-device
-* recording config. NOTE on events (source of truth, R5/C3): this cap carries
-* NO event surface — `getPlaybackManifest` returns playlist URLs only. Timeline
-* events (motion/object/audio) come from `pipelineAnalytics` (durable SQLite
-* rows) and are the ONLY event surface — the recorder has none. The in-RAM
-* playback markers it used to build were deleted on 2026-08-29 because nothing
-* ever read them. Event<->footage joins are by time, padded with the shared
-* `EVENT_PAD_MS` (`interfaces/recording-config.ts`).
-*/
-var RecordingStatusSchema = object({
-	deviceId: number(),
-	enabled: boolean(),
-	/** THE derived storage mode, from the one definition
-	*  (`deriveRecordingMode`) — never a second enum. A duplicated list is how
-	*  `on-device-decision` could have reached the recorder and not the status. */
-	activeMode: RecordingStorageModeSchema,
-	nodeId: string(),
-	storageBytes: number()
-});
 var RecordingRangeSchema = object({
 	profile: string(),
 	startMs: number(),
 	endMs: number()
 });
+/**
+* How a source ANSWERED, on every singular read of this cap.
+*
+* `'read'` — it looked. `ranges: []` / `days: []` is then a real claim: this
+* source has no coverage in the window. `'unreadable'` — nobody could look
+* (the camera was unreachable, the calendar rung threw, the location is
+* unmounted, the node is still on the old build), and the emptiness beside it
+* means NOTHING.
+*
+* The batch rows have carried this since the grid existed; the SINGULAR
+* answers gained it with the collection (D625 §10.4), because they are the
+* ones the single-camera picker uses and because a half-converted fleet makes
+* "nobody looked" common for the length of a deploy. Without it the timeline
+* has no vocabulary for it, and `(data ?? [])` in a viewer turns a rollout into
+* a fleet of cameras that appear to have lost their recordings (D315, D393).
+*/
+var RecordingReadSchema = _enum(["read", "unreadable"]);
 var RecordingAvailabilitySchema = object({
 	deviceId: number(),
+	/** See {@link RecordingReadSchema}. An `'unreadable'` answer carries an empty
+	*  `ranges` that means nothing — never draw it as "no footage". */
+	read: RecordingReadSchema,
 	ranges: array(RecordingRangeSchema),
 	/**
-	* Every profile this camera has footage in — not only the one `ranges`
-	* describes (D433).
+	* Every profile this camera has footage in AT THIS SOURCE — not only the one
+	* `ranges` describes (D433).
 	*
 	* `ranges` answers for ONE profile by design: the timeline is a single bar,
 	* and enumerating all of them triples the directory reads for a bar that
@@ -34231,15 +33749,285 @@ var RecordingAvailabilitySchema = object({
 });
 var RecordingDaysSchema = object({
 	deviceId: number(),
+	/** See {@link RecordingReadSchema}. `days: []` on an `'unreadable'` answer is
+	*  "nobody could look", and the date-picker must not spell it the same as
+	*  "no footage this month". */
+	read: RecordingReadSchema,
 	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
 	days: array(number())
 });
+var RecordingManifestSchema = object({
+	deviceId: number(),
+	/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
+	localMasterPath: string().nullable(),
+	/** HTTP(S) URL to the master playlist on the recording node's playback server
+	*  (the PRIMARY candidate); null when no recording / server. Carries the
+	*  scoped playback token in its path. */
+	playbackUrl: string().nullable(),
+	/**
+	* Candidate master-playlist URLs the client tries in order (LAN first, then
+	* remote — Tailscale/Cloudflare if the operator configured extra hosts), each
+	* carrying the same scoped token. `playbackUrl` is the first entry. Empty when
+	* there is no recording / server.
+	*/
+	playbackEndpoints: array(string())
+});
+var RecordingSourceAvailabilitySchema = object({
+	state: _enum([
+		"ok",
+		"sleeping",
+		"unreachable",
+		"no-storage",
+		"index-empty"
+	]),
+	/** Free text, shown verbatim. Names the camera's own refusal when there is one. */
+	reason: string().optional(),
+	/** When this source's coverage was last CONFIRMED. A cached answer is never
+	*  drawn as current: the surface shows the age whenever it is older than the
+	*  refresh interval. The clip catalog's `catalogAsOf`, under the name the
+	*  timeline uses for it. */
+	coverageAsOf: number().optional()
+});
+/**
+* One SOURCE of recorded coverage for a camera — a row of the picker.
+*
+* A provider lists the sources IT serves for that device, and answers for each
+* of them whether it can answer at all. A provider with nothing to offer on a
+* camera returns `[]` — it is not that camera's business. The five availability
+* states are `ClipSourceAvailability`'s verbatim: they mean exactly the same
+* things about a coverage index as about a clip catalog, and `sleeping` in
+* particular is what stops a battery camera being woken to paint a bar.
+*/
+var RecordingSourceSchema = object({
+	/** The source id. {@link RECORDING_SOURCE_CAMSTACK} for ours (RESERVED), a
+	*  vendor namespace (`native:reolink:onboard`, …) for a camera's own store. */
+	source: string(),
+	/** Operator-facing name of the source ("CamStack recordings", "SD card"). */
+	label: string(),
+	/**
+	* The addon that SERVES this row, and the value a later call passes as
+	* `provider`.
+	*
+	* 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 (D557 §4).
+	*/
+	addonId: string().optional(),
+	availability: RecordingSourceAvailabilitySchema
+});
+/**
+* What a surface may DRAW for this (camera, source) — D612's rule applied to a
+* timeline: **the source declares what it can do, and the surface draws what
+* was declared. It never assumes, and never offers a gesture it will then
+* refuse.** D612 exists because `8` and `16` were offered as clip rates, the
+* broker clamped them to `4`, and no line anywhere said so.
+*
+* Asked once per (camera, source) before anything is drawn — never replaced by
+* a constant the surface keeps, which is the second authority D612 ends.
+*/
+var RecordingSourceOptionsSchema = object({
+	/** How this source's media reaches the player.
+	*  `archive` = our own indexed segment tree; `stream` = the provider's
+	*  forward-only fMP4 (D597); `realtime` = a replay bound to wall clock. */
+	transport: _enum([
+		"archive",
+		"stream",
+		"realtime"
+	]),
+	/** What the BAR means. `continuous` = gaps are holes in a recording;
+	*  `sparse` = gaps are the absence of one, and must be drawn as such.
+	*
+	*  Not an onboard-only concession: measured 2026-09-24, OUR bar covers 98.8 %
+	*  of 592's day and 1.2 % of 1436's. It is a fact about a (source, camera)
+	*  pair, and ours answers it per camera from `deriveRecordingMode`. */
+	coverage: _enum(["continuous", "sparse"]),
+	/** Where the playhead may be put.
+	*  `free`    — anywhere, to the frame.
+	*  `forward` — only ahead of the current position.
+	*  `segment` — a position SNAPS to the head of the covering segment; a finer
+	*              ask is accepted by the camera and SILENTLY IGNORED. Measured
+	*              on 1436 (Hikvision V5.7.1, 2026-09-23): a window-narrowed
+	*              `ContentMgmt/search` returns a row and a `playbackURI`, the
+	*              replay opens 200 and delivers media — and the burned-in OSD of
+	*              the first frame reads the SEGMENT HEAD every time. Calling
+	*              that `forward` would tell the surface it may move the playhead
+	*              ahead within a loaded segment, which it may not. */
+	seek: _enum([
+		"free",
+		"forward",
+		"segment"
+	]),
+	/** Frame-step BACKWARD is meaningful. */
+	stepBack: boolean(),
+	/** Whether the drag-scrub gesture is served, as opposed to refused by name. */
+	scrub: boolean(),
+	/** Deliverable rates, ascending, always containing `1`. The surface draws its
+	*  picker from this and from NOTHING else (D612, D620, D621). `0` is not a
+	*  member: pause is the absence of a rate. */
+	rates: array(number().positive()).min(1).readonly(),
+	/** TRUE when a read of this source HOLDS the camera's only playback session.
+	*  A surface with this set makes at most ONE read at a time and draws no
+	*  scrub-thumbnail strip, no hover preview, no prefetch and no background
+	*  refresh. The precedent is exact and expensive: filling one screen of
+	*  Hikvision thumbnails at 1.01× realtime consumed fifteen minutes of that
+	*  camera's only playback session (1.2.126, reported within minutes), and a
+	*  timeline is a screenful of reads by construction. */
+	exclusive: boolean()
+});
+/**
+* How to PLAY the instant that was asked for, from the chosen source.
+*
+* No new media transport is built for onboard sources: the `clip` arm is a
+* DELEGATION to the `videoclips` transport that vendor already has (D597 /
+* D616 / D617). The onboard half of this collection is a PROJECTION of
+* `videoclips` for coverage and a delegation to it for bytes.
+*/
+var RecordingPlaybackSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("hls"),
+		manifest: RecordingManifestSchema
+	}),
+	object({
+		kind: literal("clip"),
+		/** The `videoclips` source namespace this clip id belongs to. */
+		source: string(),
+		clipId: string(),
+		/** Where this clip actually STARTS. On a `seek: 'segment'` source the
+		*  playhead lands here, not at the requested instant — the surface must be
+		*  TOLD, not left to discover it from a burned-in OSD. */
+		startsAtMs: number()
+	}),
+	object({
+		kind: literal("none"),
+		reason: string()
+	})
+]);
+DeviceType.Camera, method(object({ deviceId: number() }), array(RecordingSourceSchema).readonly(), {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	/**
+	* WHICH provider to ask — the `addonId` a {@link RecordingSourceSchema}
+	* row carries, never a source id and never a list. **REQUIRED**, in the
+	* schema, where the generated types make it unomittable rather than
+	* merely discouraged (D554 amended).
+	*
+	* It was learned the expensive way on `videoclips.listClips`: 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 — `device-collection-dispatch.ts`
+	* leaves an unpinned fan-out un-narrowed, so absence buys the union the
+	* method exists not to be. An un-narrowed `getAvailability` would do
+	* that to a TIMELINE: our ranges and the card's clips unioned into one
+	* bar, which is "two sources are never drawn together" broken in the
+	* one place it matters most.
+	*
+	* A provider the device is not bound to is refused BY NAME (D552's
+	* `rejectUnresolvedAddonPin`), never answered by another one.
+	*/
+	provider: string().min(1),
+	fromMs: number(),
+	toMs: number(),
+	/**
+	* Answer for THIS profile instead of the source's preferred one (D433).
+	* Absent keeps the timeline's behaviour — one bar, one profile, one set
+	* of reads. `profilesWithFootage` on the answer says what may be asked
+	* for.
+	*/
+	profile: string().optional()
+}), RecordingAvailabilitySchema, {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	provider: string().min(1),
+	fromMs: number(),
+	toMs: number(),
+	tzOffsetMinutes: number()
+}), RecordingDaysSchema, {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	provider: string().min(1),
+	fromMs: number(),
+	toMs: number(),
+	profile: CamProfileSchema.optional()
+}), RecordingPlaybackSchema, {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	provider: string().min(1)
+}), RecordingSourceOptionsSchema, {
+	kind: "query",
+	auth: "protected"
+});
+/**
+* `recording-archive` — OUR archive, and the intent that fills it.
+*
+* The system-singleton half of the 2026-09-24 cut (D625). `recording` used to
+* be one 33-method system singleton holding two unrelated subjects: three
+* per-camera READS about coverage and playback, and everything else — storage
+* locations, retention, relocation, rebalance, the ops log, the placement
+* table and the byte-plane primitives our scrub and export are built on.
+*
+* The reads became a device-scoped COLLECTION, so a camera's own card can be a
+* source beside ours (`recording.cap.ts`). Everything that is about OUR store,
+* or unimplementable by a camera, stayed here.
+*
+* ## On the name
+*
+* `recording-storage` was the obvious choice and is wrong: this cap also holds
+* `getDeviceConfig`/`setDeviceConfig`, which are recording INTENT — bands,
+* retention, the D62 switch authority — and a name that says "storage" invites
+* the next reader to move them out again. An archive is a thing we keep, and
+* what we keep it under is a policy; the name covers both halves honestly and
+* sits in the existing family (`recording-onboard`, `recording-export`,
+* `recording-signal`).
+*
+* ## What must NOT happen to it
+*
+* It stays a SINGLETON. It is registered by `recorder`, which is
+* `placement: 'any-node'` and runs on every recording node; the hub dispatches
+* to one of them. Putting the ledger, the placement table or the relocation
+* jobs behind a fan-out is the one genuinely dangerous move in this cut.
+*
+* `getDeviceConfig` / `setDeviceConfig` in particular are the D62 recording
+* authority (`CameraSwitch.authority`). If a write reached a different provider
+* than the read — which a collection fan-out permits — two authorities would
+* decide when one camera records, and the symptom (recording silently off, or
+* a `bands` array clobbered by a partial write) is durable and silent. Keeping
+* them here means the worst case during a rollout is a 412: the switch refuses
+* to flip and SAYS so. **Do not move them into the collection, at any point,
+* for any reason.**
+*
+* ## The two batch reads
+*
+* `getAvailabilityBatch` / `getDaysWithRecordingsBatch` take `deviceIds:
+* number[]` with no single `deviceId`, and a device-scoped mount routes
+* through `getProviderForDevice(deviceId)` — there is nothing for it to route
+* on. They stay here, and on this cap the batch is explicitly OURS: a grid has
+* no per-camera picker, and a caller that wants another source's coverage asks
+* `recording.getAvailability` per device with that source's `provider`.
+*/
+var RecordingStatusSchema = object({
+	deviceId: number(),
+	enabled: boolean(),
+	/** THE derived storage mode, from the one definition
+	*  (`deriveRecordingMode`) — never a second enum. A duplicated list is how
+	*  `on-device-decision` could have reached the recorder and not the status. */
+	activeMode: RecordingStorageModeSchema,
+	nodeId: string(),
+	storageBytes: number()
+});
 /**
 * One camera's row in a `getAvailabilityBatch` answer.
 *
-* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
-* batch collapses the transport, not the work — plus the one thing the singular
-* method never had to say:
+* `ranges` is EXACTLY what `recording.getAvailability` returns for that camera
+* at OUR source — the batch collapses the transport, not the work — plus the
+* `read` mark the singular answer now carries too (D625):
 *
 *  - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
 *    no footage in the window", which is a real claim.
@@ -34271,22 +34059,6 @@ var RecordingDaysForDeviceSchema = object({
 	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
 	days: array(number()).readonly()
 });
-var RecordingManifestSchema = object({
-	deviceId: number(),
-	/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
-	localMasterPath: string().nullable(),
-	/** HTTP(S) URL to the master playlist on the recording node's playback server
-	*  (the PRIMARY candidate); null when no recording / server. Carries the
-	*  scoped playback token in its path. */
-	playbackUrl: string().nullable(),
-	/**
-	* Candidate master-playlist URLs the client tries in order (LAN first, then
-	* remote — Tailscale/Cloudflare if the operator configured extra hosts), each
-	* carrying the same scoped token. `playbackUrl` is the first entry. Empty when
-	* there is no recording / server.
-	*/
-	playbackEndpoints: array(string())
-});
 /**
 * Recording storage usage for one camera — what the ARCHIVE holds for it,
 * across every profile and every resolvable location on this node.
@@ -34545,34 +34317,12 @@ var ReadWindowBytesResultSchema = discriminatedUnion("kind", [object({
 	segmentEndMs: number()
 })]);
 method(object({
-	deviceId: number(),
-	fromMs: number(),
-	toMs: number(),
-	/**
-	* Answer for THIS profile instead of the preferred one (D433). Absent
-	* keeps the timeline's behaviour — one bar, one profile, one set of
-	* reads. `profilesWithFootage` on the answer says what may be asked
-	* for.
-	*/
-	profile: string().optional()
-}), RecordingAvailabilitySchema, {
-	kind: "query",
-	auth: "protected"
-}), method(object({
 	deviceIds: array(number()).min(1).max(200),
 	fromMs: number(),
 	toMs: number()
 }), array(RecordingAvailabilityForDeviceSchema).readonly(), {
 	kind: "query",
 	auth: "protected"
-}), method(object({
-	deviceId: number(),
-	fromMs: number(),
-	toMs: number(),
-	tzOffsetMinutes: number()
-}), RecordingDaysSchema, {
-	kind: "query",
-	auth: "protected"
 }), method(object({
 	deviceIds: array(number()).min(1).max(200),
 	fromMs: number(),
@@ -34581,13 +34331,6 @@ method(object({
 }), array(RecordingDaysForDeviceSchema).readonly(), {
 	kind: "query",
 	auth: "protected"
-}), method(object({
-	deviceId: number(),
-	fromMs: number(),
-	toMs: number()
-}), RecordingManifestSchema, {
-	kind: "query",
-	auth: "protected"
 }), method(object({}), RecordingStorageUsageSchema, {
 	kind: "query",
 	auth: "admin"
@@ -35039,6 +34782,511 @@ method(object({
 	auth: "protected"
 });
 /**
+* Vendor-neutral **onboard** recording + storage cap — what the CAMERA
+* writes to the CAMERA's own card, on the camera's own schedule.
+*
+* This is NOT `recording.cap.ts`. That one is CamStack's recorder: our
+* footage ledger, our storage locations, our retention. This one has a
+* different authority — the camera's firmware — and per D62 it stores
+* nothing of its own. Every value here is read from the camera and every
+* write goes back to the camera; there is no CamStack-side mirror that
+* could disagree with the device.
+*
+* ## One shape, two firmwares
+*
+* Measured 2026-09-22 against the live fleet:
+*
+* | fact | Hikvision (ISAPI) | Reolink (Baichuan) |
+* | --- | --- | --- |
+* | storage | `ContentMgmt/Storage` `<hdd>` rows: status, capacity, freeSpace (MB) | `getHddInfoList` (cmd 102): `mount`, `format`, `capacity` GB + `capacityM` MB remainder |
+* | tracks | several (101 **and** 103 on both 1436 and 3833), each with its own schedule | one per channel |
+* | schedule | per track, 7 `ScheduleAction` blocks: DayOfWeek + TimeOfDay range + ONE `ActionRecordingMode` | per trigger type, a 168-char weekly HOUR mask |
+* | triggers | `CMR`, `MOTION` | `Normal`, `MD`, `people`, `vehicle`, `dog_cat`, `crossline`, `intrude`, `loitering` |
+* | pre-record | `PreRecordTimeSeconds` | `preRecordTime` |
+* | post-record | `PostRecordTimeSeconds` | `recordDelayTime` |
+* | overwrite | per track `LoopEnable` | `cycle`, with `cycleList` enumerating the accepted values |
+* | segment length | not exposed on V5.7.1 | `packageTime` (minutes) |
+*
+* The two schedule models look different and are the same thing in
+* different coordinates: both answer "for this trigger, during which
+* weekly windows does the camera record". {@link RecordWindow} is that
+* question in one shape — Hikvision's ranges map straight onto it,
+* Reolink's mask expands into hour-aligned windows.
+*
+* ## Union, not intersection
+*
+* **The same fields exist on every camera.** What differs per device is
+* which VALUES that device accepts, and that is what {@link
+* RecordingOnboardOptions} reports — a `{ readable, writable, reason }`
+* per field plus the schedule's own limits. A control a camera cannot
+* honour is rendered DISABLED WITH ITS REASON, never missing and never
+* dead: disabled must not look like broken.
+*
+* ## Refusal by name
+*
+* A write a camera cannot honour is refused with a sentence the operator
+* can read — never accepted and dropped. Both providers refuse through
+* {@link describeOnboardRefusal}, so the vocabulary is one function and
+* one test, not two hand-written vendor opinions.
+*
+* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+* `getOptions` advertises per-camera availability, `getStatus` (auto-
+* injected from `status`) reports the live values, and a single
+* `setSettings` mutation applies a partial change. No hand-written
+* settings-contribution methods.
+*/
+/**
+* What makes the camera start recording during a window.
+*
+* The union of both vendors' vocabularies. `continuous` is Hikvision's
+* `CMR` and Reolink's `Normal`; `motion` is `MOTION` / `MD`. The
+* object-class triggers are Reolink-only today and the smart-event ones
+* (`lineCrossing`, `intrusion`, `loitering`) are Reolink-only on the
+* firmwares measured — a camera that cannot record on a trigger simply
+* does not list it in `options.schedule.triggers`, and a window naming
+* it is REFUSED, not dropped.
+*/
+var RecordTriggerSchema = _enum([
+	"continuous",
+	"motion",
+	"person",
+	"vehicle",
+	"animal",
+	"lineCrossing",
+	"intrusion",
+	"loitering",
+	"alarmInput"
+]);
+/**
+* One weekly recording window: "on `day`, from `startMinute` to
+* `endMinute`, record on `trigger`".
+*
+* `day` is 0 = Monday … 6 = Sunday (ISO order, which is also the order
+* both firmwares enumerate). Minutes are local camera time since
+* midnight; `endMinute` may be 1440, meaning end of day — that is
+* Hikvision's literal `24:00` and Reolink's 24th mask slot, and
+* collapsing it to 0 would turn a whole-day window into an empty one.
+*/
+var RecordWindowSchema = object({
+	trigger: RecordTriggerSchema,
+	day: number().int().min(0).max(6),
+	startMinute: number().int().min(0).max(1439),
+	endMinute: number().int().min(1).max(1440)
+});
+/** Status of one physical volume, as the camera itself describes it. */
+var OnboardStorageVolumeSchema = object({
+	/** The camera's own id for the volume (`hdd/id`, Reolink `HddInfo/number`). */
+	id: string(),
+	/** The camera's own name for it, when it gives one (`hddName`). */
+	label: string().optional(),
+	status: _enum([
+		"ok",
+		"unformatted",
+		"error",
+		"offline",
+		"unknown"
+	]),
+	/**
+	* Total size in MB, or **null when the camera did not say**.
+	*
+	* Never 0 for an unreadable value: a measurement that failed is not a
+	* measurement (D393), and a card whose size is unknown must not be
+	* rendered as a card of size zero.
+	*/
+	capacityMb: number().nullable(),
+	/**
+	* Free space in MB, or null when unknown.
+	*
+	* **Not a proxy for "has footage".** Measured 2026-09-22: 1436 and
+	* 1439 both report exactly 11776 MB free — the fixed reserve a looping
+	* card converges on once it has wrapped. At loop steady state the
+	* number is identical whether the camera recorded yesterday or stopped
+	* a month ago.
+	*/
+	freeMb: number().nullable(),
+	/** True when the camera reports the volume writable (`property` RW). */
+	writable: boolean().optional()
+});
+/**
+* What the camera is doing with its own storage, right now.
+*
+* Every scalar is nullable and **null means the camera did not answer**,
+* never a default. A form that seeds `0` from an unanswered read invites
+* the operator to save that 0 back onto the camera.
+*/
+var RecordingOnboardStatusSchema = object({
+	storage: discriminatedUnion("kind", [
+		object({
+			kind: literal("present"),
+			volumes: array(OnboardStorageVolumeSchema)
+		}),
+		object({
+			kind: literal("absent"),
+			reason: string()
+		}),
+		object({
+			kind: literal("unknown"),
+			reason: string()
+		})
+	]),
+	tracks: array(object({
+		id: string(),
+		enabled: boolean(),
+		isVideo: boolean(),
+		/** From the camera's own track description. Null when it does not say. */
+		codec: string().nullable(),
+		resolution: string().nullable(),
+		/** Per-track overwrite flag, where the firmware keeps it per track. */
+		overwriteWhenFull: boolean().nullable()
+	})),
+	/**
+	* The track the write path targets — the enabled VIDEO one. Null when
+	* no track could be identified, which is itself a refusal reason.
+	*/
+	primaryTrackId: string().nullable(),
+	/** Master "record to the card at all" switch. */
+	enabled: boolean().nullable(),
+	overwriteWhenFull: boolean().nullable(),
+	preRecordSec: number().nullable(),
+	postRecordSec: number().nullable(),
+	/** Length of one recorded file, in minutes. */
+	segmentMinutes: number().nullable(),
+	/** The primary track's weekly windows, flattened. */
+	windows: array(RecordWindowSchema),
+	/**
+	* How many windows the camera described that CamStack could NOT read —
+	* an unrecognised trigger, an unparseable clock, a weekday it does not
+	* name.
+	*
+	* A dropped window is work the reader threw away, and a schedule that
+	* silently shows fewer rows than the camera holds is how an operator
+	* saves back a schedule shorter than the one they were looking at
+	* (D391). Non-zero means the window list is INCOMPLETE and a write
+	* that replaces it would delete what was not shown — which is why a
+	* provider reporting a non-zero count also reports the schedule as not
+	* writable.
+	*/
+	unreadableWindows: number(),
+	/**
+	* The camera is scheduled to record and has NO usable storage.
+	*
+	* A first-class fact because it is the fleet's most common silent
+	* defect: measured 2026-09-22, 1441 and 3831 are both motion-recording
+	* to a card that is not there. Neither the schedule nor the storage
+	* read says anything wrong on its own; only the pair does.
+	*/
+	recordingToNowhere: boolean(),
+	lastFetchedAt: number()
+});
+/** Numeric range descriptor — `{ min, max, step }` per the getOptions convention. */
+var RangeSchema = object({
+	min: number(),
+	max: number(),
+	step: number()
+});
+/**
+* The values a camera actually takes for a numeric field, when they are a SET
+* rather than a range.
+*
+* `{min,max,step}` cannot say what these two firmwares do. Measured on 1436
+* (I91DN) on 2026-09-22 by writing each value and reading it back:
+*
+* - pre-record: `0, 5, 10, 15, 20, 25, 30` and `2147483647` (INT32_MAX, the
+*   camera's "no limit" — `-1` and `4294967295` both land on it);
+* - post-record: `5, 10, 30, 60, 120, 300, 600`.
+*
+* Neither is expressible as a step: the first has a sentinel two billion away
+* from its neighbours, the second doubles and then jumps. A range that tried
+* would forbid values the camera takes AND permit values it silently replaces
+* with 5 — wrong in both directions at once.
+*
+* `sentinel` names the member that is not a duration, so a surface can render
+* "no limit" instead of `2147483647` seconds.
+*/
+var AllowedValuesSchema = object({
+	values: array(number()).min(1),
+	sentinel: object({
+		value: number(),
+		meaning: _enum(["no-limit", "disabled"])
+	}).optional()
+});
+/**
+* Per-field availability on ONE camera.
+*
+* The field exists on every camera — this says whether this one can be
+* read and whether it can be written, and `reason` says why not when
+* either is false. The UI renders the control DISABLED with the reason
+* rather than hiding it, so a limitation is legible instead of looking
+* like a missing feature.
+*/
+var OnboardFieldSupportSchema = object({
+	readable: boolean(),
+	writable: boolean(),
+	/** Required whenever `readable` or `writable` is false. */
+	reason: string().optional()
+});
+/** What this camera's schedule model can express. */
+var OnboardScheduleSupportSchema = object({
+	support: OnboardFieldSupportSchema,
+	/**
+	* The smallest time step the camera can express, in minutes.
+	*
+	* Hikvision takes arbitrary minutes (`00:05:00`–`23:57:00` observed on
+	* 1436's track 103). Reolink's schedule is a 7×24 HOUR mask, so 60. A
+	* window whose edges are not a multiple of this is REFUSED rather than
+	* quietly rounded — rounding is how an operator's 06:30 becomes 06:00
+	* and nothing says so.
+	*/
+	granularityMinutes: number(),
+	/** Triggers this camera can record on. A window naming another is refused. */
+	triggers: array(RecordTriggerSchema),
+	/**
+	* False when the camera stores ONE trigger per time range, so two
+	* windows overlapping on the same day cannot carry different triggers.
+	* True on Reolink, whose mask is per-trigger and independent.
+	*/
+	supportsOverlappingTriggers: boolean()
+});
+var RecordingOnboardOptionsSchema = object({
+	enabled: OnboardFieldSupportSchema,
+	overwriteWhenFull: OnboardFieldSupportSchema,
+	preRecordSec: OnboardFieldSupportSchema,
+	preRecordSecRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	preRecordSecAllowed: AllowedValuesSchema.optional(),
+	postRecordSec: OnboardFieldSupportSchema,
+	postRecordSecRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	postRecordSecAllowed: AllowedValuesSchema.optional(),
+	segmentMinutes: OnboardFieldSupportSchema,
+	segmentMinutesRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	segmentMinutesAllowed: AllowedValuesSchema.optional(),
+	schedule: OnboardScheduleSupportSchema
+});
+/**
+* A partial change. Every field optional.
+*
+* Unlike the other `deviceConfig` caps, a provider here does **NOT**
+* silently ignore a field it cannot support — it refuses, by name,
+* through {@link describeOnboardRefusal}. Silence on a recording setting
+* is the failure D62 exists to prevent: the operator believes the camera
+* is recording the way the form says, and it is not.
+*/
+var RecordingOnboardPatchSchema = object({
+	enabled: boolean().optional(),
+	overwriteWhenFull: boolean().optional(),
+	preRecordSec: number().optional(),
+	postRecordSec: number().optional(),
+	segmentMinutes: number().optional(),
+	/** The complete new window set for the primary track — not a delta. */
+	windows: array(RecordWindowSchema).optional()
+});
+var recordingOnboardCapability = {
+	name: "recording-onboard",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "derived-form",
+		builderId: "recording-onboard",
+		tab: "recording"
+	} },
+	methods: {
+		getOptions: method(object({ deviceId: number() }), RecordingOnboardOptionsSchema),
+		setSettings: method(object({
+			deviceId: number(),
+			settings: RecordingOnboardPatchSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: RecordingOnboardStatusSchema,
+		kind: "poll"
+	},
+	runtimeState: RecordingOnboardStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — operator-set camera-side
+	* recording config; mutation-driven, and the storage half is the last
+	* thing the camera said about its own card.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastFetchedAt"]
+};
+/**
+* Day-of-week names in the cap's index order (0 = Monday), for messages
+* an operator reads and for Hikvision's `<DayOfWeek>` element.
+*/
+var DAY_NAMES = [
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday",
+	"Sunday"
+];
+/**
+* Does `patch` ask this camera for something it cannot do?
+*
+* Returns the operator-readable reason, or `null` when every field in
+* the patch is within what `options` says this camera accepts. A
+* provider calls this BEFORE touching the camera and throws the string:
+* refusing is the point, and refusing identically on both vendors is why
+* this is one function.
+*
+* The order of checks is the order an operator would read them: the
+* scalar knobs first, then the schedule, because a schedule complaint is
+* longer and a scalar one is usually the real problem.
+*/
+function describeOnboardRefusal(options, patch) {
+	if (patch.enabled !== void 0 && !options.enabled.writable) return unwritable("the master recording switch", options.enabled.reason);
+	if (patch.overwriteWhenFull !== void 0 && !options.overwriteWhenFull.writable) return unwritable("overwrite-when-full", options.overwriteWhenFull.reason);
+	const preRefusal = refuseNumeric("pre-record seconds", patch.preRecordSec, options.preRecordSec, options.preRecordSecRange, options.preRecordSecAllowed);
+	if (preRefusal) return preRefusal;
+	const postRefusal = refuseNumeric("post-record seconds", patch.postRecordSec, options.postRecordSec, options.postRecordSecRange, options.postRecordSecAllowed);
+	if (postRefusal) return postRefusal;
+	const segmentRefusal = refuseNumeric("segment length (minutes)", patch.segmentMinutes, options.segmentMinutes, options.segmentMinutesRange, options.segmentMinutesAllowed);
+	if (segmentRefusal) return segmentRefusal;
+	if (patch.windows !== void 0) {
+		const scheduleRefusal = refuseSchedule(options, patch.windows);
+		if (scheduleRefusal) return scheduleRefusal;
+	}
+	return null;
+}
+function unwritable(what, reason) {
+	return reason ? `this camera cannot change ${what}: ${reason}` : `this camera cannot change ${what}`;
+}
+function refuseNumeric(what, value, support, range, allowed) {
+	if (value === void 0) return null;
+	if (!support.writable) return unwritable(what, support.reason);
+	if (!Number.isFinite(value)) return `${what} must be a number, got ${String(value)}`;
+	if (allowed) {
+		if (allowed.values.includes(value)) return null;
+		const say = (v) => allowed.sentinel !== void 0 && v === allowed.sentinel.value ? allowed.sentinel.meaning === "no-limit" ? "no limit" : "off" : String(v);
+		return `this camera accepts ${what} only as ${allowed.values.map(say).join(", ")}; ${say(value)} is not one of them`;
+	}
+	if (!range) return null;
+	if (value < range.min || value > range.max) return `this camera accepts ${what} between ${String(range.min)} and ${String(range.max)}; ${String(value)} is outside that`;
+	if (range.step > 0 && (value - range.min) % range.step !== 0) return `this camera accepts ${what} in steps of ${String(range.step)} from ${String(range.min)}; ${String(value)} is not one of them`;
+	return null;
+}
+function refuseSchedule(options, windows) {
+	const schedule = options.schedule;
+	if (!schedule.support.writable) return unwritable("the recording schedule", schedule.support.reason);
+	const allowed = new Set(schedule.triggers);
+	for (const window of windows) {
+		if (!allowed.has(window.trigger)) {
+			const offer = schedule.triggers.length > 0 ? schedule.triggers.join(", ") : "none";
+			return `this camera cannot record on "${window.trigger}"; it records on: ${offer}`;
+		}
+		if (window.endMinute <= window.startMinute) return `a window on ${dayName(window.day)} ends at or before it starts (${String(window.startMinute)} → ${String(window.endMinute)})`;
+		const step = schedule.granularityMinutes;
+		if (step > 1 && (window.startMinute % step !== 0 || window.endMinute % step !== 0)) return `this camera's schedule only moves in ${String(step)}-minute steps; the ${dayName(window.day)} window ${formatMinutes(window.startMinute)}–${formatMinutes(window.endMinute)} is not aligned to them`;
+	}
+	if (!schedule.supportsOverlappingTriggers) {
+		const clash = findOverlapWithDifferentTrigger(windows);
+		if (clash) return `this camera stores one trigger per time range, so "${clash.a.trigger}" and "${clash.b.trigger}" cannot both cover ${dayName(clash.a.day)} ${formatMinutes(Math.max(clash.a.startMinute, clash.b.startMinute))}–${formatMinutes(Math.min(clash.a.endMinute, clash.b.endMinute))}`;
+	}
+	return null;
+}
+function findOverlapWithDifferentTrigger(windows) {
+	for (let i = 0; i < windows.length; i += 1) for (let j = i + 1; j < windows.length; j += 1) {
+		const a = windows[i];
+		const b = windows[j];
+		if (!a || !b) continue;
+		if (a.day !== b.day) continue;
+		if (a.trigger === b.trigger) continue;
+		if (a.startMinute < b.endMinute && b.startMinute < a.endMinute) return {
+			a,
+			b
+		};
+	}
+	return null;
+}
+function dayName(day) {
+	return DAY_NAMES[day] ?? `day ${String(day)}`;
+}
+/** `510` → `08:30`. For messages, not for the wire. */
+function formatMinutes(minute) {
+	const hour = Math.floor(minute / 60);
+	const rest = minute % 60;
+	return `${String(hour).padStart(2, "0")}:${String(rest).padStart(2, "0")}`;
+}
+/**
+* Index of the mask character covering `day` at `hour`.
+*
+* **Layout: day-major, Monday first** — `day * 24 + hour`.
+*
+* This is an ASSUMPTION, and it is recorded as one because the fleet
+* cannot currently confirm it: every `valueTable` on every Reolink
+* measured on 2026-09-22 is uniform (all `1` or all `0`), and a uniform
+* mask reads identically under either layout. To settle it, set a single
+* hour on one day from the Reolink app and re-read `getRecordSchedule`.
+* Until then, a NON-uniform mask is reported as windows under this
+* layout and the day labels may be transposed; a uniform one is exact.
+*/
+function weeklyMaskIndex(day, hour) {
+	return day * 24 + hour;
+}
+/**
+* Expand one trigger's weekly hour mask into windows, merging adjacent
+* set hours into one window per run so a full day is ONE window rather
+* than twenty-four.
+*
+* A mask of the wrong length yields no windows: a truncated table is not
+* a schedule of fewer days, it is an answer we did not understand.
+*/
+function weeklyMaskToWindows(mask, trigger) {
+	if (mask.length !== 168) return [];
+	const out = [];
+	for (let day = 0; day < 7; day += 1) {
+		let runStart = null;
+		for (let hour = 0; hour <= 24; hour += 1) {
+			const set = hour < 24 && mask[weeklyMaskIndex(day, hour)] === "1";
+			if (set && runStart === null) runStart = hour;
+			else if (!set && runStart !== null) {
+				out.push({
+					trigger,
+					day,
+					startMinute: runStart * 60,
+					endMinute: hour * 60
+				});
+				runStart = null;
+			}
+		}
+	}
+	return out;
+}
+/**
+* Collapse this trigger's windows back into a weekly hour mask.
+*
+* Windows for other triggers are ignored — the mask is per trigger. A
+* window that is not hour-aligned is REFUSED upstream by
+* {@link describeOnboardRefusal}; this function rounds nothing, it
+* simply sets every hour the window fully or partly covers, so a caller
+* that skipped the refusal cannot silently lose coverage.
+*/
+function windowsToWeeklyMask(windows, trigger) {
+	const slots = new Array(168).fill("0");
+	for (const window of windows) {
+		if (window.trigger !== trigger) continue;
+		if (window.day < 0 || window.day >= 7) continue;
+		const firstHour = Math.floor(window.startMinute / 60);
+		const lastHour = Math.ceil(window.endMinute / 60);
+		for (let hour = firstHour; hour < lastHour && hour < 24; hour += 1) slots[weeklyMaskIndex(window.day, hour)] = "1";
+	}
+	return slots.join("");
+}
+/**
 * A camera's own "record me NOW" LEVEL — a signal the device raises while
 * something it knows about is happening (a robot vacuum cleaning, a machine
 * running, a gate open) and lowers when it stops.
@@ -42875,24 +43123,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"events.getEventClipUrl": {
-		capName: "events",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
-	"events.getEvents": {
-		capName: "events",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
-	"events.getEventThumbnail": {
-		capName: "events",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
 	"faceGallery.assignFace": {
 		capName: "face-gallery",
 		capScope: "system",
@@ -45767,224 +45997,236 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"recording.applyDeviceSettingsPatch": {
+	"recording.getAvailability": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
-	"recording.cancelRelocateJob": {
+	"recording.getDaysWithRecordings": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
-	"recording.cancelStorageMigrationMove": {
+	"recording.getPlayback": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
-	"recording.deleteFootprint": {
+	"recording.getPlaybackOptions": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
-		access: "delete"
+		access: "view"
 	},
-	"recording.getAvailability": {
+	"recording.listSources": {
 		capName: "recording",
-		capScope: "system",
+		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getAvailabilityBatch": {
-		capName: "recording",
+	"recordingArchive.applyDeviceSettingsPatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
-		access: "view"
+		access: "create"
 	},
-	"recording.getDaysWithRecordings": {
-		capName: "recording",
+	"recordingArchive.cancelRelocateJob": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
-		access: "view"
+		access: "create"
 	},
-	"recording.getDaysWithRecordingsBatch": {
-		capName: "recording",
+	"recordingArchive.cancelStorageMigrationMove": {
+		capName: "recording-archive",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"recordingArchive.deleteFootprint": {
+		capName: "recording-archive",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"recordingArchive.getAvailabilityBatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDeviceConfig": {
-		capName: "recording",
+	"recordingArchive.getDaysWithRecordingsBatch": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDeviceLiveContribution": {
-		capName: "recording",
+	"recordingArchive.getDeviceConfig": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getDeviceSettingsContribution": {
-		capName: "recording",
+	"recordingArchive.getDeviceLiveContribution": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getPlacement": {
-		capName: "recording",
+	"recordingArchive.getDeviceSettingsContribution": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getPlaybackManifest": {
-		capName: "recording",
+	"recordingArchive.getPlacement": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getRelocateResidue": {
-		capName: "recording",
+	"recordingArchive.getRelocateResidue": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getStatus": {
-		capName: "recording",
+	"recordingArchive.getStatus": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getStorageMigrationMoveStatus": {
-		capName: "recording",
+	"recordingArchive.getStorageMigrationMoveStatus": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.getStorageUsage": {
-		capName: "recording",
+	"recordingArchive.getStorageUsage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.listOpsLog": {
-		capName: "recording",
+	"recordingArchive.listOpsLog": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.listRelocateJobs": {
-		capName: "recording",
+	"recordingArchive.listRelocateJobs": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.locateSegment": {
-		capName: "recording",
+	"recordingArchive.locateSegment": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.pauseForStorageMigration": {
-		capName: "recording",
+	"recordingArchive.pauseForStorageMigration": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.planStorageRebalance": {
-		capName: "recording",
+	"recordingArchive.planStorageRebalance": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.pruneFootage": {
-		capName: "recording",
+	"recordingArchive.pruneFootage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.readGopBytes": {
-		capName: "recording",
+	"recordingArchive.readGopBytes": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.readSegmentBytes": {
-		capName: "recording",
+	"recordingArchive.readSegmentBytes": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.readWindowBytes": {
-		capName: "recording",
+	"recordingArchive.readWindowBytes": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"recording.reconcileLedgerAgainstDisk": {
-		capName: "recording",
+	"recordingArchive.reconcileLedgerAgainstDisk": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.refreshStorageLocationsForMigration": {
-		capName: "recording",
+	"recordingArchive.refreshStorageLocationsForMigration": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.relocateFootage": {
-		capName: "recording",
+	"recordingArchive.relocateFootage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.renderClip": {
-		capName: "recording",
+	"recordingArchive.renderClip": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.renderGif": {
-		capName: "recording",
+	"recordingArchive.renderGif": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.rescanStorage": {
-		capName: "recording",
+	"recordingArchive.rescanStorage": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.resumeForStorageMigration": {
-		capName: "recording",
+	"recordingArchive.resumeForStorageMigration": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.setDeviceConfig": {
-		capName: "recording",
+	"recordingArchive.setDeviceConfig": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.setDevicePlacement": {
-		capName: "recording",
+	"recordingArchive.setDevicePlacement": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.startStorageMigrationMove": {
-		capName: "recording",
+	"recordingArchive.startStorageMigrationMove": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"recording.startStorageRebalance": {
-		capName: "recording",
+	"recordingArchive.startStorageRebalance": {
+		capName: "recording-archive",
 		capScope: "system",
 		addonId: null,
 		access: "create"
@@ -48289,21 +48531,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"events.getEventClipUrl": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"events.getEvents": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"events.getEventThumbnail": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"faceGallery.getFaceByTrack": [{
 		name: "deviceId",
 		form: "single",
@@ -49222,107 +49449,117 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"recording.deleteFootprint": [{
+	"recording.getAvailability": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getAvailability": [{
+	"recording.getDaysWithRecordings": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getAvailabilityBatch": [{
-		name: "deviceIds",
-		form: "array",
+	"recording.getPlayback": [{
+		name: "deviceId",
+		form: "single",
 		optional: false
 	}],
-	"recording.getDaysWithRecordings": [{
+	"recording.getPlaybackOptions": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getDaysWithRecordingsBatch": [{
-		name: "deviceIds",
-		form: "array",
+	"recording.listSources": [{
+		name: "deviceId",
+		form: "single",
 		optional: false
 	}],
-	"recording.getDeviceConfig": [{
+	"recordingArchive.deleteFootprint": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.getPlaybackManifest": [{
+	"recordingArchive.getAvailabilityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"recordingArchive.getDaysWithRecordingsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"recordingArchive.getDeviceConfig": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.listOpsLog": [{
+	"recordingArchive.listOpsLog": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
 	}],
-	"recording.locateSegment": [{
+	"recordingArchive.locateSegment": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.pruneFootage": [{
+	"recordingArchive.pruneFootage": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.readGopBytes": [{
+	"recordingArchive.readGopBytes": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.readSegmentBytes": [{
+	"recordingArchive.readSegmentBytes": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.readWindowBytes": [{
+	"recordingArchive.readWindowBytes": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.reconcileLedgerAgainstDisk": [{
+	"recordingArchive.reconcileLedgerAgainstDisk": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
 	}],
-	"recording.relocateFootage": [{
+	"recordingArchive.relocateFootage": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
 	}],
-	"recording.renderClip": [{
+	"recordingArchive.renderClip": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.renderGif": [{
+	"recordingArchive.renderGif": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.rescanStorage": [{
+	"recordingArchive.rescanStorage": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.setDeviceConfig": [{
+	"recordingArchive.setDeviceConfig": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.setDevicePlacement": [{
+	"recordingArchive.setDevicePlacement": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"recording.startStorageMigrationMove": [{
+	"recordingArchive.startStorageMigrationMove": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
@@ -72916,7 +73153,7 @@ var require_yazl = /* @__PURE__ */ require_chunk.__commonJSMin(((exports) => {
 	}
 }));
 //#endregion
-//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-E2N7WTCC.js
+//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-AQQAL7CF.js
 var import_undici = require_undici();
 var import_yazl = /* @__PURE__ */ require_chunk.__toESM(require_yazl(), 1);
 var formatterCache = /* @__PURE__ */ new Map();
@@ -74262,13 +74499,13 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 				sec: 59
 			};
 		}
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Date conversion: start=${start.toISOString()} -> ReolinkTime=${JSON.stringify(startTime)}, end=${end.toISOString()} -> ReolinkTime=${JSON.stringify(endTime)}`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Date conversion: start=${start.toISOString()} -> ReolinkTime=${JSON.stringify(startTime)}, end=${end.toISOString()} -> ReolinkTime=${JSON.stringify(endTime)}`);
 		if (!bypassCache) {
 			this.cleanRecordingsCache();
 			const cacheKey = this.getNvrRecordingsCacheKey(channel, startTime, endTime, streamType, iLogicChannel, autoSearchByDay);
 			const cached = this.recordingsCache.get(cacheKey);
 			if (cached && cached.expiresAt > Date.now()) {
-				require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Cache hit: returning ${cached.data.length} cached enriched recordings`);
+				require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Cache hit: returning ${cached.data.length} cached enriched recordings`);
 				return cached.data;
 			}
 		}
@@ -74320,7 +74557,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 							const firstResult = dayResponse[0];
 							if (firstResult && firstResult.code === 0 && firstResult.value?.SearchResult?.File) {
 								const files = firstResult.value.SearchResult.File;
-								if (files.length > 0 && files[0]) require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Raw API response for day ${day}/${month}/${year}: ${JSON.stringify({
+								if (files.length > 0 && files[0]) require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Raw API response for day ${day}/${month}/${year}: ${JSON.stringify({
 									fileCount: files.length,
 									sampleFile: {
 										name: files[0].name,
@@ -74356,7 +74593,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 					} catch (e) {}
 					enriched2.push(this.enrichVodFile(vodFile, channel, streamUrl));
 				}
-				require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Returning ${enriched2.length} enriched recording files from autoSearchByDay`);
+				require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Returning ${enriched2.length} enriched recording files from autoSearchByDay`);
 				if (!bypassCache) {
 					const cacheKey = this.getNvrRecordingsCacheKey(channel, startTime, endTime, streamType, iLogicChannel, autoSearchByDay);
 					this.recordingsCache.set(cacheKey, {
@@ -74384,7 +74621,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 			const response = await this.call("Search", param, 0);
 			allResults.push(...response);
 		} else {
-			require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Range spans ${dayRanges.length} days, splitting into separate day queries`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Range spans ${dayRanges.length} days, splitting into separate day queries`);
 			for (const range of dayRanges) {
 				const param = { Search: {
 					channel,
@@ -74394,7 +74631,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 					EndTime: range.end
 				} };
 				if (iLogicChannel > 0) param.Search.iLogicChannel = iLogicChannel;
-				require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Querying day: ${range.start.year}-${range.start.mon}-${range.start.day} (${range.start.hour}:${range.start.min}:${range.start.sec} to ${range.end.hour}:${range.end.min}:${range.end.sec})`);
+				require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Querying day: ${range.start.year}-${range.start.mon}-${range.start.day} (${range.start.hour}:${range.start.min}:${range.start.sec} to ${range.end.hour}:${range.end.min}:${range.end.sec})`);
 				const response = await this.call("Search", param, 0);
 				allResults.push(...response);
 			}
@@ -74404,7 +74641,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 			const firstResult = result[0];
 			if (firstResult && firstResult.code === 0 && firstResult.value?.SearchResult?.File) {
 				const files = firstResult.value.SearchResult.File;
-				if (files.length > 0 && files[0]) require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Raw API response (normal search): ${JSON.stringify({
+				if (files.length > 0 && files[0]) require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Raw API response (normal search): ${JSON.stringify({
 					fileCount: files.length,
 					sampleFile: {
 						name: files[0].name,
@@ -74421,12 +74658,12 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 			const searchResult = res.value?.SearchResult;
 			if (searchResult?.File) allFiles.push(...searchResult.File);
 		}
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Collected ${allFiles.length} raw VodFiles from API search results`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Collected ${allFiles.length} raw VodFiles from API search results`);
 		if (allFiles.length > 0) {
 			const sampleSize = Math.min(3, allFiles.length);
 			for (let i = 0; i < sampleSize; i++) {
 				const file = allFiles[i];
-				if (file) require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Sample file ${i + 1}/${allFiles.length}: ${JSON.stringify({
+				if (file) require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Sample file ${i + 1}/${allFiles.length}: ${JSON.stringify({
 					name: file.name,
 					type: file.type,
 					size: file.size,
@@ -74449,7 +74686,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 			} catch (e) {}
 			enriched.push(this.enrichVodFile(vodFile, channel, streamUrl));
 		}
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Returning ${enriched.length} enriched recording files`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclips", `Returning ${enriched.length} enriched recording files`);
 		if (!bypassCache) {
 			const cacheKey = this.getNvrRecordingsCacheKey(channel, startTime, endTime, streamType, iLogicChannel, autoSearchByDay);
 			this.recordingsCache.set(cacheKey, {
@@ -74486,7 +74723,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 			prepare: true,
 			seek: seekSeconds
 		});
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclipThumbnailJpeg", `Extracting thumbnail from VOD URL (FLV): ${vodUrl.substring(0, 100)}... (seek=${seekSeconds}s)`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclipThumbnailJpeg", `Extracting thumbnail from VOD URL (FLV): ${vodUrl.substring(0, 100)}... (seek=${seekSeconds}s)`);
 		const { spawn: spawn2 } = await import("child_process");
 		return new Promise((resolve, reject) => {
 			const chunks = [];
@@ -74534,7 +74771,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 						reject(/* @__PURE__ */ new Error(`ffmpeg produced too small output: ${jpeg.length} bytes`));
 						return;
 					}
-					require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclipThumbnailJpeg", `Successfully extracted thumbnail: ${jpeg.length} bytes`);
+					require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "getVideoclipThumbnailJpeg", `Successfully extracted thumbnail: ${jpeg.length} bytes`);
 					resolve(jpeg);
 				} else reject(/* @__PURE__ */ new Error(`ffmpeg exited with code ${code}: ${stderr.slice(-500)}`));
 			});
@@ -74583,10 +74820,10 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 				}
 			} }
 		}];
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "prepareNvrVodDownload", `Request body: ${JSON.stringify(body)}`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "prepareNvrVodDownload", `Request body: ${JSON.stringify(body)}`);
 		try {
 			const response = await this.callMany(body);
-			require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "prepareNvrVodDownload", `Response: ${JSON.stringify(response)}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "prepareNvrVodDownload", `Response: ${JSON.stringify(response)}`);
 			const first = response[0];
 			if (!first || first.code !== 0 || !first.value?.fileList) {
 				const rspCode = first?.error?.rspCode;
@@ -74607,7 +74844,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 			if (!filename) throw new Error(`NvrDownload: no files found in response`);
 			return filename;
 		} catch (error) {
-			require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "prepareNvrVodDownload", `Error: ${error instanceof Error ? error.message : String(error)}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "prepareNvrVodDownload", `Error: ${error instanceof Error ? error.message : String(error)}`);
 			throw error;
 		}
 	}
@@ -74803,7 +75040,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 	* Convert a VodFile to RecordingFile with parsed metadata.
 	*/
 	enrichVodFile(vodFile, channel, streamUrl) {
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `RAW VodFile from API: ${JSON.stringify({
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `RAW VodFile from API: ${JSON.stringify({
 			name: vodFile.name,
 			type: vodFile.type,
 			size: vodFile.size,
@@ -74856,7 +75093,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 				hashBits0to15: hashRevBin.slice(0, 16)
 			};
 		}
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Parsed filename: ${JSON.stringify({
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Parsed filename: ${JSON.stringify({
 			fileName: vodFile.name,
 			filenameParts,
 			hexValueFromFilename,
@@ -74883,13 +75120,13 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 		const hexFlags = parsed?.flags;
 		if (parsed?.devType === "hub" && parsed?.version === 4) {
 			if (hexValueFromFilename && hexValueFromFilename !== "unknown") {
-				require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `WARNING: Hub v4 hex value "${hexValueFromFilename}" appears to be constant across files. Detection flags are likely NOT encoded in filename for this version. Detection information may need to be retrieved via a separate API call or may not be available.`);
-				require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `NOTE: For Hub v4, the API response only provides 'type' field which is "${vodFile.type}". No detection-specific fields are available in the Search API response.`);
+				require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `WARNING: Hub v4 hex value "${hexValueFromFilename}" appears to be constant across files. Detection flags are likely NOT encoded in filename for this version. Detection information may need to be retrieved via a separate API call or may not be available.`);
+				require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `NOTE: For Hub v4, the API response only provides 'type' field which is "${vodFile.type}". No detection-specific fields are available in the Search API response.`);
 			}
 		}
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Hex flags from filename: ${JSON.stringify(hexFlags)}`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Hex flags from filename: ${JSON.stringify(hexFlags)}`);
 		const typeFlags = this.parseRecordTypeFlags(vodFile.type);
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Type flags from recordType "${vodFile.type}": ${JSON.stringify(typeFlags)}`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Type flags from recordType "${vodFile.type}": ${JSON.stringify(typeFlags)}`);
 		const hasPerson = (hexFlags?.aiPerson ?? false) || typeFlags.hasPerson;
 		const hasVehicle = (hexFlags?.aiVehicle ?? false) || typeFlags.hasVehicle;
 		const hasAnimal = (hexFlags?.aiAnimal ?? false) || typeFlags.hasAnimal;
@@ -74900,7 +75137,7 @@ var ReolinkCgiApi = class _ReolinkCgiApi {
 		const hasPackage = (hexFlags?.package ?? false) || typeFlags.hasPackage;
 		const hasRf = (hexFlags?.rf ?? false) || typeFlags.hasRf;
 		const hasOther = (hexFlags?.aiOther ?? false) || typeFlags.hasOther;
-		require_chunk_OSVYEFMM.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Final merged flags: ${JSON.stringify({
+		require_chunk_XAKOGDFB.recordingsTraceLog(this.debugConfig, this.logger, "enrichVodFile", `Final merged flags: ${JSON.stringify({
 			hasPerson,
 			hasVehicle,
 			hasAnimal,
@@ -75306,8 +75543,8 @@ function nowIsoCompact() {
 	return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function nalTypesSummary(videoType, accessUnitAnnexB) {
-	if (videoType === "H264") return require_chunk_OSVYEFMM.splitAnnexBToNalPayloads(accessUnitAnnexB).map((n) => (n[0] ?? 0) & 31);
-	return require_chunk_OSVYEFMM.splitAnnexBToNalPayloads2(accessUnitAnnexB).map((nal) => require_chunk_OSVYEFMM.getH265NalType(nal)).filter((t) => typeof t === "number");
+	if (videoType === "H264") return require_chunk_XAKOGDFB.splitAnnexBToNalPayloads(accessUnitAnnexB).map((n) => (n[0] ?? 0) & 31);
+	return require_chunk_XAKOGDFB.splitAnnexBToNalPayloads2(accessUnitAnnexB).map((nal) => require_chunk_XAKOGDFB.getH265NalType(nal)).filter((t) => typeof t === "number");
 }
 function normalizeProfiles(p) {
 	const out = [];
@@ -75747,7 +75984,7 @@ async function sampleStreams(opts) {
 				});
 			};
 			api.client.on("frame", onFrame);
-			const videoStream = new require_chunk_OSVYEFMM.BaichuanVideoStream({
+			const videoStream = new require_chunk_XAKOGDFB.BaichuanVideoStream({
 				client: api.client,
 				api,
 				channel,
@@ -76797,7 +77034,7 @@ async function runMultifocalDiagnosticsConsecutively(params) {
 		let audioFrames = 0;
 		let lastSnapshotAtMs = 0;
 		const client = params.api.client;
-		const videoStream = new require_chunk_OSVYEFMM.BaichuanVideoStream({
+		const videoStream = new require_chunk_XAKOGDFB.BaichuanVideoStream({
 			client,
 			channel: chNative,
 			profile,
@@ -76881,7 +77118,7 @@ async function runMultifocalDiagnosticsConsecutively(params) {
 		const baseStreamName = profile === "main" ? "mainStream" : profile === "sub" ? "subStream" : "externStream";
 		const headerStreamTypeCandidates = profile === "sub" ? [1, 3] : profile === "main" ? [0, 2] : [0];
 		const channelIdTagCandidates = uniq([chNative, chNative + 1].filter((n) => Number.isFinite(n) && n >= 0));
-		const messageClassCandidates = params.probeFull ? [require_chunk_OSVYEFMM.BC_CLASS_MODERN_24, 0] : [require_chunk_OSVYEFMM.BC_CLASS_MODERN_24];
+		const messageClassCandidates = params.probeFull ? [require_chunk_XAKOGDFB.BC_CLASS_MODERN_24, 0] : [require_chunk_XAKOGDFB.BC_CLASS_MODERN_24];
 		const extensionXmlCandidates = params.probeFull ? ["", buildChannelExtensionXml(chNative)] : [buildChannelExtensionXml(chNative)];
 		const attempts = [];
 		for (const messageClass of messageClassCandidates) for (const streamTypeHeader of headerStreamTypeCandidates) for (const extensionXml of extensionXmlCandidates) {
@@ -79402,14 +79639,21 @@ var require_lz4 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports) => {
 	};
 }));
 //#endregion
-//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-7B2Z5FIA.js
+//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-OXQH2ZT3.js
 var import_fxp = require_fxp();
 var import_lz4 = /* @__PURE__ */ require_chunk.__toESM(require_lz4(), 1);
+function bcHeaderLen(messageClass, buf, bodyLen) {
+	if (require_chunk_XAKOGDFB.bcHeaderHasPayloadOffset(messageClass)) return 24;
+	if (require_chunk_XAKOGDFB.bcHeaderIsKnown20(messageClass)) return 20;
+	if (buf.length < 24) throw new Error("not enough data for Baichuan header (needs 24 bytes)");
+	const candidate = buf.readUInt32LE(20);
+	return candidate >= 20 && candidate <= bodyLen ? 24 : 20;
+}
 function encodeHeader(h) {
-	const hasOffset = require_chunk_OSVYEFMM.bcHeaderHasPayloadOffset(h.messageClass);
+	const hasOffset = require_chunk_XAKOGDFB.bcHeaderHasPayloadOffset(h.messageClass);
 	const headerLen = hasOffset ? 24 : 20;
 	const buf = Buffer.alloc(headerLen);
-	const magic = h.magic ?? require_chunk_OSVYEFMM.BC_MAGIC;
+	const magic = h.magic ?? require_chunk_XAKOGDFB.BC_MAGIC;
 	if (magic.length !== 4) throw new Error("magic must be 4 bytes");
 	magic.copy(buf, 0);
 	buf.writeUInt32LE(h.cmdId >>> 0, 4);
@@ -79425,7 +79669,7 @@ function encodeHeader(h) {
 function decodeHeader(buf) {
 	if (buf.length < 20) throw new Error("not enough data for Baichuan header");
 	const magic = buf.subarray(0, 4);
-	if (!magic.equals(require_chunk_OSVYEFMM.BC_MAGIC) && !magic.equals(require_chunk_OSVYEFMM.BC_MAGIC_REV)) throw new Error(`invalid Baichuan magic: ${magic.toString("hex")}`);
+	if (!magic.equals(require_chunk_XAKOGDFB.BC_MAGIC) && !magic.equals(require_chunk_XAKOGDFB.BC_MAGIC_REV)) throw new Error(`invalid Baichuan magic: ${magic.toString("hex")}`);
 	const cmdId = buf.readUInt32LE(4);
 	const bodyLen = buf.readUInt32LE(8);
 	const channelId = buf.readUInt8(12);
@@ -79433,7 +79677,7 @@ function decodeHeader(buf) {
 	const msgNum = buf.readUInt16LE(14);
 	const responseCode = buf.readUInt16LE(16);
 	const messageClass = buf.readUInt16LE(18);
-	const headerLen = require_chunk_OSVYEFMM.bcHeaderHasPayloadOffset(messageClass) ? 24 : 20;
+	const headerLen = bcHeaderLen(messageClass, buf, bodyLen);
 	if (buf.length < headerLen) throw new Error("not enough data for Baichuan header (needs 24 bytes)");
 	const messageKey = buf.readUInt32LE(12);
 	const header = {
@@ -79503,9 +79747,9 @@ var BaichuanFrameParser = class {
 				this.needed = 4;
 				break;
 			}
-			if (!this.buffer.subarray(0, 4).equals(require_chunk_OSVYEFMM.BC_MAGIC) && !this.buffer.subarray(0, 4).equals(require_chunk_OSVYEFMM.BC_MAGIC_REV)) {
-				const idx = this.buffer.indexOf(require_chunk_OSVYEFMM.BC_MAGIC);
-				const idxRev = this.buffer.indexOf(require_chunk_OSVYEFMM.BC_MAGIC_REV);
+			if (!this.buffer.subarray(0, 4).equals(require_chunk_XAKOGDFB.BC_MAGIC) && !this.buffer.subarray(0, 4).equals(require_chunk_XAKOGDFB.BC_MAGIC_REV)) {
+				const idx = this.buffer.indexOf(require_chunk_XAKOGDFB.BC_MAGIC);
+				const idxRev = this.buffer.indexOf(require_chunk_XAKOGDFB.BC_MAGIC_REV);
 				const next = idx === -1 ? idxRev : idxRev === -1 ? idx : Math.min(idx, idxRev);
 				if (next === -1) {
 					this.buffer = this.buffer.subarray(Math.max(0, this.buffer.length - 3));
@@ -81366,6 +81610,9 @@ function createDebugGateLogger(base, enabled = false) {
 function isTalkCmd(cmdId) {
 	return cmdId === 10 || cmdId === 11 || cmdId === 201 || cmdId === 202;
 }
+function toWireChannelId(channelId) {
+	return channelId & 255;
+}
 var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 	/**
 	* Process-wide streaming activity registry.
@@ -81531,7 +81778,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 	constructor(options) {
 		super();
 		this.opts = options;
-		this.debugCfg = require_chunk_OSVYEFMM.normalizeDebugOptions(options.debugOptions);
+		this.debugCfg = require_chunk_XAKOGDFB.normalizeDebugOptions(options.debugOptions);
 		this.logger = createDebugGateLogger(options.logger, this.debugCfg.general || this.debugCfg.traceNativeStream || this.debugCfg.traceRecordings || this.debugCfg.traceTalk || this.debugCfg.traceEvents || this.debugCfg.debugRtsp);
 		this.on("error", (err) => {
 			this.logFixed("error", {
@@ -82013,7 +82260,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			streamType: 0,
 			msgNum,
 			responseCode: 0,
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			payloadOffset: 0
 		});
 		this.logDebug("udp_keepalive_ping_tx", {
@@ -82045,7 +82292,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 				cmdId: 93,
 				channel: this.opts.channel ?? 0,
 				channelIdOverride: 0,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				streamType: 0,
 				extensionXml: "",
 				internal: true
@@ -82384,7 +82631,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 				cmdId: 2,
 				payloadXml: logoutXml,
 				extensionXml: "",
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				channelIdOverride: effectiveHostChannelId,
 				timeoutMs: 5e3
 			})).header.responseCode;
@@ -82497,12 +82744,12 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			};
 			s.frames++;
 			if (now - s.lastLogMs >= 1e3) {
-				require_chunk_OSVYEFMM.debugLog(this.debugCfg, this.logger, "BaichuanRx", `rx cmdId=3 frames=${s.frames} lastMsgNum=${frame.header.msgNum} lastResponseCode=${frame.header.responseCode} lastChannelId=${frame.header.channelId} lastStreamType=${frame.header.streamType} lastBodyLen=${frame.body.length} lastPayloadLen=${frame.payload.length}`);
+				require_chunk_XAKOGDFB.debugLog(this.debugCfg, this.logger, "BaichuanRx", `rx cmdId=3 frames=${s.frames} lastMsgNum=${frame.header.msgNum} lastResponseCode=${frame.header.responseCode} lastChannelId=${frame.header.channelId} lastStreamType=${frame.header.streamType} lastBodyLen=${frame.body.length} lastPayloadLen=${frame.payload.length}`);
 				s.lastLogMs = now;
 				s.frames = 0;
 			}
 			this.rxCmdTraceStats.set(3, s);
-		} else require_chunk_OSVYEFMM.debugLog(this.debugCfg, this.logger, "BaichuanRx", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} streamType=${frame.header.streamType} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
+		} else require_chunk_XAKOGDFB.debugLog(this.debugCfg, this.logger, "BaichuanRx", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} streamType=${frame.header.streamType} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
 		if (this.transport === "udp" && frame.header.cmdId === 234) {
 			try {
 				const header = encodeHeader({
@@ -82539,7 +82786,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			}
 			return;
 		}
-		if (this.debugCfg.traceTalk && isTalkCmd(frame.header.cmdId)) require_chunk_OSVYEFMM.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
+		if (this.debugCfg.traceTalk && isTalkCmd(frame.header.cmdId)) require_chunk_XAKOGDFB.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
 		this.emit("frame", frame);
 		const key = `${frame.header.cmdId}:${frame.header.msgNum}`;
 		const pending = this.pending.get(key);
@@ -82560,7 +82807,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 					};
 					s.frames++;
 					if (now2 - s.lastLogMs >= 500) {
-						require_chunk_OSVYEFMM.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `rx stream frames cmdId=3 msgNum=${frame.header.msgNum} frames=${s.frames} lastChannelId=${frame.header.channelId} lastBodyLen=${frame.body.length} lastPayloadLen=${frame.payload.length} lastPayloadOffset=${frame.header.payloadOffset ?? 0}`);
+						require_chunk_XAKOGDFB.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `rx stream frames cmdId=3 msgNum=${frame.header.msgNum} frames=${s.frames} lastChannelId=${frame.header.channelId} lastBodyLen=${frame.body.length} lastPayloadLen=${frame.payload.length} lastPayloadOffset=${frame.header.payloadOffset ?? 0}`);
 						s.lastLogMs = now2;
 						s.frames = 0;
 					}
@@ -82591,7 +82838,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			const eventLogTag = sid ? `BaichuanEvent sid=${sid}` : "BaichuanEvent";
 			const events$1 = this.parseEvents(frame);
 			for (const event of events$1) {
-				require_chunk_OSVYEFMM.eventTraceLog(this.debugCfg, this.logger, eventLogTag, `dispatch cmdId=33 msgNum=${frame.header.msgNum} channelId=${frame.header.channelId} type=${event.type} eventChannel=${event.channel}` + (event.type === "ai" ? ` aiType=${event.ai?.type ?? "unknown"} detected=${event.ai?.detected ?? ""}` : "") + (event.type === "motion" ? ` source=${event.motion?.source ?? ""}` : ""));
+				require_chunk_XAKOGDFB.eventTraceLog(this.debugCfg, this.logger, eventLogTag, `dispatch cmdId=33 msgNum=${frame.header.msgNum} channelId=${frame.header.channelId} type=${event.type} eventChannel=${event.channel}` + (event.type === "ai" ? ` aiType=${event.ai?.type ?? "unknown"} detected=${event.ai?.detected ?? ""}` : "") + (event.type === "motion" ? ` source=${event.motion?.source ?? ""}` : ""));
 				this.emit("event", event);
 			}
 		} catch (error) {
@@ -82650,7 +82897,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 		if (!xml || !xml.startsWith("<?xml")) return [];
 		if (this.debugCfg.traceEvents) {
 			const snippet = xml.length > 500 ? `${xml.slice(0, 500)}...` : xml;
-			require_chunk_OSVYEFMM.eventTraceLog(this.debugCfg, this.logger, eventRawLogTag, `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} xml=${JSON.stringify(snippet)}`);
+			require_chunk_XAKOGDFB.eventTraceLog(this.debugCfg, this.logger, eventRawLogTag, `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} xml=${JSON.stringify(snippet)}`);
 		}
 		const fallbackChannelId = frame.header.channelId;
 		const fallbackChannel = fallbackChannelId === 250 ? 0 : Math.max(0, fallbackChannelId - 1);
@@ -82668,7 +82915,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 				const timeStampRaw2 = (getXmlText(alarmXml, "timeStamp") ?? getXmlText(alarmXml, "timestamp") ?? "").trim();
 				const timeStampNum2 = timeStampRaw2.length ? Number(timeStampRaw2) : void 0;
 				const alarmTimeStamp2 = Number.isFinite(timeStampNum2) ? timeStampNum2 : void 0;
-				if (this.debugCfg.traceEvents) require_chunk_OSVYEFMM.eventTraceLog(this.debugCfg, this.logger, eventRawLogTag, `AlarmEvent channel=${channel} status=${JSON.stringify(status2)} aiType=${JSON.stringify(aiTypeRaw2)}`);
+				if (this.debugCfg.traceEvents) require_chunk_XAKOGDFB.eventTraceLog(this.debugCfg, this.logger, eventRawLogTag, `AlarmEvent channel=${channel} status=${JSON.stringify(status2)} aiType=${JSON.stringify(aiTypeRaw2)}`);
 				const statusTokens2 = status2.toLowerCase().split(",").map((t) => t.trim()).filter((t) => t.length > 0);
 				const visitorActive2 = statusTokens2.includes("visitor");
 				const dayNightActive2 = statusTokens2.includes("dn") || statusTokens2.includes("daynight");
@@ -83022,15 +83269,15 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 		const extBuf = Buffer.from(extXml, "utf8");
 		const payloadBuf = Buffer.from(payloadXml, "utf8");
 		if (enc.kind === "none") return Buffer.concat([extBuf, payloadBuf]);
-		if (enc.kind === "bc") return Buffer.concat([require_chunk_OSVYEFMM.bcEncrypt(extBuf, channelId), require_chunk_OSVYEFMM.bcEncrypt(payloadBuf, channelId)]);
-		if (enc.kind === "aes" || enc.kind === "full_aes") return Buffer.concat([require_chunk_OSVYEFMM.aesEncrypt(extBuf, enc.key), require_chunk_OSVYEFMM.aesEncrypt(payloadBuf, enc.key)]);
+		if (enc.kind === "bc") return Buffer.concat([require_chunk_XAKOGDFB.bcEncrypt(extBuf, channelId), require_chunk_XAKOGDFB.bcEncrypt(payloadBuf, channelId)]);
+		if (enc.kind === "aes" || enc.kind === "full_aes") return Buffer.concat([require_chunk_XAKOGDFB.aesEncrypt(extBuf, enc.key), require_chunk_XAKOGDFB.aesEncrypt(payloadBuf, enc.key)]);
 		return Buffer.concat([extBuf, payloadBuf]);
 	}
 	encodeBodyBinary(extXml, payload, channelId, enc) {
 		const extBuf = Buffer.from(extXml, "utf8");
 		if (enc.kind === "none") return Buffer.concat([extBuf, payload]);
-		if (enc.kind === "bc") return Buffer.concat([require_chunk_OSVYEFMM.bcEncrypt(extBuf, channelId), payload]);
-		if (enc.kind === "aes" || enc.kind === "full_aes") return Buffer.concat([require_chunk_OSVYEFMM.aesEncrypt(extBuf, enc.key), payload]);
+		if (enc.kind === "bc") return Buffer.concat([require_chunk_XAKOGDFB.bcEncrypt(extBuf, channelId), payload]);
+		if (enc.kind === "aes" || enc.kind === "full_aes") return Buffer.concat([require_chunk_XAKOGDFB.aesEncrypt(extBuf, enc.key), payload]);
 		return Buffer.concat([extBuf, payload]);
 	}
 	/**
@@ -83075,7 +83322,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			bodyLen,
 			binaryPayload: true
 		});
-		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_OSVYEFMM.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset} binaryPayloadLen=${params.payload.length}`);
+		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_XAKOGDFB.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset} binaryPayloadLen=${params.payload.length}`);
 		this.recordTx({
 			cmdId,
 			responseCode: 0,
@@ -83092,8 +83339,8 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			let dec;
 			try {
 				if (enc.kind === "none") dec = buf;
-				else if (enc.kind === "bc") dec = require_chunk_OSVYEFMM.bcDecrypt(buf, channelId);
-				else dec = require_chunk_OSVYEFMM.aesDecrypt(buf, enc.key);
+				else if (enc.kind === "bc") dec = require_chunk_XAKOGDFB.bcDecrypt(buf, channelId);
+				else dec = require_chunk_XAKOGDFB.aesDecrypt(buf, enc.key);
 			} catch {
 				return;
 			}
@@ -83159,8 +83406,8 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			messageClass,
 			bodyLen
 		});
-		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_OSVYEFMM.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
-		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_OSVYEFMM.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
+		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_XAKOGDFB.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
+		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_XAKOGDFB.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
 		this.recordTx({
 			cmdId,
 			responseCode: 0,
@@ -83175,8 +83422,8 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			responseCode: frame.header.responseCode,
 			msgNum: frame.header.msgNum
 		});
-		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_OSVYEFMM.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
-		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_OSVYEFMM.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
+		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_XAKOGDFB.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
+		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_XAKOGDFB.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
 		if (frame.header.responseCode === 400) {
 			if (frame.body.length === 0) throw new Error("Baichuan authentication failed (responseCode 400, empty body) - check username/password");
 		}
@@ -83246,9 +83493,9 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			messageClass,
 			bodyLen
 		});
-		if (_BaichuanClient.recordingCmdIds.has(cmdId)) require_chunk_OSVYEFMM.recordingsTraceLog(this.debugCfg, this.logger, "BaichuanRecordings", `tx recording cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} bodyLen=${bodyLen}`);
-		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_OSVYEFMM.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
-		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_OSVYEFMM.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
+		if (_BaichuanClient.recordingCmdIds.has(cmdId)) require_chunk_XAKOGDFB.recordingsTraceLog(this.debugCfg, this.logger, "BaichuanRecordings", `tx recording cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} bodyLen=${bodyLen}`);
+		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_XAKOGDFB.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
+		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_XAKOGDFB.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `tx cmdId=${cmdId} msgNum=${msgNum} channelId=${channelId} streamType=${params.streamType ?? 0} class=0x${messageClass.toString(16)} bodyLen=${bodyLen} payloadOffset=${payloadOffset}`);
 		this.recordTx({
 			cmdId,
 			responseCode: 0,
@@ -83263,9 +83510,9 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			responseCode: frame.header.responseCode,
 			msgNum: frame.header.msgNum
 		});
-		if (_BaichuanClient.recordingCmdIds.has(frame.header.cmdId)) require_chunk_OSVYEFMM.recordingsTraceLog(this.debugCfg, this.logger, "BaichuanRecordings", `rx recording cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
-		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_OSVYEFMM.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
-		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_OSVYEFMM.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
+		if (_BaichuanClient.recordingCmdIds.has(frame.header.cmdId)) require_chunk_XAKOGDFB.recordingsTraceLog(this.debugCfg, this.logger, "BaichuanRecordings", `rx recording cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
+		if (this.debugCfg.traceNativeStream && (cmdId === 3 || cmdId === 4)) require_chunk_XAKOGDFB.traceLog(this.debugCfg, this.logger, "BaichuanTrace", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
+		if (this.debugCfg.traceTalk && isTalkCmd(cmdId)) require_chunk_XAKOGDFB.talkTraceLog(this.debugCfg, this.logger, "BaichuanTalk", `rx cmdId=${frame.header.cmdId} msgNum=${frame.header.msgNum} responseCode=${frame.header.responseCode} channelId=${frame.header.channelId} bodyLen=${frame.body.length} payloadLen=${frame.payload.length} payloadOffset=${frame.header.payloadOffset ?? 0}`);
 		if (!internal) this.kickIdleDisconnectTimer();
 		return frame;
 	}
@@ -83534,7 +83781,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 		await this.connect();
 		params.channel ?? this.opts.channel;
 		const sessionCounter = this.nextMsgNum();
-		const channelId = params.channelIdOverride ?? sessionCounter;
+		const channelId = toWireChannelId(params.channelIdOverride ?? sessionCounter);
 		const discriminator = params.channelIdOverride == null ? {
 			kind: "minted",
 			channelId
@@ -83651,25 +83898,25 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 					return;
 				}
 				if (lockedStreamType !== void 0 && frame.header.streamType !== lockedStreamType) return;
-				if (lockedChannelId !== void 0 && frame.header.channelId !== lockedChannelId) {
+				if (lockedChannelId !== void 0 && frame.header.channelId !== toWireChannelId(lockedChannelId)) {
 					this.countReplayDrop(session, frame, "foreign-channel");
 					return;
 				}
 				if (streamMsgNum !== void 0 && frame.header.msgNum !== streamMsgNum) return;
+				let markedBinary = false;
+				let encryptLen;
+				if (frame.extension.length > 0) try {
+					const extDec = this.tryDecryptXml(frame.extension, frame.header.channelId, enc);
+					if (extDec.includes("<binaryData>1</binaryData>")) markedBinary = true;
+					const encryptLenMatch = extDec.match(/<encryptLen>(\d+)<\/encryptLen>/i);
+					if (encryptLenMatch && encryptLenMatch[1]) encryptLen = parseInt(encryptLenMatch[1], 10);
+				} catch {}
 				const rc = frame.header.responseCode;
-				if (rc >= 400 && rc < 6e4 && frame.header.msgNum === msgNum) {
+				if (streamMsgNum === void 0 && !markedBinary && !(rc === 0 || rc === 200 || rc === 201) && frame.header.msgNum === msgNum) {
 					fail(/* @__PURE__ */ new Error(`Baichuan FileInfoList replay rejected (cmdId=${cmdId} reqChannelId=${channelId} rspChannelId=${frame.header.channelId} streamType=${expectedStreamType} msgNum=${frame.header.msgNum} responseCode=${rc})`));
 					return;
 				}
 				try {
-					let markedBinary = false;
-					let encryptLen;
-					if (frame.extension.length > 0) try {
-						const extDec = this.tryDecryptXml(frame.extension, frame.header.channelId, enc);
-						if (extDec.includes("<binaryData>1</binaryData>")) markedBinary = true;
-						const encryptLenMatch = extDec.match(/<encryptLen>(\d+)<\/encryptLen>/i);
-						if (encryptLenMatch && encryptLenMatch[1]) encryptLen = parseInt(encryptLenMatch[1], 10);
-					} catch {}
 					const decrypted = decryptBinaryForReplay(frame.payload, frame.header.channelId, encryptLen);
 					if (decrypted.length === 0) return;
 					if (!markedBinary && looksLikeXml(decrypted)) return;
@@ -83899,7 +84146,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 		await this.connect();
 		params.channel ?? this.opts.channel;
 		const sessionCounter = this.nextMsgNum();
-		const channelId = params.channelIdOverride ?? sessionCounter;
+		const channelId = toWireChannelId(params.channelIdOverride ?? sessionCounter);
 		const msgNum = params.msgNumOverride ?? 0;
 		const cmdId = params.cmdId;
 		const extXml = params.extensionXml ?? "";
@@ -84110,8 +84357,8 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 		const tryAs = (enc) => {
 			try {
 				if (enc.kind === "none") return buf;
-				if (enc.kind === "bc") return require_chunk_OSVYEFMM.bcDecrypt(buf, channelId);
-				if (enc.kind === "aes" || enc.kind === "full_aes") return require_chunk_OSVYEFMM.aesDecrypt(buf, enc.key);
+				if (enc.kind === "bc") return require_chunk_XAKOGDFB.bcDecrypt(buf, channelId);
+				if (enc.kind === "aes" || enc.kind === "full_aes") return require_chunk_XAKOGDFB.aesDecrypt(buf, enc.key);
 				return null;
 			} catch {
 				return null;
@@ -84141,7 +84388,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 				streamType: 0,
 				msgNum,
 				responseCode: encByte,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_LEGACY
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_LEGACY
 			});
 			const pendingKey = `${cmdId}:${msgNum}`;
 			const framePromise = new Promise((resolve, reject) => {
@@ -84173,15 +84420,15 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 			else if (encType === 1) this.enc = { kind: "bc" };
 			else if (encType === 2) this.enc = {
 				kind: "aes",
-				key: require_chunk_OSVYEFMM.deriveAesKey(nonce, this.opts.password)
+				key: require_chunk_XAKOGDFB.deriveAesKey(nonce, this.opts.password)
 			};
 			else if (encType === 18) this.enc = {
 				kind: "full_aes",
-				key: require_chunk_OSVYEFMM.deriveAesKey(nonce, this.opts.password)
+				key: require_chunk_XAKOGDFB.deriveAesKey(nonce, this.opts.password)
 			};
 			else throw new Error(`Baichuan login: unknown encType=0x${encType.toString(16)}`);
-			const userHash = require_chunk_OSVYEFMM.md5StrModern(`${this.opts.username}${nonce}`);
-			const passHash = require_chunk_OSVYEFMM.md5StrModern(`${this.opts.password}${nonce}`);
+			const userHash = require_chunk_XAKOGDFB.md5StrModern(`${this.opts.username}${nonce}`);
+			const passHash = require_chunk_XAKOGDFB.md5StrModern(`${this.opts.password}${nonce}`);
 			const loginXml = buildLoginXml(userHash, passHash);
 			this.logDebug("login_hash", {
 				username: this.opts.username,
@@ -84196,7 +84443,7 @@ var BaichuanClient = class _BaichuanClient extends events.EventEmitter {
 				cmdId: 1,
 				payloadXml: loginXml,
 				extensionXml: "",
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				channelIdOverride: effectiveHostChannelId,
 				encryption: loginEnc,
 				timeoutMs: 1e4
@@ -84256,7 +84503,7 @@ async function* createNativeStream(api, channel, profile, options) {
 			client = api.client;
 		}
 	}
-	const videoStream = new require_chunk_OSVYEFMM.BaichuanVideoStream({
+	const videoStream = new require_chunk_XAKOGDFB.BaichuanVideoStream({
 		client,
 		api,
 		channel,
@@ -84774,7 +85021,7 @@ var H264Flow = class extends BaseFlow {
 		super(transport, "H264");
 	}
 	extractParameterSets(accessUnitAnnexB) {
-		const nals = require_chunk_OSVYEFMM.splitAnnexBToNalPayloads(accessUnitAnnexB);
+		const nals = require_chunk_XAKOGDFB.splitAnnexBToNalPayloads(accessUnitAnnexB);
 		for (const nal of nals) {
 			if (nal.length < 1) continue;
 			const nalType = (nal[0] ?? 0) & 31;
@@ -84819,9 +85066,9 @@ var H265Flow = class extends BaseFlow {
 		super(transport, "H265");
 	}
 	extractParameterSets(accessUnitAnnexB) {
-		const vps = require_chunk_OSVYEFMM.extractVpsFromAnnexB(accessUnitAnnexB);
-		const sps = require_chunk_OSVYEFMM.extractSpsFromAnnexB(accessUnitAnnexB);
-		const pps = require_chunk_OSVYEFMM.extractPpsFromAnnexB(accessUnitAnnexB);
+		const vps = require_chunk_XAKOGDFB.extractVpsFromAnnexB(accessUnitAnnexB);
+		const sps = require_chunk_XAKOGDFB.extractSpsFromAnnexB(accessUnitAnnexB);
+		const pps = require_chunk_XAKOGDFB.extractPpsFromAnnexB(accessUnitAnnexB);
 		if (vps && !this.vps) this.vps = vps;
 		if (sps && !this.sps) this.sps = sps;
 		if (pps && !this.pps) this.pps = pps;
@@ -85205,8 +85452,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends events.EventEmitter {
 	/** Returns true if the raw (packed/Annex B) frame is an IDR (H.264) or IRAP (H.265). */
 	isRawFrameKeyframe(frame) {
 		try {
-			if (frame.videoType === "H264") return _BaichuanRtspServer.splitAnnexBNals(require_chunk_OSVYEFMM.convertToAnnexB(frame.data)).some((n) => n.length >= 1 && (n[0] & 31) === 5);
-			if (frame.videoType === "H265") return require_chunk_OSVYEFMM.splitAnnexBToNalPayloads2(require_chunk_OSVYEFMM.convertToAnnexB2(frame.data)).some((n) => n.length >= 2 && require_chunk_OSVYEFMM.isH265Irap(n[0] >> 1 & 63));
+			if (frame.videoType === "H264") return _BaichuanRtspServer.splitAnnexBNals(require_chunk_XAKOGDFB.convertToAnnexB(frame.data)).some((n) => n.length >= 1 && (n[0] & 31) === 5);
+			if (frame.videoType === "H265") return require_chunk_XAKOGDFB.splitAnnexBToNalPayloads2(require_chunk_XAKOGDFB.convertToAnnexB2(frame.data)).some((n) => n.length >= 2 && require_chunk_XAKOGDFB.isH265Irap(n[0] >> 1 & 63));
 		} catch {}
 		return false;
 	}
@@ -86106,13 +86353,13 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends events.EventEmitter {
 			if (resources?.rtpAudioTimestamp !== void 0) resources.rtpAudioTimestamp = resources.rtpAudioTimestamp + 1024 >>> 0;
 		};
 		const isH265IrapAccessUnit = (annexB) => {
-			const nals = require_chunk_OSVYEFMM.splitAnnexBToNalPayloads2(annexB);
+			const nals = require_chunk_XAKOGDFB.splitAnnexBToNalPayloads2(annexB);
 			for (const nal of nals) {
 				if (nal.length < 2) continue;
 				const b0 = nal[0];
 				if (b0 === void 0) continue;
 				if ((b0 & 128) !== 0) continue;
-				if (require_chunk_OSVYEFMM.isH265Irap(b0 >> 1 & 63)) return true;
+				if (require_chunk_XAKOGDFB.isH265Irap(b0 >> 1 & 63)) return true;
 			}
 			return false;
 		};
@@ -86268,7 +86515,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends events.EventEmitter {
 						continue;
 					}
 					if (frame.videoType === "H264" || frame.videoType === "H265") {
-						const normalizedVideoData = frame.videoType === "H264" ? require_chunk_OSVYEFMM.convertToAnnexB(frame.data) : require_chunk_OSVYEFMM.convertToAnnexB2(frame.data);
+						const normalizedVideoData = frame.videoType === "H264" ? require_chunk_XAKOGDFB.convertToAnnexB(frame.data) : require_chunk_XAKOGDFB.convertToAnnexB2(frame.data);
 						if (frameCount === 0) this.setFlowVideoType(frame.videoType, "first video frame");
 						if (!this.flow.getFmtp().hasParamSets) {
 							this.flow.extractParameterSets(normalizedVideoData);
@@ -86284,7 +86531,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends events.EventEmitter {
 					}
 					if (useDirectRtp) {
 						const videoType = frame.videoType ?? this.flow.videoType;
-						const normalizedVideoData = videoType === "H264" ? require_chunk_OSVYEFMM.convertToAnnexB(frame.data) : require_chunk_OSVYEFMM.convertToAnnexB2(frame.data);
+						const normalizedVideoData = videoType === "H264" ? require_chunk_XAKOGDFB.convertToAnnexB(frame.data) : require_chunk_XAKOGDFB.convertToAnnexB2(frame.data);
 						if (!resources?.seenFirstVideoKeyframe) if (videoType === "H265") {
 							const { hasParamSets } = this.flow.getFmtp();
 							if (!hasParamSets) {
@@ -86360,7 +86607,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends events.EventEmitter {
 								const headHex = frame.data.subarray(0, 16).toString("hex");
 								this.rtspDebugLog(`First video frame written to ffmpeg stdin for client ${clientId} (len=${frame.data.length}, head=${headHex})`);
 							}
-							if (!stdin.write(frame.videoType === "H264" ? require_chunk_OSVYEFMM.convertToAnnexB(frame.data) : frame.data)) await new Promise((resolve) => {
+							if (!stdin.write(frame.videoType === "H264" ? require_chunk_XAKOGDFB.convertToAnnexB(frame.data) : frame.data)) await new Promise((resolve) => {
 								if (stdin) stdin.once("drain", () => resolve());
 								else resolve();
 							});
@@ -86472,7 +86719,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends events.EventEmitter {
 	ensureContinuousStream(dedicatedClient) {
 		if (this.continuousStream) return this.continuousStream;
 		const createLiveStream = async () => {
-			return new require_chunk_OSVYEFMM.BaichuanVideoStream({
+			return new require_chunk_XAKOGDFB.BaichuanVideoStream({
 				client: dedicatedClient ?? this.api.client,
 				api: this.api,
 				channel: this.channel,
@@ -88169,6 +88416,117 @@ var estimateVideoTiming = (params) => {
 		fpsSource: "unknown"
 	};
 };
+var parseRecStartParamIfPresent = (fileName) => {
+	const m = /Rec(\w{3})(?:_|_DST)(\d{8})_(\d{6})_.*/.exec(fileName);
+	if (!m) return void 0;
+	return `${m[2]}${m[3]}`;
+};
+var buildReplayStopNameFromFileName = (fileName, channel = 0) => {
+	const trimmed = (fileName ?? "").trim();
+	if (/^\d{2}\d{14}$/.test(trimmed)) return trimmed;
+	const start = parseRecStartParamIfPresent(fileName);
+	if (!start) return void 0;
+	return `${String(channel + 1).padStart(2, "0")}${start}`;
+};
+var buildFileInfoListReplayByIdXml = (params) => {
+	const st = params.streamType ?? "mainStream";
+	const supportSub = st === "subStream" ? 1 : 0;
+	const xmlCh = params.xmlChannelId ?? params.channel;
+	const iframe = params.iframeReplay;
+	const iframeXml = iframe === true || iframe === "both" ? "<bIframeReplay>1</bIframeReplay><iIframeReplay>1</iIframeReplay>" : iframe === "b" ? "<bIframeReplay>1</bIframeReplay>" : iframe === "i" ? "<iIframeReplay>1</iIframeReplay>" : "";
+	const lines = [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>",
+		"<body>",
+		"<FileInfoList version=\"1.1\">",
+		"<FileInfo>",
+		`<channelId>${xmlCh}</channelId>`,
+		`<Id>${xmlEscape(params.id)}</Id>`
+	];
+	if (params.uid) lines.push(`<uid>${xmlEscape(params.uid)}</uid>`);
+	lines.push(`<supportSub>${supportSub}</supportSub>`, "<playSpeed>1</playSpeed>", `<streamType>${xmlEscape(st)}</streamType>`);
+	if (iframeXml) lines.push(iframeXml);
+	lines.push("</FileInfo>", "</FileInfoList>", "</body>");
+	return lines.join("\n");
+};
+var buildFileInfoListReplayByNameXml = (params) => {
+	const st = params.streamType ?? "mainStream";
+	const supportSub = st === "subStream" ? 1 : 0;
+	const xmlCh = params.xmlChannelId ?? params.channel;
+	const iframe = params.iframeReplay;
+	const iframeXml = iframe === true || iframe === "both" ? "<bIframeReplay>1</bIframeReplay><iIframeReplay>1</iIframeReplay>" : iframe === "b" ? "<bIframeReplay>1</bIframeReplay>" : iframe === "i" ? "<iIframeReplay>1</iIframeReplay>" : "";
+	const lines = [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>",
+		"<body>",
+		"<FileInfoList version=\"1.1\">",
+		"<FileInfo>",
+		`<channelId>${xmlCh}</channelId>`,
+		`<Id>${xmlEscape(params.name)}</Id>`
+	];
+	if (params.uid) lines.push(`<uid>${xmlEscape(params.uid)}</uid>`);
+	lines.push(`<supportSub>${supportSub}</supportSub>`, "<playSpeed>1</playSpeed>", `<streamType>${xmlEscape(st)}</streamType>`);
+	if (iframeXml) lines.push(iframeXml);
+	lines.push("</FileInfo>", "</FileInfoList>", "</body>");
+	return lines.join("\n");
+};
+var buildFileInfoListStopXml = (params) => {
+	const st = params.streamType ?? "mainStream";
+	return `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<FileInfoList version="1.1">
+<FileInfo>
+<channelId>${params.channel}</channelId>
+<name>${xmlEscape(params.name)}</name>
+<streamType>${xmlEscape(st)}</streamType>
+</FileInfo>
+</FileInfoList>
+</body>`;
+};
+var REPLAY_SEEK_MAX_DRIFT_MS = 3e3;
+var buildReplaySeekXml = (params) => {
+	const p = params.parts;
+	const seq = params.seq ?? Math.floor(Date.now() / 1e3);
+	return `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<ReplaySeek version="1.1">
+<channelId>${params.channel}</channelId>
+<seq>${seq}</seq>
+<seekTime>
+<year>${p.year}</year>
+<month>${p.month}</month>
+<day>${p.day}</day>
+<hour>${p.hour}</hour>
+<minute>${p.minute}</minute>
+<second>${p.second}</second>
+</seekTime>
+</ReplaySeek>
+</body>
+`;
+};
+var BC_IFRAME_MAGIC_MIN = 1667510320;
+var BC_IFRAME_MAGIC_MAX = 1667510329;
+var BC_MAX_ADDITIONAL_HEADER = 4096;
+var readFirstIframeWallClock = (chunk) => {
+	const limit = chunk.length - 28;
+	for (let i = 0; i <= limit; i++) {
+		const magic = chunk.readUInt32LE(i);
+		if (magic < BC_IFRAME_MAGIC_MIN || magic > BC_IFRAME_MAGIC_MAX) continue;
+		const videoType = chunk.toString("utf8", i + 4, i + 8);
+		if (videoType !== "H264" && videoType !== "H265") continue;
+		const additionalHeaderSize = chunk.readUInt32LE(i + 12);
+		if (additionalHeaderSize < 4 || additionalHeaderSize > BC_MAX_ADDITIONAL_HEADER) continue;
+		const t = chunk.readUInt32LE(i + 24);
+		if (t < 1e9 || t > 4e9) continue;
+		const d = /* @__PURE__ */ new Date(t * 1e3);
+		return {
+			year: d.getUTCFullYear(),
+			month: d.getUTCMonth() + 1,
+			day: d.getUTCDate(),
+			hour: d.getUTCHours(),
+			minute: d.getUTCMinutes(),
+			second: d.getUTCSeconds()
+		};
+	}
+};
 function daysInMonth(year, month) {
 	return new Date(Date.UTC(year, month, 0)).getUTCDate();
 }
@@ -90114,71 +90472,6 @@ var buildFileInfoListDownloadXml = (params) => {
 </FileInfoList>
 </body>`;
 };
-var parseRecStartParamIfPresent = (fileName) => {
-	const m = /Rec(\w{3})(?:_|_DST)(\d{8})_(\d{6})_.*/.exec(fileName);
-	if (!m) return void 0;
-	return `${m[2]}${m[3]}`;
-};
-var buildReplayStopNameFromFileName = (fileName, channel = 0) => {
-	const trimmed = (fileName ?? "").trim();
-	if (/^\d{2}\d{14}$/.test(trimmed)) return trimmed;
-	const start = parseRecStartParamIfPresent(fileName);
-	if (!start) return void 0;
-	return `${String(channel + 1).padStart(2, "0")}${start}`;
-};
-var buildFileInfoListReplayByIdXml = (params) => {
-	const st = params.streamType ?? "mainStream";
-	const supportSub = st === "subStream" ? 1 : 0;
-	const xmlCh = params.xmlChannelId ?? params.channel;
-	const iframe = params.iframeReplay;
-	const iframeXml = iframe === true || iframe === "both" ? "<bIframeReplay>1</bIframeReplay><iIframeReplay>1</iIframeReplay>" : iframe === "b" ? "<bIframeReplay>1</bIframeReplay>" : iframe === "i" ? "<iIframeReplay>1</iIframeReplay>" : "";
-	const lines = [
-		"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>",
-		"<body>",
-		"<FileInfoList version=\"1.1\">",
-		"<FileInfo>",
-		`<channelId>${xmlCh}</channelId>`,
-		`<Id>${xmlEscape(params.id)}</Id>`
-	];
-	if (params.uid) lines.push(`<uid>${xmlEscape(params.uid)}</uid>`);
-	lines.push(`<supportSub>${supportSub}</supportSub>`, "<playSpeed>1</playSpeed>", `<streamType>${xmlEscape(st)}</streamType>`);
-	if (iframeXml) lines.push(iframeXml);
-	lines.push("</FileInfo>", "</FileInfoList>", "</body>");
-	return lines.join("\n");
-};
-var buildFileInfoListReplayByNameXml = (params) => {
-	const st = params.streamType ?? "mainStream";
-	const supportSub = st === "subStream" ? 1 : 0;
-	const xmlCh = params.xmlChannelId ?? params.channel;
-	const iframe = params.iframeReplay;
-	const iframeXml = iframe === true || iframe === "both" ? "<bIframeReplay>1</bIframeReplay><iIframeReplay>1</iIframeReplay>" : iframe === "b" ? "<bIframeReplay>1</bIframeReplay>" : iframe === "i" ? "<iIframeReplay>1</iIframeReplay>" : "";
-	const lines = [
-		"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>",
-		"<body>",
-		"<FileInfoList version=\"1.1\">",
-		"<FileInfo>",
-		`<channelId>${xmlCh}</channelId>`,
-		`<Id>${xmlEscape(params.name)}</Id>`
-	];
-	if (params.uid) lines.push(`<uid>${xmlEscape(params.uid)}</uid>`);
-	lines.push(`<supportSub>${supportSub}</supportSub>`, "<playSpeed>1</playSpeed>", `<streamType>${xmlEscape(st)}</streamType>`);
-	if (iframeXml) lines.push(iframeXml);
-	lines.push("</FileInfo>", "</FileInfoList>", "</body>");
-	return lines.join("\n");
-};
-var buildFileInfoListStopXml = (params) => {
-	const st = params.streamType ?? "mainStream";
-	return `<?xml version="1.0" encoding="UTF-8" ?>
-<body>
-<FileInfoList version="1.1">
-<FileInfo>
-<channelId>${params.channel}</channelId>
-<name>${xmlEscape(params.name)}</name>
-<streamType>${xmlEscape(st)}</streamType>
-</FileInfo>
-</FileInfoList>
-</body>`;
-};
 var videoCodecMap = {
 	0: "H.264",
 	1: "H.265",
@@ -90419,7 +90712,7 @@ var sendTalkConfigWithReset = async (params) => {
 			channel: params.channel,
 			...params.channelIdOverride != null ? { channelIdOverride: params.channelIdOverride } : {},
 			payloadXml: params.payloadXml,
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 		})).header.responseCode;
 	};
 	const code = await trySend();
@@ -90429,7 +90722,7 @@ var sendTalkConfigWithReset = async (params) => {
 			channel: params.channel,
 			...params.channelIdOverride != null ? { channelIdOverride: params.channelIdOverride } : {},
 			payloadXml: "",
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 		});
 		const retryCode = await trySend();
 		if (retryCode !== 200) throw new Error(`TalkConfig rejected after reset (responseCode ${retryCode})`);
@@ -90496,7 +90789,7 @@ var createBufferedTalkSession = (params) => {
 			...channelIdOverride != null ? { channelIdOverride } : {},
 			extensionXml: buildBinaryExtensionXml(channel),
 			payload: Buffer.concat(parts),
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 		});
 		const playLengthMs = samplesSent / info.audioConfig.sampleRate * 1e3;
 		const now = Date.now();
@@ -90542,7 +90835,7 @@ var createBufferedTalkSession = (params) => {
 			channel,
 			...channelIdOverride != null ? { channelIdOverride } : {},
 			payloadXml: "",
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 		});
 		if (frame.header.responseCode !== 200) throw new Error(`TalkReset rejected (responseCode ${frame.header.responseCode})`);
 		if (params.closeSocketOnStop) try {
@@ -91067,6 +91360,7 @@ var isNvrHubModel = (model) => {
 	if (NVR_HUB_EXACT_TYPES.includes(upper)) return true;
 	return NVR_HUB_MODEL_PATTERNS.some((pattern) => pattern.test(normalized));
 };
+var SEEKED_CHANNELS = /* @__PURE__ */ new WeakMap();
 var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 	logger;
 	httpClient;
@@ -92225,7 +92519,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 		if (debugCfg) {
 			const sid = this.client.getSocketSessionId?.();
 			const tag2 = sid ? `ReolinkSimpleEvent sid=${sid}` : "ReolinkSimpleEvent";
-			require_chunk_OSVYEFMM.eventTraceLog(debugCfg, this.logger, tag2, `dispatch type=${evt.type} channel=${evt.channel} timestamp=${evt.timestamp}`);
+			require_chunk_XAKOGDFB.eventTraceLog(debugCfg, this.logger, tag2, `dispatch type=${evt.type} channel=${evt.channel} timestamp=${evt.timestamp}`);
 		}
 		for (const cb of this.simpleEventListeners) try {
 			Promise.resolve(cb(evt)).catch((e) => {
@@ -92236,7 +92530,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 		}
 	}
 	constructor(opts) {
-		const dbg = require_chunk_OSVYEFMM.normalizeDebugOptions(opts.debugOptions);
+		const dbg = require_chunk_XAKOGDFB.normalizeDebugOptions(opts.debugOptions);
 		this.logger = createDebugGateLogger(opts.logger, dbg.general || dbg.traceNativeStream || dbg.traceRecordings || dbg.traceTalk || dbg.traceEvents || dbg.debugRtsp);
 		this.clientOptions = {
 			host: opts.host,
@@ -92824,7 +93118,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 			return;
 		}
 		entry.startInFlight = (async () => {
-			const { BaichuanVideoStream: BaichuanVideoStream2 } = await Promise.resolve().then(() => require("./BaichuanVideoStream-UG3DIMIE-DViuQDJ4.js"));
+			const { BaichuanVideoStream: BaichuanVideoStream2 } = await Promise.resolve().then(() => require("./BaichuanVideoStream-PR2SYJAE-JpggQ5Wq.js"));
 			const sessionKey = `live:object-detections:ch${entry.channel}:${entry.profile}`;
 			const dedicated = await this.createDedicatedSession(sessionKey);
 			const stream$12 = new BaichuanVideoStream2({
@@ -93305,7 +93599,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 			channel: ch,
 			...channelIdOverride != null ? { channelIdOverride } : {},
 			payloadXml: "",
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 		});
 		if (frame.header.responseCode !== 200) throw new Error(`TalkReset rejected (responseCode ${frame.header.responseCode})`);
 	}
@@ -93324,7 +93618,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 				channel: ch,
 				...channelIdOverride != null ? { channelIdOverride } : {},
 				payloadXml,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 			})).header.responseCode;
 		};
 		const code = await trySend();
@@ -93476,7 +93770,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 			cmdId: 10,
 			channel,
 			payloadXml: "",
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 		});
 		return parseTalkAbilityXml(frame.body.length === 0 ? "" : client.tryDecryptXml(frame.body, frame.header.channelId, client.enc));
 	}
@@ -94549,8 +94843,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 			const start = params.start;
 			const endOfStartDay = endOfWallClockDay(start, timeZone);
 			const end = params.end.getTime() > endOfStartDay.getTime() ? endOfStartDay : params.end;
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "getVideoclips", `Query: start=${start.toISOString()}, end=${end.toISOString()} (forced same day)`);
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "getVideoclips", `Using UID for channel ${channel}: ${uid}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "getVideoclips", `Query: start=${start.toISOString()}, end=${end.toISOString()} (forced same day)`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "getVideoclips", `Using UID for channel ${channel}: ${uid}`);
 			const streamType = params.streamType ?? "subStream";
 			const recordType = params.recordType ?? "manual,sched,io,md,people,face,vehicle,dog_cat,visitor,other,package,crossline,intrusion,loitering,legacy,loss";
 			const fileRecordTypes = params.fileRecordTypes ?? (params.recordType === void 0 ? DEFAULT_RECORDING_SEARCH_FILE_RECORD_TYPES : void 0);
@@ -94569,7 +94863,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 				...timeZone !== void 0 ? { timeZone } : {}
 			});
 			const unique = dedupeRecordingFiles(files);
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "getVideoclips", `FileInfoList complete: ${unique.length} unique files (from ${files.length} total)`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "getVideoclips", `FileInfoList complete: ${unique.length} unique files (from ${files.length} total)`);
 			return unique;
 		});
 	}
@@ -94610,7 +94904,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 			const start = params.start;
 			const endOfStartDay = endOfWallClockDay(start, timeZone);
 			const end = params.end.getTime() > endOfStartDay.getTime() ? endOfStartDay : params.end;
-			if (end !== params.end) require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "searchAlarmVideos", `Window clamped to one camera-local day: ${params.end.toISOString()} \u2192 ${end.toISOString()} (the firmware answers the START day only)`);
+			if (end !== params.end) require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "searchAlarmVideos", `Window clamped to one camera-local day: ${params.end.toISOString()} \u2192 ${end.toISOString()} (the firmware answers the START day only)`);
 			const windows = await searchAlarmVideosViaFindAlarmVideo({
 				sendXml: (p) => this.sendXml(p),
 				channel,
@@ -94626,7 +94920,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 				maxPages: params.maxPages ?? 200,
 				...params.timeoutMs != null ? { timeoutMs: params.timeoutMs } : {}
 			});
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "searchAlarmVideos", `findAlarmVideo complete: ${windows.length} windows over ${new Set(windows.map((w) => w.fileName)).size} files (channel=${channel})`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "searchAlarmVideos", `findAlarmVideo complete: ${windows.length} windows over ${new Set(windows.map((w) => w.fileName)).size} files (channel=${channel})`);
 			return windows;
 		});
 	}
@@ -94691,7 +94985,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 				seen.add(key);
 				return true;
 			});
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "searchEventLog", `findEventLog complete: ${unique.length} events over ${devices.length} device(s) (${events$6.length - unique.length} repeated across pages), ${unique.filter((e) => !e.hasRecFile).length} without a recording file`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "searchEventLog", `findEventLog complete: ${unique.length} events over ${devices.length} device(s) (${events$6.length - unique.length} repeated across pages), ${unique.filter((e) => !e.hasRecFile).length} without a recording file`);
 			return unique;
 		});
 	}
@@ -94744,7 +95038,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 		});
 		const msgNum = 0;
 		dedicatedClient.subscribeVideoStream(5, msgNum);
-		const stream$14 = new require_chunk_OSVYEFMM.BaichuanVideoStream({
+		const stream$14 = new require_chunk_XAKOGDFB.BaichuanVideoStream({
 			client: dedicatedClient,
 			channel,
 			profile: streamType === "subStream" ? "sub" : "main",
@@ -94763,7 +95057,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 				channel,
 				channelIdOverride: sessionCounter,
 				payloadXml,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				msgNumOverride: 0,
 				timeoutMs: params.timeoutMs,
 				internal: true
@@ -94795,7 +95089,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 					cmdId: 7,
 					channel,
 					payloadXml: stopXml,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 					timeoutMs: 2e3,
 					internal: true
 				});
@@ -94852,7 +95146,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 		});
 		const msgNum = 0;
 		dedicatedClient.subscribeVideoStream(5, msgNum);
-		const stream$15 = new require_chunk_OSVYEFMM.BaichuanVideoStream({
+		const stream$15 = new require_chunk_XAKOGDFB.BaichuanVideoStream({
 			client: dedicatedClient,
 			channel,
 			profile: streamType === "subStream" ? "sub" : "main",
@@ -94872,7 +95166,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 				channelIdOverride,
 				payloadXml,
 				extensionXml: "",
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				msgNumOverride: msgNum,
 				timeoutMs: params.timeoutMs,
 				internal: true
@@ -94904,7 +95198,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 					cmdId: 7,
 					channel,
 					payloadXml: stopXml,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 					timeoutMs: 2e3,
 					internal: true
 				});
@@ -94991,35 +95285,35 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 	async ensureUidForRecordings(channel, explicitUid) {
 		const dbg = this.client.getDebugConfig?.();
 		const logger = this.logger;
-		require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Checking UID: explicitUid=${explicitUid}, this.uid=${this.uid}`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Checking UID: explicitUid=${explicitUid}, this.uid=${this.uid}`);
 		const trimmedExplicit = explicitUid?.trim();
 		if (trimmedExplicit) {
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using explicit UID: ${trimmedExplicit}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using explicit UID: ${trimmedExplicit}`);
 			return trimmedExplicit;
 		}
 		const perChannel = await this.discoverUidForRecordingsForChannel(channel);
 		if (perChannel) {
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using per-channel UID: ${perChannel}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using per-channel UID: ${perChannel}`);
 			return perChannel;
 		}
 		const configured = this.uid?.trim();
 		if (configured) {
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using configured UID: ${configured}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using configured UID: ${configured}`);
 			return configured;
 		}
 		if (this.nativeOnly) {
 			const viaGetUid = await this.discoverUidViaGetUidNative(channel);
 			if (viaGetUid) {
-				require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using device UID from cmd 114 GetUid: ${viaGetUid}`);
+				require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using device UID from cmd 114 GetUid: ${viaGetUid}`);
 				return viaGetUid;
 			}
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Native-only: no UID available (channel=${channel})`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Native-only: no UID available (channel=${channel})`);
 			throw new Error("UID is required to access recordings in native-only mode. Provide a UID explicitly, configure the client with a UID, or wait for cmd_id=145 push cache to populate per-channel UIDs.");
 		}
-		require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `No UID available, attempting device auto-discovery (ch=${channel})`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `No UID available, attempting device auto-discovery (ch=${channel})`);
 		const discovered = await this.discoverDeviceUidForRecordings(channel);
 		if (discovered) return discovered;
-		require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Auto-discovery failed - no UID found`);
+		require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Auto-discovery failed - no UID found`);
 		throw new Error("UID is required to access recordings. Provide a UID explicitly or configure the client with a UID.");
 	}
 	cacheChannelUid(channel, uid) {
@@ -95042,28 +95336,28 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 		const logger = this.logger;
 		const fromPush = this.getUidFromPushCacheForChannel(channel);
 		if (fromPush) {
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using per-channel UID from push cache: ${fromPush}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using per-channel UID from push cache: ${fromPush}`);
 			return fromPush;
 		}
 		if (this.nativeOnly) {
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Native-only: skipping per-channel UID discovery via HTTP/CGI (channel=${channel})`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Native-only: skipping per-channel UID discovery via HTTP/CGI (channel=${channel})`);
 			return;
 		}
 		try {
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Attempting per-channel UID discovery via HTTP CGI GetChannelstatus (channel=${channel})`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Attempting per-channel UID discovery via HTTP CGI GetChannelstatus (channel=${channel})`);
 			const uidCandidate = await discoverPerChannelUidViaCgiChannelstatus({
 				channel,
 				login: () => this.cgiApi.login(),
 				getChannelstatus: () => this.cgiApi.GetChannelstatus()
 			});
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `[HTTP CGI] GetChannelstatus channel=${channel} uid=${uidCandidate || "(missing)"}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `[HTTP CGI] GetChannelstatus channel=${channel} uid=${uidCandidate || "(missing)"}`);
 			if (uidCandidate) {
 				this.cacheChannelUid(channel, uidCandidate);
-				require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using per-channel UID from GetChannelstatus: ${uidCandidate}`);
+				require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `Using per-channel UID from GetChannelstatus: ${uidCandidate}`);
 				return uidCandidate;
 			}
 		} catch (e) {
-			require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `[HTTP CGI] GetChannelstatus failed: ${formatErrorForLog(e)}`);
+			require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", `[HTTP CGI] GetChannelstatus failed: ${formatErrorForLog(e)}`);
 		}
 	}
 	/**
@@ -95075,7 +95369,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 	*/
 	async discoverUidViaGetUidNative(channel) {
 		const dbg = this.client.getDebugConfig?.();
-		const trace = (message) => require_chunk_OSVYEFMM.recordingsTraceLog(dbg, this.logger, "ensureUidForRecordings", message);
+		const trace = (message) => require_chunk_XAKOGDFB.recordingsTraceLog(dbg, this.logger, "ensureUidForRecordings", message);
 		let isNvr = this._isNvr;
 		if (isNvr === void 0) try {
 			isNvr = await this.isNvrDevice();
@@ -95101,7 +95395,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 		if (this.nativeOnly) return void 0;
 		const dbg = this.client.getDebugConfig?.();
 		const logger = this.logger;
-		const trace = (message) => require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", message);
+		const trace = (message) => require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "ensureUidForRecordings", message);
 		const discoveredUid = await discoverDeviceUidForRecordings({
 			channel,
 			getInfo: () => this.getInfo(),
@@ -95176,7 +95470,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
 		await this.client.login();
 		const dbg = this.client.getDebugConfig?.();
 		const logger = this.logger;
-		const trace = (message) => require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "getVideoclipThumbnail", message);
+		const trace = (message) => require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "getVideoclipThumbnail", message);
 		const channel = this.normalizeChannel(params.channel);
 		const snapStreamType = (params.snapType ?? "sub") === "main" ? "mainStream" : "subStream";
 		const timeoutMs = params.timeoutMs ?? 3e4;
@@ -95231,7 +95525,7 @@ ${xml}`);
 				cmdId: 298,
 				...isNvr && headerChannelIdOverride != null ? { channelIdOverride: headerChannelIdOverride } : {},
 				msgNumOverride: 0,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				streamType: 0,
 				payloadXml: xml,
 				timeoutMs
@@ -95710,7 +96004,7 @@ ${stderr}`));
 		await this.client.login();
 		const dbg = this.client.getDebugConfig?.();
 		const logger = this.logger;
-		const trace = (message) => require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "fileInfoListDownload", message);
+		const trace = (message) => require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "fileInfoListDownload", message);
 		const channel = this.normalizeChannel(params.channel);
 		const uid = await this.ensureUidForRecordings(channel, params.uid);
 		const headerChannelIdOverride = this.resolveHeaderChannelIdForLogicalChannel(channel);
@@ -95756,7 +96050,7 @@ ${stderr}`));
 							cmdId: 13,
 							channel,
 							...typeof chId === "number" ? { channelIdOverride: chId } : {},
-							messageClass: require_chunk_OSVYEFMM.BC_CLASS_FILE_DOWNLOAD,
+							messageClass: require_chunk_XAKOGDFB.BC_CLASS_FILE_DOWNLOAD,
 							extensionXml: buildBinaryExtensionXml(channel),
 							payloadXml,
 							streamType: st,
@@ -95785,7 +96079,7 @@ ${stderr}`));
 		await this.client.login();
 		const dbg = this.client.getDebugConfig?.();
 		const logger = this.logger;
-		const trace = (message) => require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "fileInfoListPagedDownload", message);
+		const trace = (message) => require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "fileInfoListPagedDownload", message);
 		const channel = this.normalizeChannel(params.channel);
 		const uid = await this.ensureUidForRecordings(channel, params.uid);
 		trace(`Starting paged download: channel=${channel}, uid=${uid}, fileName=${params.fileName}`);
@@ -95822,7 +96116,7 @@ ${stderr}`));
 		await this.client.login();
 		const dbg = this.client.getDebugConfig?.();
 		const logger = this.logger;
-		const trace = (message) => require_chunk_OSVYEFMM.recordingsTraceLog(dbg, logger, "fileInfoListReplayBinaryDownload", message);
+		const trace = (message) => require_chunk_XAKOGDFB.recordingsTraceLog(dbg, logger, "fileInfoListReplayBinaryDownload", message);
 		const channel = this.normalizeChannel(params.channel);
 		const headerChannelIdOverride = this.resolveHeaderChannelIdForLogicalChannel(channel);
 		const ident = params.fileName;
@@ -95847,24 +96141,66 @@ ${stderr}`));
 		trace(`download: channel=${channel} uid=${uid || "(missing)"} ident=${ident} streamType=${streamType} isNvr=${isNvr} timeoutMs=${timeoutMs}`);
 		const pinnedHeaderChannelId = params.headerChannelIdOverride;
 		let abandoned = false;
+		const timeZone = params.timeZone ?? this.recordingsTimeZone;
+		const clipStart = this.replayStartInstantOf(ident, timeZone);
+		const requestedAt = params.seekTo ?? clipStart;
+		const outcome = {
+			requestedAt: params.seekTo ?? null,
+			deliveredAt: null,
+			driftMs: null,
+			seekApplied: false
+		};
+		const dirty = SEEKED_CHANNELS.get(this.client)?.has(channel) === true;
+		if (requestedAt && (params.seekTo !== void 0 || dirty)) {
+			outcome.seekApplied = await this.replaySeek({
+				channel,
+				at: requestedAt,
+				...timeZone !== void 0 ? { timeZone } : {}
+			});
+			if (!outcome.seekApplied) {
+				outcome.reason = "camera did not accept cmd 123 <ReplaySeek>; the transfer runs unpositioned";
+				trace(`seek not applied for ${ident}: ${outcome.reason}`);
+			}
+		} else if (!requestedAt) {
+			outcome.reason = `no start instant derivable from ${ident}; the transfer runs unpositioned`;
+			trace(outcome.reason);
+		} else trace(`channel ${String(channel)} never seeked on this connection; ${ident} runs unpositioned at full rate`);
+		let deliveredParts;
+		const observeChunk = (chunk) => {
+			if (deliveredParts === void 0) deliveredParts = readFirstIframeWallClock(chunk);
+		};
+		const settleOutcome = () => {
+			if (deliveredParts !== void 0) {
+				outcome.deliveredAt = dateFromWallClock(deliveredParts, timeZone);
+				if (outcome.requestedAt) {
+					outcome.driftMs = outcome.deliveredAt.getTime() - outcome.requestedAt.getTime();
+					if (Math.abs(outcome.driftMs) > 3e3) this.logger?.warn?.(`[fileInfoListReplayBinaryDownload] seek drift ${outcome.driftMs} ms for ${ident}: asked ${outcome.requestedAt.toISOString()}, delivered ${outcome.deliveredAt.toISOString()} (> ${REPLAY_SEEK_MAX_DRIFT_MS} ms \u2014 the camera did not honour the position)`);
+				}
+			} else if (outcome.reason === void 0) outcome.reason = "no I-frame in the transfer; delivered position unknown";
+			params.onSeekOutcome?.(outcome);
+		};
 		try {
 			return await this.client.sendBinary({
 				cmdId: 5,
 				channel,
 				...pinnedHeaderChannelId != null ? { channelIdOverride: pinnedHeaderChannelId } : {},
 				msgNumOverride: 0,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				payloadXml,
 				streamType: 0,
 				timeoutMs,
 				...params.idleTimeoutMs != null ? { idleTimeoutMs: params.idleTimeoutMs } : {},
-				...params.onChunk ? { onChunk: params.onChunk } : {}
+				onChunk: (chunk) => {
+					observeChunk(chunk);
+					params.onChunk?.(chunk);
+				}
 			});
 		} catch (e) {
 			trace(`download failed: ${e instanceof Error ? e.message : String(e)}`);
 			abandoned = true;
 			throw e;
 		} finally {
+			settleOutcome();
 			await this.stopFileInfoListReplay({
 				channel,
 				fileName: ident,
@@ -95874,6 +96210,76 @@ ${stderr}`));
 		}
 	}
 	/**
+	* The instant a recording begins, read out of its own file name.
+	*
+	* `Rec*_YYYYMMDD_HHMMSS_…` is the camera's wall clock with no offset on the
+	* wire, so it is resolved through the same zone as every other recording
+	* timestamp. `undefined` for a name that does not carry one — an identifier
+	* this library did not get from a FileInfoList listing, for instance.
+	*/
+	replayStartInstantOf(fileName, timeZone) {
+		const stamp = parseRecStartParamIfPresent(fileName);
+		if (!stamp) return void 0;
+		return dateFromWallClock({
+			year: Number(stamp.slice(0, 4)),
+			month: Number(stamp.slice(4, 6)),
+			day: Number(stamp.slice(6, 8)),
+			hour: Number(stamp.slice(8, 10)),
+			minute: Number(stamp.slice(10, 12)),
+			second: Number(stamp.slice(12, 14))
+		}, timeZone);
+	}
+	/**
+	* Position the NEXT replay of this channel — cmd 123 `<ReplaySeek>`.
+	*
+	* The camera can replay one recording from an arbitrary instant inside it,
+	* and this is how the official app asks: a wall-clock second, sent BEFORE
+	* the cmd 5 that opens the stream. Measured 2026-09-23 — asked +40 s into a
+	* 75 s clip, the first I-frame delivered was the clip's start +40 s, on an
+	* E1 Outdoor PoE (v3.1.0.5223) and on a Home Hub child (v3.3.0.456).
+	*
+	* Two things a caller must know:
+	*
+	* - **The granularity is a KEYFRAME, not a second.** The stream begins at
+	*   the I-frame nearest the instant asked for — 592 rounded up, the hub
+	*   child rounded down, both by up to one GOP (~2 s). Read the position back
+	*   (`fileInfoListReplayBinaryDownload` reports it) rather than assuming it.
+	* - **The position is STICKY for the life of the connection.** Measured: a
+	*   seek, then a replay, then ANOTHER replay that asked for no seek — and
+	*   the second one still started at the seek point. This is why
+	*   `fileInfoListReplayBinaryDownload` always sends a `<ReplaySeek>`, to the
+	*   clip's own start when the caller asked for no offset. Calling this
+	*   method directly leaves that discipline to you.
+	*
+	* Returns `true` when the camera accepted the command. A camera that does
+	* not support cmd 123 returns `false` rather than throwing, because a seek
+	* is an enhancement to a download and must never be the reason one fails.
+	*/
+	async replaySeek(params) {
+		const channel = this.normalizeChannel(params.channel);
+		const timeZone = params.timeZone ?? this.recordingsTimeZone;
+		const payloadXml = buildReplaySeekXml({
+			channel,
+			parts: wallClockParts(params.at, timeZone)
+		});
+		try {
+			await this.client.sendXml({
+				cmdId: 123,
+				extensionXml: "",
+				payloadXml,
+				timeoutMs: params.timeoutMs ?? 8e3
+			});
+			const client = this.client;
+			const seeked = SEEKED_CHANNELS.get(client) ?? /* @__PURE__ */ new Set();
+			seeked.add(channel);
+			SEEKED_CHANNELS.set(client, seeked);
+			return true;
+		} catch (e) {
+			this.logger?.warn?.(`[replaySeek] channel=${channel} at=${params.at.toISOString()} not applied: ${e instanceof Error ? e.message : String(e)}`);
+			return false;
+		}
+	}
+	/**
 	* Close a cmd 5 replay session at the camera (cmd 7) and wait for the wire to
 	* go quiet.
 	*
@@ -95899,7 +96305,7 @@ ${stderr}`));
 					name: stopName,
 					streamType: params.streamType
 				}),
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				timeoutMs: 4e3,
 				internal: true
 			});
@@ -95987,7 +96393,7 @@ ${stderr}`));
 		const frames = [];
 		const timestampsUs = [];
 		const audioFrames = [];
-		const decoder = new require_chunk_OSVYEFMM.BcMediaAnnexBDecoder({
+		const decoder = new require_chunk_XAKOGDFB.BcMediaAnnexBDecoder({
 			strict: false,
 			logger: this.logger,
 			onVideoAccessUnit: ({ annexB, microseconds }) => {
@@ -96053,7 +96459,7 @@ ${stderr}`));
 		const videoFrames = [];
 		const audioFrames = [];
 		let audioCodec = null;
-		const decoder = new require_chunk_OSVYEFMM.BcMediaAnnexBDecoder({
+		const decoder = new require_chunk_XAKOGDFB.BcMediaAnnexBDecoder({
 			strict: false,
 			logger: this.logger,
 			onVideoAccessUnit: ({ annexB, microseconds }) => {
@@ -96451,7 +96857,7 @@ ${stderr}`));
 				params: {
 					cmdId: 31,
 					channelIdOverride: channel,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 				}
 			},
 			{
@@ -96459,7 +96865,7 @@ ${stderr}`));
 				params: {
 					cmdId: 31,
 					channelIdOverride: 251,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 				}
 			},
 			{
@@ -96467,7 +96873,7 @@ ${stderr}`));
 				params: {
 					cmdId: 31,
 					channelIdOverride: 250,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 				}
 			},
 			{
@@ -96475,7 +96881,7 @@ ${stderr}`));
 				params: {
 					cmdId: 31,
 					channelIdOverride: 250,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 					extensionXml: `<?xml version="1.0" encoding="UTF-8" ?><Extension version="1.1"><channelId>251</channelId></Extension>`
 				}
 			}
@@ -96518,7 +96924,7 @@ ${stderr}`));
 			const frame = await this.client.sendFrame({
 				cmdId: 31,
 				channelIdOverride: Number(channel),
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				timeoutMs
 			});
 			lastCode = frame.header.responseCode;
@@ -96799,7 +97205,7 @@ ${stderr}`));
 					msgNumOverride: msgNum,
 					extensionXml: buildChannelExtensionXml(channelId),
 					payloadXml,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 					streamType: config.streamType,
 					timeoutMs: 2e4
 				};
@@ -96931,7 +97337,7 @@ ${stderr}`));
 					channelIdOverride: channelId,
 					extensionXml: a.extensionXml,
 					payloadXml: a.payloadXml,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 					streamType: a.streamType,
 					...msgNum !== void 0 ? { msgNumOverride: msgNum } : {},
 					timeoutMs: 2e3
@@ -96961,7 +97367,7 @@ ${stderr}`));
 				channel: ch,
 				channelIdOverride: channelId,
 				extensionXml: buildChannelExtensionXml(channelId),
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				streamType: 0
 			});
 		} catch (e) {
@@ -97003,7 +97409,7 @@ ${stderr}`));
 				channel: ch,
 				channelIdOverride: channelId,
 				extensionXml: buildChannelExtensionXml(channelId),
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 				streamType: 0
 			});
 		} catch (e) {
@@ -97025,7 +97431,7 @@ ${stderr}`));
 			channelIdOverride: channelId,
 			extensionXml,
 			payloadXml,
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 		if (frame.header.responseCode !== 200) {
@@ -97057,7 +97463,7 @@ ${stderr}`));
 			channelIdOverride: channelId,
 			extensionXml,
 			payloadXml,
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 		if (frame.header.responseCode !== 200) throw new Error(`PTZ preset move rejected (response_code ${frame.header.responseCode})`);
@@ -97078,7 +97484,7 @@ ${stderr}`));
 			channelIdOverride: channelId,
 			extensionXml,
 			payloadXml,
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 		if (frame.header.responseCode !== 200) throw new Error(`PTZ preset save rejected (response_code ${frame.header.responseCode})`);
@@ -97095,7 +97501,7 @@ ${stderr}`));
 			channelIdOverride: channelId,
 			extensionXml,
 			payloadXml,
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 		if (frame.header.responseCode !== 200) throw new Error(`PTZ goto preset rejected (response_code ${frame.header.responseCode})`);
@@ -97122,7 +97528,7 @@ ${stderr}`));
 					channelIdOverride: channelId,
 					extensionXml,
 					payloadXml,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 					streamType: 0
 				})).header.responseCode };
 			},
@@ -97176,7 +97582,7 @@ ${stderr}`));
 			channel: ch,
 			channelIdOverride: ch,
 			extensionXml: buildPtzGuardExtensionXml(ch, "read"),
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		}));
 	}
@@ -97202,7 +97608,7 @@ ${stderr}`));
 				timeoutSeconds: options.timeoutSeconds,
 				setPosition: options.setPosition === true
 			}),
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 	}
@@ -97223,7 +97629,7 @@ ${stderr}`));
 			channelIdOverride: ch,
 			extensionXml: buildPtzGuardExtensionXml(ch, "write"),
 			payloadXml: buildPtzGuardGoXml(ch),
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 	}
@@ -97239,7 +97645,7 @@ ${stderr}`));
 			channel: ch,
 			channelIdOverride: channelId,
 			extensionXml: buildChannelExtensionXml(channelId),
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 		const parseTriplet = (sectionTag) => {
@@ -97277,7 +97683,7 @@ ${stderr}`));
 			channelIdOverride: channelId,
 			extensionXml,
 			payloadXml,
-			messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24,
+			messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24,
 			streamType: 0
 		});
 		if (frame.header.responseCode !== 200) throw new Error(`Zoom rejected (response_code ${frame.header.responseCode})`);
@@ -99028,7 +99434,7 @@ ${xml}`);
 	* @returns Test results for all stream types and profiles
 	*/
 	async testChannelStreams(channel, logger) {
-		const { testChannelStreams } = await Promise.resolve().then(() => require("./DiagnosticsTools-YIWXO7IJ-CD4rRF8a.js"));
+		const { testChannelStreams } = await Promise.resolve().then(() => require("./DiagnosticsTools-DS5X2UVY-CD4rRF8a.js"));
 		return await testChannelStreams({
 			api: this,
 			channel: this.normalizeChannel(channel),
@@ -99044,7 +99450,7 @@ ${xml}`);
 	* @returns Complete diagnostics for all channels and streams
 	*/
 	async collectMultifocalDiagnostics(logger) {
-		const { collectMultifocalDiagnostics } = await Promise.resolve().then(() => require("./DiagnosticsTools-YIWXO7IJ-CD4rRF8a.js"));
+		const { collectMultifocalDiagnostics } = await Promise.resolve().then(() => require("./DiagnosticsTools-DS5X2UVY-CD4rRF8a.js"));
 		return await collectMultifocalDiagnostics({
 			api: this,
 			logger
@@ -101254,7 +101660,7 @@ ${scheduleItems}
 		if (raw.length === 0) throw new Error("Downloaded recording is empty");
 		const videoFrames = [];
 		let videoType = null;
-		const decoder = new require_chunk_OSVYEFMM.BcMediaAnnexBDecoder({
+		const decoder = new require_chunk_XAKOGDFB.BcMediaAnnexBDecoder({
 			strict: false,
 			logger: this.logger,
 			onVideoAccessUnit: ({ annexB: annexB2, microseconds }) => {
@@ -101602,7 +102008,7 @@ ${scheduleItems}
 		return {
 			getPlaylist: () => {
 				try {
-					const { readFileSync } = require_chunk_OSVYEFMM.__require("fs");
+					const { readFileSync } = require_chunk_XAKOGDFB.__require("fs");
 					return readFileSync(playlistPath, "utf8");
 				} catch {
 					return "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-TARGETDURATION:4\n";
@@ -101611,7 +102017,7 @@ ${scheduleItems}
 			getSegment: (name) => {
 				if (segments.has(name)) return segments.get(name);
 				try {
-					const { readFileSync } = require_chunk_OSVYEFMM.__require("fs");
+					const { readFileSync } = require_chunk_XAKOGDFB.__require("fs");
 					const data = readFileSync(path$3.join(tempDir, name));
 					segments.set(name, data);
 					return data;
@@ -101621,7 +102027,7 @@ ${scheduleItems}
 			},
 			listSegments: () => {
 				try {
-					const { readdirSync } = require_chunk_OSVYEFMM.__require("fs");
+					const { readdirSync } = require_chunk_XAKOGDFB.__require("fs");
 					return readdirSync(tempDir).filter((f) => f.endsWith(".ts"));
 				} catch {
 					return [];
@@ -103206,41 +103612,41 @@ async function autoDetectDeviceType(inputs) {
 				variant: "cmd80 class=0x6414",
 				op: () => api.getInfo(void 0, {
 					timeoutMs: 2500,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 				})
 			},
 			{
 				variant: "cmd80 class=0x6614",
 				op: () => api.getInfo(void 0, {
 					timeoutMs: 3e3,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_20
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_20
 				})
 			},
 			{
 				variant: "cmd318(ch0) class=0x6414",
 				op: () => api.getInfo(0, {
 					timeoutMs: 3e3,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 				})
 			},
 			{
 				variant: "cmd318(ch0) class=0x6614",
 				op: () => api.getInfo(0, {
 					timeoutMs: 3500,
-					messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_20
+					messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_20
 				})
 			}
 		]), runProbeVariants("getSupportInfo", [{
 			variant: "cmd199 class=0x6414",
 			op: () => api.getSupportInfo({
 				timeoutMs: 2500,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_24
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_24
 			})
 		}, {
 			variant: "cmd199 class=0x6614",
 			op: () => api.getSupportInfo({
 				timeoutMs: 3500,
-				messageClass: require_chunk_OSVYEFMM.BC_CLASS_MODERN_20
+				messageClass: require_chunk_XAKOGDFB.BC_CLASS_MODERN_20
 			})
 		}])]);
 		const deviceInfo = infoProbe?.value;
@@ -149769,7 +150175,7 @@ async function createRfc4571TcpServerInternal(options) {
 			streamClient = dedicatedSession.client;
 			logSessionsSummary(`dedicated session created: ${sessionKey}`);
 		} else streamClient = baseApi.client;
-		const createLiveStream = async () => new require_chunk_OSVYEFMM.BaichuanVideoStream({
+		const createLiveStream = async () => new require_chunk_XAKOGDFB.BaichuanVideoStream({
 			client: streamClient,
 			api: baseApi,
 			channel: ch,
@@ -152609,7 +153015,7 @@ function writableAt(stdio, index) {
 	if (candidate === null || candidate === void 0) return null;
 	return isWritable(candidate) ? candidate : null;
 }
-var defaultDecoder = (handlers) => new require_chunk_OSVYEFMM.BcMediaAnnexBDecoder({
+var defaultDecoder = (handlers) => new require_chunk_XAKOGDFB.BcMediaAnnexBDecoder({
 	strict: false,
 	onVideoAccessUnit: handlers.onVideoAccessUnit,
 	onAudioFrame: (frame) => handlers.onAudioFrame({
@@ -152623,6 +153029,7 @@ function createClipStreamProducer(deps) {
 	const createDecoder = deps.createDecoder ?? defaultDecoder;
 	const drainTimeoutMs = deps.drainTimeoutMs ?? 1e4;
 	const flushTimeoutMs = deps.flushTimeoutMs ?? 15e3;
+	const cutGraceMs = deps.cutGraceMs ?? 5e3;
 	const lanes = /* @__PURE__ */ new Map();
 	const activeByHost = /* @__PURE__ */ new Map();
 	const runAttempt = (input, attempt) => new ClipStreamRun({
@@ -152630,7 +153037,8 @@ function createClipStreamProducer(deps) {
 		spawnMux: deps.spawnMux,
 		createDecoder,
 		drainTimeoutMs,
-		flushTimeoutMs
+		flushTimeoutMs,
+		cutGraceMs
 	}, input, attempt).run();
 	const runAttempts = async (input) => {
 		const { deviceId } = input.device;
@@ -152731,6 +153139,8 @@ var ClipStreamRun = class {
 	input;
 	attempt;
 	accessUnits = 0;
+	/** Armed by {@link sever}; cleared when the run finally returns. */
+	cutWatch = null;
 	/** Every audio frame the decoder handed over, of any codec. */
 	audioFrames = 0;
 	audioFramesDropped = 0;
@@ -152835,6 +153245,8 @@ var ClipStreamRun = class {
 			return await this.onTransferEnded();
 		} finally {
 			this.done = true;
+			if (this.cutWatch !== null) clearTimeout(this.cutWatch);
+			this.cutWatch = null;
 			this.disposeGates();
 		}
 	}
@@ -153112,6 +153524,36 @@ var ClipStreamRun = class {
 		this.input.sink.end();
 	}
 	/** Sever every hop, once, and say why. */
+	/**
+	* The lane this run is still holding, some time after it was cut.
+	*
+	* D391: a branch that ACCEPTED work and produces nothing is the same branch
+	* as one that drops it. `sever()` already says the stream was cut; it does
+	* not say that the camera never let go, which is the part that makes every
+	* later tap on this host fail.
+	*/
+	armCutWatch(reason) {
+		const cutAt = Date.now();
+		this.cutWatch = setTimeout(() => {
+			this.cutWatch = null;
+			if (this.done) return;
+			this.deps.logger.warn("videoclips: a cut clip stream is still holding its camera lane", {
+				tags: this.tags,
+				meta: {
+					clipKey: this.input.row.clipKey,
+					twin: this.input.twin,
+					branch: "cut-not-honoured",
+					reason,
+					hostKey: this.input.device.hostKey,
+					heldSinceCutMs: Date.now() - cutAt,
+					accessUnits: this.accessUnits,
+					bytesOut: this.bytesOut,
+					begun: this.begun
+				}
+			});
+		}, this.deps.cutGraceMs);
+		this.cutWatch.unref?.();
+	}
 	sever(reason, detail) {
 		if (this.cut !== null || this.done) return;
 		this.cut = {
@@ -153136,6 +153578,7 @@ var ClipStreamRun = class {
 			}
 		});
 		if (this.begun) this.input.sink.destroy();
+		this.armCutWatch(reason);
 	}
 	cutOutcome(cut) {
 		if (this.begun) return {
@@ -155043,11 +155486,24 @@ function createReolinkVideoclipsProvider(deps) {
 		* reads only whether the dial and the file read are wired, and never the
 		* clip or the profile.
 		*
-		* The rates are the BROKER's re-pacing ladder. The camera's own
-		* `<playSpeed>` (8, 16) is real and still unwired (D597, D600): it would
-		* ride on the dial and cost a new stream per change, and its audio has no
-		* resampler on this path. When it is wired its rates join
-		* `CLIP_BROKER_PACED_RATES` — not a second list here.
+		* The rates are the BROKER's re-pacing ladder, and they are the only
+		* rates there are. The camera's own `<playSpeed>` is NOT a second rate
+		* mechanism waiting to be wired — measured on 592, 2026-09-23 (D620):
+		* at 1, 2, 4 and 8 it returns a byte-identical transfer (947 472 B, 594
+		* access units, the same 39.855 s presentation span, the same 624 AAC
+		* frames) and changes only how fast those bytes cross. It buys SUPPLY,
+		* never speed. `playSpeed 16` is not a rate either: the camera switches
+		* to one frame per GOP across the whole clip (20 units, 2 025 ms apart,
+		* no audio) — a different STREAM, dialled as one, never a rate applied to
+		* this one.
+		*
+		* So 8x and 16x do not arrive here. They arrive when the broker's pacer
+		* is allowed above 4 (`clampPlaybackRate`, the `setRate` bound and
+		* `CLIP_BROKER_PACED_RATES`, together) — and only once the supply behind
+		* them is real: D620 measured this camera delivering at 1.2–1.37x while
+		* the library positions every replay with cmd 123, against 95–116x when
+		* it does not. A ladder widened before that is a rate accepted and not
+		* delivered, which is the whole defect D612 exists to end.
 		*/
 		getPlaybackOptions: async () => CLIP_PLAYBACK_OPTIONS.stream,
 		/**