@camstack/system 1.1.48 → 1.1.49

package/dist/{dist-BMN1IAl3.mjs → dist-8phgmJ6b.mjs}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region ../types/dist/sleep-Baang_XW.mjs
+//#region ../types/dist/sleep-DkhOVOjW.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -409,10 +409,43 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["EnrichmentEmbeddingStored"] = "enrichment.embedding.stored";
 	EventCategory["EnrichmentSceneStateChanged"] = "enrichment.scene.state-changed";
 	EventCategory["EnrichmentActivitySummary"] = "enrichment.activity.summary";
+	/**
+	* Unified track-lifecycle event: ONE category carrying `phase:
+	* 'start' | 'update' | 'end'` with a rich, typed
+	* `PipelineAnalyticsTrackLifecyclePayload`. Supersedes the thin
+	* `PipelineAnalyticsTrackStarted` / `PipelineAnalyticsTrackEnded`
+	* pair — a consumer subscribes once and branches on `phase`.
+	*/
+	EventCategory["PipelineAnalyticsTrackLifecycle"] = "pipeline-analytics.track-lifecycle";
+	/**
+	* @deprecated Superseded by {@link PipelineAnalyticsTrackLifecycle}
+	* (`phase:'start'`). Kept as a soft alias — no known subscribers.
+	*/
 	EventCategory["PipelineAnalyticsTrackStarted"] = "pipeline-analytics.track-started";
+	/**
+	* @deprecated Superseded by {@link PipelineAnalyticsTrackLifecycle}
+	* (`phase:'end'`). Kept as a soft alias — no known subscribers.
+	*/
 	EventCategory["PipelineAnalyticsTrackEnded"] = "pipeline-analytics.track-ended";
 	EventCategory["PipelineAnalyticsDetectionEvent"] = "pipeline-analytics.detection-event";
 	EventCategory["PipelineAnalyticsFrameTracked"] = "pipeline-analytics.frame-tracked";
