@camstack/types 1.1.43 → 1.1.45

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DmvEGsRg.js");
+const require_sleep = require("./sleep-BdhADtqT.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 let zod = require("zod");
 //#region src/health/wiring-health.ts
@@ -69,7 +69,8 @@ var MODEL_FORMATS = [
 	"coreml",
 	"openvino",
 	"tflite",
-	"pt"
+	"pt",
+	"gguf"
 ];
 /**
 * Multi-file format payload.
@@ -113,7 +114,8 @@ var ModelFormatsSchema = zod.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
@@ -154,6 +156,15 @@ var ModelCatalogEntrySchema = zod.z.object({
 		width: zod.z.number(),
 		height: zod.z.number()
 	}),
+	/**
+	* Channel count of the model input tensor. Omit ⇒ 3 (RGB), the default for
+	* every detector / classifier / embedder. Set to 1 for a grayscale CTC text
+	* recognizer (EasyOCR VGG plate-OCR: input `[N,1,H,W]`) so the preprocess
+	* feeds a single-channel, EasyOCR-normalized tensor instead of the default
+	* 3-channel RGB one. Threaded through `PoolModelConfig.inputChannels` to the
+	* Python inference pool.
+	*/
+	inputChannels: zod.z.number().int().positive().optional(),
 	labels: zod.z.array(LabelDefinitionSchema).readonly(),
 	inputLayout: zod.z.enum(["nchw", "nhwc"]).optional(),
 	inputNormalization: zod.z.enum([
@@ -163,6 +174,16 @@ var ModelCatalogEntrySchema = zod.z.object({
 	]).optional(),
 	preprocessMode: zod.z.enum(["letterbox", "resize"]).optional(),
 	/**
+	* Per-MODEL postprocessor override. Absent ⇒ the step's own
+	* `StepDefinition.postprocessor` applies (the normal case — every model in a
+	* step shares its decode). Set it when a step hosts models with DIFFERENT raw
+	* output layouts under one slot: e.g. object-detection is `'yolo'` by default,
+	* but a Coral SSD MobileNet build emits the `TFLite_Detection_PostProcess`
+	* 4-tensor layout and needs `'ssd'`. Threaded into `PoolModelConfig.postprocessor`
+	* by the engine factory (`modelEntry.postprocessor ?? def.postprocessor`).
+	*/
+	postprocessor: zod.z.custom().optional(),
+	/**
 	* When true, the executor produces a landmark-aligned crop (similarity warp
 	* onto the canonical template) before this step runs, instead of a plain
 	* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
@@ -7515,7 +7536,8 @@ var ModelFormatSchema$1 = zod.z.enum([
 	"coreml",
 	"openvino",
 	"tflite",
-	"pt"
+	"pt",
+	"gguf"
 ]);
 var PipelineSlotSchema = zod.z.enum([
 	"detector",
@@ -7610,7 +7632,8 @@ var EngineProvisioningSchema = zod.z.object({
 	runtimeId: zod.z.enum([
 		"onnx",
 		"openvino",
-		"coreml"
+		"coreml",
+		"edgetpu"
 	]).nullable(),
 	device: zod.z.string().nullable(),
 	state: zod.z.enum([
@@ -9713,6 +9736,169 @@ var ptzAutotrackCapability = {
 	runtimeState: PtzAutotrackRuntimeStateSchema
 };
 //#endregion
+//#region src/capabilities/scene-monitor.cap.ts
+/**
+* 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 = zod.z.string();
+/** One captured reference — condition-tagged, model-version-gated. `embedding`
+*  is `number[]` (Float32Array does NOT survive MsgPack/UDS). */
+var SceneReferenceSchema = zod.z.object({
+	embedding: zod.z.array(zod.z.number()),
+	modelId: zod.z.string(),
+	condition: SceneConditionSchema,
+	capturedAt: zod.z.number(),
+	thumbnailMediaId: zod.z.string().optional()
+});
+var SceneMonitorStateSchema = zod.z.object({
+	id: zod.z.string(),
+	label: zod.z.string(),
+	references: zod.z.array(SceneReferenceSchema),
+	textPrompts: zod.z.array(zod.z.string()).optional(),
+	referenceCount: zod.z.number(),
+	currentlyMatched: zod.z.boolean()
+});
+/** Per-mode comparator params in a discriminated union so an `llm` scene never
+*  carries similarity knobs and vice-versa. */
+var SceneCheckSchema = zod.z.discriminatedUnion("mode", [zod.z.object({
+	mode: zod.z.literal("similarity"),
+	threshold: zod.z.number().min(0).max(1),
+	hysteresisCount: zod.z.number().int().positive()
+}), zod.z.object({
+	mode: zod.z.literal("llm"),
+	prompt: zod.z.string(),
+	profileId: zod.z.string().optional(),
+	hysteresisCount: zod.z.number().int().positive()
+})]);
+var SceneMonitorSchema = zod.z.object({
+	id: zod.z.string(),
+	label: zod.z.string(),
+	roi: MaskRectShapeSchema,
+	enabled: zod.z.boolean(),
+	triggerMode: zod.z.enum([
+		"periodic",
+		"on-motion",
+		"both"
+	]),
+	checkIntervalSec: zod.z.number().optional(),
+	check: SceneCheckSchema,
+	states: zod.z.array(SceneMonitorStateSchema),
+	currentStateId: zod.z.string().nullable(),
+	lastCheckedAt: zod.z.number().nullable(),
+	lastConfidence: zod.z.number().nullable(),
+	currentCondition: SceneConditionSchema.nullable(),
+	availability: zod.z.enum(["ok", "unavailable"]),
+	unavailableReason: zod.z.string().nullable()
+});
+var SceneMonitorStatusSchema = zod.z.object({
+	monitors: zod.z.array(SceneMonitorSchema),
+	lastFetchedAt: zod.z.number()
+});
+var sceneMonitorCapability = {
+	name: "scene-monitor",
+	scope: "device",
+	mode: "singleton",
+	kind: "wrapper",
+	defaultActive: true,
+	deviceTypes: [require_sleep.DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/scene-monitor-editor",
+		tab: "scenes",
+		label: "Scenes"
+	} },
+	methods: {
+		listScenes: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), SceneMonitorStatusSchema),
+		createScene: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			label: zod.z.string(),
+			roi: MaskRectShapeSchema,
+			check: SceneCheckSchema,
+			triggerMode: zod.z.enum([
+				"periodic",
+				"on-motion",
+				"both"
+			]).optional(),
+			checkIntervalSec: zod.z.number().optional()
+		}), SceneMonitorSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		updateScene: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			monitorId: zod.z.string(),
+			patch: zod.z.object({
+				label: zod.z.string().optional(),
+				roi: MaskRectShapeSchema.optional(),
+				enabled: zod.z.boolean().optional(),
+				triggerMode: zod.z.enum([
+					"periodic",
+					"on-motion",
+					"both"
+				]).optional(),
+				checkIntervalSec: zod.z.number().optional(),
+				check: SceneCheckSchema.optional()
+			})
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteScene: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			monitorId: zod.z.string()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		captureReference: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			monitorId: zod.z.string(),
+			stateId: zod.z.string().optional(),
+			label: zod.z.string().optional(),
+			condition: SceneConditionSchema.optional()
+		}), zod.z.object({
+			stateId: zod.z.string(),
+			referenceCount: zod.z.number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteReference: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			monitorId: zod.z.string(),
+			stateId: zod.z.string(),
+			index: zod.z.number()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		recheckNow: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			monitorId: zod.z.string()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: SceneMonitorStatusSchema,
+		kind: "push"
+	},
+	runtimeState: SceneMonitorStatusSchema
+};
+//#endregion
 //#region src/capabilities/script-runner.cap.ts
 /**
 * Script-runner cap. Models HA `script.*` entities on
@@ -10488,6 +10674,36 @@ var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
 	*  with the per-track detail panel and live overlay. */
 	trackIds: zod.z.array(zod.z.string()).readonly()
 });
