@camstack/addon-ai 0.2.20 → 0.4.1

package/dist/addon.mjs

@@ -7,7 +7,7 @@ import { brotliCompress, gzip } from "node:zlib";
 import * as fsp from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { createServer } from "node:net";
-//#region ../types/dist/event-category-Cv9dO26A.mjs
+//#region ../types/dist/event-category-Bxo5yJjt.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -214,6 +214,33 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["PipelineCameraAssigned"] = "pipeline.camera-assigned";
 	EventCategory["PipelineCameraUnassigned"] = "pipeline.camera-unassigned";
 	/**
+	* A node the orchestrator would otherwise place cameras on has NO usable
+	* inference device: the operator enabled one or more accelerators there and
+	* the live probe reports every one of them unavailable. Emitted once per
+	* TRANSITION into that state (never per dispatch), and the node is dropped
+	* from the placement candidate set for as long as it holds.
+	*
+	* This exists because the state was previously invisible: little-unraid
+	* absorbed 283k inference errors in a day while still being handed cameras,
+	* and nothing in the system said so.
+	*
+	* A node with no accelerators configured at all is NOT this — its devices
+	* are `disabled`, not `unavailable`, and the runner's default CPU pool
+	* serves it exactly as before.
+	*/
+	EventCategory["PipelineNodeInferenceUnavailable"] = "pipeline.node-inference-unavailable";
+	/**
+	* A camera has an OPEN detection session and has produced no detection at
+	* all for longer than the blind threshold — the camera is being decoded and
+	* inferred and is returning nothing. Emitted once per transition into blind,
+	* per camera.
+	*
+	* The failure it reports: a 1h43 detection blackout on the entrance camera
+	* that nobody noticed, because "a camera that detects nothing" and "a quiet
+	* camera" produce byte-identical silence.
+	*/
+	EventCategory["PipelineDetectionBlind"] = "pipeline.detection-blind";
+	/**
 	* Per-camera pipeline config was mutated by the orchestrator
 	* (3-level settings change via `setAgentAddonDefaults` /
 	* `setCameraStepToggle` / `setCameraPipelineForAgent` or a
@@ -3005,6 +3032,9 @@ function handlePipeResult(left, next, ctx) {
 		fallback: left.fallback
 	}, ctx);
 }
+var $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
+	$ZodPipe.init(inst, def);
+});
 var $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -4322,7 +4352,7 @@ var parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
 var encode = /* @__PURE__ */ _encode(ZodRealError);
-var decode = /* @__PURE__ */ _decode(ZodRealError);
+var decode$1 = /* @__PURE__ */ _decode(ZodRealError);
 var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
 var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
 var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
@@ -4383,7 +4413,7 @@ var ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 	inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
 	inst.spa = inst.safeParseAsync;
 	inst.encode = (data, params) => encode(inst, data, params);
-	inst.decode = (data, params) => decode(inst, data, params);
+	inst.decode = (data, params) => decode$1(inst, data, params);
 	inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
 	inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
 	inst.safeEncode = (data, params) => safeEncode(inst, data, params);
@@ -5190,6 +5220,10 @@ function pipe(in_, out) {
 		out
 	});
 }
+var ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
+	ZodPipe.init(inst, def);
+	$ZodPreprocess.init(inst, def);
+});
 var ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
