@camstack/system 1.2.287 → 1.2.289

package/dist/{dist-jv1aoo9E.mjs → dist-DKFb2936.mjs}

@@ -691,7 +691,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-De1BvmWo.mjs
+//#region ../types/dist/sleep-i3eUVc-d.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -11973,6 +11973,118 @@ var deviceAdoptionCapability = {
 	}
 };
 /**
+* 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 = z.enum(["device", "integration"]);
+var DeviceAdminLinkSchema = z.object({
+	/**
+	* Absolute `http(s)://` URL. Built by `buildDeviceAdminUrl` and therefore
+	* free of userinfo and of any credential-shaped query key.
+	*/
+	url: z.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: z.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: z.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(z.object({ deviceId: z.number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" }) }
+};
+/**
 * `device-export` — collection cap for addons that export camstack
 * devices to external ecosystems (HomeAssistant via MQTT discovery,
 * HomeKit/HAP, Alexa Smart Home, …).
@@ -29259,6 +29371,390 @@ 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 = z.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 = z.object({
+	trigger: RecordTriggerSchema,
+	day: z.number().int().min(0).max(6),
+	startMinute: z.number().int().min(0).max(1439),
+	endMinute: z.number().int().min(1).max(1440)
+});
+/** Status of one physical volume, as the camera itself describes it. */
+var OnboardStorageVolumeSchema = z.object({
+	/** The camera's own id for the volume (`hdd/id`, Reolink `HddInfo/number`). */
+	id: z.string(),
+	/** The camera's own name for it, when it gives one (`hddName`). */
+	label: z.string().optional(),
+	status: z.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: z.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: z.number().nullable(),
+	/** True when the camera reports the volume writable (`property` RW). */
+	writable: z.boolean().optional()
+});
+/**
+* Whether the camera has usable onboard storage.
+*
+* Three states, never two: an unreadable answer is `unknown`, never
+* folded into `absent`. Folding a failed read into "no card" is how a
+* healthy camera gets reported as broken, and the inverse is how a
+* camera with no card reports `ok` and then an empty list (D393).
+*/
+var OnboardStorageSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("present"),
+		volumes: z.array(OnboardStorageVolumeSchema)
+	}),
+	z.object({
+		kind: z.literal("absent"),
+		reason: z.string()
+	}),
+	z.object({
+		kind: z.literal("unknown"),
+		reason: z.string()
+	})
+]);
+/**
+* One recording track the camera exposes. Read-only.
+*
+* Hikvision lists several — 1436 and 3833 each list 101 AND 103, with
+* DIFFERENT schedules (101 MOTION all day, 103 CMR 00:05–23:57) — so a
+* cap that reported one number for "the schedule" would be lying on
+* every Hikvision in the fleet. Reolink has exactly one per channel.
+*
+* There is deliberately **no `framerate`**. Hikvision declares it in the
+* track `Description` and it is WRONG: 1436 says `2.260000 fps` while
+* the media measures 12.55 fps. `codec` and `resolution` from the same
+* string ARE right — those are the only two worth surfacing.
+*/
+var OnboardRecordTrackSchema = z.object({
+	id: z.string(),
+	enabled: z.boolean(),
+	isVideo: z.boolean(),
+	/** From the camera's own track description. Null when it does not say. */
+	codec: z.string().nullable(),
+	resolution: z.string().nullable(),
+	/** Per-track overwrite flag, where the firmware keeps it per track. */
+	overwriteWhenFull: z.boolean().nullable()
+});
+/**
+* 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 = z.object({
+	storage: OnboardStorageSchema,
+	tracks: z.array(OnboardRecordTrackSchema),
+	/**
+	* The track the write path targets — the enabled VIDEO one. Null when
+	* no track could be identified, which is itself a refusal reason.
+	*/
+	primaryTrackId: z.string().nullable(),
+	/** Master "record to the card at all" switch. */
+	enabled: z.boolean().nullable(),
+	overwriteWhenFull: z.boolean().nullable(),
+	preRecordSec: z.number().nullable(),
+	postRecordSec: z.number().nullable(),
+	/** Length of one recorded file, in minutes. */
+	segmentMinutes: z.number().nullable(),
+	/** The primary track's weekly windows, flattened. */
+	windows: z.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: z.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: z.boolean(),
+	lastFetchedAt: z.number()
+});
+/** Numeric range descriptor — `{ min, max, step }` per the getOptions convention. */
+var RangeSchema = z.object({
+	min: z.number(),
+	max: z.number(),
+	step: z.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 = z.object({
+	values: z.array(z.number()).min(1),
+	sentinel: z.object({
+		value: z.number(),
+		meaning: z.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 = z.object({
+	readable: z.boolean(),
+	writable: z.boolean(),
+	/** Required whenever `readable` or `writable` is false. */
+	reason: z.string().optional()
+});
+/** What this camera's schedule model can express. */
+var OnboardScheduleSupportSchema = z.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: z.number(),
+	/** Triggers this camera can record on. A window naming another is refused. */
+	triggers: z.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: z.boolean()
+});
+var RecordingOnboardOptionsSchema = z.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 = z.object({
+	enabled: z.boolean().optional(),
+	overwriteWhenFull: z.boolean().optional(),
+	preRecordSec: z.number().optional(),
+	postRecordSec: z.number().optional(),
+	segmentMinutes: z.number().optional(),
+	/** The complete new window set for the primary track — not a delta. */
+	windows: z.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(z.object({ deviceId: z.number() }), RecordingOnboardOptionsSchema),
+		setSettings: method(z.object({
+			deviceId: z.number(),
+			settings: RecordingOnboardPatchSchema
+		}), z.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"]
+};
+/** Minutes in a day. `endMinute === 1440` means "to end of day". */
+var MINUTES_PER_DAY = 1440;
+/**
+* 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"
+];
+/** `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")}`;
+}
+/**
 * 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
@@ -39467,6 +39963,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	pressureSensor: pressureSensorCapability,
 	privacyMask: privacyMaskCapability,
 	ptzAutotrack: ptzAutotrackCapability,
+	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
@@ -41820,6 +42317,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"ptz",
 	"ptz-autotrack",
 	"recording",
+	"recording-onboard",
 	"recording-signal",
 	"scene-monitor",
 	"script-runner",
@@ -41890,6 +42388,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	dayNightCapability,
 	decoderCapability,
 	detectionPipelineCapability,
+	deviceAdminLinkCapability,
 	deviceAdoptionCapability,
 	deviceDiscoveryCapability,
 	deviceExportCapability,
@@ -41964,6 +42463,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	rebootCapability,
 	recordingCapability,
 	recordingExportCapability,
+	recordingOnboardCapability,
 	recordingSignalCapability,
 	sceneMonitorCapability,
 	scriptRunnerCapability,
@@ -43308,6 +43808,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceAdminLink.getAdminLink": {
+		capName: "device-admin-link",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"deviceAdoption.adopt": {
 		capName: "device-adoption",
 		capScope: "system",
@@ -47346,6 +47852,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recordingOnboard.getOptions": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recordingOnboard.getStatus": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recordingOnboard.setSettings": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"recordingSignal.getStatus": {
 		capName: "recording-signal",
 		capScope: "device",
@@ -49232,6 +49756,11 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"deviceAdminLink.getAdminLink": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceAdoption.release": [{
 		name: "camDeviceId",
 		form: "single",
@@ -50617,6 +51146,16 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"recordingOnboard.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recordingOnboard.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"recordingSignal.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -51000,7 +51539,7 @@ Object.freeze({
 });
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 68 caps: 35 `restored`, 33 `session`.
+* `runtimeState`. 69 caps: 36 `restored`, 33 `session`.
 *
 * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
 * with `durability: 'session'` has one and has decided not to keep it.
@@ -51202,6 +51741,10 @@ var RUNTIME_STATE_POLICY = {
 		durability: "session",
 		volatileFields: []
 	},
+	"recording-onboard": {
+		durability: "restored",
+		volatileFields: ["lastFetchedAt"]
+	},
 	"recording-signal": {
 		durability: "session",
 		volatileFields: []
@@ -51990,4 +52533,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { deviceStateCapability as $, storageProviderCapability as $t, StorageLocationModeSchema as A, parseJsonUnknown as An, motionCapability as At, bareAddonId as B, resolveContainerPrimaryChild as Bt, RecordingStatusSchema as C, emitReadiness as Cn, logDestinationCapability as Ct, STREAM_PROFILE_META as D, isEvent as Dn, mayWriteToLocation as Dt, STORAGE_ACCESS_FALLBACK as E, isDeviceConfigCap as En, mayReadLocation as Et, addonSettingsCapability as F, EventCategory as Fn, platformProbeCapability as Ft, coreBlockAddonId as G, scopesAllowDeviceCap as Gt, buildStreamParamsConfigSchema as H, resolveMethodAuth as Ht, addonWidgetsCapability as I, procedureAuthKey as It, dataStoreProviderCapability as J, siteZoneKey as Jt, coreBlockIdFromAddonId as K, scoreRuntimes as Kt, alertsCapability as L, ptzAutotrackCapability as Lt, StorageMigrationJobSchema as M, resolveCapMount as Mn, objectInputDeclaresAddonId as Mt, UserRecordSchema as N, scopeKey as Nn, objectInputDeclaresRequiredDeviceId as Nt, ScopedTokenSchema as O, nodePin as On, metricsProviderCapability as Ot, addonPagesCapability as P, sleep as Pn, parseStreamParamsFormPatch as Pt, deviceManagerCapability as Q, storageOccupancyCapability as Qt, authProviderCapability as R, reducePoints as Rt, RUNTIME_DEFAULTS as S, emitDownForOwnedCaps as Sn, locationIconKey as St, SOURCE_DEVICE_TYPES as T, hydrateSchema as Tn, looseSchema as Tt, cameraGridLayoutCapability as U, runtimeStatePolicyFor as Ut, batteryCapability as V, resolveLocationMode as Vt, collectSecretConfigKeys as W, scopesAllowAddon as Wt, decodeVectorBase64 as X, storageCapability as Xt, declarationOwnerNodeId as Y, snapshotCapability as Yt, deriveBatteryPresence as Z, storageMigrationCapability as Zt, LegacyStorageLocationDefaultSchema as _, WELL_KNOWN_TAB_MAP as _n, isVoidInput as _t, BatteryStatusSchema as a, withLocationMode as an, evaluateSensorEdge as at, MOTION_CLOSE_AFTER_MS as b, asString as bn, lifecycleJobSchema as bt, CORE_BLOCKS_ADDON_ID as c, BaseAddon as cn, filesystemBrowseCapability as ct, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as d, DEVICE_STATUS_METHOD as dn, isArrayOutputSchema as dt, streamCatalogCapability as en, deviceStatusCapability as et, DERIVED_CAMERA_SILENCED_CAP_NAMES as f, DeviceFeature as fn, isCollectionArrayMethod as ft, LOG_LEVEL_RANK as g, ReadinessTimeoutError as gn, isSourceCap as gt, FIRST_LEVEL_MACRO_CLASSES as h, ReadinessRegistry as hn, isSameAddonId as ht, BaseDevice as i, vectorStoreCapability as in, enumerateSchemaFields as it, StorageLocationTypeSchema as j, readinessKey as jn, normalizeUnit as jt, StorageCleanupJobSchema as k, parseJsonObject as kn, modeMayWrite as kt, CORE_BLOCK_ADDON_PREFIX as l, DATAPLANE_SECRET_HEADER as ln, foldSnapshotByFunction as lt, DeviceStatusSchema as m, DeviceType as mn, isObjectInput as mt, AlertSchema as n, userManagementCapability as nn, enumerateInferenceDevices as nt, CAMERA_SWITCH_ORDER as o, errMsg as on, evictionPolicyOfLocation as ot, DeclaredDevices as p, DeviceRole as pn, isLocationEnabled as pt, coreBlocksCapability as q, settingsStoreCapability as qt, ApiKeyRecordSchema as r, vectorDimFromBase64 as rn, enumerateItemArrayFields as rt, CAP_NAMES_WITH_STATUS as s, buildFfmpegArgs as sn, extractNestedAddonId as st, ALL_CAPABILITY_DEFINITIONS as t, streamQualityLabel as tn, doorbellCapability as tt, CoreBlockSchema as u, DEVICE_SETTINGS_CONTRIBUTION_METHODS as un, gbToBytes as ut, LocationIconIdSchema as v, asJsonObject as vn, kebabToCamel as vt, SOURCE_CAPS as w, expandCapMethods as wn, logLevelAtMost as wt, REDACTED_SECRET as x, createEvent as xn, localNetworkCapability as xt, METHOD_ACCESS_MAP as y, asNumber as yn, legacyModeOf as yt, backupCapability as z, resolveBucketMs as zt };
+export { deriveBatteryPresence as $, storageCapability as $t, ScopedTokenSchema as A, isEvent as An, mayWriteToLocation as At, authProviderCapability as B, ptzAutotrackCapability as Bt, REDACTED_SECRET as C, asString as Cn, lifecycleJobSchema as Ct, SOURCE_DEVICE_TYPES as D, expandCapMethods as Dn, logLevelAtMost as Dt, SOURCE_CAPS as E, emitReadiness as En, logDestinationCapability as Et, UserRecordSchema as F, resolveCapMount as Fn, objectInputDeclaresAddonId as Ft, cameraGridLayoutCapability as G, resolveMethodAuth as Gt, bareAddonId as H, resolveBucketMs as Ht, addonPagesCapability as I, scopeKey as In, objectInputDeclaresRequiredDeviceId as It, coreBlockIdFromAddonId as J, scopesAllowDeviceCap as Jt, collectSecretConfigKeys as K, runtimeStatePolicyFor as Kt, addonSettingsCapability as L, sleep as Ln, parseStreamParamsFormPatch as Lt, StorageLocationModeSchema as M, parseJsonObject as Mn, modeMayWrite as Mt, StorageLocationTypeSchema as N, parseJsonUnknown as Nn, motionCapability as Nt, STORAGE_ACCESS_FALLBACK as O, hydrateSchema as On, looseSchema as Ot, StorageMigrationJobSchema as P, readinessKey as Pn, normalizeUnit as Pt, decodeVectorBase64 as Q, snapshotCapability as Qt, addonWidgetsCapability as R, EventCategory as Rn, platformProbeCapability as Rt, MOTION_CLOSE_AFTER_MS as S, asNumber as Sn, legacyModeOf as St, RecordingStatusSchema as T, emitDownForOwnedCaps as Tn, locationIconKey as Tt, batteryCapability as U, resolveContainerPrimaryChild as Ut, backupCapability as V, reducePoints as Vt, buildStreamParamsConfigSchema as W, resolveLocationMode as Wt, dataStoreProviderCapability as X, settingsStoreCapability as Xt, coreBlocksCapability as Y, scoreRuntimes as Yt, declarationOwnerNodeId as Z, siteZoneKey as Zt, LOG_LEVEL_RANK as _, DeviceType as _n, isObjectInput as _t, BatteryStatusSchema as a, userManagementCapability as an, enumerateItemArrayFields as at, METHOD_ACCESS_MAP as b, WELL_KNOWN_TAB_MAP as bn, isVoidInput as bt, CORE_BLOCKS_ADDON_ID as c, withLocationMode as cn, evictionPolicyOfLocation as ct, DAY_NAMES as d, BaseAddon as dn, foldSnapshotByFunction as dt, storageMigrationCapability as en, deviceManagerCapability as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, DATAPLANE_SECRET_HEADER as fn, formatMinutes as ft, FIRST_LEVEL_MACRO_CLASSES as g, DeviceRole as gn, isLocationEnabled as gt, DeviceStatusSchema as h, DeviceFeature as hn, isCollectionArrayMethod as ht, BaseDevice as i, streamQualityLabel as in, enumerateInferenceDevices as it, StorageCleanupJobSchema as j, nodePin as jn, metricsProviderCapability as jt, STREAM_PROFILE_META as k, isDeviceConfigCap as kn, mayReadLocation as kt, CORE_BLOCK_ADDON_PREFIX as l, errMsg as ln, extractNestedAddonId as lt, DeclaredDevices as m, DEVICE_STATUS_METHOD as mn, isArrayOutputSchema as mt, AlertSchema as n, storageProviderCapability as nn, deviceStatusCapability as nt, CAMERA_SWITCH_ORDER as o, vectorDimFromBase64 as on, enumerateSchemaFields as ot, DERIVED_CAMERA_SILENCED_CAP_NAMES as p, DEVICE_SETTINGS_CONTRIBUTION_METHODS as pn, gbToBytes as pt, coreBlockAddonId as q, scopesAllowAddon as qt, ApiKeyRecordSchema as r, streamCatalogCapability as rn, doorbellCapability as rt, CAP_NAMES_WITH_STATUS as s, vectorStoreCapability as sn, evaluateSensorEdge as st, ALL_CAPABILITY_DEFINITIONS as t, storageOccupancyCapability as tn, deviceStateCapability as tt, CoreBlockSchema as u, buildFfmpegArgs as un, filesystemBrowseCapability as ut, LegacyStorageLocationDefaultSchema as v, ReadinessRegistry as vn, isSameAddonId as vt, RUNTIME_DEFAULTS as w, createEvent as wn, localNetworkCapability as wt, MINUTES_PER_DAY as x, asJsonObject as xn, kebabToCamel as xt, LocationIconIdSchema as y, ReadinessTimeoutError as yn, isSourceCap as yt, alertsCapability as z, procedureAuthKey as zt };

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-C51Z6L6t.js");
+const require_dist = require("./dist-BYnHJU96.js");
 const require_builtins_alerts_alerts_addon = require("./builtins/alerts/alerts.addon.js");
 require("./builtins/alerts/index.js");
 const require_formatter = require("./formatter-DqAKDlvN.js");

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM$1, r as __exportAll, t as __commonJSMin$1 } from "./chunk-CNf5ZN-e.mjs";
-import { An as parseJsonUnknown, F as addonSettingsCapability, Fn as EventCategory$1, Gt as scopesAllowDeviceCap, Ht as resolveMethodAuth, It as procedureAuthKey, Mn as resolveCapMount, Mt as objectInputDeclaresAddonId, Nn as scopeKey, Nt as objectInputDeclaresRequiredDeviceId, S as RUNTIME_DEFAULTS, Sn as emitDownForOwnedCaps, Tt as looseSchema, Wt as scopesAllowAddon, _t as isVoidInput, bn as asString$1, bt as lifecycleJobSchema, dn as DEVICE_STATUS_METHOD, dt as isArrayOutputSchema, ft as isCollectionArrayMethod, g as LOG_LEVEL_RANK, gn as ReadinessTimeoutError, hn as ReadinessRegistry, jn as readinessKey, kn as parseJsonObject, ln as DATAPLANE_SECRET_HEADER$1, mt as isObjectInput, on as errMsg$1, st as extractNestedAddonId, t as ALL_CAPABILITY_DEFINITIONS, un as DEVICE_SETTINGS_CONTRIBUTION_METHODS, vn as asJsonObject$1, vt as kebabToCamel, wn as expandCapMethods, wt as logLevelAtMost, xn as createEvent, y as METHOD_ACCESS_MAP, yn as asNumber } from "./dist-jv1aoo9E.mjs";
+import { Cn as asString$1, Ct as lifecycleJobSchema, Dn as expandCapMethods, Dt as logLevelAtMost, Fn as resolveCapMount, Ft as objectInputDeclaresAddonId, Gt as resolveMethodAuth, In as scopeKey, It as objectInputDeclaresRequiredDeviceId, Jt as scopesAllowDeviceCap, L as addonSettingsCapability, Mn as parseJsonObject, Nn as parseJsonUnknown, Ot as looseSchema, Pn as readinessKey, Rn as EventCategory$1, Sn as asNumber, Tn as emitDownForOwnedCaps, _ as LOG_LEVEL_RANK, _t as isObjectInput, b as METHOD_ACCESS_MAP, bt as isVoidInput, fn as DATAPLANE_SECRET_HEADER$1, ht as isCollectionArrayMethod, ln as errMsg$1, lt as extractNestedAddonId, mn as DEVICE_STATUS_METHOD, mt as isArrayOutputSchema, pn as DEVICE_SETTINGS_CONTRIBUTION_METHODS, qt as scopesAllowAddon, t as ALL_CAPABILITY_DEFINITIONS, vn as ReadinessRegistry, w as RUNTIME_DEFAULTS, wn as createEvent, xn as asJsonObject$1, xt as kebabToCamel, yn as ReadinessTimeoutError, zt as procedureAuthKey } from "./dist-DKFb2936.mjs";
 import { AlertCenterAddon } from "./builtins/alerts/alerts.addon.mjs";
 import "./builtins/alerts/index.mjs";
 import { t as formatLogLine } from "./formatter-B7qW8bPJ.mjs";