@camstack/addon-ai 0.2.20 → 0.4.1

package/dist/addon.js

@@ -45,7 +45,7 @@ let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
 let node_child_process = require("node:child_process");
 let node_net = require("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";
@@ -252,6 +252,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
@@ -3043,6 +3070,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);
@@ -4360,7 +4390,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);
@@ -4421,7 +4451,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);
@@ -5228,6 +5258,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);
@@ -5286,6 +5320,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". */
@@ -5402,6 +5443,12 @@ Object.fromEntries([
 		icon: "shapes",
 		order: 38
 	},
+	{
+		id: "scenes",
+		label: "Scenes",
+		icon: "scan-eye",
+		order: 36
+	},
 	{
 		id: "analytics",
 		label: "Analytics",
@@ -13071,11 +13118,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",
@@ -13083,9 +13152,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({
@@ -13285,6 +13358,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",
@@ -14077,11 +14168,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",
@@ -14136,7 +14231,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)
 });
@@ -14375,18 +14479,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(),
 	/**
@@ -14778,7 +14911,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
@@ -15290,7 +15496,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,
@@ -15306,18 +15592,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(),
@@ -15634,7 +15910,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.).
@@ -15770,7 +16046,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
@@ -15907,6 +16197,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
 });
@@ -17314,10 +17626,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 = {
@@ -17515,15 +17843,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),
 	/**
@@ -23626,7 +23960,7 @@ method(object({
 	toMs: number()
 }), RecordingAvailabilitySchema, {
 	kind: "query",
-	auth: "admin"
+	auth: "protected"
 }), method(object({
 	deviceId: number(),
 	fromMs: number(),
@@ -23634,14 +23968,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"
@@ -23936,9 +24270,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({
@@ -23946,7 +24304,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(),
@@ -23968,6 +24333,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(),
@@ -23986,7 +24370,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),
@@ -24019,7 +24437,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",
@@ -24056,6 +24481,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.
@@ -29349,6 +29782,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",
@@ -30640,6 +31079,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",
@@ -31067,7 +33183,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;
 }
@@ -31194,10 +33310,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) {
@@ -31209,33 +33325,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
@@ -31246,7 +33362,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;
@@ -31312,10 +33428,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) {
@@ -31352,7 +33468,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",
@@ -31367,7 +33483,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,
@@ -31378,10 +33494,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
@@ -31416,7 +33532,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;
@@ -31434,10 +33550,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) {
@@ -31472,37 +33588,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
@@ -31540,7 +33656,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;
@@ -32713,10 +34829,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;
@@ -33112,6 +36061,8 @@ var USAGE_RETENTION_DAYS = 90;
 var AiAddon = class extends BaseAddon {
 	supervisor;
 	timers = [];
+	/** Hub only — see `serveTestChatPlane`. */
+	testChatPlane = null;
 	constructor() {
 		super({});
 	}
@@ -33140,16 +36091,21 @@ var AiAddon = class extends BaseAddon {
 				binDir,
 				logger: logger.child("llama-bin")
 			}),
-			execute: (await Promise.resolve().then(() => require("./execute-plan-gwFcJjeV.js")).then((n) => n.execute_plan_exports)).createFetchExecutor(),
+			execute: (await Promise.resolve().then(() => require("./execute-plan-7uof6Kam.js"))).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) {
@@ -33168,6 +36124,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);
@@ -33203,35 +36231,41 @@ var AiAddon = class extends BaseAddon {
 exports.AI_ADDON_ID = AI_ADDON_ID;
 exports.AiAddon = AiAddon;
 exports.default = AiAddon;
-exports.DefaultsStore = DefaultsStore;
 exports.LLM_MODEL_CATALOG = LLM_MODEL_CATALOG;
 exports.LlamaSupervisor = LlamaSupervisor;
 exports.LlmErrorCodeSchema = LlmErrorCodeSchema;
 exports.LlmProfileKindSchema = LlmProfileKindSchema;
-exports.PROFILES_COLLECTION = PROFILES_COLLECTION;
-exports.ProfileStore = ProfileStore;
-exports.REDACTED_MARKER = REDACTED_MARKER;
-exports.SEED_PROFILE_ID = SEED_PROFILE_ID;
+exports.TEST_CHAT_CONNECT_TIMEOUT_MS = TEST_CHAT_CONNECT_TIMEOUT_MS;
+exports.TEST_CHAT_CONSUMER = TEST_CHAT_CONSUMER;
+exports.TEST_CHAT_DEFAULT_FIRST_TOKEN_TIMEOUT_MS = TEST_CHAT_DEFAULT_FIRST_TOKEN_TIMEOUT_MS;
+exports.TEST_CHAT_IDLE_TIMEOUT_MS = TEST_CHAT_IDLE_TIMEOUT_MS;
+exports.TEST_CHAT_MAX_FIRST_TOKEN_TIMEOUT_MS = TEST_CHAT_MAX_FIRST_TOKEN_TIMEOUT_MS;
+exports.TEST_CHAT_MIN_VISION_INPUT_TOKENS = TEST_CHAT_MIN_VISION_INPUT_TOKENS;
+exports.TEST_CHAT_PREFIX = TEST_CHAT_PREFIX;
+exports.TRACK_MEDIA_PREFERENCE = TRACK_MEDIA_PREFERENCE;
+exports.TestChatEventSchema = TestChatEventSchema;
+exports.TestChatRequestSchema = TestChatRequestSchema;
 exports.__exportAll = __exportAll;
 exports.__toESM = __toESM;
-exports.anthropicAdapter = anthropicAdapter;
-exports.assembleAi = assembleAi;
 exports.boolean = boolean;
 exports.catalogById = catalogById;
+exports.chunksFromSse = chunksFromSse;
 exports.createApiSettingsStorePort = createApiSettingsStorePort;
+exports.createChatCompletionsStreamer = createChatCompletionsStreamer;
 exports.createDefaultModelOps = createDefaultModelOps;
 exports.createLlmProvider = createLlmProvider;
 exports.createLlmRuntimeProvider = createLlmRuntimeProvider;
 exports.createMemorySettingsStorePort = createMemorySettingsStorePort;
 exports.createRuntimeClient = createRuntimeClient;
+exports.createTestChatPlaneHandler = createTestChatPlaneHandler;
+exports.encodeEvent = encodeEvent;
 exports.entryForRef = entryForRef;
 exports.fileSha256 = fileSha256;
-exports.googleAdapter = googleAdapter;
-exports.mergeProfileSecrets = mergeProfileSecrets;
 exports.number = number;
 exports.object = object;
-exports.openAiAdapter = openAiAdapter;
-exports.openAiCompatibleAdapter = openAiCompatibleAdapter;
-exports.redactProfileForRead = redactProfileForRead;
-exports.resolveProfile = resolveProfile;
+exports.pickTrackMedia = pickTrackMedia;
+exports.renderTranscript = renderTranscript;
+exports.resolveImage = resolveImage;
+exports.runTestChatStream = runTestChatStream;
+exports.sseData = sseData;
 exports.string = string;