@@ -5248,6 +5282,13 @@ function _instanceof(cls, params = {}) {
 	};
 	return inst;
 }
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
+}
 //#endregion
 //#region ../../node_modules/zod/v4/classic/compat.js
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
@@ -5364,6 +5405,12 @@ Object.fromEntries([
 		icon: "shapes",
 		order: 38
 	},
+	{
+		id: "scenes",
+		label: "Scenes",
+		icon: "scan-eye",
+		order: 36
+	},
 	{
 		id: "analytics",
 		label: "Analytics",
@@ -13033,11 +13080,33 @@ var NotificationFormatSchema = _enum([
 * Named by INTENT, never by glyph. "check" would tie the vocabulary to one
 * renderer's icon set; "acknowledge" survives an adapter that draws it
 * differently.
+*
+* ── A TOKEN IS NOT A WIRE VALUE ─────────────────────────────────────
+*
+* These names are for US. **No adapter may forward one verbatim.** Each maps
+* the whole set onto its own renderer's vocabulary through a
+* `Record<NotificationActionIcon, string>` — a Record, never a lookup with a
+* fallback, so adding a member here fails every adapter's build until someone
+* decides its glyph, which is the only place that decision can be made
+* honestly.
+*
+* This paragraph is the bug. Zentik declared `actionIcons: true` and passed
+* `disarm` straight through; iOS feeds that string to
+* `UNNotificationActionIcon(systemImageName:)`, `disarm` is not an SF Symbol,
+* and every snooze and alarm button arrived BLANK. A pass-through is not a
+* mapping, and "the field is documented" is not "the value renders".
+*
+* Adding a member is TRAIN-BOUND. The enum lives in the published
+* `@camstack/server` closure and the cap seam validates against the HUB's copy,
+* so an addon that emits a token the running hub does not know does not lose an
+* icon — its whole `send` fails Zod validation and the notification never
+* arrives. Never emit a new token from an addon before the train carrying it.
 */
 var NotificationActionIconSchema = _enum([
 	"acknowledge",
 	"dismiss",
 	"silence",
+	"snooze",
 	"view",
 	"play",
 	"open",
@@ -13045,9 +13114,13 @@ var NotificationActionIconSchema = _enum([
 	"lock",
 	"unlock",
 	"arm",
+	"arm-home",
+	"arm-away",
+	"arm-night",
 	"disarm",
 	"light",
-	"alert"
+	"alert",
+	"camera"
 ]);
 /** A single tap-through action button. */
 var NotificationActionSchema = object({
@@ -13247,6 +13320,24 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	targetId: string(),
 	enabled: boolean()
 }), _void(), { kind: "mutation" });
+new Set([
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+].map((l) => l.id));
 var COCO_TO_MACRO = {
 	mapping: {
 		person: "person",
@@ -14039,11 +14130,15 @@ var NcSystemEventKindSchema = _enum([
 	"stream-offline",
 	"node-online",
 	"node-offline",
+	"node-inference-unavailable",
+	"detection-blind",
 	"addon-update-available",
 	"server-update-available",
 	"alarm-triggered",
 	"alarm-armed",
 	"alarm-disarmed",
+	"alarm-arming",
+	"alarm-arm-refused",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -14098,7 +14193,16 @@ var NcScheduleSchema = object({
 });
 /** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
 var NcPlateMatcherSchema = object({
-	values: array(string().min(1)).min(1),
+	/**
+	* Plate texts (or gallery vehicle names) to match. EMPTY = **any plate the
+	* pipeline could read** — the plate half of "no selection = no narrowing",
+	* and the switch that says this rule is about vehicles that were IDENTIFIED
+	* rather than merely seen. A subject carrying no plate still fails.
+	*
+	* The `.min(1)` this used to carry made that state unauthorable; nothing has
+	* ever persisted an empty list, so widening it cannot change an existing rule.
+	*/
+	values: array(string().min(1)),
 	/** Max Levenshtein distance after normalization (uppercase alphanumeric). */
 	maxDistance: number().int().min(0).max(3).default(1)
 });
@@ -14337,18 +14441,47 @@ var NcConditionsSchema = object({
 	*/
 	labelEquals: array(string().min(1)).optional(),
 	/**
-	* Identity matcher. P1 boundary: matched against the record's collapsed
-	* `label` (the identity display name propagated by the face pipeline) —
-	* identity-ID matching rides in P2 when identity ids reach the record.
+	* KNOWN FACES — the rule's identity scope, and the switch that says the rule
+	* is about recognised people at all.
+	*
+	* Three states, and the empty one is the point:
+	*
+	* | value | meaning |
+	* | --- | --- |
+	* | absent | the rule does not care who it is; an unrecognised person matches |
+	* | `[]` | **only known faces** — any identity in the gallery, nobody in particular |
+	* | a list | only these identities |
+	*
+	* `[]` is the repo-wide "no selection = no narrowing" reading (an absent
+	* `devices` list is every device), applied one level down: the operator has
+	* turned the face scope ON and narrowed it to nothing, which is every known
+	* face. No second field states the same thing — a switch that can disagree
+	* with the list under it is worse than no switch (D62).
+	*
+	* MEMBERS ARE FACE-GALLERY `Identity.id`s (uuid), not display names. A name is
+	* renameable, and a rule authored on "Gianluca" went silently dark the moment
+	* the operator fixed the spelling. The id reaches the record on
+	* `LabelAttribution.identityId`; the name is what the editor shows and what
+	* `{{label}}` renders.
+	*
+	* Rules written before this carry NAMES, and are resolved to ids lazily at
+	* load (`NcRuleStore.load`) against the live gallery — a name nothing answers
+	* for is left as it stands and reported, never dropped. The engine also
+	* accepts a display-name hit as a compatibility leg, so a rule whose
+	* migration could not resolve keeps matching exactly what it matched before.
 	*/
 	identities: array(string().min(1)).optional(),
-	/** Fuzzy plate matcher against the record's `label` (plate text). */
+	/**
+	* KNOWN PLATES / VEHICLES — the plate mirror of {@link identities}, including
+	* the empty-list reading: `values: []` is "any plate the OCR could read",
+	* a non-empty list is those plates (fuzzily). See {@link NcPlateMatcherSchema}.
+	*/
 	plates: NcPlateMatcherSchema.optional(),
 	/**
-	* Identity EXCLUDE — mirror of {@link identities} with `notIn` semantics.
-	* Same P1 boundary: matched against the record's collapsed `label` (the
-	* identity display name). A record with NO label passes (nothing to
-	* exclude), unlike the include variant which fails on an absent label.
+	* Identity EXCLUDE — mirror of {@link identities} with `notIn` semantics, and
+	* the same id members and the same lazy name→id migration. A record with NO
+	* identity passes (nothing to exclude), unlike the include variant which
+	* fails on an unrecognised subject. An EMPTY list excludes nobody.
 	*/
 	identitiesExclude: array(string().min(1)).optional(),
 	/**
@@ -14740,7 +14873,80 @@ var NcRuleInputSchema = object({
 	* a rule that predates the gate must keep delivering byte-for-byte as it
 	* did, and absent is the only way to say that without a migration.
 	*/
-	confirm: NcConfirmSchema.optional()
+	confirm: NcConfirmSchema.optional(),
+	/**
+	* WAIT for face/plate recognition before saying anything.
+	*
+	* A notification's TEXT is frozen at enqueue and its media is re-resolved at
+	* send; the identity is neither. A face is confirmed after `confirmFrames`
+	* agreeing observations — p50 **11.4 s** after the track was first seen,
+	* measured on this hub — and an `immediate` rule enqueues on the first object
+	* event, seconds before that. So "Gianluca è arrivato" is unsayable on the
+	* immediate path, and no amount of media re-resolution fixes a sentence.
+	*
+	* Only two honest answers exist, and this flag picks between them. It has
+	* effect ONLY on a rule that declares a recognition scope
+	* ({@link NcConditions.identities} or {@link NcConditions.plates}) — on any
+	* other rule there is nothing to wait for and the flag is inert.
+	*
+	* | value | what happens |
+	* | --- | --- |
+	* | `true` | the rule stops firing on the object event and fires at TRACK CLOSE instead, once, with the name — later, and complete |
+	* | absent / `false` | it fires at once WITHOUT the name, and if recognition lands before the track closes a SECOND, "…is Gianluca" notification follows (one per track, per rule, per target) |
+	*
+	* `.optional()` and deliberately NOT `.default()`: a Zod default does not run
+	* on the addon cap path, and absent has to keep meaning exactly what every
+	* rule authored before this field meant.
+	*
+	* The cost of `true` is stated here because the editor states it too: a rule
+	* that waits also inherits track-close SEMANTICS — its `zones` condition
+	* tests every zone the track visited and a `crossing` condition can no longer
+	* be satisfied, because a closed track carries no crossing.
+	*/
+	waitForEnhancement: boolean().optional(),
+	/**
+	* GROUP a burst of subjects into ONE notification that grows.
+	*
+	* Seconds of quiet after the last matching subject before the burst is
+	* considered over. While it is open, the first subject enqueues immediately —
+	* **exactly as today, with no added latency** — and every real growth (a new
+	* subject, or a name confirmed on one already in it) REPLACES that
+	* notification with an updated one naming everybody. The push carries the
+	* group's own coalescing tag, so the phone replaces rather than stacks.
+	*
+	* `0` / absent = off, and off is today's behaviour byte for byte.
+	*
+	* ### Why an idle cutoff and not a window
+	*
+	* The measured seven-person arrival on device 590 spans 110 s with every
+	* internal gap under 30 s. A 12 s fixed window cuts it into three groups; an
+	* idle cutoff holds it as one and ends it when the arrival actually ends.
+	* 30 is Frigate's shipped value for the same decision.
+	*
+	* ### What it replaces
+	*
+	* The blind cooldown, which collapses a burst by DISCARDING it. Measured on
+	* device 615 / *Persona su Uscio* over six days: 116 qualifying tracks → 74
+	* notifications, **44 (37.9%) suppressed outright**, 23 of them overlapping a
+	* track that did fire and 7 carrying a confirmed identity nobody heard about.
+	* A group collapses the same volume by MERGING, so the cooldown becomes a
+	* budget over GROUPS — which is what it always meant — and a growth is never
+	* throttled by the window its own first member spent.
+	*
+	* ### Interaction with {@link waitForEnhancement}
+	*
+	* They compose, and the order matters. `waitForEnhancement` defers the rule to
+	* TRACK CLOSE, so with both set the group is opened by the first member to
+	* CLOSE — already carrying its name — and grows as later members close. That
+	* is later, and complete. With grouping alone the group opens on the first
+	* object event and picks up names as they are confirmed, through the growth
+	* path. Neither combination fires twice for one subject.
+	*
+	* `.optional()` and deliberately NOT `.default()`: a Zod default does not run
+	* on the addon cap path, so absent must keep meaning what it meant before this
+	* field existed.
+	*/
+	groupIdleSec: number().int().min(0).max(600).optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -15252,7 +15458,87 @@ var MethodAccessSchema = _enum([
 var AllowedProviderSchema = union([literal("*"), array(string())]);
 var AllowedDevicesSchema = record(string(), union([literal("*"), array(string())]));
 var CapScopeSchema = _enum(["device", "system"]);
-var TokenScopeSchema = discriminatedUnion("type", [
+/**
+* DeviceSelector (scope model v3 — 2026-08-12).
+*
+* A `device` grant no longer carries a frozen list of deviceIds. It carries
+* a SELECTOR the matcher resolves against the live fleet, so the grant can be
+* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
+* AFTER the grant was minted — no re-grant, no re-login.
+*
+*   - `all`       — every device in the deployment. The broad viewer/operator
+*     lever without a `category` grant (a `category` grant also covers device
+*     caps that carry no deviceId; `all` is specifically the device set).
+*   - `ids`       — an explicit deviceId list. This is what a v2 `device:[…]`
+*     grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
+*     is NOT covered until the grant is edited.
+*   - `types`     — every device of a `DeviceType` (e.g. every `camera`).
+*     DYNAMIC. A device that changes type, or a new device of the type,
+*     re-resolves on the next request.
+*   - `locations` — every device whose operator-assigned `location` label is
+*     in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
+*     null/unset location matches NO `locations` selector.
+*/
+var DeviceSelectorSchema = discriminatedUnion("kind", [
+	object({ kind: literal("all") }),
+	object({
+		kind: literal("ids"),
+		ids: array(number().int()).min(1)
+	}),
+	object({
+		kind: literal("types"),
+		types: array(_enum(DeviceType)).min(1)
+	}),
+	object({
+		kind: literal("locations"),
+		locations: array(string().min(1)).min(1)
+	})
+]);
+var DeviceTokenScopeSchema = object({
+	type: literal("device"),
+	/** The device SET this grant covers — resolved against the live fleet. */
+	selector: DeviceSelectorSchema,
+	access: array(MethodAccessSchema).min(1),
+	/**
+	* Whether a grant on a PARENT device transparently covers its accessory
+	* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
+	* Direction is parent → children ONLY.
+	*
+	* Absent → the matcher DERIVES it from the access flavour: `view`
+	* inherits (a camera viewer sees the camera's accessories), `create` /
+	* `delete` do NOT (actuating/removing a child is an explicit act the
+	* operator must grant on the child, not inherit from the parent). Set it
+	* explicitly to override that default per grant.
+	*/
+	includeLinked: boolean().optional()
+});
+/**
+* v2 → v3 lazy migration. A pre-v3 `device` grant carried
+* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
+* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
+* EVERY parse path — stored records AND the JWT-carried scope arrays
+* normalised at the request boundary ({@link normalizeTokenScopes} in
+* `device-selector.ts`). Chosen over a one-time DB migration because a
+* migration cannot reach a JWT already in a client's hands; parse-time
+* migration covers both without a flag day. No cast — the raw object is read
+* through `Reflect.get` (its static type is `unknown`).
+*/
+function migrateLegacyTokenScope(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
+	if (Reflect.get(raw, "type") !== "device") return raw;
+	if (Reflect.get(raw, "selector") !== void 0) return raw;
+	const targets = Reflect.get(raw, "targets");
+	if (!Array.isArray(targets)) return raw;
+	return {
+		type: "device",
+		selector: {
+			kind: "ids",
+			ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
+		},
+		access: Reflect.get(raw, "access")
+	};
+}
+var TokenScopeSchema = preprocess(migrateLegacyTokenScope, discriminatedUnion("type", [
 	object({
 		type: literal("category"),
 		target: CapScopeSchema,
@@ -15268,18 +15554,8 @@ var TokenScopeSchema = discriminatedUnion("type", [
 		target: string(),
 		access: array(MethodAccessSchema).min(1)
 	}),
-	object({
-		type: literal("device"),
-		/**
-		* One or more deviceIds (serialised as strings for wire-format
-		* consistency with the rest of the union). Matcher accepts if
-		* `input.deviceId` ∈ `targets`. Array shape avoids the row-explosion
-		* of one scope-per-device when granting access to a set of cameras.
-		*/
-		targets: array(string()).min(1),
-		access: array(MethodAccessSchema).min(1)
-	})
-]);
+	DeviceTokenScopeSchema
+]));
 object({
 	id: string(),
 	username: string(),
@@ -15596,7 +15872,7 @@ var TrackEnvelopeSchema = object({
 * `snapshots[]` references — megabytes across a page of tracks. `slim`
 * keeps every scalar the list surfaces actually render (ids, class(es),
 * label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
-* zonesVisited, bestEventId, envelope, hasFace) and returns `positions` /
+* zonesVisited, bestEventId, envelope, hasFace, hasRider) and returns `positions` /
 * `snapshots` as EMPTY arrays — detail views re-fetch the full row via
 * `getTrack`. Mirrors the event-store `projection` convention
 * (`getObjectEvents` et al.).
@@ -15732,7 +16008,21 @@ union([literal(1), literal(2)]);
 var LabelAttributionSchema = object({
 	stepId: string(),
 	modelId: string().optional(),
-	decidedAt: number()
+	decidedAt: number(),
+	/**
+	* The GALLERY id behind a recognised tier-2 label — a face-gallery
+	* `Identity.id` or a plate-gallery `Vehicle.id` (both `randomUUID`).
+	*
+	* The text alone is a DISPLAY NAME, and a display name is renameable: a
+	* notification rule authored on "Gianluca" stopped matching the moment the
+	* operator fixed the spelling in the gallery, and nothing said so. The id is
+	* the thing that does not move, so it is what a rule matches on
+	* (`NcConditions.identities`) and the text is what a human is shown.
+	*
+	* Absent when the label names no gallery row — a plate the OCR read but no
+	* vehicle claims, a sub-class, a species, any tier-1 value.
+	*/
+	identityId: string().optional()
 });
 /**
 * The TIERED label model (roadmap 4g), spread into `TrackSchema` and
@@ -15869,6 +16159,28 @@ var TrackSchema = object({
 	* `=== true` and render nothing otherwise, never infer "no face".
 	*/
 	hasFace: boolean().optional(),
+	/**
+	* This subject CONTAINS a folded rider — a person the rider-pairing step
+	* ([D34](../decisions/adr-0034.md)) removed from the frame BEFORE the tracker,
+	* so the passage is tracked once and as a VEHICLE.
+	*
+	* It exists because the fold's record was dishonest. D34 and the code both
+	* said "the person is not lost — it is reported so both entities stay on the
+	* record"; in fact the pair went into a per-processor RAM field behind an
+	* accessor nobody called, and every durable surface said `vehicle`, full
+	* stop. This is the composition note that makes the row true.
+	*
+	* A COMPOSITION, never a class and never a label. "This vehicle contains a
+	* person" is not an answer to "what is this" — both label tiers would refuse
+	* a macro token anyway (D89), and correctly. Nothing here changes what the
+	* subject IS: a cyclist stays one vehicle track, occupancy still counts one,
+	* and a `person` rule still does not fire for someone cycling past.
+	*
+	* **Absent ≠ false**, exactly like {@link hasFace}: every row written before
+	* the column, and every hub that predates the field, omits it. Test
+	* `=== true` and render nothing otherwise — never infer "no rider".
+	*/
+	hasRider: boolean().optional(),
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
@@ -17276,10 +17588,26 @@ var detectionFpsField = {
 	default: 10,
 	step: 1
 };
+/**
+* The occupancy re-check interval. DEFAULT 300 s (2026-08-13 — was 30 s).
+*
+* The recheck is now on by default (a parked car is invisible to occupancy
+* rules until the stationary registry has been rebuilt by motion, which after a
+* restart may be never on a quiet camera). Each cycle re-subscribes a detection
+* session — an RTSP re-dial — so the switch is only affordable at a WIDE
+* interval: 300 s is ~12 re-dials an hour per camera, against 120 at the old
+* 30 s. A parked car is therefore counted within 5 minutes of a restart.
+*
+* Why not wider: `max` is 300 and raising it is TRAIN-BOUND, not addon-bound —
+* the host validates `attachCamera` against ITS copy of this schema, so a
+* runner asked for 600 would be rejected by the hub until a `@camstack/server`
+* carrying the wider bound is installed everywhere. 300 is the widest value
+* that ships with an addon deploy.
+*/
 var occupancyRecheckSecField = {
 	min: 0,
 	max: 300,
-	default: 30,
+	default: 300,
 	step: 5
 };
 var occupancyRecheckFramesField = {
@@ -17477,15 +17805,21 @@ var RunnerCameraConfigSchema = object({
 	*/
 	onboardMotionDrivesAnalyzer: boolean().default(true),
 	/**
-	* Master toggle for the occupancy re-check. When `false` (DEFAULT) the runner
-	* never arms the periodic recheck timer, regardless of `occupancyRecheckSec` —
-	* this is off by default because the recheck re-subscribes a detection session
-	* every N seconds while `watching`, a major source of pull-decoder re-dial
-	* churn (each cycle creates+tears a session → RTSP re-dial → latency). The
+	* Master toggle for the occupancy re-check. When `false` the runner never arms
+	* the periodic recheck timer, regardless of `occupancyRecheckSec`; the
 	* `occupancyRecheckSec` / `occupancyRecheckFrames` sliders only take effect
 	* (and only render) when this is enabled.
-	*/
-	occupancyRecheckEnabled: boolean().default(false),
+	*
+	* DEFAULT `true` since 2026-08-13 (was `false`). It was off because the
+	* recheck re-subscribes a detection session every N seconds while `watching`
+	* — each cycle creates+tears a session ⇒ an RTSP re-dial ⇒ latency, a major
+	* pull-decoder churn source. What that bought was a blind spot: a STATIONARY
+	* object is counted only while the stationary registry holds it, and the
+	* registry rebuilds from motion, so after a restart a parked car was invisible
+	* to every occupancy rule until something moved in front of it. The churn is
+	* now paid on the interval instead — see `occupancyRecheckSecField`.
+	*/
+	occupancyRecheckEnabled: boolean().default(true),
 	occupancyRecheckSec: number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
 	/**
@@ -23588,7 +23922,7 @@ method(object({
 	toMs: number()
 }), RecordingAvailabilitySchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({
 	deviceId: number(),
 	fromMs: number(),
@@ -23596,14 +23930,14 @@ method(object({
 	tzOffsetMinutes: number()
 }), RecordingDaysSchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({
 	deviceId: number(),
 	fromMs: number(),
 	toMs: number()
 }), RecordingManifestSchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({}), RecordingStorageUsageSchema, {
 	kind: "query",
 	auth: "admin"
@@ -23898,9 +24232,33 @@ method(object({
 * settings-contribution methods. `status.kind:'push'` — the engine pushes on
 * every hysteresis flip / availability change; consumers never poll.
 */
-/** Extensible condition tag. Seeded 'day' | 'night'; open by design so more can
-*  be added without a wire break (matching falls back to any-condition refs). */
+/** Extensible condition tag. Seeded 'day' | 'ir' (the two variants the operator
+*  captures) plus 'night' | 'dawn' | 'dusk' from the resolver's sun-times band.
+*  Open by design so more can be added without a wire break.
+*
+*  Matching does NOT fall back across conditions: cross-condition cosines are
+*  not comparable, so "I have never seen this scene in this light" is reported
+*  as `unknown`, never guessed. A day reference scored against an IR frame
+*  collapses the cosine and would latch a false alarm every single night. */
 var SceneConditionSchema = string();
+/** `matched` = the baseline is what we see; `diverged` = it demonstrably is not;
+*  `unknown` = we cannot judge (no reference for this condition, encoder model
+*  changed, view shifted, no snapshot). `unknown` is a real value, not a null,
+*  and never counts toward hysteresis in either direction. */
+var SceneVerdictSchema = _enum([
+	"matched",
+	"diverged",
+	"unknown"
+]);
+/** Why a scene cannot judge. Named, because this feature's failure mode is
+*  silence that reads as "nothing has happened". */
+var SceneUnavailableSchema = _enum([
+	"no-reference-for-condition",
+	"view-shifted",
+	"no-vision-profile",
+	"encoder-model-changed",
+	"no-snapshot"
+]);
 /** One captured reference — condition-tagged, model-version-gated. `embedding`
 *  is `number[]` (Float32Array does NOT survive MsgPack/UDS). */
 var SceneReferenceSchema = object({
@@ -23908,7 +24266,14 @@ var SceneReferenceSchema = object({
 	modelId: string(),
 	condition: SceneConditionSchema,
 	capturedAt: number(),
-	thumbnailMediaId: string().optional()
+	thumbnailMediaId: string().optional(),
+	/** Whole-frame (downscaled) embedding captured alongside the ROI crop. The
+	*  anti-view-shift anchor: a bumped camera, a PTZ preset or a re-aim makes the
+	*  normalized rect frame a different piece of world, and the scene would
+	*  diverge forever with a perfectly plausible cosine. Checked LAZILY, only
+	*  when hysteresis is about to flip — one extra encode per candidate
+	*  transition, not per poll. */
+	anchorEmbedding: array(number()).optional()
 });
 var SceneMonitorStateSchema = object({
 	id: string(),
@@ -23930,6 +24295,25 @@ var SceneCheckSchema = discriminatedUnion("mode", [object({
 	profileId: string().optional(),
 	hysteresisCount: number().int().positive()
 })]);
+var SCENE_DEFAULT_ANCHOR_THRESHOLD = .85;
+/**
+* Vision-model adjudication of a candidate flip. Field names deliberately
+* mirror `NcConfirmSchema` so an operator meets one vocabulary, not two.
+*
+* `onTimeout` defaults to **'hold'**, the OPPOSITE of `NcConfirmGate`'s
+* fail-open: a notification suppressed is the worse error there, but a vision
+* model that timed out has not told us the bin is gone, and a latch is a
+* stateful claim that costs the operator a trip to reset.
+*/
+var SceneConfirmSchema = object({
+	enabled: boolean().default(false),
+	prompt: string().min(1).max(1e3),
+	profileId: string().optional(),
+	timeoutMs: number().int().min(1e3).max(2e4).default(8e3),
+	maxImagePx: number().int().min(64).max(2048).default(448),
+	/** What a timeout / unavailable model means for the PENDING flip. */
+	onTimeout: _enum(["flip", "hold"]).default("hold")
+});
 var SceneMonitorSchema = object({
 	id: string(),
 	label: string(),
@@ -23948,7 +24332,41 @@ var SceneMonitorSchema = object({
 	lastConfidence: number().nullable(),
 	currentCondition: SceneConditionSchema.nullable(),
 	availability: _enum(["ok", "unavailable"]),
-	unavailableReason: string().nullable()
+	unavailableReason: string().nullable(),
+	/** Which state is "the initial screen". `null` until the first capture. */
+	baselineStateId: string().nullable(),
+	/** Which boolean drives notification rules and any export. */
+	emit: _enum(["latched", "live"]).default("latched"),
+	/** Live: does the region match the baseline RIGHT NOW. */
+	verdict: SceneVerdictSchema,
+	/** Has it been `diverged` at least once since `armedAt` — the operator's boolean. */
+	latched: boolean(),
+	/** Last reset (or creation). */
+	armedAt: number(),
+	divergedAt: number().nullable(),
+	restoredAt: number().nullable(),
+	/** A check is only COUNTED when the device has been quiet this long. Motion
+	*  during the window DISCARDS the observation — a car pulling up in front of
+	*  the bin must not be able to spend hysteresis credit. */
+	quietSeconds: number().int().min(0).max(3600).default(60),
+	/** An observation only advances the pending count when it is at least this
+	*  far from the previously counted one, so N agreeing checks span real time
+	*  rather than N adjacent polls inside one occlusion. */
+	minObservationSpacingSec: number().int().min(0).max(3600).default(120),
+	/** Vision-model adjudication of a candidate flip. Similarity primary only. */
+	confirm: SceneConfirmSchema.optional(),
+	/** Whole-frame anchor cosine below which a flip is REFUSED as `view-shifted`. */
+	anchorThreshold: number().min(0).max(1).default(SCENE_DEFAULT_ANCHOR_THRESHOLD),
+	/** Clear the latch on its own when the scene matches again? Default false —
+	*  `restoredAt` and the `scene-restored` edge are recorded regardless, so an
+	*  automation can react to the bin coming back without the operator's own
+	*  alarm silently clearing itself. */
+	autoRestore: boolean().default(false),
+	/** Named cause when `verdict === 'unknown'`. */
+	unavailable: SceneUnavailableSchema.nullable(),
+	/** Conditions that have at least one comparable reference — the coverage line
+	*  ("day ✓ · ir ✓ · dusk ✗") that turns a silent fallback into a visible fact. */
+	coveredConditions: array(SceneConditionSchema)
 });
 var SceneMonitorStatusSchema = object({
 	monitors: array(SceneMonitorSchema),
@@ -23981,7 +24399,14 @@ DeviceType.Camera, method(object({ deviceId: number() }), SceneMonitorStatusSche
 			"both"
 		]).optional(),
 		checkIntervalSec: number().optional(),
-		check: SceneCheckSchema.optional()
+		check: SceneCheckSchema.optional(),
+		emit: _enum(["latched", "live"]).optional(),
+		quietSeconds: number().int().min(0).max(3600).optional(),
+		minObservationSpacingSec: number().int().min(0).max(3600).optional(),
+		anchorThreshold: number().min(0).max(1).optional(),
+		autoRestore: boolean().optional(),
+		/** `null` clears the vision-model adjudicator. */
+		confirm: SceneConfirmSchema.nullable().optional()
 	})
 }), _void(), {
 	kind: "mutation",
@@ -24018,6 +24443,14 @@ DeviceType.Camera, method(object({ deviceId: number() }), SceneMonitorStatusSche
 }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	monitorId: string(),
+	/** Defaults to TRUE at the provider seam — see `SCENE_RESET_RECAPTURES`. */
+	recapture: boolean().optional()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
 });
 /**
 * Per-stage gating mode applied to the zones a rule references.
@@ -29311,6 +29744,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"sceneMonitor.resetScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"sceneMonitor.updateScene": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -30602,6 +31041,1683 @@ Object.freeze({
 		access: "create"
 	}
 });
+Object.freeze({
+	"accessories.setChildHidden": [{
+		name: "childDeviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"addonSettings.getDeviceSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"addonSettings.updateDeviceSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"alarmPanel.arm": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"alarmPanel.disarm": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"alarmPanel.trigger": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"audioAnalysis.resolveDeviceSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"audioAnalyzer.classify": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"audioMetrics.getCurrentSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"audioMetrics.getHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"automationControl.disable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"automationControl.enable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"automationControl.trigger": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"battery.wakeForStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"brightness.setBrightness": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"button.press": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraCredentials.getCredentials": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getBrokerStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getCameraStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getProfileRtspEntries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.getRtspEntries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cameraStreams.pickStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setFanMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setPreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setSwingHorizontal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setSwingVertical": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setTarget": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setTargetHumidity": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"climateControl.setTargetRange": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"color.setColor": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"consumables.reset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"control.setValue": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.close": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.open": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.setPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.setTiltPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"cover.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dayNight.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dayNight.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"decoder.createSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceAdoption.release": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceAdoption.resync": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.adoptDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.listDiscovered": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.refreshDiscovery": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceDiscovery.releaseDevice": [{
+		name: "childDeviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.adoptionRelease": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.adoptionResync": [{
+		name: "camDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.applyInitialMeta": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "linkDeviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceManager.disable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.enable": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getBindings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getChildren": [{
+		name: "parentDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getConfigSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceLiveInfoAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceSettingsAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceStatusAggregate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getDeviceStatusAggregateBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"deviceManager.getLinkedDevices": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getSettingsSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getStreamProfileMap": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getStreamSources": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.getWireableFields": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.loadConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.loadMeta": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.loadRuntimeState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.persistConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.probeStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.registerDevice": [{
+		name: "parentDeviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceManager.remove": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.removeDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.runDeviceAction": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setChildLayout": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setDisabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setDisplay": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setIntegrationId": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setLinkDeviceId": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "linkDeviceId",
+		form: "single",
+		optional: true
+	}],
+	"deviceManager.setLocation": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setMetadata": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setName": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setPrimaryChildEntityId": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setRole": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setStreamProfileMap": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setType": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.setWrapperActive": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.testField": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.updateConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.updateDeviceField": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceManager.updateDeviceFieldsBatch": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getConfigEntries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getRawState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getSettingsSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.getStreamSources": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.removeDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.runAction": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceOps.setConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceState.getCapSlice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceState.getSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceState.setCapSlice": [{
+		name: "deviceId",
+		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",
+		optional: false
+	}],
+	"faceGallery.listRecentFaces": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"fanControl.setDirection": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"fanControl.setOscillating": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"fanControl.setPercentage": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"fanControl.setPreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"humidifier.setMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"humidifier.setOn": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"humidifier.setTargetHumidity": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"imageSettings.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"imageSettings.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.endTalkSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.handleAnswer": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.pushTalkAudio": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.startSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.startTalkSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"intercom.stopSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lawnMowerControl.dock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lawnMowerControl.pause": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lawnMowerControl.startMowing": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lockControl.lock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lockControl.open": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"lockControl.unlock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.next": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.pause": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.play": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.playMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.previous": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.seek": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.selectSource": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setMute": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setRepeat": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setShuffle": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.setVolume": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motion.isDetected": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionDetection.analyze": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionDetection.removeCamera": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionTrigger.setMotionTrigger": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionZones.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"motionZones.setZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"nativeObjectDetection.setEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"networkQuality.getDeviceStats": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"networkQuality.reportClientStats": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"notificationRules.setDeviceMuted": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"notifier.cancel": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"notifier.send": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osd.setOverlay": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.clearSlotBinding": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.copyDeviceConfiguration": [{
+		name: "sourceDeviceId",
+		form: "single",
+		optional: false
+	}, {
+		name: "targetDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.getDeviceOsd": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.getSourceCatalog": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.previewSlot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.renderDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"osdManager.setSlotBinding": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.callPet": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.cancelFeed": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.feed": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.markFoodReplenished": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.playSound": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.resetDesiccant": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setChildLock": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setFeedSound": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setIndicatorLight": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"petFeeder.setVolume": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.clearTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.completeRetrainTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.deleteDeviceEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.deleteTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.deselectRetrainFrame": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getActiveTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getAudioEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getEventDensity": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getKeyEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getMotionEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getObjectEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getRetrainExportUrl": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.getSensorEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.getTrainingExportSummary": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.getTrainingExportUrl": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.listEventKinds": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.listEventKindsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"pipelineAnalytics.listOpsLog": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineAnalytics.listRecentTracks": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"pipelineAnalytics.listRetrainStaging": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineAnalytics.listTracks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.proposeRetrainAnnotations": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.pruneEventsBefore": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.pruneTracksBefore": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.rebuildObjectEmbeddings": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineAnalytics.restageRetrainTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.saveRetrainAnnotations": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.searchObjectEvents": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineAnalytics.selectRetrainFrames": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.setTrackFlags": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineAnalytics.wipeAllAnalytics": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineExecutor.runPipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineExecutor.runPipelineBatch": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"pipelineOrchestrator.assignAudio": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.assignPipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getAudioAssignment": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraMetrics": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraStatuses": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
+	"pipelineOrchestrator.getCameraStepOverrides": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getCameraSwitches": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getPipelineAssignment": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.getPipelineDevicePin": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.resolvePipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraPipelineForAgent": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraStepOverride": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraStepToggle": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setCameraSwitch": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.setPipelineDevicePin": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.unassignAudio": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineOrchestrator.unassignPipeline": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.attachCamera": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.detachCamera": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.getCameraMetrics": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.reportMotion": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.runDetailSubtree": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.runStatelessStep": [{
+		name: "sourceDeviceId",
+		form: "single",
+		optional: false
+	}],
+	"plateGallery.getPlateByTrack": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"plateGallery.listPlates": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"privacyMask.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"privacyMask.setAudioEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"privacyMask.setMask": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.continuousMove": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.deletePreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.getPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.getPresets": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.goHome": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.goToPreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.move": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.savePreset": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.setAutofocus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptz.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.getSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.setEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"ptzAutotrack.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"reboot.reboot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.deleteFootprint": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getAvailability": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getDaysWithRecordings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getDeviceConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.getPlaybackManifest": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.listOpsLog": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"recording.locateSegment": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.pruneFootage": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.readGopBytes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.readSegmentBytes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.relocateFootage": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"recording.renderClip": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.renderGif": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.rescanStorage": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.setDeviceConfig": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recording.startStorageMigrationMove": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"recordingExport.createExport": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recordingExport.listExports": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"sceneMonitor.captureReference": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.createScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.deleteReference": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.deleteScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.listScenes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.recheckNow": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.resetScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"sceneMonitor.updateScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"scriptRunner.run": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"scriptRunner.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"snapshot.getSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"snapshot.getSnapshotOverview": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
+	"snapshot.invalidateCache": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.acquireEgressTranscode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.assignProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.getDeviceAudioMute": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.getStreamWithCodec": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.produceEventMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.publishCameraStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.renderPreBufferClip": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.restartProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.retractCameraStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.setDeviceAudioMute": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamBroker.unassignProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamCatalog.getCatalog": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamParams.getConfigSchema": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamParams.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"streamParams.setProfile": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"switch.setState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.locate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.pause": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.returnToBase": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.setFanSpeed": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.start": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"vacuumControl.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.close": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.open": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.setPosition": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"valve.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"videoclips.getClipPlayback": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"videoclips.listClips": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"waterHeater.setAway": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"waterHeater.setOperationMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"waterHeater.setTargetTemp": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.addIceCandidate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.closeSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.createSession": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.getIceCandidates": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.getSessionState": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.handleAnswer": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.handleOffer": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.hasAdaptiveBitrate": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"webrtcSession.listStreams": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getCameraHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getCurrentSnapshot": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getUnzonedHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneAnalytics.getZoneHistory": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneRules.listRules": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zoneRules.setRules": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.addZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.listZones": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.removeZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"zones.updateZone": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}]
+});
 Object.freeze({
 	"broker": "broker",
 	"device-export": "device-export",
@@ -31029,7 +33145,7 @@ function mapHttpError(res) {
 	};
 }
 /** Narrow an unknown to a plain object record (documented JSON type boundary). */
-function asRecord(value) {
+function asRecord$1(value) {
 	if (value !== null && typeof value === "object" && !Array.isArray(value)) return value;
 	return null;
 }
@@ -31156,10 +33272,10 @@ function buildChatCompletionsBody(profile, request) {
 	};
 	return body;
 }
-function readString$2(value) {
+function readString$3(value) {
 	return typeof value === "string" ? value : void 0;
 }
-function readNumber$2(value) {
+function readNumber$3(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 function parseChatCompletionsResult(res, latencyMs) {
@@ -31171,33 +33287,33 @@ function parseChatCompletionsResult(res, latencyMs) {
 		code: "adapter-error",
 		message: "invalid JSON response"
 	};
-	const choice = asRecord((Array.isArray(body.choices) ? body.choices : [])[0]);
+	const choice = asRecord$1((Array.isArray(body.choices) ? body.choices : [])[0]);
 	if (choice === null) return {
 		ok: false,
 		code: "adapter-error",
 		message: "missing choices[0]"
 	};
-	const finishReason = readString$2(choice.finish_reason);
+	const finishReason = readString$3(choice.finish_reason);
 	if (finishReason === "content_filter") return {
 		ok: false,
 		code: "refusal",
 		message: "content filtered"
 	};
-	const messageObj = asRecord(choice.message);
-	const text = messageObj !== null ? readString$2(messageObj.content) : void 0;
+	const messageObj = asRecord$1(choice.message);
+	const text = messageObj !== null ? readString$3(messageObj.content) : void 0;
 	if (text === void 0) return {
 		ok: false,
 		code: "adapter-error",
 		message: "missing message.content"
 	};
-	const usageObj = asRecord(body.usage) ?? {};
+	const usageObj = asRecord$1(body.usage) ?? {};
 	return {
 		ok: true,
 		text,
-		model: readString$2(body.model) ?? "",
+		model: readString$3(body.model) ?? "",
 		usage: {
-			inputTokens: readNumber$2(usageObj.prompt_tokens),
-			outputTokens: readNumber$2(usageObj.completion_tokens)
+			inputTokens: readNumber$3(usageObj.prompt_tokens),
+			outputTokens: readNumber$3(usageObj.completion_tokens)
 		},
 		truncated: finishReason === "length",
 		latencyMs
@@ -31208,7 +33324,7 @@ function parseModelsList(res) {
 	const data = body !== null && Array.isArray(body.data) ? body.data : [];
 	const ids = [];
 	for (const entry of data) if (entry !== null && typeof entry === "object") {
-		const id = readString$2(entry.id);
+		const id = readString$3(entry.id);
 		if (id !== void 0) ids.push(id);
 	}
 	return ids;
@@ -31274,10 +33390,10 @@ function userContent(request) {
 	});
 	return parts;
 }
-function readString$1(value) {
+function readString$2(value) {
 	return typeof value === "string" ? value : void 0;
 }
-function readNumber$1(value) {
+function readNumber$2(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 function buildMessagesBody(profile, request) {
@@ -31314,7 +33430,7 @@ function parseMessagesResult(res, latencyMs) {
 		code: "adapter-error",
 		message: "invalid JSON response"
 	};
-	const stopReason = readString$1(body.stop_reason);
+	const stopReason = readString$2(body.stop_reason);
 	if (stopReason === "refusal") return {
 		ok: false,
 		code: "refusal",
@@ -31329,7 +33445,7 @@ function parseMessagesResult(res, latencyMs) {
 			text = JSON.stringify(b.input);
 			break;
 		}
-		if (b.type === "text" && text === void 0) text = readString$1(b.text);
+		if (b.type === "text" && text === void 0) text = readString$2(b.text);
 	}
 	if (text === void 0) return {
 		ok: false,
@@ -31340,10 +33456,10 @@ function parseMessagesResult(res, latencyMs) {
 	return {
 		ok: true,
 		text,
-		model: readString$1(body.model) ?? "",
+		model: readString$2(body.model) ?? "",
 		usage: {
-			inputTokens: readNumber$1(usageObj.input_tokens),
-			outputTokens: readNumber$1(usageObj.output_tokens)
+			inputTokens: readNumber$2(usageObj.input_tokens),
+			outputTokens: readNumber$2(usageObj.output_tokens)
 		},
 		truncated: stopReason === "max_tokens",
 		latencyMs
@@ -31378,7 +33494,7 @@ var anthropicAdapter = {
 		const data = body !== null && Array.isArray(body.data) ? body.data : [];
 		const ids = [];
 		for (const entry of data) if (entry !== null && typeof entry === "object") {
-			const id = readString$1(entry.id);
+			const id = readString$2(entry.id);
 			if (id !== void 0) ids.push(id);
 		}
 		return ids;
@@ -31396,10 +33512,10 @@ function headers(profile) {
 		...profile.extraHeaders
 	};
 }
-function readString(value) {
+function readString$1(value) {
 	return typeof value === "string" ? value : void 0;
 }
-function readNumber(value) {
+function readNumber$1(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 function buildGenerateContentBody(profile, request) {
@@ -31434,37 +33550,37 @@ function parseGenerateContentResult(res, latencyMs) {
 		code: "adapter-error",
 		message: "invalid JSON response"
 	};
-	const promptFeedback = asRecord(body.promptFeedback);
-	if (promptFeedback !== null && readString(promptFeedback.blockReason) !== void 0) return {
+	const promptFeedback = asRecord$1(body.promptFeedback);
+	if (promptFeedback !== null && readString$1(promptFeedback.blockReason) !== void 0) return {
 		ok: false,
 		code: "refusal",
-		message: `blocked: ${readString(promptFeedback.blockReason)}`
+		message: `blocked: ${readString$1(promptFeedback.blockReason)}`
 	};
-	const candidate = asRecord((Array.isArray(body.candidates) ? body.candidates : [])[0]);
+	const candidate = asRecord$1((Array.isArray(body.candidates) ? body.candidates : [])[0]);
 	if (candidate === null) return {
 		ok: false,
 		code: "adapter-error",
 		message: "missing candidates[0]"
 	};
-	const finishReason = readString(candidate.finishReason);
+	const finishReason = readString$1(candidate.finishReason);
 	if (finishReason === "SAFETY" || finishReason === "PROHIBITED_CONTENT") return {
 		ok: false,
 		code: "refusal",
 		message: `finish: ${finishReason}`
 	};
-	const contentObj = asRecord(candidate.content) ?? {};
+	const contentObj = asRecord$1(candidate.content) ?? {};
 	const text = (Array.isArray(contentObj.parts) ? contentObj.parts : []).map((p) => {
-		const rec = asRecord(p);
-		return rec !== null ? readString(rec.text) : void 0;
+		const rec = asRecord$1(p);
+		return rec !== null ? readString$1(rec.text) : void 0;
 	}).filter((t) => t !== void 0).join("");
-	const usageObj = asRecord(body.usageMetadata) ?? {};
+	const usageObj = asRecord$1(body.usageMetadata) ?? {};
 	return {
 		ok: true,
 		text,
-		model: readString(body.modelVersion) ?? "",
+		model: readString$1(body.modelVersion) ?? "",
 		usage: {
-			inputTokens: readNumber(usageObj.promptTokenCount),
-			outputTokens: readNumber(usageObj.candidatesTokenCount)
+			inputTokens: readNumber$1(usageObj.promptTokenCount),
+			outputTokens: readNumber$1(usageObj.candidatesTokenCount)
 		},
 		truncated: finishReason === "MAX_TOKENS",
 		latencyMs
@@ -31502,7 +33618,7 @@ var googleAdapter = {
 		const models = body !== null && Array.isArray(body.models) ? body.models : [];
 		const ids = [];
 		for (const entry of models) if (entry !== null && typeof entry === "object") {
-			const name = readString(entry.name);
+			const name = readString$1(entry.name);
 			if (name !== void 0) ids.push(stripModelsPrefix(name));
 		}
 		return ids;
@@ -32642,7 +34758,7 @@ async function assembleAi(deps) {
 		registrations,
 		runtimeProvider
 	};
-	const { UsageStore } = await import("./usage-store-1FrTJdpU.mjs").then((n) => n.i);
+	const { UsageStore } = await import("./usage-store-CsJWTWNX.mjs").then((n) => n.i);
 	const store = new ProfileStore(deps.settingsPort);
 	const defaults = new DefaultsStore(deps.settingsPort);
 	const usage = new UsageStore(deps.settingsPort, Date.now, deps.logger.child("llm-usage"));
@@ -32675,10 +34791,843 @@ async function assembleAi(deps) {
 		runtimeProvider,
 		llmProvider,
 		store,
+		usage,
 		prune: (retentionDays) => usage.prune(retentionDays)
 	};
 }
 //#endregion
+//#region src/test-chat/chat-completions-stream.ts
+/** The profile kinds whose wire this module speaks. */
+var STREAMABLE_KINDS = new Set(["openai-compatible", "openai"]);
+var OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
+function baseUrlFor(profile) {
+	if (profile.baseUrl !== void 0 && profile.baseUrl.length > 0) return trimTrailingSlash(profile.baseUrl);
+	return profile.kind === "openai" ? OPENAI_DEFAULT_BASE_URL : null;
+}
+function readString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+/**
+* Split a byte stream into SSE `data:` payloads.
+*
+* Chunk boundaries fall wherever TCP puts them, so a frame is buffered until
+* its newline arrives — reading a half-written JSON object is the classic way
+* a streaming client "works" until the first slow link.
+*/
+async function* sseData(stream) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for await (const chunk of stream) {
+		buffer += decoder.decode(chunk, { stream: true });
+		let index = buffer.indexOf("\n");
+		while (index >= 0) {
+			const line = buffer.slice(0, index).replace(/\r$/, "");
+			buffer = buffer.slice(index + 1);
+			if (line.startsWith("data:")) yield line.slice(5).trim();
+			index = buffer.indexOf("\n");
+		}
+	}
+	const tail = buffer.replace(/\r$/, "");
+	if (tail.startsWith("data:")) yield tail.slice(5).trim();
+}
+/** SSE payloads → normalised chunks. Ends at `[DONE]` or stream end. */
+async function* chunksFromSse(payloads) {
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let truncated = false;
+	for await (const payload of payloads) {
+		if (payload === "") continue;
+		if (payload === "[DONE]") break;
+		let parsed;
+		try {
+			parsed = JSON.parse(payload);
+		} catch {
+			continue;
+		}
+		const body = asRecord(parsed);
+		if (body === null) continue;
+		const usage = asRecord(body.usage);
+		if (usage !== null) {
+			inputTokens = readNumber(usage.prompt_tokens);
+			outputTokens = readNumber(usage.completion_tokens);
+		}
+		const choice = asRecord((Array.isArray(body.choices) ? body.choices : [])[0]);
+		if (choice === null) continue;
+		if (readString(choice.finish_reason) === "length") truncated = true;
+		const delta = asRecord(choice.delta);
+		const text = delta !== null ? readString(delta.content) : void 0;
+		if (text !== void 0 && text.length > 0) yield {
+			kind: "token",
+			text
+		};
+	}
+	yield {
+		kind: "end",
+		inputTokens,
+		outputTokens,
+		truncated
+	};
+}
+/**
+* Open the streamed completion.
+*
+* The connect bound covers ONLY the wait for response headers — once the
+* provider has answered, the first-token and idle bounds take over upstream.
+* They are separated because "the port is closed" and "the model is loading"
+* deserve different patience and different sentences.
+*/
+function createChatCompletionsStreamer(deps = {}) {
+	const fetchImpl = deps.fetchImpl ?? fetch;
+	return async (request, opts) => {
+		const profile = request.profile;
+		if (!STREAMABLE_KINDS.has(profile.kind)) return { kind: "unsupported" };
+		const base = baseUrlFor(profile);
+		if (base === null) return { kind: "unsupported" };
+		const body = {
+			...buildChatCompletionsBody(profile, {
+				prompt: request.prompt,
+				...request.system !== void 0 ? { system: request.system } : {},
+				...request.images !== void 0 ? { images: request.images } : {},
+				...request.maxTokens !== void 0 ? { maxTokens: request.maxTokens } : {},
+				...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+			}),
+			stream: true,
+			stream_options: { include_usage: true }
+		};
+		const connectController = new AbortController();
+		const onOuterAbort = () => connectController.abort();
+		opts.signal.addEventListener("abort", onOuterAbort, { once: true });
+		const connectTimer = setTimeout(() => connectController.abort(), opts.connectTimeoutMs);
+		connectTimer.unref?.();
+		let res;
+		try {
+			res = await fetchImpl(`${base}/chat/completions`, {
+				method: "POST",
+				headers: {
+					...authHeaders(profile),
+					accept: "text/event-stream"
+				},
+				body: JSON.stringify(body),
+				signal: connectController.signal
+			});
+		} catch (cause) {
+			if (cause instanceof Error && cause.name === "AbortError" && !opts.signal.aborted) return {
+				kind: "connect-timeout",
+				timeoutMs: opts.connectTimeoutMs
+			};
+			return {
+				kind: "network",
+				message: cause instanceof Error ? cause.message : String(cause)
+			};
+		} finally {
+			clearTimeout(connectTimer);
+			opts.signal.removeEventListener("abort", onOuterAbort);
+		}
+		if (!res.ok) {
+			const detail = (await res.text().catch(() => "")).slice(0, 500);
+			return {
+				kind: "network",
+				message: `HTTP ${String(res.status)}${detail ? `: ${detail}` : ""}`
+			};
+		}
+		if (res.body === null) return {
+			kind: "network",
+			message: "the provider returned no body"
+		};
+		const bytes = res.body;
+		return {
+			kind: "open",
+			chunks: chunksFromSse(sseData(bytes))
+		};
+	};
+}
+/** Per-message cap — the prompt is flattened, so this bounds the whole call. */
+var TEST_CHAT_MAX_CONTENT_CHARS = 8e3;
+/** The data-plane prefix under `/addon/ai/`. */
+var TEST_CHAT_PREFIX = "test-chat";
+/** The usage tag every test turn is billed under (`llm.getUsage`). */
+var TEST_CHAT_CONSUMER = "adhoc-ui";
+var TEST_CHAT_CONNECT_TIMEOUT_MS = 1e4;
+var TEST_CHAT_DEFAULT_FIRST_TOKEN_TIMEOUT_MS = 12e4;
+var TEST_CHAT_MAX_FIRST_TOKEN_TIMEOUT_MS = 6e5;
+var TEST_CHAT_IDLE_TIMEOUT_MS = 6e4;
+var TestChatMessageSchema = object({
+	role: _enum(["user", "assistant"]),
+	content: string().max(TEST_CHAT_MAX_CONTENT_CHARS)
+});
+/**
+* WHAT to look at, never the pixels themselves.
+*
+* `snapshot` is the camera's current frame through the snapshot wrapper (cache
+* + coalescing + the battery-camera sleep gate all still apply — this is a test
+* surface and has no business setting `force`).
+*
+* `track` is a stored best-shot: the addon picks ONE media row the pipeline
+* already wrote (see `TRACK_MEDIA_PREFERENCE`) and sends it verbatim. No crop
+* rectangle is computed here — D52 keeps that in the runner, and a test chat
+* that derived its own would be judging a rectangle nothing else ever sees.
+*/
+var TestChatImageRefSchema = discriminatedUnion("kind", [object({
+	kind: literal("snapshot"),
+	deviceId: number().int().positive()
+}), object({
+	kind: literal("track"),
+	trackId: string().min(1)
+})]);
+/**
+* `.strict()`, and it is load-bearing.
+*
+* Measured on the live hub: a request that named the attachment field
+* `attachment` against a schema that called it `imageRef` was accepted, the
+* unknown key was STRIPPED by the default object parse, and the run answered a
+* vision question with a text-only turn — "specify what you want described",
+* `inputTokens: 10`. No error, no log, no way to tell it from a model that
+* simply could not see. A stripped field is a silent behaviour change, which is
+* the one thing a diagnostic surface must never do; `.strict()` turns it into a
+* 400 naming the key.
+*/
+var TestChatRequestSchema = object({
+	/** Explicit profile — the test chat NEVER falls through to the default
+	*  resolution chain, because "which model answered" is the whole question. */
+	profileId: string().min(1),
+	messages: array(TestChatMessageSchema).min(1).max(40),
+	/** Optional system turn, authored by the operator in the page. */
+	system: string().max(TEST_CHAT_MAX_CONTENT_CHARS).optional(),
+	/** The picture to look at, BY REFERENCE. Named `attachment` because that is
+	*  what every caller reaches for; the previous `imageRef` cost a live
+	*  debugging session to the strip described above. */
+	attachment: TestChatImageRefSchema.optional(),
+	temperature: number().min(0).max(2).optional(),
+	maxTokens: number().int().positive().max(8192).optional(),
+	/** See the timeout block above. Applies to a VISION turn identically —
+	*  vision inference is the slower one, so a bound tuned on text is a bound
+	*  that only fails on the interesting case. */
+	firstTokenTimeoutMs: number().int().positive().max(TEST_CHAT_MAX_FIRST_TOKEN_TIMEOUT_MS).default(TEST_CHAT_DEFAULT_FIRST_TOKEN_TIMEOUT_MS)
+}).strict();
+/**
+* Below this, a turn that CARRIED an image almost certainly did not deliver it.
+*
+* A vision model prices a picture in hundreds of input tokens (qwen3-vl bills a
+* 480 px crop at several hundred); a text-only turn of a short prompt bills
+* about ten. The live failure above reported exactly `10`. So when the provider
+* tells us the input count and an image was attached, a count this low is
+* evidence the picture did not reach the model — worth a warning line even
+* though the run "succeeded", because the answer will look like an answer.
+*
+* Only checked when the provider actually reported a count: a streamed
+* completion without `stream_options.include_usage` reports none, and 0 must
+* never be read as 10.
+*/
+var TEST_CHAT_MIN_VISION_INPUT_TOKENS = 100;
+/**
+* What the server actually attached — metadata only, never the bytes.
+*
+* The operator has to be able to tell a vision answer about the wrong picture
+* from a vision answer about the right one, and the only way to do that from
+* the client is to be told which media row was used and how old it is.
+*/
+var TestChatAttachmentSchema = object({
+	kind: _enum(["snapshot", "track"]),
+	mimeType: string(),
+	sizeBytes: number().int().nonnegative(),
+	/** Track attachments only: the `MediaFileKind` that won `TRACK_MEDIA_PREFERENCE`. */
+	mediaKind: string().optional(),
+	/** Epoch ms of the frame, when the source knows it. */
+	capturedAt: number().optional()
+});
+/**
+* What the run is doing right now — so a wait reads as progress, not as a hang.
+*
+* `first-token-wait` is the one that matters: it is the phase a cold model
+* spends minutes in, and the page renders it as "the model is loading…" rather
+* than as silence.
+*/
+var TestChatPhaseSchema = _enum([
+	"resolving-image",
+	"connecting",
+	"first-token-wait",
+	"streaming"
+]);
+/**
+* One NDJSON line. A discriminated union so the client narrows on `kind` and a
+* line this build does not understand is skipped rather than half-read.
+*
+* `meta` arrives BEFORE the first token: it is what the server committed to —
+* which profile, which model, which picture — and the page shows it while the
+* model is still loading, so a long wait is at least an informed one.
+*/
+var TestChatEventSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("status"),
+		phase: TestChatPhaseSchema
+	}),
+	object({
+		kind: literal("meta"),
+		profileName: string(),
+		model: string(),
+		/**
+		* WHAT MEDIA WAS ACTUALLY SENT — and the contract is that this is non-null
+		* whenever the request carried an `attachment`.
+		*
+		* There is no path where a requested picture goes missing and the run
+		* continues: a resolution failure ends the stream with an `error` event.
+		* That rule exists because the opposite shipped — a vision question answered
+		* text-only, indistinguishable from a model that looked and saw nothing.
+		*/
+		mediaSent: TestChatAttachmentSchema.nullable(),
+		/** False when the profile's wire has no token stream and the whole answer
+		*  arrives at once. Said out loud rather than faked. */
+		streamed: boolean(),
+		/** Echoed so the page states the bound it is really working under. */
+		firstTokenTimeoutMs: number()
+	}),
+	object({
+		kind: literal("token"),
+		text: string()
+	}),
+	object({
+		kind: literal("done"),
+		inputTokens: number(),
+		outputTokens: number(),
+		latencyMs: number(),
+		truncated: boolean()
+	}),
+	object({
+		kind: literal("error"),
+		code: string(),
+		message: string()
+	})
+]);
+/** Serialise one event as an NDJSON line, terminator included. */
+function encodeEvent(event) {
+	return `${JSON.stringify(event)}\n`;
+}
+//#endregion
+//#region src/test-chat/media.ts
+/**
+* Which stored media a track attachment is allowed to be, best first.
+*
+* `keyFrameSmall` wins because it is the CLEAN best-shot (no drawn box) at a
+* size a vision model actually ingests — a boxed frame teaches the model to
+* describe the annotation, and the native `keyFrame` is megabytes for no gain.
+* The subject crops come next for a track whose key frame was never written,
+* and `fullFrameBoxed` is absent on purpose: it is the one variant with
+* graphics painted over the evidence.
+*/
+var TRACK_MEDIA_PREFERENCE = [
+	"keyFrameSmall",
+	"keyFrame",
+	"thumbnailSmall",
+	"thumbnail",
+	"crop"
+];
+/** JPEG is what every media row and every snapshot in this system is. */
+var DEFAULT_MIME = "image/jpeg";
+/**
+* Flatten the transcript into the single prompt the chat-completions wire takes
+* as one user turn.
+*
+* A SINGLE user turn is sent verbatim: prefixing one message with `User:`
+* teaches small local models to answer in the same transcript format, which
+* makes the very first test a confusing one.
+*/
+function renderTranscript(messages) {
+	if (messages.length === 1 && messages[0].role === "user") return messages[0].content;
+	return messages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n\n");
+}
+/** The highest-preference media row present, or null when none qualifies. */
+function pickTrackMedia(rows) {
+	for (const kind of TRACK_MEDIA_PREFERENCE) {
+		const hit = rows.find((r) => r.kind === kind);
+		if (hit !== void 0) return hit;
+	}
+	return null;
+}
+function decode(base64) {
+	const buf = Buffer.from(base64, "base64");
+	const bytes = new Uint8Array(new ArrayBuffer(buf.byteLength));
+	bytes.set(buf);
+	return bytes;
+}
+async function resolveImage(deps, ref) {
+	if (ref.kind === "snapshot") {
+		const tags = { deviceId: ref.deviceId };
+		let shot;
+		try {
+			shot = await deps.getSnapshot(ref.deviceId);
+		} catch (cause) {
+			const message = cause instanceof Error ? cause.message : String(cause);
+			deps.logger.warn("ai test chat: snapshot read failed — turn dropped", {
+				tags,
+				meta: { error: message }
+			});
+			return {
+				ok: false,
+				failure: {
+					code: "unavailable",
+					message: `snapshot unavailable: ${message}`
+				}
+			};
+		}
+		if (shot === null) {
+			deps.logger.warn("ai test chat: camera has no frame — turn dropped", { tags });
+			return {
+				ok: false,
+				failure: {
+					code: "unavailable",
+					message: "this camera has produced no frame yet"
+				}
+			};
+		}
+		const bytes = decode(shot.base64);
+		const mimeType = shot.contentType.length > 0 ? shot.contentType : DEFAULT_MIME;
+		return {
+			ok: true,
+			resolved: {
+				image: {
+					bytes,
+					mimeType
+				},
+				attachment: {
+					kind: "snapshot",
+					mimeType,
+					sizeBytes: bytes.byteLength
+				}
+			}
+		};
+	}
+	let rows;
+	try {
+		rows = await deps.getTrackMedia(ref.trackId, TRACK_MEDIA_PREFERENCE);
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		deps.logger.warn("ai test chat: track media read failed — turn dropped", { meta: {
+			trackId: ref.trackId,
+			error: message
+		} });
+		return {
+			ok: false,
+			failure: {
+				code: "unavailable",
+				message: `track media unavailable: ${message}`
+			}
+		};
+	}
+	const row = pickTrackMedia(rows);
+	if (row === null) {
+		deps.logger.warn("ai test chat: track has no usable media — turn dropped", { meta: {
+			trackId: ref.trackId,
+			kindsFound: rows.map((r) => r.kind)
+		} });
+		return {
+			ok: false,
+			failure: {
+				code: "unavailable",
+				message: "this track has no stored best-shot left (evicted or never written)"
+			}
+		};
+	}
+	const bytes = decode(row.base64);
+	return {
+		ok: true,
+		resolved: {
+			image: {
+				bytes,
+				mimeType: DEFAULT_MIME
+			},
+			attachment: {
+				kind: "track",
+				mimeType: DEFAULT_MIME,
+				sizeBytes: bytes.byteLength,
+				mediaKind: row.kind,
+				capturedAt: row.timestamp
+			}
+		}
+	};
+}
+//#endregion
+//#region src/test-chat/run-stream.ts
+/** Race `promise` against a timer; `null` means the timer won. */
+async function withDeadline(promise, ms) {
+	let timer;
+	const expiry = new Promise((resolve) => {
+		timer = setTimeout(() => resolve({ timedOut: true }), ms);
+		timer.unref?.();
+	});
+	try {
+		return await Promise.race([promise.then((value) => ({
+			timedOut: false,
+			value
+		})), expiry]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/**
+* Pull the next chunk under a deadline.
+*
+* The iterator is NOT abandoned on a timeout — the caller stops reading and the
+* signal tears the socket down, which is what actually frees the provider. A
+* dangling `next()` promise here would keep the generator alive.
+*/
+async function nextChunk(iterator, ms) {
+	const raced = await withDeadline(iterator.next(), ms);
+	if (raced.timedOut) return { kind: "timeout" };
+	return raced.value.done === true ? { kind: "end" } : {
+		kind: "chunk",
+		value: raced.value.value
+	};
+}
+async function runTestChatStream(deps, request, emit, signal) {
+	const startedAt = deps.now();
+	const tags = request.attachment?.kind === "snapshot" ? { deviceId: request.attachment.deviceId } : void 0;
+	const withTags = (meta) => tags !== void 0 ? {
+		tags,
+		meta
+	} : { meta };
+	let profileForUsage = null;
+	let imageCount = 0;
+	let finished = false;
+	const finish = async (ending, counts) => {
+		if (finished) return;
+		finished = true;
+		const latencyMs = deps.now() - startedAt;
+		await deps.recordUsage({
+			ts: startedAt,
+			consumer: TEST_CHAT_CONSUMER,
+			...profileForUsage !== null ? {
+				profileId: profileForUsage.id,
+				kind: profileForUsage.kind,
+				model: profileForUsage.model
+			} : {},
+			inputTokens: counts.inputTokens,
+			outputTokens: counts.outputTokens,
+			latencyMs,
+			ok: ending === null,
+			...ending !== null ? { errorCode: ending.code } : {},
+			imageCount
+		}).catch(() => void 0);
+		if (ending !== null) emit({
+			kind: "error",
+			code: ending.code,
+			message: ending.message
+		});
+	};
+	const fail = async (ending, logMessage, meta = {}) => {
+		deps.logger.warn(logMessage, withTags({
+			profileId: request.profileId,
+			...meta
+		}));
+		await finish(ending, {
+			inputTokens: 0,
+			outputTokens: 0
+		});
+	};
+	if (signal.aborted) {
+		deps.logger.info("ai test chat: client had already left before the run started", withTags({}));
+		return;
+	}
+	const profile = await deps.getProfile(request.profileId);
+	if (profile === null || !profile.enabled) {
+		await fail({
+			code: "no-profile",
+			message: `profile "${request.profileId}" not found or disabled`
+		}, "ai test chat: profile missing or disabled — turn dropped");
+		return;
+	}
+	profileForUsage = profile;
+	let attachment = null;
+	let images;
+	if (request.attachment !== void 0) {
+		if (!profile.supportsVision) {
+			await fail({
+				code: "bad-request",
+				message: `profile "${profile.name}" is not vision-capable`
+			}, "ai test chat: profile is not vision-capable — image turn refused", { model: profile.model });
+			return;
+		}
+		emit({
+			kind: "status",
+			phase: "resolving-image"
+		});
+		const outcome = await resolveImage(deps, request.attachment);
+		if (!outcome.ok) {
+			await fail(outcome.failure, "ai test chat: attachment could not be resolved — vision turn refused", { attachmentKind: request.attachment.kind });
+			return;
+		}
+		attachment = outcome.resolved.attachment;
+		images = [outcome.resolved.image];
+		imageCount = 1;
+	}
+	if (signal.aborted) {
+		deps.logger.info("ai test chat: client aborted before the provider was called", withTags({}));
+		return;
+	}
+	const streamRequest = {
+		profile,
+		prompt: renderTranscript(request.messages),
+		...request.system !== void 0 ? { system: request.system } : {},
+		...images !== void 0 ? { images } : {},
+		...request.maxTokens !== void 0 ? { maxTokens: request.maxTokens } : {},
+		...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+	};
+	emit({
+		kind: "status",
+		phase: "connecting"
+	});
+	const opened = await deps.openStream(streamRequest, {
+		signal,
+		connectTimeoutMs: TEST_CHAT_CONNECT_TIMEOUT_MS
+	});
+	if (opened.kind === "connect-timeout") {
+		await fail({
+			code: "unavailable",
+			message: `the endpoint did not accept the connection within ${String(Math.round(opened.timeoutMs / 1e3))}s — check that the provider is running and the base URL is right`
+		}, "ai test chat: provider endpoint unreachable (connect timeout) — turn dropped", {
+			baseUrl: profile.baseUrl ?? "",
+			connectTimeoutMs: opened.timeoutMs
+		});
+		return;
+	}
+	if (opened.kind === "network") {
+		await fail({
+			code: "unavailable",
+			message: `the endpoint could not be reached: ${opened.message}`
+		}, "ai test chat: provider endpoint unreachable (network error) — turn dropped", {
+			baseUrl: profile.baseUrl ?? "",
+			error: opened.message
+		});
+		return;
+	}
+	const streamed = opened.kind === "open";
+	emit({
+		kind: "meta",
+		profileName: profile.name,
+		model: profile.model,
+		mediaSent: attachment,
+		streamed,
+		firstTokenTimeoutMs: request.firstTokenTimeoutMs
+	});
+	const warnIfPictureLikelyMissing = (inputTokens) => {
+		if (attachment === null || inputTokens <= 0) return;
+		if (inputTokens >= 100) return;
+		deps.logger.warn("ai test chat: image turn billed like a text turn — the picture may not have reached the model", withTags({
+			profileId: profile.id,
+			model: profile.model,
+			inputTokens,
+			expectedAtLeast: 100,
+			attachmentBytes: attachment.sizeBytes
+		}));
+	};
+	if (!streamed) {
+		emit({
+			kind: "status",
+			phase: "first-token-wait"
+		});
+		const raced = await withDeadline(deps.generateOnce(streamRequest), request.firstTokenTimeoutMs);
+		if (signal.aborted) {
+			deps.logger.info("ai test chat: client aborted mid-generation", withTags({}));
+			return;
+		}
+		if (raced.timedOut) {
+			await failFirstToken();
+			return;
+		}
+		const result = raced.value;
+		if (!result.ok) {
+			await fail({
+				code: result.code,
+				message: result.message
+			}, "ai test chat: provider returned an error — turn dropped", {
+				code: result.code,
+				error: result.message
+			});
+			return;
+		}
+		warnIfPictureLikelyMissing(result.usage.inputTokens);
+		emit({
+			kind: "token",
+			text: result.text
+		});
+		emit({
+			kind: "done",
+			inputTokens: result.usage.inputTokens,
+			outputTokens: result.usage.outputTokens,
+			latencyMs: deps.now() - startedAt,
+			truncated: result.truncated
+		});
+		await finish(null, {
+			inputTokens: result.usage.inputTokens,
+			outputTokens: result.usage.outputTokens
+		});
+		return;
+	}
+	async function failFirstToken() {
+		await fail({
+			code: "timeout",
+			message: `the model produced no output within ${String(Math.round(request.firstTokenTimeoutMs / 1e3))}s — a cold load can take minutes; warm the model or raise the first-token timeout`
+		}, "ai test chat: no first token before the bound — model probably still loading", { firstTokenTimeoutMs: request.firstTokenTimeoutMs });
+	}
+	emit({
+		kind: "status",
+		phase: "first-token-wait"
+	});
+	const iterator = opened.chunks[Symbol.asyncIterator]();
+	let sawFirstToken = false;
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let truncated = false;
+	for (;;) {
+		if (signal.aborted) {
+			deps.logger.info("ai test chat: client aborted mid-stream — provider call torn down", { ...withTags({ sawFirstToken }) });
+			return;
+		}
+		const next = await nextChunk(iterator, sawFirstToken ? TEST_CHAT_IDLE_TIMEOUT_MS : request.firstTokenTimeoutMs);
+		if (next.kind === "timeout") {
+			if (!sawFirstToken) {
+				await failFirstToken();
+				return;
+			}
+			await fail({
+				code: "timeout",
+				message: `the answer stopped mid-stream — no further output for ${String(Math.round(TEST_CHAT_IDLE_TIMEOUT_MS / 1e3))}s`
+			}, "ai test chat: stream stalled after the first token — turn cut short", {
+				idleTimeoutMs: TEST_CHAT_IDLE_TIMEOUT_MS,
+				outputTokens
+			});
+			return;
+		}
+		if (next.kind === "end") break;
+		if (next.value.kind === "token") {
+			if (!sawFirstToken) {
+				sawFirstToken = true;
+				emit({
+					kind: "status",
+					phase: "streaming"
+				});
+			}
+			emit({
+				kind: "token",
+				text: next.value.text
+			});
+			continue;
+		}
+		inputTokens = next.value.inputTokens;
+		outputTokens = next.value.outputTokens;
+		truncated = next.value.truncated;
+	}
+	if (signal.aborted) {
+		deps.logger.info("ai test chat: client aborted before the stream finished", withTags({}));
+		return;
+	}
+	if (!sawFirstToken) {
+		await fail({
+			code: "adapter-error",
+			message: "the provider closed the stream without producing any output"
+		}, "ai test chat: provider closed an empty stream — turn dropped", {});
+		return;
+	}
+	warnIfPictureLikelyMissing(inputTokens);
+	emit({
+		kind: "done",
+		inputTokens,
+		outputTokens,
+		latencyMs: deps.now() - startedAt,
+		truncated
+	});
+	await finish(null, {
+		inputTokens,
+		outputTokens
+	});
+}
+//#endregion
+//#region src/test-chat/plane.ts
+/** Bounded so a malformed or hostile body cannot buy memory. */
+var MAX_BODY_BYTES = 256 * 1024;
+async function readBody(req) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of req) {
+		const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+		total += buf.byteLength;
+		if (total > MAX_BODY_BYTES) return null;
+		chunks.push(buf);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+function sendJson(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, {
+		"content-type": "application/json",
+		"content-length": Buffer.byteLength(text),
+		"cache-control": "no-store"
+	});
+	res.end(text);
+}
+function createTestChatPlaneHandler(deps) {
+	return async (req, res) => {
+		if ((req.method ?? "GET").toUpperCase() !== "POST") {
+			sendJson(res, 405, { error: "POST only" });
+			return;
+		}
+		const raw = await readBody(req);
+		if (raw === null) {
+			sendJson(res, 413, { error: "request body too large" });
+			return;
+		}
+		let parsedJson;
+		try {
+			parsedJson = JSON.parse(raw);
+		} catch {
+			sendJson(res, 400, { error: "invalid JSON body" });
+			return;
+		}
+		const parsed = TestChatRequestSchema.safeParse(parsedJson);
+		if (!parsed.success) {
+			const detail = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+			deps.logger.warn("ai test chat: request rejected — turn never ran", { meta: { detail } });
+			sendJson(res, 400, {
+				error: "invalid request",
+				detail
+			});
+			return;
+		}
+		const controller = new AbortController();
+		res.on("close", () => controller.abort());
+		res.writeHead(200, {
+			"content-type": "application/x-ndjson; charset=utf-8",
+			"cache-control": "no-store, no-transform",
+			"content-encoding": "identity",
+			"x-no-compression": "1",
+			connection: "keep-alive"
+		});
+		res.flushHeaders();
+		const emit = (event) => {
+			if (res.writableEnded) return;
+			res.write(encodeEvent(event));
+		};
+		try {
+			await runTestChatStream(deps.stream, parsed.data, emit, controller.signal);
+		} catch (cause) {
+			const message = cause instanceof Error ? cause.message : String(cause);
+			deps.logger.error("ai test chat: run threw — stream closed with an error event", { meta: { error: message } });
+			emit({
+				kind: "error",
+				code: "adapter-error",
+				message
+			});
+		} finally {
+			if (!res.writableEnded) res.end();
+		}
+	};
+}
+//#endregion
 //#region src/runtime/crash-policy.ts
 var CrashPolicy = class {
 	opts;
@@ -33074,6 +36023,8 @@ var USAGE_RETENTION_DAYS = 90;
 var AiAddon = class extends BaseAddon {
 	supervisor;
 	timers = [];
+	/** Hub only — see `serveTestChatPlane`. */
+	testChatPlane = null;
 	constructor() {
 		super({});
 	}
@@ -33090,7 +36041,7 @@ var AiAddon = class extends BaseAddon {
 		const settingsPort = api !== void 0 ? createApiSettingsStorePort(api) : createMemorySettingsStorePort();
 		if (api === void 0) logger.warn("addon-ai: no ctx.api — profiles are in-memory only");
 		const binDir = path$1.join(ctx.nodeDataDir, "bin");
-		const { ensureLlamaServer } = await import("./ensure-llama-server-Dmh3cZ41.mjs").then((n) => n.r);
+		const { ensureLlamaServer } = await import("./ensure-llama-server-BIz14RoW.mjs").then((n) => n.r);
 		const assembly = await assembleAi({
 			nodeId: ownNodeId,
 			isHub,
@@ -33102,16 +36053,21 @@ var AiAddon = class extends BaseAddon {
 				binDir,
 				logger: logger.child("llama-bin")
 			}),
-			execute: (await import("./execute-plan-KbxnOqY1.mjs").then((n) => n.n)).createFetchExecutor(),
+			execute: (await import("./execute-plan-EMmlVCr5.mjs")).createFetchExecutor(),
 			...isHub && api !== void 0 ? { runtimeApi: this.asRuntimeApi(api) } : {},
 			...isHub && api !== void 0 ? { distributeModel: this.makeDistributeModel(api) } : {}
 		});
-		if (isHub) this.schedulePostBoot(assembly);
+		if (isHub) {
+			this.schedulePostBoot(assembly);
+			await this.serveTestChatPlane(assembly, api);
+		}
 		return assembly.registrations;
 	}
 	async onShutdown() {
 		for (const timer of this.timers) clearTimeout(timer);
 		this.timers.length = 0;
+		await this.testChatPlane?.dispose();
+		this.testChatPlane = null;
 		await this.supervisor?.stop();
 	}
 	asRuntimeApi(api) {
@@ -33130,6 +36086,78 @@ var AiAddon = class extends BaseAddon {
 			});
 		};
 	}
+	/**
+	* `POST /addon/ai/test-chat` — the admin AI page's streaming test chat.
+	*
+	* A DATA-PLANE route, not a cap method and not a custom action. It shipped
+	* first as `addons.custom` and the operator's first real use failed with
+	* `UDS request timed out after 60000ms`: `callAddonOnChild` passes no options
+	* and therefore takes `DEFAULT_UDS_REQUEST_TIMEOUT_MS`, with no per-call
+	* override on that path. A generation that legitimately takes minutes on a
+	* cold GPU load cannot live inside a unary RPC — and the error it produced
+	* named the transport rather than the model or the endpoint.
+	*
+	* HUB ONLY, and that is not a shortcut: the `llm` provider, the profile store
+	* and the api keys exist only here, and the facility binds `127.0.0.1`, which
+	* the hub could not reach on an agent anyway.
+	*
+	* `getProfile` reads the store DIRECTLY rather than through `listProfiles`,
+	* which redacts the api key — the streamed call needs the real one, and it
+	* never leaves this process either way.
+	*
+	* `getSnapshot` deliberately omits `force`. That flag is an OPERATOR signal
+	* that walks past the wrapper's battery-camera sleep gate, and a chat turn is
+	* not a reason to wake a camera: a stale-but-honest frame is the right answer
+	* and the `meta` event reports how old it is.
+	*/
+	async serveTestChatPlane(assembly, api) {
+		const store = assembly.store;
+		const provider = assembly.llmProvider;
+		const usage = assembly.usage;
+		if (store === void 0 || provider === void 0 || usage === void 0 || api === void 0) {
+			this.ctx.logger.warn("addon-ai: test-chat plane not served — no llm provider on this node");
+			return;
+		}
+		const logger = this.ctx.logger.child("llm-test-chat");
+		const stream = {
+			getProfile: (profileId) => store.getById(profileId),
+			openStream: createChatCompletionsStreamer(),
+			generateOnce: async (request) => {
+				const base = {
+					profileId: request.profile.id,
+					consumer: TEST_CHAT_CONSUMER,
+					prompt: request.prompt,
+					...request.system !== void 0 ? { system: request.system } : {},
+					...request.maxTokens !== void 0 ? { maxTokens: request.maxTokens } : {},
+					...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+				};
+				return request.images === void 0 || request.images.length === 0 ? provider.generate(base) : provider.generateVision({
+					...base,
+					images: [...request.images]
+				});
+			},
+			getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }),
+			getTrackMedia: (trackId, kinds) => api.pipelineAnalytics.getTrackMedia.query({
+				trackId,
+				kinds: [...kinds]
+			}),
+			recordUsage: (row) => usage.record(row),
+			logger,
+			now: () => Date.now()
+		};
+		this.testChatPlane = await this.ctx.dataPlane?.serve({
+			prefix: "test-chat",
+			access: "authenticated",
+			handler: createTestChatPlaneHandler({
+				stream,
+				logger
+			})
+		}) ?? null;
+		this.ctx.logger.info("ai test-chat data-plane served", { meta: {
+			served: this.testChatPlane !== null,
+			path: `/addon/${this.ctx.id}/${TEST_CHAT_PREFIX}`
+		} });
+	}
 	schedulePostBoot(assembly) {
 		const kick = setTimeout(() => {
 			assembly.prune?.(USAGE_RETENTION_DAYS).catch(() => void 0);
@@ -33162,4 +36190,4 @@ var AiAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { object as A, AiAddon, AiAddon as default, googleAdapter as C, LlmProfileKindSchema as D, LlmErrorCodeSchema as E, boolean as O, openAiAdapter as S, openAiCompatibleAdapter as T, redactProfileForRead as _, createLlmRuntimeProvider as a, SEED_PROFILE_ID as b, LLM_MODEL_CATALOG as c, createRuntimeClient as d, AI_ADDON_ID as f, mergeProfileSecrets as g, REDACTED_MARKER as h, assembleAi as i, string as j, number as k, catalogById as l, resolveProfile as m, createMemorySettingsStorePort as n, fileSha256 as o, createLlmProvider as p, LlamaSupervisor as r, createDefaultModelOps as s, createApiSettingsStorePort as t, entryForRef as u, PROFILES_COLLECTION as v, anthropicAdapter as w, DefaultsStore as x, ProfileStore as y };
+export { AI_ADDON_ID as A, AiAddon, AiAddon as default, createLlmRuntimeProvider as C, catalogById as D, LLM_MODEL_CATALOG as E, number as F, object as I, string as L, LlmErrorCodeSchema as M, LlmProfileKindSchema as N, entryForRef as O, boolean as P, sseData as S, createDefaultModelOps as T, TestChatEventSchema as _, runTestChatStream as a, chunksFromSse as b, renderTranscript as c, TEST_CHAT_CONSUMER as d, TEST_CHAT_DEFAULT_FIRST_TOKEN_TIMEOUT_MS as f, TEST_CHAT_PREFIX as g, TEST_CHAT_MIN_VISION_INPUT_TOKENS as h, createTestChatPlaneHandler as i, createLlmProvider as j, createRuntimeClient as k, resolveImage as l, TEST_CHAT_MAX_FIRST_TOKEN_TIMEOUT_MS as m, createMemorySettingsStorePort as n, TRACK_MEDIA_PREFERENCE as o, TEST_CHAT_IDLE_TIMEOUT_MS as p, LlamaSupervisor as r, pickTrackMedia as s, createApiSettingsStorePort as t, TEST_CHAT_CONNECT_TIMEOUT_MS as u, TestChatRequestSchema as v, fileSha256 as w, createChatCompletionsStreamer as x, encodeEvent as y };