+	/**
+	* Fired by `addon-post-analysis` whenever a gallery face row changes:
+	* `kind:'buffered'` a new detected face was persisted, `'assigned'` /
+	* `'unassigned'` its identity link changed, `'deleted'` the row was
+	* removed. Telemetry semantics (D8): a lost event only delays a refresh,
+	* never a correctness issue. Payload `PipelineAnalyticsFaceGalleryChangedPayload`.
+	*/
+	EventCategory["PipelineAnalyticsFaceGalleryChanged"] = "pipeline-analytics.face-gallery-changed";
+	/**
+	* Fired by `addon-post-analysis` whenever a gallery plate row changes:
+	* `kind:'buffered'` a new read was persisted (`PlateRecognizer.onTrackEnd`),
+	* `'assigned'` / `'unassigned'` its vehicle link changed
+	* (`PlateGalleryProvider`), `'deleted'` the row was removed. Telemetry
+	* semantics (D8): a lost event only delays a refresh, never a correctness
+	* issue. Payload `PipelineAnalyticsPlateGalleryChangedPayload`.
+	*/
+	EventCategory["PipelineAnalyticsPlateGalleryChanged"] = "pipeline-analytics.plate-gallery-changed";
 	EventCategory["FrigateLiveEvent"] = "frigate.live-event";
 	EventCategory["CameraStreamsProfileSlotsChanged"] = "camera-streams.onProfileSlotsChanged";
 	/**
@@ -2860,7 +2893,8 @@ var MODEL_FORMATS = [
 	"coreml",
 	"openvino",
 	"tflite",
-	"pt"
+	"pt",
+	"gguf"
 ];
 /**
 * Multi-file format payload.
@@ -2904,7 +2938,8 @@ var ModelFormatsSchema = z.object({
 	coreml: ModelFormatEntrySchema.optional(),
 	openvino: ModelFormatEntrySchema.optional(),
 	tflite: ModelFormatEntrySchema.optional(),
-	pt: ModelFormatEntrySchema.optional()
+	pt: ModelFormatEntrySchema.optional(),
+	gguf: ModelFormatEntrySchema.optional()
 });
 /**
 * Variant-selector grouping axes. Shared by the full `ModelCatalogEntry` and by
@@ -7849,7 +7884,8 @@ var ModelFormatSchema$1 = z.enum([
 	"coreml",
 	"openvino",
 	"tflite",
-	"pt"
+	"pt",
+	"gguf"
 ]);
 var PipelineSlotSchema = z.enum([
 	"detector",
@@ -9860,6 +9896,167 @@ var ptzAutotrackCapability = {
 	runtimeState: PtzAutotrackRuntimeStateSchema
 };
 /**
+* scene-monitor — device-scoped reference-region state cap. An operator marks
+* a rect ROI on a camera frame and names one or more states; the engine
+* (pipeline-analytics, designated post-processing node) reports which state is
+* active on an ongoing basis. Two operator-selectable check modes share every-
+* thing except the comparator: `similarity` (CLIP cosine at the same ROI coords
+* vs condition-tagged references) and `llm` (vision-LLM judgment over the crop).
+*
+* D14 device-config archetype (`deviceConfig.ui.kind:'widget'`) — the framework
+* derives the device-detail contribution; the provider carries NO hand-written
+* 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). */
+var SceneConditionSchema = z.string();
+/** One captured reference — condition-tagged, model-version-gated. `embedding`
+*  is `number[]` (Float32Array does NOT survive MsgPack/UDS). */
+var SceneReferenceSchema = z.object({
+	embedding: z.array(z.number()),
+	modelId: z.string(),
+	condition: SceneConditionSchema,
+	capturedAt: z.number(),
+	thumbnailMediaId: z.string().optional()
+});
+var SceneMonitorStateSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	references: z.array(SceneReferenceSchema),
+	textPrompts: z.array(z.string()).optional(),
+	referenceCount: z.number(),
+	currentlyMatched: z.boolean()
+});
+/** Per-mode comparator params in a discriminated union so an `llm` scene never
+*  carries similarity knobs and vice-versa. */
+var SceneCheckSchema = z.discriminatedUnion("mode", [z.object({
+	mode: z.literal("similarity"),
+	threshold: z.number().min(0).max(1),
+	hysteresisCount: z.number().int().positive()
+}), z.object({
+	mode: z.literal("llm"),
+	prompt: z.string(),
+	profileId: z.string().optional(),
+	hysteresisCount: z.number().int().positive()
+})]);
+var SceneMonitorSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	roi: MaskRectShapeSchema,
+	enabled: z.boolean(),
+	triggerMode: z.enum([
+		"periodic",
+		"on-motion",
+		"both"
+	]),
+	checkIntervalSec: z.number().optional(),
+	check: SceneCheckSchema,
+	states: z.array(SceneMonitorStateSchema),
+	currentStateId: z.string().nullable(),
+	lastCheckedAt: z.number().nullable(),
+	lastConfidence: z.number().nullable(),
+	currentCondition: SceneConditionSchema.nullable(),
+	availability: z.enum(["ok", "unavailable"]),
+	unavailableReason: z.string().nullable()
+});
+var SceneMonitorStatusSchema = z.object({
+	monitors: z.array(SceneMonitorSchema),
+	lastFetchedAt: z.number()
+});
+var sceneMonitorCapability = {
+	name: "scene-monitor",
+	scope: "device",
+	mode: "singleton",
+	kind: "wrapper",
+	defaultActive: true,
+	deviceTypes: [DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/scene-monitor-editor",
+		tab: "scenes",
+		label: "Scenes"
+	} },
+	methods: {
+		listScenes: method(z.object({ deviceId: z.number() }), SceneMonitorStatusSchema),
+		createScene: method(z.object({
+			deviceId: z.number(),
+			label: z.string(),
+			roi: MaskRectShapeSchema,
+			check: SceneCheckSchema,
+			triggerMode: z.enum([
+				"periodic",
+				"on-motion",
+				"both"
+			]).optional(),
+			checkIntervalSec: z.number().optional()
+		}), SceneMonitorSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		updateScene: method(z.object({
+			deviceId: z.number(),
+			monitorId: z.string(),
+			patch: z.object({
+				label: z.string().optional(),
+				roi: MaskRectShapeSchema.optional(),
+				enabled: z.boolean().optional(),
+				triggerMode: z.enum([
+					"periodic",
+					"on-motion",
+					"both"
+				]).optional(),
+				checkIntervalSec: z.number().optional(),
+				check: SceneCheckSchema.optional()
+			})
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteScene: method(z.object({
+			deviceId: z.number(),
+			monitorId: z.string()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		captureReference: method(z.object({
+			deviceId: z.number(),
+			monitorId: z.string(),
+			stateId: z.string().optional(),
+			label: z.string().optional(),
+			condition: SceneConditionSchema.optional()
+		}), z.object({
+			stateId: z.string(),
+			referenceCount: z.number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteReference: method(z.object({
+			deviceId: z.number(),
+			monitorId: z.string(),
+			stateId: z.string(),
+			index: z.number()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		recheckNow: method(z.object({
+			deviceId: z.number(),
+			monitorId: z.string()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: SceneMonitorStatusSchema,
+		kind: "push"
+	},
+	runtimeState: SceneMonitorStatusSchema
+};
+/**
 * Script-runner cap. Models HA `script.*` entities on
 * `DeviceType.Script`. A Script is a pre-recorded action sequence
 * that can be invoked imperatively — optionally with a variables
@@ -11560,7 +11757,12 @@ var NotificationRuleConditionsSchema = z.object({
 	clipDescription: z.object({
 		text: z.string().min(1),
 		minSimilarity: z.number().min(0).max(1)
-	}).optional()
+	}).optional(),
+	/** Match events whose recognized-entity label (face identity name or plate
+	*  vehicle name, propagated onto `event.data.label`) is one of these values.
+	*  Empty/absent → unaffected (back-compat). Enables "notify me when <named
+	*  vehicle/person> is seen". */
+	labels: z.array(z.string()).readonly().optional()
 });
 var NotificationRuleTemplateSchema = z.object({
 	title: z.string(),
@@ -11944,11 +12146,19 @@ var authProviderCapability = {
 *    login page needs NO change.
 *
 *  - `widget` — a Module-Federation widget the login page mounts (via
-*    `loadRemoteBundle`) for an in-page ceremony. Covers the passkey
-*    login ceremony, which must run `@simplewebauthn/browser` INSIDE the
-*    addon bundle. The referenced widget also declares `preAuth: true` in
-*    its `addon-widgets-source` catalog entry. `auth.listLoginMethods`
-*    stamps a public `bundleUrl` from `addonId` + `bundle`.
+*    `loadRemoteBundle`) for an in-page ceremony. `auth.listLoginMethods`
+*    stamps a public `bundleUrl` from `addonId` + `bundle`. Generic
+*    mechanism kept for future use; no shipped addon uses it on the login
+*    page (the passkey ceremony below runs natively in the shell instead).
+*
+*  - `passkey` — a declarative WebAuthn ceremony the shell renders
+*    natively (`@simplewebauthn/browser` lives in `addon-admin-ui`, not in
+*    a remotely-loaded bundle). Carries the addon's effective `rpId` /
+*    `origin` (from its `resolveRpID()` / `resolveOrigin()`) so the shell
+*    can gate visibility (IP-literal origin, hostname/rpId mismatch) WITHOUT
+*    fetching any remote code pre-auth. Contribution stays unconditional —
+*    enrollment state is never leaked pre-auth; visibility is a shell
+*    decision.
 *
 * Every contribution carries a `stage`:
 *  - `primary`        — shown on the first credentials screen (OIDC /
@@ -11997,8 +12207,30 @@ var WidgetLoginMethodSchema = z.object({
 	remote: WidgetRemoteSchema,
 	stage: LoginStageEnum
 });
-/** One login-method contribution — redirect button OR pre-auth widget. */
-var LoginMethodContributionSchema = z.discriminatedUnion("kind", [RedirectLoginMethodSchema, WidgetLoginMethodSchema]);
+/**
+* A declarative WebAuthn ceremony the shell renders natively (no remote
+* code). Carries the addon's EFFECTIVE `rpId`/`origin` so the shell can
+* gate visibility (IP-literal origin, hostname/rpId mismatch) before ever
+* showing the button — the contribution itself stays unconditional.
+*/
+var PasskeyLoginMethodSchema = z.object({
+	kind: z.literal("passkey"),
+	/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-direct-login`). */
+	id: z.string(),
+	/** Operator-facing button label. */
+	label: z.string(),
+	stage: LoginStageEnum,
+	/** Effective WebAuthn RP ID (`resolveRpID()`) — the shell gates visibility on it. */
+	rpId: z.string(),
+	/** Effective expected origin (`resolveOrigin()`), null when unconfigured. */
+	origin: z.string().nullable()
+});
+/** One login-method contribution — redirect button, pre-auth widget, or native passkey ceremony. */
+var LoginMethodContributionSchema = z.discriminatedUnion("kind", [
+	RedirectLoginMethodSchema,
+	WidgetLoginMethodSchema,
+	PasskeyLoginMethodSchema
+]);
 var loginMethodCapability = {
 	name: "login-method",
 	scope: "system",
@@ -12514,18 +12746,6 @@ var cameraPipelineConfigCapability = {
 	exposesDeviceSettings: true,
 	methods: {}
 };
-/**
-* Shared cap-router predicates — the SINGLE source for the structural Zod-shape
-* checks + naming used by BOTH the runtime cap-router builder
-* (`@camstack/system` `cap-router-builder.ts` + the server's
-* `cap-router-runtime.ts`) AND the codegen scripts (`scripts/generate-cap-*.ts`).
-*
-* These used to be independently reimplemented on each side, held in sync only
-* by "must stay byte-identical" comments — a live drift risk. Consolidating them
-* here (next to `resolveCapMount` / `expandCapMethods`, the other shared model)
-* makes the two paths provably agree. Each predicate accepts both Zod 4
-* (`_def.type`) and legacy Zod 3 (`_def.typeName` / `constructor.name`) shapes.
-*/
 /** `z.void()` — input carries no data. */
 function isVoidInput(schema) {
 	const def = schema._def;
@@ -12553,6 +12773,26 @@ function isArrayOutputSchema(schema) {
 	return false;
 }
 /**
+* True when `method` on cap `def` is a COLLECTION cap's array-returning
+* (non-subscription) method — the methods whose contract is "union the result
+* across every registered provider" (`listTargets`, `listTargetKinds`,
+* `discoverTargets`, `listEndpoints`, …).
+*
+* Such a method is aggregated at the hub via `concatCollection` / the runtime
+* `concatArrayMethod`, both of which SKIP a provider that doesn't implement it
+* (contributes `[]`). That local skip is invisible across the UDS boundary — a
+* hub-side per-provider proxy fabricates a callable for every property, so the
+* call reaches the child's real (possibly partial) provider. This predicate lets
+* the child-side dispatcher reproduce the same graceful skip: a missing method
+* here yields `[]`, not a "method not found" error. Singleton caps and non-array
+* methods return `false` so a genuinely missing method still surfaces as a bug.
+*/
+function isCollectionArrayMethod(def, method) {
+	if (def === void 0 || def.mode !== "collection") return false;
+	const m = expandCapMethods(def)[method];
+	return m !== void 0 && m.kind !== "subscription" && isArrayOutputSchema(m.output);
+}
+/**
 * Apply `.loose()` to an object input schema when available (Zod 4) so the
 * router accepts the out-of-band `nodeId`/`addonId` selector keys without
 * stripping them. Falls back to the schema unchanged when `.loose()` is absent.
@@ -14671,14 +14911,14 @@ var TargetKindCapsSchema = z.object({
 * the union is large and not meant for runtime validation here; the exported
 * `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
 */
-var ConfigSchemaPassthrough = z.unknown();
+var ConfigSchemaPassthrough$1 = z.unknown();
 var TargetKindSchema = z.object({
 	kind: z.string(),
 	label: z.string(),
 	icon: z.string(),
 	/** Stamped by each provider so the concat-fanned catalog stays routable. */
 	addonId: z.string(),
-	configSchema: ConfigSchemaPassthrough,
+	configSchema: ConfigSchemaPassthrough$1,
 	supportsDiscovery: z.boolean(),
 	caps: TargetKindCapsSchema
 });
@@ -14745,6 +14985,345 @@ var notificationOutputCapability = {
 	}
 };
 /**
+* Shared LLM generate contracts — imported by BOTH `llm.cap.ts` (consumer
+* surface) and `llm-runtime.cap.ts` (node-side managed executor) so the two
+* caps stay wire-compatible without a circular cap→cap import.
+*
+* Errors are a discriminated-union RESULT, never thrown: the shape survives
+* every transport tier structurally, and failed calls still write usage rows.
+* Token counts only in v1 — no costUsd (operator decision, 2026-07-15).
+*/
+var LlmUsageSchema = z.object({
+	inputTokens: z.number(),
+	outputTokens: z.number()
+});
+var LlmErrorCodeSchema = z.enum([
+	"timeout",
+	"rate-limited",
+	"auth",
+	"refusal",
+	"bad-request",
+	"unavailable",
+	"no-profile",
+	"budget-exceeded",
+	"adapter-error"
+]);
+var LlmGenerateOkSchema = z.object({
+	ok: z.literal(true),
+	text: z.string(),
+	model: z.string(),
+	usage: LlmUsageSchema,
+	truncated: z.boolean(),
+	latencyMs: z.number()
+});
+var LlmGenerateErrSchema = z.object({
+	ok: z.literal(false),
+	code: LlmErrorCodeSchema,
+	message: z.string(),
+	retryAfterMs: z.number().optional()
+});
+var LlmGenerateResultSchema = z.discriminatedUnion("ok", [LlmGenerateOkSchema, LlmGenerateErrSchema]);
+/**
+* `Uint8Array` is the sanctioned binary convention — superjson + the UDS
+* MsgPack channel round-trip typed arrays (embedding-encoder.cap.ts:29,
+* notification-output.cap.ts:27-31 precedents).
+*/
+var LlmImageSchema = z.object({
+	bytes: z.instanceof(Uint8Array),
+	mimeType: z.string()
+});
+var LlmGenerateBaseInputSchema = z.object({
+	/** Collection routing (the notification-output posture). */
+	addonId: z.string().optional(),
+	/** Explicit profile; else the resolution chain (spec §3). */
+	profileId: z.string().optional(),
+	/** MANDATORY usage tag: 'ai-summary', 'notifier-rules', 'adhoc-ui', … */
+	consumer: z.string(),
+	system: z.string().optional(),
+	/** v1: single-turn. `messages[]` is a v2 additive field. */
+	prompt: z.string(),
+	/** Structured output — adapter-mapped (response_format / forced tool / responseSchema). */
+	jsonSchema: z.record(z.string(), z.unknown()).optional(),
+	/** Per-call override of the profile default. */
+	maxTokens: z.number().int().positive().optional(),
+	temperature: z.number().optional()
+});
+/**
+* `llm-runtime` — node-side managed llama.cpp executor (spec §4). Registered
+* on EVERY node where `addon-ai` is installed; the hub `llm` provider reaches
+* a specific node's runtime with `nodePin(profile.runtime.nodeId)` — normal
+* cap routing, zero bespoke plumbing. `internal: true`: the operator reaches
+* this only through the `llm` cap's methods.
+*
+* One running llama-server child per node in v1 (models are RAM-heavy).
+* Resource ceiling = llama-server flags + idleStopMinutes ONLY (no RSS
+* watchdog — operator decision #3).
+*/
+var ManagedModelRefSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("catalog"),
+		catalogId: z.string()
+	}),
+	z.object({
+		kind: z.literal("url"),
+		url: z.string(),
+		sha256: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("path"),
+		path: z.string()
+	})
+]);
+var ManagedRuntimeConfigSchema = z.object({
+	/** WHERE the runtime lives — hub or any agent. */
+	nodeId: z.string(),
+	/** Closed for v1; 'ollama' is a v2 candidate. */
+	engine: z.enum(["llama-cpp"]),
+	model: ManagedModelRefSchema,
+	contextSize: z.number().int().default(4096),
+	/** 0 = CPU-only. */
+	gpuLayers: z.number().int().default(0),
+	/** Default: cpus-2, clamped ≥1 (resolved node-side). */
+	threads: z.number().int().optional(),
+	/** Concurrent slots. */
+	parallel: z.number().int().default(1),
+	/** Else lazy: first generate boots it. */
+	autoStart: z.boolean().default(false),
+	/** 0 = never; frees RAM after quiet periods. */
+	idleStopMinutes: z.number().int().default(30)
+});
+var LlmRuntimeStatusSchema = z.object({
+	/** Status is ALWAYS node-qualified. */
+	nodeId: z.string(),
+	state: z.enum([
+		"stopped",
+		"downloading",
+		"starting",
+		"ready",
+		"crashed",
+		"failed"
+	]),
+	pid: z.number().optional(),
+	port: z.number().optional(),
+	modelPath: z.string().optional(),
+	modelId: z.string().optional(),
+	downloadProgress: z.number().min(0).max(1).optional(),
+	lastError: z.string().optional(),
+	crashesInWindow: z.number(),
+	/** Child RSS (sampled best-effort). */
+	memoryBytes: z.number().optional(),
+	vramBytes: z.number().optional()
+});
+var LlmNodeModelSchema = z.object({
+	file: z.string(),
+	sizeBytes: z.number(),
+	catalogId: z.string().optional(),
+	installedAt: z.number().optional()
+});
+var LlmRuntimeDiskUsageSchema = z.object({
+	nodeId: z.string(),
+	modelsBytes: z.number(),
+	freeBytes: z.number().optional()
+});
+var llmRuntimeCapability = {
+	name: "llm-runtime",
+	scope: "system",
+	mode: "singleton",
+	internal: true,
+	methods: {
+		complete: method(LlmGenerateBaseInputSchema.extend({
+			images: z.array(LlmImageSchema).optional(),
+			runtime: ManagedRuntimeConfigSchema,
+			/** The managed profile's timeout, threaded by the hub provider. */
+			timeoutMs: z.number().int().positive().optional()
+		}), LlmGenerateResultSchema, { kind: "mutation" }),
+		ensureStarted: method(z.object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stop: method(z.object({}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		status: method(z.object({}), LlmRuntimeStatusSchema),
+		installModel: method(z.object({ model: ManagedModelRefSchema }), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteModel: method(z.object({ file: z.string() }), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		listLocalModels: method(z.object({}), z.array(LlmNodeModelSchema)),
+		getDiskUsage: method(z.object({}), LlmRuntimeDiskUsageSchema)
+	}
+};
+/**
+* `llm` — consumer-facing LLM surface (spec §1-§3). Collection-mode: array
+* methods concat-fan across providers; single-row methods route to ONE
+* provider by the `addonId` in the call input (the notification-output
+* posture, notification-output.cap.ts:215-250). Provided by `addon-ai`
+* (hub-placed); the cap stays open for future providers.
+*
+* Profiles are ROWS (data), not addons: one row = one usable model endpoint.
+* `apiKey` is a password field — providers REDACT it on read and merge on
+* write; a stored key NEVER round-trips to a client.
+*/
+var LlmProfileKindSchema = z.enum([
+	"openai-compatible",
+	"openai",
+	"anthropic",
+	"google",
+	"managed-local"
+]);
+var LlmProfileSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	kind: LlmProfileKindSchema,
+	/** Stamped by the provider — keeps the fanned catalog routable. */
+	addonId: z.string(),
+	enabled: z.boolean(),
+	/** Vendor model id, or the managed runtime's loaded model. */
+	model: z.string(),
+	/** Required for openai-compatible; override for cloud kinds. */
+	baseUrl: z.string().optional(),
+	/** ConfigUISchema type:'password' — never round-trips (spec §5). */
+	apiKey: z.string().optional(),
+	supportsVision: z.boolean(),
+	temperature: z.number().min(0).max(2).optional(),
+	maxTokens: z.number().int().positive().optional(),
+	timeoutMs: z.number().int().positive().default(6e4),
+	extraHeaders: z.record(z.string(), z.string()).optional(),
+	/** kind === 'managed-local' only (spec §4). */
+	runtime: ManagedRuntimeConfigSchema.optional()
+});
+/** ConfigUISchema tree passed through untyped on the wire (the
+*  notification-output `ConfigSchemaPassthrough` precedent at
+*  notification-output.cap.ts:151); the exported TS type re-tightens it. */
+var ConfigSchemaPassthrough = z.unknown();
+var LlmProfileKindDescriptorSchema = z.object({
+	kind: LlmProfileKindSchema,
+	label: z.string(),
+	icon: z.string(),
+	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	addonId: z.string(),
+	configSchema: ConfigSchemaPassthrough
+});
+var LlmDefaultSelectorSchema = z.union([z.object({ consumer: z.string() }), z.object({ purpose: z.enum(["text", "vision"]) })]);
+var LlmDefaultSchema = z.object({
+	selector: LlmDefaultSelectorSchema,
+	profileId: z.string()
+});
+/** Server-side rollup row — getUsage never dumps raw call rows (spec §6). */
+var LlmUsageRollupSchema = z.object({
+	day: z.string(),
+	consumer: z.string(),
+	profileId: z.string(),
+	calls: z.number(),
+	okCalls: z.number(),
+	errorCalls: z.number(),
+	inputTokens: z.number(),
+	outputTokens: z.number(),
+	avgLatencyMs: z.number()
+});
+/** LLM-facing view over the reused ModelCatalogEntry mechanism (spec §4.2). */
+var ManagedModelCatalogEntrySchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	family: z.string(),
+	purpose: z.enum(["text", "vision"]),
+	url: z.string(),
+	sha256: z.string(),
+	sizeBytes: z.number(),
+	quantization: z.string(),
+	/** Load-time guidance shown in the picker. */
+	minRamBytes: z.number(),
+	contextSizeDefault: z.number().int(),
+	/** Vision models: companion projector file. */
+	mmprojUrl: z.string().optional()
+});
+var LlmRuntimeNodeSchema = z.object({
+	nodeId: z.string(),
+	reachable: z.boolean(),
+	status: LlmRuntimeStatusSchema.optional(),
+	disk: LlmRuntimeDiskUsageSchema.optional(),
+	error: z.string().optional()
+});
+var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: z.array(LlmImageSchema).min(1) });
+var ProfileRefInputSchema = z.object({
+	addonId: z.string(),
+	profileId: z.string()
+});
+var llmCapability = {
+	name: "llm",
+	scope: "system",
+	mode: "collection",
+	internal: false,
+	providerKind: "ai",
+	/** `nodeId` inputs below are DATA (the hub provider pins itself), never routing. */
+	nodeIdMode: "data",
+	methods: {
+		generate: method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		generateVision: method(GenerateVisionInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		listProfileKinds: method(z.object({}), z.array(LlmProfileKindDescriptorSchema)),
+		listProfiles: method(z.object({}), z.array(LlmProfileSchema)),
+		upsertProfile: method(z.object({ profile: LlmProfileSchema }), LlmProfileSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteProfile: method(ProfileRefInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		testProfile: method(ProfileRefInputSchema, LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Live vendor enumeration (GET /models etc.). */
+		listModels: method(ProfileRefInputSchema, z.array(z.string())),
+		getDefaults: method(z.object({}), z.array(LlmDefaultSchema)),
+		setDefault: method(z.object({
+			selector: LlmDefaultSelectorSchema,
+			profileId: z.string().nullable()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getUsage: method(z.object({
+			since: z.number().optional(),
+			until: z.number().optional(),
+			consumer: z.string().optional(),
+			profileId: z.string().optional()
+		}), z.array(LlmUsageRollupSchema)),
+		listModelCatalog: method(z.object({}), z.array(ManagedModelCatalogEntrySchema)),
+		listRuntimeNodes: method(z.object({}), z.array(LlmRuntimeNodeSchema)),
+		listNodeModels: method(z.object({ nodeId: z.string() }), z.array(LlmNodeModelSchema)),
+		installModel: method(z.object({
+			nodeId: z.string(),
+			model: ManagedModelRefSchema
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteModel: method(z.object({
+			nodeId: z.string(),
+			file: z.string()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getRuntimeStatus: method(ProfileRefInputSchema, LlmRuntimeStatusSchema),
+		startRuntime: method(ProfileRefInputSchema, LlmRuntimeStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stopRuntime: method(ProfileRefInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	}
+};
+/**
 * Zod schemas for persisted record types.
 *
 * These schemas serve as the single source of truth for types that are
@@ -14966,6 +15545,10 @@ var TrackSchema = z.object({
 	snapshots: z.array(TrackSnapshotSchema).readonly(),
 	/** Deduplicated zones the track has entered at least once. */
 	zonesVisited: z.array(z.string()).readonly(),
+	/** Deduplicated set of detector classes observed for this track over its
+	*  life (a track may be reclassified, e.g. person→vehicle). Absent on
+	*  legacy rows written before class accumulation shipped. */
+	classes: z.array(z.string()).readonly().optional(),
 	/** Cumulative normalized distance travelled (0..1 units = full frame width). */
 	totalDistance: z.number(),
 	state: TrackStateSchema,
@@ -15127,7 +15710,7 @@ var KeyEventSchema = z.object({
 	/** Track lifetime in ms (lastSeen - firstSeen). */
 	windowMs: z.number().optional()
 });
-var TrackedDetectionSchema = z.object({
+z.object({
 	trackId: z.string(),
 	className: z.string(),
 	confidence: z.number(),
@@ -15135,6 +15718,23 @@ var TrackedDetectionSchema = z.object({
 	zones: z.array(z.string()).readonly(),
 	state: TrackStateSchema
 });
+var OverlayDetectionSchema = z.looseObject({
+	id: z.string(),
+	kind: z.enum(["first-level", "detail"]),
+	macroClass: z.string(),
+	score: z.number(),
+	bbox: z.object({
+		x: z.number(),
+		y: z.number(),
+		width: z.number(),
+		height: z.number()
+	}),
+	labels: z.array(z.looseObject({
+		label: z.string(),
+		score: z.number()
+	})).readonly(),
+	parentId: z.string().optional()
+});
 var ScoredObjectEventSchema = ObjectEventSchema.extend({ score: z.number() });
 var SearchObjectEventsInput = z.object({
 	text: z.string(),
@@ -15145,6 +15745,20 @@ var SearchObjectEventsInput = z.object({
 	limit: z.number().default(50),
 	minScore: z.number().min(0).max(1).default(.2)
 });
+var TrackCascadeCountsSchema = z.object({
+	/** Persisted track roots deleted (authoritative). */
+	tracks: z.number().int(),
+	/** Object events removed with their tracks (best-effort; see note above). */
+	events: z.number().int(),
+	/** Track/face/plate-owned media removed (best-effort). Never identity media. */
+	media: z.number().int(),
+	/** Unassigned (non-enrolled) face reads removed (best-effort). */
+	faces: z.number().int(),
+	/** Unassigned plate reads removed (best-effort; plate leg deferred to plate-intelligence). */
+	plates: z.number().int(),
+	/** Per-track CLIP search vectors removed (best-effort). */
+	embeddings: z.number().int()
+});
 var pipelineAnalyticsCapability = {
 	name: "pipeline-analytics",
 	scope: "device",
@@ -15198,12 +15812,14 @@ var pipelineAnalyticsCapability = {
 			audio: z.number().int()
 		})).readonly()),
 		/**
-		* Delete all events (motion + object + audio) for the given device
-		* that are older than `cutoffMs` (exclusive), and delete their
-		* thumbnails in lockstep. Returns per-kind deleted counts.
-		*
-		* Called by Phase B3 recorder orchestration to keep event history
-		* aligned with available footage.
+		* @deprecated Prefer `pruneTracksBefore` — the track is the ROOT of the
+		* analytics model and retention must cascade from it (design §5.1). This
+		* event-only prune leaves orphaned tracks/faces/plates/embeddings behind.
+		* Retained as a compat shim for the Phase-B3 recorder orchestration caller,
+		* which prunes events to keep history aligned with available footage and
+		* reads the per-kind counts. Delete all events (motion + object + audio)
+		* for the given device older than `cutoffMs` (exclusive) + their thumbnails
+		* in lockstep; returns per-kind deleted counts.
 		*/
 		pruneEventsBefore: method(z.object({
 			deviceId: z.number(),
@@ -15216,6 +15832,55 @@ var pipelineAnalyticsCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Track-centric retention entry point (design §5.1). Selects every
+		* persisted track for the device whose `lastSeen < cutoffMs` (paged) and
+		* runs the extensible whole-track deletion cascade (design §3): object
+		* events + their media, track/face/plate-owned media, unassigned face
+		* reads, per-track CLIP embeddings, then the track root LAST. ENROLLED
+		* (assigned) faces/plates and `ownerKind:'identity'` media are exempt —
+		* the durable matching gallery always persists. Fires the per-track
+		* live-state cleanup so a pruned track can't linger in dispatch/overlay
+		* state. Returns per-family deleted counts (`tracks` authoritative).
+		*
+		* Replaces `pruneEventsBefore` as the correct time-based retention prune.
+		*/
+		pruneTracksBefore: method(z.object({
+			deviceId: z.number(),
+			cutoffMs: z.number()
+		}), TrackCascadeCountsSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Operator "clean slate" for a device (design §5.3): prune EVERY track for
+		* the device via the same cascade as `pruneTracksBefore` with `cutoffMs =
+		* now`. One call per device — no client-side track enumeration. Enrolled
+		* gallery + identity media are exempt (design §4). Returns per-family
+		* deleted counts.
+		*/
+		wipeAllAnalytics: method(z.object({ deviceId: z.number() }), TrackCascadeCountsSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Delete whole tracks (object events) by id for the given device,
+		* cascading their media in lockstep. Returns the number of tracks
+		* actually deleted plus the ids that could not be removed.
+		*
+		* Operator-driven from the DI Events page (batch delete). Routes through
+		* the same widened track-deletion cascade (design §5.2).
+		*/
+		deleteTracks: method(z.object({
+			deviceId: z.number(),
+			trackIds: z.array(z.string()).min(1)
+		}), z.object({
+			deleted: z.number().int(),
+			failed: z.array(z.string()).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		getEventMedia: method(z.object({
 			eventId: z.string(),
 			kind: MediaFileKindEnum.optional()
@@ -15233,17 +15898,19 @@ var pipelineAnalyticsCapability = {
 	},
 	events: {
 		/**
-		* Enriched frame emitted after refinement. Carries lightweight
-		* tracked-detection metadata (track id, class, zones, state) so
-		* downstream consumers (stream overlays, notifications) can
-		* annotate without querying full Track state.
+		* Enriched frame emitted after refinement — the live-overlay source of
+		* truth (two-plane re-injection). Carries the frame's detections in the
+		* `ObjectDetection` wire shape: first-level roots (with track info +
+		* enrichment labels) plus synthesized `kind:'detail'` face/plate entries
+		* re-projected from per-track detail state, so stream overlays render
+		* boxes + recognized names without querying full Track state.
 		*/
 		onFrameTracked: { data: z.object({
 			deviceId: z.number(),
 			timestamp: z.number(),
 			frameWidth: z.number(),
 			frameHeight: z.number(),
-			detections: z.array(TrackedDetectionSchema).readonly()
+			detections: z.array(OverlayDetectionSchema).readonly()
 		}) },
 		/** Track entered active state (first-seen). */
 		onTrackStarted: { data: z.object({
@@ -19239,6 +19906,24 @@ setOverlay: method(z.object({
 		}
 	}] }
 };
+var VehicleSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	sampleCount: z.number().int().nonnegative(),
+	coverMediaKey: z.string().optional(),
+	/** Inline base64 of the cover sample's plate crop, resolved from `coverMediaKey`. */
+	coverBase64: z.string().optional()
+});
+var VehicleSampleInfoSchema = z.object({
+	id: z.string(),
+	/** The plate text this sample enrolled (self-labeling — no embedding). */
+	text: z.string(),
+	/** OCR confidence of the enrolled read (0..1). */
+	score: z.number(),
+	addedAt: z.number().int(),
+	deviceId: z.number().int().optional(),
+	base64: z.string().optional()
+});
 var PlateInfoSchema = z.object({
 	plateId: z.string(),
 	deviceId: z.number().int(),
@@ -19250,6 +19935,16 @@ var PlateInfoSchema = z.object({
 	score: z.number(),
 	/** True when the text was manually corrected (exempt from retention). */
 	corrected: z.boolean(),
+	/** Recognized vehicle id when a matcher lookup named this read (SQL NULL → absent). */
+	recognizedVehicleId: z.string().optional(),
+	/** Resolved vehicle name for `recognizedVehicleId` (UI convenience). */
+	vehicleName: z.string().optional(),
+	/** True once the read was assigned to a vehicle (enrolled as a sample). */
+	assigned: z.boolean(),
+	/** keyFrame parity: the plate bbox (pixel space) on the native key frame. */
+	plateBbox: BoundingBoxSchema.optional(),
+	/** keyFrame parity: MediaStore key of the track's native-resolution key frame. */
+	keyFrameMediaKey: z.string().optional(),
 	base64: z.string().optional()
 });
 var MediaFileLiteSchema = z.object({
@@ -19311,6 +20006,58 @@ var plateGalleryCapability = {
 		deletePlate: method(z.object({ plateId: z.string() }), z.void(), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		listVehicles: method(z.void(), z.array(VehicleSchema).readonly()),
+		createVehicle: method(z.object({ name: z.string().min(1) }), VehicleSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		renameVehicle: method(z.object({
+			id: z.string(),
+			name: z.string().min(1)
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteVehicle: method(z.object({ id: z.string() }), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		listVehicleSamples: method(z.object({ vehicleId: z.string() }), z.array(VehicleSampleInfoSchema).readonly()),
+		removeVehicleSample: method(z.object({
+			vehicleId: z.string(),
+			sampleId: z.string()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		assignPlate: method(z.object({
+			plateId: z.string(),
+			vehicleId: z.string()
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		unassignPlate: method(z.object({ plateId: z.string() }), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		assignPlates: method(z.object({
+			plateIds: z.array(z.string()).min(1),
+			vehicleId: z.string()
+		}), z.object({
+			assigned: z.number().int(),
+			failed: z.array(z.string()).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		unassignPlates: method(z.object({ plateIds: z.array(z.string()).min(1) }), z.object({
+			unassigned: z.number().int(),
+			failed: z.array(z.string()).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -20471,6 +21218,8 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	integrationsCapability,
 	intercomCapability,
 	lawnMowerControlCapability,
+	llmCapability,
+	llmRuntimeCapability,
 	localNetworkCapability,
 	lockControlCapability,
 	logDestinationCapability,
@@ -20509,6 +21258,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	ptzAutotrackCapability,
 	rebootCapability,
 	recordingCapability,
+	sceneMonitorCapability,
 	scriptRunnerCapability,
 	serverManagementCapability,
 	settingsStoreCapability,
@@ -20603,6 +21353,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"ptz",
 	"ptz-autotrack",
 	"recording",
+	"scene-monitor",
 	"script-runner",
 	"smoke",
 	"snapshot",
@@ -22526,6 +23277,168 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"llm.deleteModel": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"llm.deleteProfile": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"llm.generate": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.generateVision": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.getDefaults": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.getRuntimeStatus": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.getUsage": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.installModel": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.listModelCatalog": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listModels": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listNodeModels": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listProfileKinds": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listProfiles": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listRuntimeNodes": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.setDefault": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.startRuntime": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.stopRuntime": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.testProfile": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.upsertProfile": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.complete": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.deleteModel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"llmRuntime.ensureStarted": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.getDiskUsage": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.installModel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.listLocalModels": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.status": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.stop": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.getAllowedAddresses": {
 		capName: "local-network",
 		capScope: "system",
@@ -23156,6 +24069,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineAnalytics.deleteTracks": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineAnalytics.getActiveTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -23222,12 +24141,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.pruneTracksBefore": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.searchObjectEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.wipeAllAnalytics": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineExecutor.cacheFrameInPool": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -23732,18 +24663,42 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"plateGallery.assignPlate": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"plateGallery.assignPlates": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"plateGallery.correctPlateText": {
 		capName: "plate-gallery",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"plateGallery.createVehicle": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"plateGallery.deletePlate": {
 		capName: "plate-gallery",
 		capScope: "system",
 		addonId: null,
 		access: "delete"
 	},
+	"plateGallery.deleteVehicle": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"plateGallery.getPlateByTrack": {
 		capName: "plate-gallery",
 		capScope: "system",
@@ -23762,6 +24717,30 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"plateGallery.listVehicles": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"plateGallery.listVehicleSamples": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"plateGallery.removeVehicleSample": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"plateGallery.renameVehicle": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"plateGallery.searchPlates": {
 		capName: "plate-gallery",
 		capScope: "system",
@@ -23774,6 +24753,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"plateGallery.unassignPlate": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"plateGallery.unassignPlates": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"platformProbe.getCapabilities": {
 		capName: "platform-probe",
 		capScope: "system",
@@ -23966,6 +24957,48 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"sceneMonitor.captureReference": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"sceneMonitor.createScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"sceneMonitor.deleteReference": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
+	"sceneMonitor.deleteScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
+	"sceneMonitor.listScenes": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"sceneMonitor.recheckNow": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"sceneMonitor.updateScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"scriptRunner.run": {
 		capName: "script-runner",
 		capScope: "device",
@@ -25050,6 +26083,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 Object.freeze({
 	"broker": "broker",
 	"device-export": "device-export",
+	"llm": "ai",
 	"mesh-network": "mesh",
 	"mqtt-broker": "broker",
 	"network-access": "ingress",
@@ -25138,4 +26172,4 @@ function scoreRuntimes(hw) {
 	};
 }
 //#endregion
-export { errMsg as $, isVoidInput as A, platformProbeCapability as B, enumerateItemArrayFields as C, resolveCapMount as Ct, getByPath as D, filesystemBrowseCapability as E, looseSchema as F, settingsStoreCapability as G, readNodePin as H, metricsProviderCapability as I, storageProviderCapability as J, snapshotCapability as K, nodePin as L, lifecycleJobSchema as M, localNetworkCapability as N, isArrayOutputSchema as O, logDestinationCapability as P, validateExpressionSource as Q, normalizeUnit as R, deviceStatusCapability as S, readinessKey as St, evaluateLinkExpression as T, sleep as Tt, scoreRuntimes as U, procedureAuthKey as V, setByPath as W, toExpressionValue as X, streamQualityLabel as Y, userManagementCapability as Z, authProviderCapability as _, expandCapMethods as _t, DeviceStatusSchema as a, DeviceRole as at, deviceManagerCapability as b, parseJsonObject as bt, STREAM_PROFILE_META as c, ReadinessRegistry as ct, UserRecordSchema as d, asJsonObject as dt, BaseAddon as et, addonPagesCapability as f, asNumber as ft, applyTransform as g, emitReadiness as gt, alertsCapability as h, emitDownForOwnedCaps as ht, CAP_NAMES_WITH_STATUS as i, DeviceFeature as it, kebabToCamel as j, isObjectInput as k, ScopedTokenSchema as l, ReadinessTimeoutError as lt, addonWidgetsCapability as m, createEvent as mt, AlertSchema as n, DEVICE_SETTINGS_CONTRIBUTION_METHODS as nt, METHOD_ACCESS_MAP as o, DeviceType as ot, addonSettingsCapability as p, asString as pt, storageCapability as q, ApiKeyRecordSchema as r, DEVICE_STATUS_METHOD as rt, RUNTIME_DEFAULTS as s, EventCategory as st, ALL_CAPABILITY_DEFINITIONS as t, DATAPLANE_SECRET_HEADER as tt, StorageLocationTypeSchema as u, WELL_KNOWN_TAB_MAP as ut, backupCapability as v, hydrateSchema as vt, enumerateSchemaFields as w, scopeKey as wt, deviceStateCapability as x, parseJsonUnknown as xt, buildStreamParamsConfigSchema as y, isDeviceConfigCap as yt, parseStreamParamsFormPatch as z };
+export { validateExpressionSource as $, isObjectInput as A, parseStreamParamsFormPatch as B, enumerateItemArrayFields as C, readinessKey as Ct, getByPath as D, filesystemBrowseCapability as E, sleep as Et, logDestinationCapability as F, setByPath as G, procedureAuthKey as H, looseSchema as I, storageCapability as J, settingsStoreCapability as K, metricsProviderCapability as L, kebabToCamel as M, lifecycleJobSchema as N, isArrayOutputSchema as O, localNetworkCapability as P, userManagementCapability as Q, nodePin as R, deviceStatusCapability as S, parseJsonUnknown as St, evaluateLinkExpression as T, scopeKey as Tt, readNodePin as U, platformProbeCapability as V, scoreRuntimes as W, streamQualityLabel as X, storageProviderCapability as Y, toExpressionValue as Z, authProviderCapability as _, emitReadiness as _t, DeviceStatusSchema as a, DeviceFeature as at, deviceManagerCapability as b, isDeviceConfigCap as bt, STREAM_PROFILE_META as c, EventCategory as ct, UserRecordSchema as d, WELL_KNOWN_TAB_MAP as dt, errMsg as et, addonPagesCapability as f, asJsonObject as ft, applyTransform as g, emitDownForOwnedCaps as gt, alertsCapability as h, createEvent as ht, CAP_NAMES_WITH_STATUS as i, DEVICE_STATUS_METHOD as it, isVoidInput as j, isCollectionArrayMethod as k, ScopedTokenSchema as l, ReadinessRegistry as lt, addonWidgetsCapability as m, asString as mt, AlertSchema as n, DATAPLANE_SECRET_HEADER as nt, METHOD_ACCESS_MAP as o, DeviceRole as ot, addonSettingsCapability as p, asNumber as pt, snapshotCapability as q, ApiKeyRecordSchema as r, DEVICE_SETTINGS_CONTRIBUTION_METHODS as rt, RUNTIME_DEFAULTS as s, DeviceType as st, ALL_CAPABILITY_DEFINITIONS as t, BaseAddon as tt, StorageLocationTypeSchema as u, ReadinessTimeoutError as ut, backupCapability as v, expandCapMethods as vt, enumerateSchemaFields as w, resolveCapMount as wt, deviceStateCapability as x, parseJsonObject as xt, buildStreamParamsConfigSchema as y, hydrateSchema as yt, normalizeUnit as z };