+/**
+* A parked ("stationary") object surfaced alongside occupancy — an object that
+* settled and stopped moving. It is NO LONGER a tracked object (the tracker was
+* told to forget it so it stops re-spawning tracks/events), but it IS still
+* physically present, so it keeps counting toward `frame` occupancy and is
+* listed here so the UI can show it in a dedicated "Stationary" section instead
+* of flooding the live event feed.
+*/
+var StationaryObjectSchema = zod.z.object({
+	id: zod.z.string(),
+	className: zod.z.string(),
+	bbox: zod.z.object({
+		x: zod.z.number(),
+		y: zod.z.number(),
+		w: zod.z.number(),
+		h: zod.z.number()
+	}),
+	frameWidth: zod.z.number().int().nonnegative(),
+	frameHeight: zod.z.number().int().nonnegative(),
+	/** When the source track was first seen. */
+	firstSeenAt: zod.z.number().int(),
+	/** When the object was recognised as parked (promotion time). */
+	becameStationaryAt: zod.z.number().int(),
+	/** Last frame a detection confirmed the object is still there. */
+	lastConfirmedAt: zod.z.number().int(),
+	/** Enrichment label carried from the source track (identity / plate). */
+	label: zod.z.string().optional(),
+	/** Native-resolution key-frame media key for the parked object's best image. */
+	keyFrameMediaKey: zod.z.string().optional()
+});
 var CameraOccupancySnapshotSchema = zod.z.object({
 	/** Frame timestamp of the inference result that produced this snapshot. */
 	ts: zod.z.number().int(),
@@ -10496,10 +10712,15 @@ var CameraOccupancySnapshotSchema = zod.z.object({
 	frameHeight: zod.z.number().int().nonnegative(),
 	/** Per-zone breakdown — one entry per defined zone (user + onboard). */
 	zones: zod.z.array(ZoneScopeBreakdownSchema).readonly(),
-	/** Frame-wide aggregate (everywhere, regardless of zone membership). */
+	/** Frame-wide aggregate (everywhere, regardless of zone membership).
+	*  INCLUDES currently-confirmed stationary objects (they are still present). */
 	frame: PerScopeBreakdownSchema,
 	/** Detections that landed outside every zone. Empty when no zones defined. */
-	unzoned: PerScopeBreakdownSchema
+	unzoned: PerScopeBreakdownSchema,
+	/** Parked objects on this camera (additive — absent on legacy snapshots).
+	*  Surfaced separately so the UI shows them in a dedicated section rather
+	*  than as repeated tracks/events. */
+	stationaryObjects: zod.z.array(StationaryObjectSchema).readonly().optional()
 });
 /**
 * Time-series resolution. The history methods return one bucket per
@@ -10799,6 +11020,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	pressureSensor: pressureSensorCapability,
 	privacyMask: privacyMaskCapability,
 	ptzAutotrack: ptzAutotrackCapability,
+	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
 	smoke: smokeCapability,
 	streamParams: streamParamsCapability,
@@ -12558,6 +12780,27 @@ function createSystemProxy(api) {
 			getAvailableTypes: (input) => dispatch("integrations", "getAvailableTypes", "query", input),
 			testConnection: (input) => dispatch("integrations", "testConnection", "mutation", input)
 		},
+		llm: {
+			generate: (input) => dispatch("llm", "generate", "mutation", input),
+			generateVision: (input) => dispatch("llm", "generateVision", "mutation", input),
+			listProfileKinds: (input) => dispatch("llm", "listProfileKinds", "query", input),
+			listProfiles: (input) => dispatch("llm", "listProfiles", "query", input),
+			upsertProfile: (input) => dispatch("llm", "upsertProfile", "mutation", input),
+			deleteProfile: (input) => dispatch("llm", "deleteProfile", "mutation", input),
+			testProfile: (input) => dispatch("llm", "testProfile", "mutation", input),
+			listModels: (input) => dispatch("llm", "listModels", "query", input),
+			getDefaults: (input) => dispatch("llm", "getDefaults", "query", input),
+			setDefault: (input) => dispatch("llm", "setDefault", "mutation", input),
+			getUsage: (input) => dispatch("llm", "getUsage", "query", input),
+			listModelCatalog: (input) => dispatch("llm", "listModelCatalog", "query", input),
+			listRuntimeNodes: (input) => dispatch("llm", "listRuntimeNodes", "query", input),
+			listNodeModels: (input) => dispatch("llm", "listNodeModels", "query", input),
+			installModel: (input) => dispatch("llm", "installModel", "mutation", input),
+			deleteModel: (input) => dispatch("llm", "deleteModel", "mutation", input),
+			getRuntimeStatus: (input) => dispatch("llm", "getRuntimeStatus", "query", input),
+			startRuntime: (input) => dispatch("llm", "startRuntime", "mutation", input),
+			stopRuntime: (input) => dispatch("llm", "stopRuntime", "mutation", input)
+		},
 		localNetwork: {
 			list: (input) => dispatch("localNetwork", "list", "query", input),
 			getPreferred: (input) => dispatch("localNetwork", "getPreferred", "query", input),
@@ -12707,7 +12950,17 @@ function createSystemProxy(api) {
 			searchPlates: (input) => dispatch("plateGallery", "searchPlates", "query", input),
 			suggestPlateClusters: (input) => dispatch("plateGallery", "suggestPlateClusters", "query", input),
 			correctPlateText: (input) => dispatch("plateGallery", "correctPlateText", "mutation", input),
-			deletePlate: (input) => dispatch("plateGallery", "deletePlate", "mutation", input)
+			deletePlate: (input) => dispatch("plateGallery", "deletePlate", "mutation", input),
+			listVehicles: (input) => dispatch("plateGallery", "listVehicles", "query", input),
+			createVehicle: (input) => dispatch("plateGallery", "createVehicle", "mutation", input),
+			renameVehicle: (input) => dispatch("plateGallery", "renameVehicle", "mutation", input),
+			deleteVehicle: (input) => dispatch("plateGallery", "deleteVehicle", "mutation", input),
+			listVehicleSamples: (input) => dispatch("plateGallery", "listVehicleSamples", "query", input),
+			removeVehicleSample: (input) => dispatch("plateGallery", "removeVehicleSample", "mutation", input),
+			assignPlate: (input) => dispatch("plateGallery", "assignPlate", "mutation", input),
+			unassignPlate: (input) => dispatch("plateGallery", "unassignPlate", "mutation", input),
+			assignPlates: (input) => dispatch("plateGallery", "assignPlates", "mutation", input),
+			unassignPlates: (input) => dispatch("plateGallery", "unassignPlates", "mutation", input)
 		},
 		recording: { getStorageUsage: (input) => dispatch("recording", "getStorageUsage", "query", input) },
 		serverManagement: {
@@ -13909,7 +14162,12 @@ var NotificationRuleConditionsSchema = zod.z.object({
 	clipDescription: zod.z.object({
 		text: zod.z.string().min(1),
 		minSimilarity: zod.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: zod.z.array(zod.z.string()).readonly().optional()
 });
 var NotificationRuleTemplateSchema = zod.z.object({
 	title: zod.z.string(),
@@ -14339,11 +14597,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 /
@@ -14392,8 +14658,30 @@ var WidgetLoginMethodSchema = zod.z.object({
 	remote: WidgetRemoteSchema,
 	stage: LoginStageEnum
 });
-/** One login-method contribution — redirect button OR pre-auth widget. */
-var LoginMethodContributionSchema = zod.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 = zod.z.object({
+	kind: zod.z.literal("passkey"),
+	/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-direct-login`). */
+	id: zod.z.string(),
+	/** Operator-facing button label. */
+	label: zod.z.string(),
+	stage: LoginStageEnum,
+	/** Effective WebAuthn RP ID (`resolveRpID()`) — the shell gates visibility on it. */
+	rpId: zod.z.string(),
+	/** Effective expected origin (`resolveOrigin()`), null when unconfigured. */
+	origin: zod.z.string().nullable()
+});
+/** One login-method contribution — redirect button, pre-auth widget, or native passkey ceremony. */
+var LoginMethodContributionSchema = zod.z.discriminatedUnion("kind", [
+	RedirectLoginMethodSchema,
+	WidgetLoginMethodSchema,
+	PasskeyLoginMethodSchema
+]);
 var loginMethodCapability = {
 	name: "login-method",
 	scope: "system",
@@ -14915,18 +15203,6 @@ var cameraPipelineConfigCapability = {
 };
 //#endregion
 //#region src/capabilities/cap-router-predicates.ts
-/**
-* 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;
@@ -14954,6 +15230,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 = require_sleep.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.
@@ -14962,6 +15258,64 @@ function looseSchema(schema) {
 	const loose = schema.loose;
 	return typeof loose === "function" ? loose.call(schema) : schema;
 }
+/**
+* Derive a COLLECTION-cap routing `addonId` from a NON-array mutation input
+* when the caller did NOT supply the top-level `{ addonId }` selector.
+*
+* Background: a `scope:'system', mode:'collection'` cap fans its ARRAY methods
+* (`listTargets`, `listTargetKinds`, …) across every provider, but routes each
+* single-object method (`send` / CRUD) to ONE provider. The runtime router
+* strips a TOP-LEVEL `addonId` selector and routes it via
+* `getProviderByAddonId`; absent that selector it falls through to the FIRST
+* registered provider — which misroutes (or hard-crashes on a partial provider)
+* when the target is owned by a DIFFERENT provider. See
+* `notification-output.cap.ts` (`Target.addonId` / `TargetKind.addonId` are
+* "stamped by each provider so the concat-fanned catalog stays routable").
+*
+* That routing `addonId` is ALREADY carried inside the mutation payload the
+* caller sends — e.g. `upsertTarget({ target: { …, addonId } })`. This helper
+* recovers it: it scans the input's DIRECT child object properties (bounded to
+* one level, first match wins) for a string `addonId`. Mirrors the child-side
+* `extractArgsAddonId` fallback in `child-cap-dispatch.ts`, which reads a
+* top-level `addonId` off the raw args; this covers the one-level-nested case
+* the top-level scan misses.
+*
+* Only used for non-array collection methods (array fan-out is never rerouted),
+* so it can never collapse a catalog aggregation onto a single provider. `null`
+* / non-object inputs yield `undefined` (fall back to the first provider,
+* preserving single-provider and id-only-payload back-compat).
+*/
+function extractNestedAddonId(input) {
+	if (input === null || typeof input !== "object") return void 0;
+	for (const value of Object.values(input)) if (value !== null && typeof value === "object") {
+		const nested = value.addonId;
+		if (typeof nested === "string") return nested;
+	}
+}
+/**
+* True when an OBJECT input schema declares a top-level `addonId` field.
+*
+* Such a cap method routes explicitly via the top-level `{ addonId }` selector
+* (the `llm.generate` / `deleteProfile` posture). The runtime router therefore
+* MUST NOT also fall back to {@link extractNestedAddonId} for it — that would
+* let an incidental nested `addonId` (e.g. a key inside a free-form `jsonSchema`
+* record) hijack routing. Nested recovery is reserved for methods whose input
+* carries NO top-level selector but embeds the owning `addonId` inside a domain
+* entity (`upsertTarget({ target: { addonId } })`, `upsertProfile({ profile })`).
+*
+* Accepts both Zod 4 (`.shape` / `_def.shape`) and legacy shapes; returns false
+* for non-object schemas.
+*/
+function objectInputDeclaresAddonId(schema) {
+	if (schema === null || typeof schema !== "object" && typeof schema !== "function") return false;
+	const direct = schema.shape;
+	const shape = direct !== void 0 && direct !== null ? direct : resolveDefShape(schema._def?.shape);
+	return shape !== void 0 && shape !== null && typeof shape === "object" && Object.prototype.hasOwnProperty.call(shape, "addonId");
+}
+/** `_def.shape` may be a thunk (Zod defers object-shape evaluation) or a plain record. */
+function resolveDefShape(defShape) {
+	return typeof defShape === "function" ? defShape() : defShape;
+}
 /** Auth level → base-procedure key. `superAdmin` collapses to `admin`. */
 function procedureAuthKey(auth) {
 	if (auth === "public") return "public";
@@ -17212,14 +17566,14 @@ var TargetKindCapsSchema = zod.z.object({
 * the union is large and not meant for runtime validation here; the exported
 * `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
 */
-var ConfigSchemaPassthrough = zod.z.unknown();
+var ConfigSchemaPassthrough$1 = zod.z.unknown();
 var TargetKindSchema = zod.z.object({
 	kind: zod.z.string(),
 	label: zod.z.string(),
 	icon: zod.z.string(),
 	/** Stamped by each provider so the concat-fanned catalog stays routable. */
 	addonId: zod.z.string(),
-	configSchema: ConfigSchemaPassthrough,
+	configSchema: ConfigSchemaPassthrough$1,
 	supportsDiscovery: zod.z.boolean(),
 	caps: TargetKindCapsSchema
 });
@@ -17286,6 +17640,352 @@ var notificationOutputCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/llm-shared.ts
+/**
+* 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 = zod.z.object({
+	inputTokens: zod.z.number(),
+	outputTokens: zod.z.number()
+});
+var LlmErrorCodeSchema = zod.z.enum([
+	"timeout",
+	"rate-limited",
+	"auth",
+	"refusal",
+	"bad-request",
+	"unavailable",
+	"no-profile",
+	"budget-exceeded",
+	"adapter-error"
+]);
+var LlmGenerateOkSchema = zod.z.object({
+	ok: zod.z.literal(true),
+	text: zod.z.string(),
+	model: zod.z.string(),
+	usage: LlmUsageSchema,
+	truncated: zod.z.boolean(),
+	latencyMs: zod.z.number()
+});
+var LlmGenerateErrSchema = zod.z.object({
+	ok: zod.z.literal(false),
+	code: LlmErrorCodeSchema,
+	message: zod.z.string(),
+	retryAfterMs: zod.z.number().optional()
+});
+var LlmGenerateResultSchema = zod.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 = zod.z.object({
+	bytes: zod.z.instanceof(Uint8Array),
+	mimeType: zod.z.string()
+});
+var LlmGenerateBaseInputSchema = zod.z.object({
+	/** Collection routing (the notification-output posture). */
+	addonId: zod.z.string().optional(),
+	/** Explicit profile; else the resolution chain (spec §3). */
+	profileId: zod.z.string().optional(),
+	/** MANDATORY usage tag: 'ai-summary', 'notifier-rules', 'adhoc-ui', … */
+	consumer: zod.z.string(),
+	system: zod.z.string().optional(),
+	/** v1: single-turn. `messages[]` is a v2 additive field. */
+	prompt: zod.z.string(),
+	/** Structured output — adapter-mapped (response_format / forced tool / responseSchema). */
+	jsonSchema: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+	/** Per-call override of the profile default. */
+	maxTokens: zod.z.number().int().positive().optional(),
+	temperature: zod.z.number().optional()
+});
+//#endregion
+//#region src/capabilities/llm-runtime.cap.ts
+/**
+* `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 = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("catalog"),
+		catalogId: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("url"),
+		url: zod.z.string(),
+		sha256: zod.z.string().optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("path"),
+		path: zod.z.string()
+	})
+]);
+var ManagedRuntimeConfigSchema = zod.z.object({
+	/** WHERE the runtime lives — hub or any agent. */
+	nodeId: zod.z.string(),
+	/** Closed for v1; 'ollama' is a v2 candidate. */
+	engine: zod.z.enum(["llama-cpp"]),
+	model: ManagedModelRefSchema,
+	contextSize: zod.z.number().int().default(4096),
+	/** 0 = CPU-only. */
+	gpuLayers: zod.z.number().int().default(0),
+	/** Default: cpus-2, clamped ≥1 (resolved node-side). */
+	threads: zod.z.number().int().optional(),
+	/** Concurrent slots. */
+	parallel: zod.z.number().int().default(1),
+	/** Else lazy: first generate boots it. */
+	autoStart: zod.z.boolean().default(false),
+	/** 0 = never; frees RAM after quiet periods. */
+	idleStopMinutes: zod.z.number().int().default(30)
+});
+var LlmRuntimeStatusSchema = zod.z.object({
+	/** Status is ALWAYS node-qualified. */
+	nodeId: zod.z.string(),
+	state: zod.z.enum([
+		"stopped",
+		"downloading",
+		"starting",
+		"ready",
+		"crashed",
+		"failed"
+	]),
+	pid: zod.z.number().optional(),
+	port: zod.z.number().optional(),
+	modelPath: zod.z.string().optional(),
+	modelId: zod.z.string().optional(),
+	downloadProgress: zod.z.number().min(0).max(1).optional(),
+	lastError: zod.z.string().optional(),
+	crashesInWindow: zod.z.number(),
+	/** Child RSS (sampled best-effort). */
+	memoryBytes: zod.z.number().optional(),
+	vramBytes: zod.z.number().optional()
+});
+var LlmNodeModelSchema = zod.z.object({
+	file: zod.z.string(),
+	sizeBytes: zod.z.number(),
+	catalogId: zod.z.string().optional(),
+	installedAt: zod.z.number().optional()
+});
+var LlmRuntimeDiskUsageSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	modelsBytes: zod.z.number(),
+	freeBytes: zod.z.number().optional()
+});
+var LlmRuntimeCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
+	images: zod.z.array(LlmImageSchema).optional(),
+	runtime: ManagedRuntimeConfigSchema,
+	/** The managed profile's timeout, threaded by the hub provider. */
+	timeoutMs: zod.z.number().int().positive().optional()
+});
+var llmRuntimeCapability = {
+	name: "llm-runtime",
+	scope: "system",
+	mode: "singleton",
+	internal: true,
+	methods: {
+		complete: require_sleep.method(LlmRuntimeCompleteInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		ensureStarted: require_sleep.method(zod.z.object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stop: require_sleep.method(zod.z.object({}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		status: require_sleep.method(zod.z.object({}), LlmRuntimeStatusSchema),
+		installModel: require_sleep.method(zod.z.object({ model: ManagedModelRefSchema }), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteModel: require_sleep.method(zod.z.object({ file: zod.z.string() }), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		listLocalModels: require_sleep.method(zod.z.object({}), zod.z.array(LlmNodeModelSchema)),
+		getDiskUsage: require_sleep.method(zod.z.object({}), LlmRuntimeDiskUsageSchema)
+	}
+};
+//#endregion
+//#region src/capabilities/llm.cap.ts
+/**
+* `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 = zod.z.enum([
+	"openai-compatible",
+	"openai",
+	"anthropic",
+	"google",
+	"managed-local"
+]);
+var LlmProfileSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	kind: LlmProfileKindSchema,
+	/** Stamped by the provider — keeps the fanned catalog routable. */
+	addonId: zod.z.string(),
+	enabled: zod.z.boolean(),
+	/** Vendor model id, or the managed runtime's loaded model. */
+	model: zod.z.string(),
+	/** Required for openai-compatible; override for cloud kinds. */
+	baseUrl: zod.z.string().optional(),
+	/** ConfigUISchema type:'password' — never round-trips (spec §5). */
+	apiKey: zod.z.string().optional(),
+	supportsVision: zod.z.boolean(),
+	temperature: zod.z.number().min(0).max(2).optional(),
+	maxTokens: zod.z.number().int().positive().optional(),
+	timeoutMs: zod.z.number().int().positive().default(6e4),
+	extraHeaders: zod.z.record(zod.z.string(), zod.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 = zod.z.unknown();
+var LlmProfileKindDescriptorSchema = zod.z.object({
+	kind: LlmProfileKindSchema,
+	label: zod.z.string(),
+	icon: zod.z.string(),
+	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	addonId: zod.z.string(),
+	configSchema: ConfigSchemaPassthrough
+});
+var LlmDefaultSelectorSchema = zod.z.union([zod.z.object({ consumer: zod.z.string() }), zod.z.object({ purpose: zod.z.enum(["text", "vision"]) })]);
+var LlmDefaultSchema = zod.z.object({
+	selector: LlmDefaultSelectorSchema,
+	profileId: zod.z.string()
+});
+/** Server-side rollup row — getUsage never dumps raw call rows (spec §6). */
+var LlmUsageRollupSchema = zod.z.object({
+	day: zod.z.string(),
+	consumer: zod.z.string(),
+	profileId: zod.z.string(),
+	calls: zod.z.number(),
+	okCalls: zod.z.number(),
+	errorCalls: zod.z.number(),
+	inputTokens: zod.z.number(),
+	outputTokens: zod.z.number(),
+	avgLatencyMs: zod.z.number()
+});
+/** LLM-facing view over the reused ModelCatalogEntry mechanism (spec §4.2). */
+var ManagedModelCatalogEntrySchema = zod.z.object({
+	id: zod.z.string(),
+	label: zod.z.string(),
+	family: zod.z.string(),
+	purpose: zod.z.enum(["text", "vision"]),
+	url: zod.z.string(),
+	sha256: zod.z.string(),
+	sizeBytes: zod.z.number(),
+	quantization: zod.z.string(),
+	/** Load-time guidance shown in the picker. */
+	minRamBytes: zod.z.number(),
+	contextSizeDefault: zod.z.number().int(),
+	/** Vision models: companion projector file. */
+	mmprojUrl: zod.z.string().optional()
+});
+var LlmRuntimeNodeSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	reachable: zod.z.boolean(),
+	status: LlmRuntimeStatusSchema.optional(),
+	disk: LlmRuntimeDiskUsageSchema.optional(),
+	error: zod.z.string().optional()
+});
+var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: zod.z.array(LlmImageSchema).min(1) });
+var ProfileRefInputSchema = zod.z.object({
+	addonId: zod.z.string(),
+	profileId: zod.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: require_sleep.method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		generateVision: require_sleep.method(GenerateVisionInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		listProfileKinds: require_sleep.method(zod.z.object({}), zod.z.array(LlmProfileKindDescriptorSchema)),
+		listProfiles: require_sleep.method(zod.z.object({}), zod.z.array(LlmProfileSchema)),
+		upsertProfile: require_sleep.method(zod.z.object({ profile: LlmProfileSchema }), LlmProfileSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteProfile: require_sleep.method(ProfileRefInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		testProfile: require_sleep.method(ProfileRefInputSchema, LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Live vendor enumeration (GET /models etc.). */
+		listModels: require_sleep.method(ProfileRefInputSchema, zod.z.array(zod.z.string())),
+		getDefaults: require_sleep.method(zod.z.object({}), zod.z.array(LlmDefaultSchema)),
+		setDefault: require_sleep.method(zod.z.object({
+			selector: LlmDefaultSelectorSchema,
+			profileId: zod.z.string().nullable()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getUsage: require_sleep.method(zod.z.object({
+			since: zod.z.number().optional(),
+			until: zod.z.number().optional(),
+			consumer: zod.z.string().optional(),
+			profileId: zod.z.string().optional()
+		}), zod.z.array(LlmUsageRollupSchema)),
+		listModelCatalog: require_sleep.method(zod.z.object({}), zod.z.array(ManagedModelCatalogEntrySchema)),
+		listRuntimeNodes: require_sleep.method(zod.z.object({}), zod.z.array(LlmRuntimeNodeSchema)),
+		listNodeModels: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), zod.z.array(LlmNodeModelSchema)),
+		installModel: require_sleep.method(zod.z.object({
+			nodeId: zod.z.string(),
+			model: ManagedModelRefSchema
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteModel: require_sleep.method(zod.z.object({
+			nodeId: zod.z.string(),
+			file: zod.z.string()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getRuntimeStatus: require_sleep.method(ProfileRefInputSchema, LlmRuntimeStatusSchema),
+		startRuntime: require_sleep.method(ProfileRefInputSchema, LlmRuntimeStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stopRuntime: require_sleep.method(ProfileRefInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	}
+};
+//#endregion
 //#region src/schemas/auth-records.ts
 /**
 * Zod schemas for persisted record types.
@@ -17499,6 +18199,22 @@ var TrackSnapshotSchema = zod.z.object({
 	/** MediaStore key; resolve via `getTrackMedia({ trackId })`. */
 	mediaKey: zod.z.string()
 });
+/**
+* One audio-classification label heard on the track's camera while the
+* track was alive, aggregated per label. An "episode" is one persisted
+* audio event (the confident-classification path: score ≥ the device's
+* `classificationMinScore`, class-change-or-heartbeat coalesced) — NOT
+* one 32 ms inference chunk, so counts stay human-scaled.
+*/
+var TrackAudioLabelSchema = zod.z.object({
+	label: zod.z.string(),
+	/** Highest classification score observed across the label's episodes. */
+	peakScore: zod.z.number(),
+	/** Number of coalesced audio-event episodes carrying this label. */
+	count: zod.z.number(),
+	firstAt: zod.z.number(),
+	lastAt: zod.z.number()
+});
 var TrackSchema = zod.z.object({
 	trackId: zod.z.string(),
 	deviceId: zod.z.number(),
@@ -17513,6 +18229,10 @@ var TrackSchema = zod.z.object({
 	snapshots: zod.z.array(TrackSnapshotSchema).readonly(),
 	/** Deduplicated zones the track has entered at least once. */
 	zonesVisited: zod.z.array(zod.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: zod.z.array(zod.z.string()).readonly().optional(),
 	/** Cumulative normalized distance travelled (0..1 units = full frame width). */
 	totalDistance: zod.z.number(),
 	state: TrackStateSchema,
@@ -17526,7 +18246,11 @@ var TrackSchema = zod.z.object({
 	bestEventId: zod.z.string().optional(),
 	/** Tag of the importance sub-signal that dominated the score
 	*  (identity|dwell|proximity|class|confidence|travel|zone). */
-	importanceReason: zod.z.string().optional()
+	importanceReason: zod.z.string().optional(),
+	/** Audio-classification labels heard on the camera during the track's
+	*  life (score ≥ device `classificationMinScore`), aggregated per label.
+	*  Absent on legacy rows / tracks with no confident audio. */
+	audioLabels: zod.z.array(TrackAudioLabelSchema).readonly().optional()
 });
 var BaseEventFields = {
 	id: zod.z.string(),
@@ -17682,6 +18406,23 @@ var TrackedDetectionSchema = zod.z.object({
 	zones: zod.z.array(zod.z.string()).readonly(),
 	state: TrackStateSchema
 });
+var OverlayDetectionSchema = zod.z.looseObject({
+	id: zod.z.string(),
+	kind: zod.z.enum(["first-level", "detail"]),
+	macroClass: zod.z.string(),
+	score: zod.z.number(),
+	bbox: zod.z.object({
+		x: zod.z.number(),
+		y: zod.z.number(),
+		width: zod.z.number(),
+		height: zod.z.number()
+	}),
+	labels: zod.z.array(zod.z.looseObject({
+		label: zod.z.string(),
+		score: zod.z.number()
+	})).readonly(),
+	parentId: zod.z.string().optional()
+});
 var ScoredObjectEventSchema = ObjectEventSchema.extend({ score: zod.z.number() });
 var SearchObjectEventsInput = zod.z.object({
 	text: zod.z.string(),
@@ -17692,6 +18433,20 @@ var SearchObjectEventsInput = zod.z.object({
 	limit: zod.z.number().default(50),
 	minScore: zod.z.number().min(0).max(1).default(.2)
 });
+var TrackCascadeCountsSchema = zod.z.object({
+	/** Persisted track roots deleted (authoritative). */
+	tracks: zod.z.number().int(),
+	/** Object events removed with their tracks (best-effort; see note above). */
+	events: zod.z.number().int(),
+	/** Track/face/plate-owned media removed (best-effort). Never identity media. */
+	media: zod.z.number().int(),
+	/** Unassigned (non-enrolled) face reads removed (best-effort). */
+	faces: zod.z.number().int(),
+	/** Unassigned plate reads removed (best-effort; plate leg deferred to plate-intelligence). */
+	plates: zod.z.number().int(),
+	/** Per-track CLIP search vectors removed (best-effort). */
+	embeddings: zod.z.number().int()
+});
 var pipelineAnalyticsCapability = {
 	name: "pipeline-analytics",
 	scope: "device",
@@ -17745,12 +18500,14 @@ var pipelineAnalyticsCapability = {
 			audio: zod.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: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
@@ -17763,34 +18520,85 @@ var pipelineAnalyticsCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		getEventMedia: require_sleep.method(zod.z.object({
-			eventId: zod.z.string(),
-			kind: MediaFileKindEnum.optional()
-		}), zod.z.array(MediaFileSchema).readonly()),
-		getTrackMedia: require_sleep.method(zod.z.object({ trackId: zod.z.string() }), zod.z.array(MediaFileSchema).readonly()),
 		/**
-		* Search object events by text query using CLIP cosine similarity.
-		* Encodes `text` via the `embedding-encoder` cap, queries the
-		* `ObjectEmbeddingStore` with optional prefilters, ranks all matching
-		* embeddings by cosine similarity, and joins winners to their
-		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
-		* `minScore`, sorted descending by score.
+		* 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.
 		*/
-		searchObjectEvents: require_sleep.method(SearchObjectEventsInput, zod.z.array(ScoredObjectEventSchema).readonly())
-	},
-	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.
+		pruneTracksBefore: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			cutoffMs: zod.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: require_sleep.method(zod.z.object({ deviceId: zod.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: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			trackIds: zod.z.array(zod.z.string()).min(1)
+		}), zod.z.object({
+			deleted: zod.z.number().int(),
+			failed: zod.z.array(zod.z.string()).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getEventMedia: require_sleep.method(zod.z.object({
+			eventId: zod.z.string(),
+			kind: MediaFileKindEnum.optional()
+		}), zod.z.array(MediaFileSchema).readonly()),
+		getTrackMedia: require_sleep.method(zod.z.object({ trackId: zod.z.string() }), zod.z.array(MediaFileSchema).readonly()),
+		/**
+		* Search object events by text query using CLIP cosine similarity.
+		* Encodes `text` via the `embedding-encoder` cap, queries the
+		* `ObjectEmbeddingStore` with optional prefilters, ranks all matching
+		* embeddings by cosine similarity, and joins winners to their
+		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
+		* `minScore`, sorted descending by score.
+		*/
+		searchObjectEvents: require_sleep.method(SearchObjectEventsInput, zod.z.array(ScoredObjectEventSchema).readonly())
+	},
+	events: {
+		/**
+		* 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: zod.z.object({
 			deviceId: zod.z.number(),
 			timestamp: zod.z.number(),
 			frameWidth: zod.z.number(),
 			frameHeight: zod.z.number(),
-			detections: zod.z.array(TrackedDetectionSchema).readonly()
+			detections: zod.z.array(OverlayDetectionSchema).readonly()
 		}) },
 		/** Track entered active state (first-seen). */
 		onTrackStarted: { data: zod.z.object({
@@ -21842,6 +22650,24 @@ setOverlay: require_sleep.method(zod.z.object({
 };
 //#endregion
 //#region src/capabilities/plate-gallery.cap.ts
+var VehicleSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	sampleCount: zod.z.number().int().nonnegative(),
+	coverMediaKey: zod.z.string().optional(),
+	/** Inline base64 of the cover sample's plate crop, resolved from `coverMediaKey`. */
+	coverBase64: zod.z.string().optional()
+});
+var VehicleSampleInfoSchema = zod.z.object({
+	id: zod.z.string(),
+	/** The plate text this sample enrolled (self-labeling — no embedding). */
+	text: zod.z.string(),
+	/** OCR confidence of the enrolled read (0..1). */
+	score: zod.z.number(),
+	addedAt: zod.z.number().int(),
+	deviceId: zod.z.number().int().optional(),
+	base64: zod.z.string().optional()
+});
 var PlateInfoSchema = zod.z.object({
 	plateId: zod.z.string(),
 	deviceId: zod.z.number().int(),
@@ -21853,6 +22679,16 @@ var PlateInfoSchema = zod.z.object({
 	score: zod.z.number(),
 	/** True when the text was manually corrected (exempt from retention). */
 	corrected: zod.z.boolean(),
+	/** Recognized vehicle id when a matcher lookup named this read (SQL NULL → absent). */
+	recognizedVehicleId: zod.z.string().optional(),
+	/** Resolved vehicle name for `recognizedVehicleId` (UI convenience). */
+	vehicleName: zod.z.string().optional(),
+	/** True once the read was assigned to a vehicle (enrolled as a sample). */
+	assigned: zod.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: zod.z.string().optional(),
 	base64: zod.z.string().optional()
 });
 var MediaFileLiteSchema = zod.z.object({
@@ -21914,6 +22750,58 @@ var plateGalleryCapability = {
 		deletePlate: require_sleep.method(zod.z.object({ plateId: zod.z.string() }), zod.z.void(), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		listVehicles: require_sleep.method(zod.z.void(), zod.z.array(VehicleSchema).readonly()),
+		createVehicle: require_sleep.method(zod.z.object({ name: zod.z.string().min(1) }), VehicleSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		renameVehicle: require_sleep.method(zod.z.object({
+			id: zod.z.string(),
+			name: zod.z.string().min(1)
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteVehicle: require_sleep.method(zod.z.object({ id: zod.z.string() }), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		listVehicleSamples: require_sleep.method(zod.z.object({ vehicleId: zod.z.string() }), zod.z.array(VehicleSampleInfoSchema).readonly()),
+		removeVehicleSample: require_sleep.method(zod.z.object({
+			vehicleId: zod.z.string(),
+			sampleId: zod.z.string()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		assignPlate: require_sleep.method(zod.z.object({
+			plateId: zod.z.string(),
+			vehicleId: zod.z.string()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		unassignPlate: require_sleep.method(zod.z.object({ plateId: zod.z.string() }), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		assignPlates: require_sleep.method(zod.z.object({
+			plateIds: zod.z.array(zod.z.string()).min(1),
+			vehicleId: zod.z.string()
+		}), zod.z.object({
+			assigned: zod.z.number().int(),
+			failed: zod.z.array(zod.z.string()).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		unassignPlates: require_sleep.method(zod.z.object({ plateIds: zod.z.array(zod.z.string()).min(1) }), zod.z.object({
+			unassigned: zod.z.number().int(),
+			failed: zod.z.array(zod.z.string()).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -21997,6 +22885,10 @@ var GpuInfoSchema = zod.z.object({
 	memoryMB: zod.z.number().optional()
 });
 var NpuInfoSchema = zod.z.object({ type: zod.z.enum(["apple-ane", "intel-npu"]) });
+var CoralInfoSchema = zod.z.object({
+	type: zod.z.literal("coral-edgetpu"),
+	bus: zod.z.string().optional()
+});
 var HardwareInfoSchema = zod.z.object({
 	platform: HardwarePlatformSchema,
 	arch: HardwareArchSchema,
@@ -22005,7 +22897,8 @@ var HardwareInfoSchema = zod.z.object({
 	totalRAM_MB: zod.z.number(),
 	availableRAM_MB: zod.z.number(),
 	gpu: GpuInfoSchema.nullable(),
-	npu: NpuInfoSchema.nullable()
+	npu: NpuInfoSchema.nullable(),
+	coral: CoralInfoSchema.nullable().optional()
 });
 var PlatformScoreSchema = zod.z.object({
 	runtime: zod.z.enum(["node", "python"]),
@@ -23112,6 +24005,8 @@ var CAPABILITY_NAMES = {
 	integrations: "integrations",
 	intercom: "intercom",
 	lawnMowerControl: "lawn-mower-control",
+	llm: "llm",
+	llmRuntime: "llm-runtime",
 	localNetwork: "local-network",
 	lockControl: "lock-control",
 	logDestination: "log-destination",
@@ -23150,6 +24045,7 @@ var CAPABILITY_NAMES = {
 	ptzAutotrack: "ptz-autotrack",
 	reboot: "reboot",
 	recording: "recording",
+	sceneMonitor: "scene-monitor",
 	scriptRunner: "script-runner",
 	serverManagement: "server-management",
 	settingsStore: "settings-store",
@@ -23454,6 +24350,14 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "lawnMowerControl",
 		name: "lawn-mower-control"
 	},
+	{
+		key: "llm",
+		name: "llm"
+	},
+	{
+		key: "llmRuntime",
+		name: "llm-runtime"
+	},
 	{
 		key: "localNetwork",
 		name: "local-network"
@@ -23606,6 +24510,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "recording",
 		name: "recording"
 	},
+	{
+		key: "sceneMonitor",
+		name: "scene-monitor"
+	},
 	{
 		key: "scriptRunner",
 		name: "script-runner"
@@ -23816,6 +24724,8 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	integrationsCapability,
 	intercomCapability,
 	lawnMowerControlCapability,
+	llmCapability,
+	llmRuntimeCapability,
 	localNetworkCapability,
 	lockControlCapability,
 	logDestinationCapability,
@@ -23854,6 +24764,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	ptzAutotrackCapability,
 	rebootCapability,
 	recordingCapability,
+	sceneMonitorCapability,
 	scriptRunnerCapability,
 	serverManagementCapability,
 	settingsStoreCapability,
@@ -23950,6 +24861,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"ptz",
 	"ptz-autotrack",
 	"recording",
+	"scene-monitor",
 	"script-runner",
 	"smoke",
 	"snapshot",
@@ -25875,6 +26787,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",
@@ -26505,6 +27579,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",
@@ -26571,12 +27651,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",
@@ -27081,18 +28173,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",
@@ -27111,6 +28227,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",
@@ -27123,6 +28263,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",
@@ -27315,6 +28467,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",
@@ -28448,6 +29642,8 @@ var KNOWN_CAP_NAMES = [
 	"integrations",
 	"intercom",
 	"lawn-mower-control",
+	"llm",
+	"llm-runtime",
 	"local-network",
 	"lock-control",
 	"log-destination",
@@ -28482,6 +29678,7 @@ var KNOWN_CAP_NAMES = [
 	"ptz-autotrack",
 	"reboot",
 	"recording",
+	"scene-monitor",
 	"script-runner",
 	"server-management",
 	"settings-store",
@@ -28552,6 +29749,7 @@ var DEVICE_CAP_NAMES = [
 	"ptz",
 	"ptz-autotrack",
 	"reboot",
+	"scene-monitor",
 	"script-runner",
 	"snapshot",
 	"stream-catalog",
@@ -28595,6 +29793,8 @@ var SYSTEM_CAP_NAMES = [
 	"face-gallery",
 	"filesystem-browse",
 	"integrations",
+	"llm",
+	"llm-runtime",
 	"local-network",
 	"log-destination",
 	"login-method",
@@ -28690,6 +29890,7 @@ var SCOPE_PRESETS = [
 var CAP_PROVIDER_KIND_MAP = Object.freeze({
 	"broker": "broker",
 	"device-export": "device-export",
+	"llm": "ai",
 	"mesh-network": "mesh",
 	"mqtt-broker": "broker",
 	"network-access": "ingress",
@@ -28699,6 +29900,7 @@ var CAP_PROVIDER_KIND_MAP = Object.freeze({
 var PROVIDER_KIND_CAP_NAMES = [
 	"broker",
 	"device-export",
+	"llm",
 	"mesh-network",
 	"mqtt-broker",
 	"network-access",
@@ -29035,6 +30237,10 @@ var CPU = {
 	value: "cpu",
 	label: "CPU"
 };
+var USB = {
+	value: "usb",
+	label: "Coral USB"
+};
 var RUNTIMES = [
 	{
 		id: "onnx",
@@ -29093,6 +30299,12 @@ var RUNTIMES = [
 			return out;
 		},
 		defaultDevice: "all"
+	},
+	{
+		id: "edgetpu",
+		supports: (hw) => hw?.coral != null,
+		devices: () => [USB],
+		defaultDevice: "usb"
 	}
 ];
 function def(id) {
@@ -29125,6 +30337,7 @@ function defaultDeviceFor(id) {
 * Delegates to `formatForRuntime` from runtime-mapping.ts.
 */
 function modelFormatForRuntime(id) {
+	if (id === "edgetpu") return "tflite";
 	return formatForRuntime(id);
 }
 /**
@@ -29446,6 +30659,24 @@ exports.KeyEventSchema = KeyEventSchema;
 exports.LabelDefinitionSchema = LabelDefinitionSchema;
 exports.LawnMowerActivitySchema = LawnMowerActivitySchema;
 exports.LawnMowerControlStatusSchema = LawnMowerControlStatusSchema;
+exports.LlmDefaultSchema = LlmDefaultSchema;
+exports.LlmDefaultSelectorSchema = LlmDefaultSelectorSchema;
+exports.LlmErrorCodeSchema = LlmErrorCodeSchema;
+exports.LlmGenerateBaseInputSchema = LlmGenerateBaseInputSchema;
+exports.LlmGenerateErrSchema = LlmGenerateErrSchema;
+exports.LlmGenerateOkSchema = LlmGenerateOkSchema;
+exports.LlmGenerateResultSchema = LlmGenerateResultSchema;
+exports.LlmImageSchema = LlmImageSchema;
+exports.LlmNodeModelSchema = LlmNodeModelSchema;
+exports.LlmProfileKindDescriptorSchema = LlmProfileKindDescriptorSchema;
+exports.LlmProfileKindSchema = LlmProfileKindSchema;
+exports.LlmProfileSchema = LlmProfileSchema;
+exports.LlmRuntimeCompleteInputSchema = LlmRuntimeCompleteInputSchema;
+exports.LlmRuntimeDiskUsageSchema = LlmRuntimeDiskUsageSchema;
+exports.LlmRuntimeNodeSchema = LlmRuntimeNodeSchema;
+exports.LlmRuntimeStatusSchema = LlmRuntimeStatusSchema;
+exports.LlmUsageRollupSchema = LlmUsageRollupSchema;
+exports.LlmUsageSchema = LlmUsageSchema;
 exports.LocateSegmentResultSchema = LocateSegmentResultSchema;
 exports.LocationStatSchema = LocationStatSchema;
 exports.LockControlStatusSchema = LockControlStatusSchema;
@@ -29463,6 +30694,9 @@ exports.MAX_EXPRESSION_EVAL_STEPS = MAX_EXPRESSION_EVAL_STEPS;
 exports.MAX_EXPRESSION_SOURCE_LENGTH = MAX_EXPRESSION_SOURCE_LENGTH;
 exports.METHOD_ACCESS_MAP = METHOD_ACCESS_MAP;
 exports.MODEL_FORMATS = MODEL_FORMATS;
+exports.ManagedModelCatalogEntrySchema = ManagedModelCatalogEntrySchema;
+exports.ManagedModelRefSchema = ManagedModelRefSchema;
+exports.ManagedRuntimeConfigSchema = ManagedRuntimeConfigSchema;
 exports.MaskGridDimsSchema = MaskGridDimsSchema;
 exports.MaskGridShapeSchema = MaskGridShapeSchema;
 exports.MaskLineShapeSchema = MaskLineShapeSchema;
@@ -29533,6 +30767,7 @@ exports.PROVIDER_KIND_CAP_NAMES = PROVIDER_KIND_CAP_NAMES;
 exports.PYTHON_SCRIPT = PYTHON_SCRIPT;
 exports.PackageUpdateSchema = PackageUpdateSchema;
 exports.PackageVersionInfoSchema = PackageVersionInfoSchema;
+exports.PasskeyLoginMethodSchema = PasskeyLoginMethodSchema;
 exports.PasskeySummarySchema = PasskeySummarySchema;
 exports.PcmSampleFormatSchema = PcmSampleFormatSchema;
 exports.PerScopeBreakdownSchema = PerScopeBreakdownSchema;
@@ -29617,6 +30852,12 @@ exports.STREAM_PROFILE_META = STREAM_PROFILE_META;
 exports.STREAM_QUALITY_LABELS = STREAM_QUALITY_LABELS;
 exports.SUB_DETECTION_TYPES = SUB_DETECTION_TYPES;
 exports.SYSTEM_CAP_NAMES = SYSTEM_CAP_NAMES;
+exports.SceneCheckSchema = SceneCheckSchema;
+exports.SceneConditionSchema = SceneConditionSchema;
+exports.SceneMonitorSchema = SceneMonitorSchema;
+exports.SceneMonitorStateSchema = SceneMonitorStateSchema;
+exports.SceneMonitorStatusSchema = SceneMonitorStatusSchema;
+exports.SceneReferenceSchema = SceneReferenceSchema;
 exports.ScopedTokenSchema = ScopedTokenSchema;
 exports.ScopedTokenSummarySchema = ScopedTokenSummarySchema;
 exports.ScoredObjectEventSchema = ScoredObjectEventSchema;
@@ -29643,6 +30884,7 @@ exports.SourceInfoSchema = SourceInfoSchema;
 exports.SpatialDetectionSchema = SpatialDetectionSchema;
 exports.SsoBridgeClaimsSchema = SsoBridgeClaimsSchema;
 exports.StartEmbeddedInputSchema = StartEmbeddedInputSchema;
+exports.StationaryObjectSchema = StationaryObjectSchema;
 exports.StorageAbortUploadInputSchema = AbortUploadInputSchema;
 exports.StorageBeginDownloadInputSchema = BeginDownloadInputSchema;
 exports.StorageBeginDownloadResultSchema = BeginDownloadResultSchema;
@@ -29691,6 +30933,7 @@ exports.TokenScopeSchema = TokenScopeSchema;
 exports.TopologyNodeSchema = TopologyNodeSchema;
 exports.TopologyProcessSchema = TopologyProcessSchema;
 exports.TopologyServiceSchema = TopologyServiceSchema;
+exports.TrackCascadeCountsSchema = TrackCascadeCountsSchema;
 exports.TrackSchema = TrackSchema;
 exports.TrackStateSchema = TrackStateSchema;
 exports.TrackedDetectionSchema = TrackedDetectionSchema;
@@ -29832,6 +31075,7 @@ exports.event = require_sleep.event;
 exports.eventEmitterCapability = eventEmitterCapability;
 exports.eventsCapability = eventsCapability;
 exports.expandCapMethods = require_sleep.expandCapMethods;
+exports.extractNestedAddonId = extractNestedAddonId;
 exports.extractSourceInfoFromMetadata = extractSourceInfoFromMetadata;
 exports.faceGalleryCapability = faceGalleryCapability;
 exports.fanControlCapability = fanControlCapability;
@@ -29858,6 +31102,7 @@ exports.integrationsCapability = integrationsCapability;
 exports.intercomCapability = intercomCapability;
 exports.isAgentOnlyPlacement = isAgentOnlyPlacement;
 exports.isArrayOutputSchema = isArrayOutputSchema;
+exports.isCollectionArrayMethod = isCollectionArrayMethod;
 exports.isDeployableToAgent = isDeployableToAgent;
 exports.isDeviceConfigCap = require_sleep.isDeviceConfigCap;
 exports.isEvent = require_sleep.isEvent;
@@ -29870,6 +31115,8 @@ exports.lifecycleJobSchema = lifecycleJobSchema;
 exports.lifecycleJobScopeSchema = lifecycleJobScopeSchema;
 exports.lifecycleJobStateSchema = lifecycleJobStateSchema;
 exports.lifecycleTaskSchema = lifecycleTaskSchema;
+exports.llmCapability = llmCapability;
+exports.llmRuntimeCapability = llmRuntimeCapability;
 exports.localNetworkCapability = localNetworkCapability;
 exports.locationSimilarity = locationSimilarity;
 exports.lockControlCapability = lockControlCapability;
@@ -29907,6 +31154,7 @@ exports.notificationOutputCapability = notificationOutputCapability;
 exports.notifierCapability = notifierCapability;
 exports.numericSensorCapability = numericSensorCapability;
 exports.oauthIntegrationCapability = oauthIntegrationCapability;
+exports.objectInputDeclaresAddonId = objectInputDeclaresAddonId;
 exports.osdCapability = osdCapability;
 exports.parseCameraStreamConfig = parseCameraStreamConfig;
 exports.parseExpression = parseExpression;
@@ -29953,6 +31201,7 @@ exports.resolveRunnerId = resolveRunnerId;
 exports.resolveVariantModelId = resolveVariantModelId;
 exports.runInferenceStep = runInferenceStep;
 exports.runtimeDevices = runtimeDevices;
+exports.sceneMonitorCapability = sceneMonitorCapability;
 exports.scopeKey = require_sleep.scopeKey;
 exports.scoreRuntimes = scoreRuntimes;
 exports.scriptRunnerCapability = scriptRunnerCapability;