@camstack/system 1.1.49 → 1.1.51

package/dist/builtins/snapshot/index.mjs

@@ -1,4 +1,4 @@
-import { R as nodePin, X as streamQualityLabel, at as DeviceFeature, et as errMsg, q as snapshotCapability, st as DeviceType, tt as BaseAddon } from "../../dist-8phgmJ6b.mjs";
+import { Q as streamQualityLabel, Y as snapshotCapability, lt as DeviceType, nt as errMsg, rt as BaseAddon, st as DeviceFeature, z as nodePin } from "../../dist-BWQX9yUj.mjs";
 import { execFile } from "node:child_process";
 //#region src/builtins/snapshot/snapshot-coalescing.ts
 /**
@@ -195,12 +195,102 @@ function raceForResult(promise, timeoutMs) {
 	});
 }
 //#endregion
+//#region src/builtins/snapshot/snapshot-media-handler.ts
+/**
+* Parse the handler-relative path (`/<deviceId>.jpg?query`) into a request.
+* Returns null for a malformed / nested / non-numeric id so the handler answers
+* 404 without ever reaching `getMedia`.
+*/
+function parseSnapshotMediaRequest(url) {
+	const qIdx = url.indexOf("?");
+	const rawPath = qIdx === -1 ? url : url.slice(0, qIdx);
+	const query = qIdx === -1 ? "" : url.slice(qIdx + 1);
+	const segment = rawPath.replace(/^\/+/, "");
+	if (segment.length === 0 || segment.includes("/")) return null;
+	const idPart = segment.replace(/\.jpe?g$/i, "");
+	if (!/^\d+$/.test(idPart)) return null;
+	const deviceId = Number.parseInt(idPart, 10);
+	if (!Number.isSafeInteger(deviceId)) return null;
+	const params = new URLSearchParams(query);
+	const rawStream = params.get("streamId");
+	const streamId = rawStream !== null && rawStream.length > 0 ? rawStream : void 0;
+	const rawForce = params.get("force");
+	return {
+		deviceId,
+		streamId,
+		force: rawForce === "1" || rawForce === "true"
+	};
+}
+/**
+* Create a data-plane handler that serves per-device snapshots as JPEG images.
+* `deps.getMedia` is called once per request; null → 404, throw → 500. A
+* conditional GET with a matching `If-None-Match` produces a 304.
+*/
+function createSnapshotMediaHandler(deps) {
+	return async (req, res) => {
+		if (req.method !== "GET" && req.method !== "HEAD") {
+			res.writeHead(405, { allow: "GET, HEAD" }).end();
+			return;
+		}
+		const parsed = parseSnapshotMediaRequest(req.url ?? "/");
+		if (parsed === null) {
+			res.writeHead(404).end();
+			return;
+		}
+		let media;
+		try {
+			media = await deps.getMedia(parsed.deviceId, parsed.streamId, parsed.force);
+		} catch {
+			const body = "Internal server error";
+			res.writeHead(500, {
+				"content-type": "text/plain",
+				"content-length": String(Buffer.byteLength(body))
+			});
+			if (req.method === "HEAD") res.end();
+			else res.end(body);
+			return;
+		}
+		if (media === null) {
+			res.writeHead(404).end();
+			return;
+		}
+		const etag = `"${parsed.deviceId}-${media.capturedAt}"`;
+		const cacheControl = `private, max-age=${Math.max(0, Math.floor(media.maxAgeS))}`;
+		if (req.headers["if-none-match"] === etag) {
+			res.writeHead(304, {
+				etag,
+				"cache-control": cacheControl
+			}).end();
+			return;
+		}
+		res.writeHead(200, {
+			"content-type": media.contentType,
+			"cache-control": cacheControl,
+			etag,
+			"content-length": String(media.bytes.byteLength)
+		});
+		if (req.method === "HEAD") res.end();
+		else res.end(Buffer.from(media.bytes));
+	};
+}
+//#endregion
 //#region src/builtins/snapshot/snapshot.addon.ts
 /** Default cache window for non-battery cams (seconds). 10s feels live. */
 var NON_BATTERY_DEFAULT_MAX_AGE_S = 10;
 /** Default cache window for battery cams (seconds). 1h ≈ "don't wake the cam unless asked". */
 var BATTERY_DEFAULT_MAX_AGE_S = 3600;
 /**
+* Effective per-device max cache age (seconds): the operator override
+* (`snapshotMaxAgeS`) when a finite non-negative number, else the battery-aware
+* default. Shared by the freshness gate (`getSnapshot`) and the HTTP endpoint's
+* `Cache-Control: max-age` (so the browser/`expo-image` layer caches for exactly
+* as long as the wrapper considers the frame fresh).
+*/
+function effectiveMaxAgeS(prefs, isBattery) {
+	const def = isBattery ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S;
+	return typeof prefs.snapshotMaxAgeS === "number" && prefs.snapshotMaxAgeS >= 0 ? prefs.snapshotMaxAgeS : def;
+}
+/**
 * SnapshotAddon — wrapper over the `snapshot` capability.
 *
 * Activated per-device (toggleable by user; default active). When active,
@@ -240,25 +330,86 @@ var SnapshotAddon = class SnapshotAddon extends BaseAddon {
 	*/
 	ownerCache = null;
 	static OWNER_CACHE_TTL_MS = 3e4;
+	/**
+	* Handle for the `/addon/snapshot/media/<deviceId>.jpg` HTTP data-plane
+	* endpoint (§3.1). Null when the host provides no `ctx.dataPlane` facility
+	* (the tRPC `getSnapshot` base64 surface still works — the endpoint is a
+	* strictly-additive delivery path). Disposed on shutdown.
+	*/
+	mediaDataPlane = null;
 	constructor() {
 		super({ staleTtlMs: 6e4 });
 	}
 	async onInitialize() {
 		this.ctx.logger.info("Snapshot wrapper initialized");
+		const provider = {
+			getSnapshot: (input) => this.getSnapshot(input),
+			invalidateCache: (input) => this.invalidateCache(input),
+			getDeviceSettingsContribution: (input) => this.buildDeviceSettingsContribution(input.deviceId),
+			getDeviceLiveContribution: async () => null,
+			applyDeviceSettingsPatch: (input) => this.saveDeviceSettingsPatch(input.deviceId, input.patch),
+			getStatus: async (input) => this.getStatus(input.deviceId),
+			getSnapshotOverview: (input) => this.getSnapshotOverview(input)
+		};
+		await this.serveMediaDataPlane();
 		return [{
 			capability: snapshotCapability,
-			provider: {
-				getSnapshot: (input) => this.getSnapshot(input),
-				invalidateCache: (input) => this.invalidateCache(input),
-				getDeviceSettingsContribution: (input) => this.buildDeviceSettingsContribution(input.deviceId),
-				getDeviceLiveContribution: async () => null,
-				applyDeviceSettingsPatch: (input) => this.saveDeviceSettingsPatch(input.deviceId, input.patch),
-				getStatus: async (input) => this.getStatus(input.deviceId),
-				getSnapshotOverview: (input) => this.getSnapshotOverview(input)
-			}
+			provider
 		}];
 	}
+	/**
+	* Serve the per-device snapshot image endpoint on the addon data-plane
+	* (§3.1). Delivery: `GET /addon/snapshot/media/<deviceId>.jpg` → raw JPEG with
+	* `ETag` + `Cache-Control: private, max-age=<device maxAgeS>`, so a grid is N
+	* independent `<Image>` tiles served from the coalesced server cache (no
+	* base64 tax, no batch head-of-line blocking, browser/`expo-image` caching for
+	* free). Best-effort: a host without a `dataPlane` facility keeps the tRPC
+	* base64 path.
+	*/
+	async serveMediaDataPlane() {
+		const handler = createSnapshotMediaHandler({ getMedia: (deviceId, streamId, force) => this.resolveSnapshotMedia(deviceId, streamId, force) });
+		try {
+			this.mediaDataPlane = await this.ctx.dataPlane?.serve({
+				prefix: "media",
+				access: "authenticated",
+				handler
+			}) ?? null;
+			this.ctx.logger.info("snapshot media data-plane served", { meta: { baseUrl: this.mediaDataPlane ? `/addon/${this.ctx.id}/media` : "(no dataPlane facility)" } });
+		} catch (err) {
+			this.ctx.logger.warn("snapshot media data-plane failed to serve", { meta: { error: errMsg(err) } });
+			this.mediaDataPlane = null;
+		}
+	}
+	/**
+	* Resolve a device (+ optional stream, + force) to renderable JPEG bytes for
+	* the HTTP endpoint. Runs the same coalesced capture ladder as the tRPC
+	* `getSnapshot` (so every consumer shares one upstream pull), then decodes the
+	* base64 cache into raw bytes and stamps the frame identity: `capturedAt` from
+	* the cache entry (matching the ETag `getSnapshotOverview` advertises) and the
+	* effective per-device `maxAgeS` for `Cache-Control`. Null → 404.
+	*/
+	async resolveSnapshotMedia(deviceId, streamId, force) {
+		const image = await this.getSnapshot({
+			deviceId,
+			...streamId !== void 0 ? { streamId } : {},
+			force
+		});
+		if (!image) return null;
+		const capturedAt = this.cache.get(deviceId)?.ts ?? Date.now();
+		const prefs = await this.readDeviceSettings(deviceId).catch(() => ({}));
+		const isBattery = (await this.lookupDeviceMeta(deviceId))?.isBattery ?? false;
+		return {
+			bytes: Buffer.from(image.base64, "base64"),
+			contentType: image.contentType,
+			capturedAt,
+			maxAgeS: effectiveMaxAgeS(prefs, isBattery)
+		};
+	}
 	async onShutdown() {
+		if (this.mediaDataPlane) {
+			await this.mediaDataPlane.dispose().catch(() => void 0);
+			this.mediaDataPlane = null;
+		}
 		this.cache.clear();
 		this.captureFlight.clear();
 		this.ownerCache = null;
@@ -311,8 +462,7 @@ var SnapshotAddon = class SnapshotAddon extends BaseAddon {
 			tags: { deviceId },
 			meta: { stream: effectiveStreamId ?? "auto" }
 		});
-		const defaultMaxAgeS = isBatteryDevice ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S;
-		const effectiveMaxAgeMs = (typeof prefs.snapshotMaxAgeS === "number" && prefs.snapshotMaxAgeS >= 0 ? prefs.snapshotMaxAgeS : defaultMaxAgeS) * 1e3;
+		const effectiveMaxAgeMs = effectiveMaxAgeS(prefs, isBatteryDevice) * 1e3;
 		const decision = decideSnapshotServe({
 			now,
 			cachedAt: hit?.ts ?? null,

package/dist/builtins/snapshot/snapshot-media-handler.d.ts

@@ -0,0 +1,38 @@
+import { DataPlaneHandler } from '@camstack/types';
+/** A renderable snapshot frame resolved for one device. */
+export interface SnapshotMedia {
+    /** Raw image bytes (already decoded from the wrapper's base64 cache). */
+    readonly bytes: Uint8Array;
+    /** MIME type — practically always `image/jpeg`. */
+    readonly contentType: string;
+    /** Epoch ms of the cached capture — drives the ETag and frame identity. */
+    readonly capturedAt: number;
+    /** Effective per-device max cache age (seconds) → `Cache-Control: max-age`. */
+    readonly maxAgeS: number;
+}
+export interface SnapshotMediaHandlerDeps {
+    /**
+     * Resolve a device (+ optional stream, + force) to a renderable frame. Runs
+     * the wrapper's coalesced capture ladder; returns null when no frame can be
+     * produced (→ 404). Throwing produces an opaque 500 (caller logs).
+     */
+    readonly getMedia: (deviceId: number, streamId: string | undefined, force: boolean) => Promise<SnapshotMedia | null>;
+}
+/** Parsed `/<deviceId>[.jpg][?streamId=…&force=1]` request. */
+export interface SnapshotMediaRequest {
+    readonly deviceId: number;
+    readonly streamId: string | undefined;
+    readonly force: boolean;
+}
+/**
+ * Parse the handler-relative path (`/<deviceId>.jpg?query`) into a request.
+ * Returns null for a malformed / nested / non-numeric id so the handler answers
+ * 404 without ever reaching `getMedia`.
+ */
+export declare function parseSnapshotMediaRequest(url: string): SnapshotMediaRequest | null;
+/**
+ * Create a data-plane handler that serves per-device snapshots as JPEG images.
+ * `deps.getMedia` is called once per request; null → 404, throw → 500. A
+ * conditional GET with a matching `If-None-Match` produces a 304.
+ */
+export declare function createSnapshotMediaHandler(deps: SnapshotMediaHandlerDeps): DataPlaneHandler;

package/dist/builtins/snapshot/snapshot.addon.d.ts

@@ -50,8 +50,34 @@ export declare class SnapshotAddon extends BaseAddon<SnapshotAddonConfig> {
      */
     private ownerCache;
     private static readonly OWNER_CACHE_TTL_MS;
+    /**
+     * Handle for the `/addon/snapshot/media/<deviceId>.jpg` HTTP data-plane
+     * endpoint (§3.1). Null when the host provides no `ctx.dataPlane` facility
+     * (the tRPC `getSnapshot` base64 surface still works — the endpoint is a
+     * strictly-additive delivery path). Disposed on shutdown.
+     */
+    private mediaDataPlane;
     constructor();
     protected onInitialize(): Promise<ProviderRegistration[]>;
+    /**
+     * Serve the per-device snapshot image endpoint on the addon data-plane
+     * (§3.1). Delivery: `GET /addon/snapshot/media/<deviceId>.jpg` → raw JPEG with
+     * `ETag` + `Cache-Control: private, max-age=<device maxAgeS>`, so a grid is N
+     * independent `<Image>` tiles served from the coalesced server cache (no
+     * base64 tax, no batch head-of-line blocking, browser/`expo-image` caching for
+     * free). Best-effort: a host without a `dataPlane` facility keeps the tRPC
+     * base64 path.
+     */
+    private serveMediaDataPlane;
+    /**
+     * Resolve a device (+ optional stream, + force) to renderable JPEG bytes for
+     * the HTTP endpoint. Runs the same coalesced capture ladder as the tRPC
+     * `getSnapshot` (so every consumer shares one upstream pull), then decodes the
+     * base64 cache into raw bytes and stamps the frame identity: `capturedAt` from
+     * the cache entry (matching the ETag `getSnapshotOverview` advertises) and the
+     * effective per-device `maxAgeS` for `Cache-Control`. Null → 404.
+     */
+    private resolveSnapshotMedia;
     protected onShutdown(): Promise<void>;
     /**
      * Drop the cached ingest owner whenever addon-level settings change —

package/dist/builtins/sqlite-storage/filesystem-storage.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BDV1WKRg.js");
+const require_dist = require("../../dist-C3uHEBtP.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");

package/dist/builtins/sqlite-storage/filesystem-storage.addon.mjs

@@ -1,4 +1,4 @@
-import { E as filesystemBrowseCapability, Y as storageProviderCapability, tt as BaseAddon } from "../../dist-8phgmJ6b.mjs";
+import { D as filesystemBrowseCapability, Z as storageProviderCapability, rt as BaseAddon } from "../../dist-BWQX9yUj.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import { basename, dirname, join, resolve, sep } from "node:path";

package/dist/builtins/sqlite-storage/sqlite-settings.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BDV1WKRg.js");
+const require_dist = require("../../dist-C3uHEBtP.js");
 let node_crypto = require("node:crypto");
 let better_sqlite3 = require("better-sqlite3");
 better_sqlite3 = require_chunk.__toESM(better_sqlite3);

package/dist/builtins/sqlite-storage/sqlite-settings.addon.mjs

@@ -1,4 +1,4 @@
-import { K as settingsStoreCapability, St as parseJsonUnknown, et as errMsg, ft as asJsonObject, s as RUNTIME_DEFAULTS, tt as BaseAddon } from "../../dist-8phgmJ6b.mjs";
+import { Ct as parseJsonUnknown, J as settingsStoreCapability, nt as errMsg, pt as asJsonObject, rt as BaseAddon, s as RUNTIME_DEFAULTS } from "../../dist-BWQX9yUj.mjs";
 import { randomUUID } from "node:crypto";
 import Database from "better-sqlite3";
 //#region src/builtins/sqlite-storage/sqlite-settings-backend.ts

package/dist/builtins/storage-orchestrator/storage-orchestrator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BDV1WKRg.js");
+const require_dist = require("../../dist-C3uHEBtP.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_fs_promises = require("node:fs/promises");

package/dist/builtins/storage-orchestrator/storage-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { J as storageCapability, tt as BaseAddon, u as StorageLocationTypeSchema, xt as parseJsonObject } from "../../dist-8phgmJ6b.mjs";
+import { St as parseJsonObject, X as storageCapability, rt as BaseAddon, u as StorageLocationTypeSchema } from "../../dist-BWQX9yUj.mjs";
 import * as path$1 from "node:path";
 import * as fs from "node:fs/promises";
 import { buildStorageLocationRegistry } from "@camstack/system";

package/dist/builtins/system-config/system-config.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BDV1WKRg.js");
+const require_dist = require("../../dist-C3uHEBtP.js");
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/system-config/system-config.addon.mjs

@@ -1,4 +1,4 @@
-import { et as errMsg, tt as BaseAddon, yt as hydrateSchema } from "../../dist-8phgmJ6b.mjs";
+import { bt as hydrateSchema, nt as errMsg, rt as BaseAddon } from "../../dist-BWQX9yUj.mjs";
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/winston-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BDV1WKRg.js");
+const require_dist = require("../../dist-C3uHEBtP.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/builtins/winston-logging/index.mjs

@@ -1,4 +1,4 @@
-import { F as logDestinationCapability, tt as BaseAddon } from "../../dist-8phgmJ6b.mjs";
+import { I as logDestinationCapability, rt as BaseAddon } from "../../dist-BWQX9yUj.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region ../types/dist/sleep-DkhOVOjW.mjs
+//#region ../types/dist/event-category-CFZs3jI4.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -430,6 +430,14 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["PipelineAnalyticsDetectionEvent"] = "pipeline-analytics.detection-event";
 	EventCategory["PipelineAnalyticsFrameTracked"] = "pipeline-analytics.frame-tracked";
 	/**
+	* Fired by `addon-post-analysis` when a parked (stationary) object appears
+	* (a track was promoted to a stationary-registry entry) or departs (the
+	* object moved / was removed). Telemetry (D8): lossy, drives a UI refresh of
+	* the dedicated "Stationary" section — never the live event feed. Payload:
+	* `{ deviceId, entryId, className, phase:'appeared'|'departed', timestamp }`.
+	*/
+	EventCategory["PipelineAnalyticsStationaryChanged"] = "pipeline-analytics.stationary-changed";
+	/**
 	* 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
@@ -2980,6 +2988,15 @@ var ModelCatalogEntrySchema = z.object({
 		width: z.number(),
 		height: 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: z.number().int().positive().optional(),
 	labels: z.array(LabelDefinitionSchema).readonly(),
 	inputLayout: z.enum(["nchw", "nhwc"]).optional(),
 	inputNormalization: z.enum([
@@ -2989,6 +3006,16 @@ var ModelCatalogEntrySchema = z.object({
 	]).optional(),
 	preprocessMode: 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: 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):
@@ -7980,7 +8007,8 @@ var EngineProvisioningSchema = z.object({
 	runtimeId: z.enum([
 		"onnx",
 		"openvino",
-		"coreml"
+		"coreml",
+		"edgetpu"
 	]).nullable(),
 	device: z.string().nullable(),
 	state: z.enum([
@@ -10806,6 +10834,36 @@ var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
 	*  with the per-track detail panel and live overlay. */
 	trackIds: z.array(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 = z.object({
+	id: z.string(),
+	className: z.string(),
+	bbox: z.object({
+		x: z.number(),
+		y: z.number(),
+		w: z.number(),
+		h: z.number()
+	}),
+	frameWidth: z.number().int().nonnegative(),
+	frameHeight: z.number().int().nonnegative(),
+	/** When the source track was first seen. */
+	firstSeenAt: z.number().int(),
+	/** When the object was recognised as parked (promotion time). */
+	becameStationaryAt: z.number().int(),
+	/** Last frame a detection confirmed the object is still there. */
+	lastConfirmedAt: z.number().int(),
+	/** Enrichment label carried from the source track (identity / plate). */
+	label: z.string().optional(),
+	/** Native-resolution key-frame media key for the parked object's best image. */
+	keyFrameMediaKey: z.string().optional()
+});
 var CameraOccupancySnapshotSchema = z.object({
 	/** Frame timestamp of the inference result that produced this snapshot. */
 	ts: z.number().int(),
@@ -10814,10 +10872,15 @@ var CameraOccupancySnapshotSchema = z.object({
 	frameHeight: z.number().int().nonnegative(),
 	/** Per-zone breakdown — one entry per defined zone (user + onboard). */
 	zones: 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: z.array(StationaryObjectSchema).readonly().optional()
 });
 /**
 * Time-series resolution. The history methods return one bucket per
@@ -12801,6 +12864,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";
@@ -15531,6 +15652,22 @@ var TrackSnapshotSchema = z.object({
 	/** MediaStore key; resolve via `getTrackMedia({ trackId })`. */
 	mediaKey: 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 = z.object({
+	label: z.string(),
+	/** Highest classification score observed across the label's episodes. */
+	peakScore: z.number(),
+	/** Number of coalesced audio-event episodes carrying this label. */
+	count: z.number(),
+	firstAt: z.number(),
+	lastAt: z.number()
+});
 var TrackSchema = z.object({
 	trackId: z.string(),
 	deviceId: z.number(),
@@ -15562,7 +15699,11 @@ var TrackSchema = z.object({
 	bestEventId: z.string().optional(),
 	/** Tag of the importance sub-signal that dominated the score
 	*  (identity|dwell|proximity|class|confidence|travel|zone). */
-	importanceReason: z.string().optional()
+	importanceReason: 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: z.array(TrackAudioLabelSchema).readonly().optional()
 });
 var BaseEventFields = {
 	id: z.string(),
@@ -17811,7 +17952,15 @@ var webrtcSessionCapability = {
 			*/
 			disableIpv6: z.boolean().optional(),
 			/** Subscriber attribution. See `createSession` for the contract. */
-			consumerAttribution: BrokerConsumerAttributionSchema.optional()
+			consumerAttribution: BrokerConsumerAttributionSchema.optional(),
+			/**
+			* Client-side stream hints (viewport, downlink) — same contract as
+			* `createSession.hints`. Client-offer viewers (the RN viewer's
+			* `WebrtcLiveSession`) negotiate via `handleOffer`, so without this
+			* field their hints were silently stripped by the schema and the
+			* adaptive ladder started blind on the client's display size.
+			*/
+			hints: webrtcClientHintsSchema.optional()
 		}), z.object({
 			sessionId: z.string(),
 			sdpAnswer: z.string()
@@ -20139,6 +20288,10 @@ var GpuInfoSchema = z.object({
 	memoryMB: z.number().optional()
 });
 var NpuInfoSchema = z.object({ type: z.enum(["apple-ane", "intel-npu"]) });
+var CoralInfoSchema = z.object({
+	type: z.literal("coral-edgetpu"),
+	bus: z.string().optional()
+});
 var HardwareInfoSchema = z.object({
 	platform: HardwarePlatformSchema,
 	arch: HardwareArchSchema,
@@ -20147,7 +20300,8 @@ var HardwareInfoSchema = z.object({
 	totalRAM_MB: z.number(),
 	availableRAM_MB: z.number(),
 	gpu: GpuInfoSchema.nullable(),
-	npu: NpuInfoSchema.nullable()
+	npu: NpuInfoSchema.nullable(),
+	coral: CoralInfoSchema.nullable().optional()
 });
 var PlatformScoreSchema = z.object({
 	runtime: z.enum(["node", "python"]),
@@ -26172,4 +26326,4 @@ function scoreRuntimes(hw) {
 	};
 }
 //#endregion
-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 };
+export { toExpressionValue as $, isCollectionArrayMethod as A, normalizeUnit as B, enumerateItemArrayFields as C, parseJsonUnknown as Ct, filesystemBrowseCapability as D, sleep as Dt, extractNestedAddonId as E, scopeKey as Et, localNetworkCapability as F, readNodePin as G, parseStreamParamsFormPatch as H, logDestinationCapability as I, settingsStoreCapability as J, scoreRuntimes as K, looseSchema as L, isVoidInput as M, kebabToCamel as N, getByPath as O, EventCategory as Ot, lifecycleJobSchema as P, streamQualityLabel as Q, metricsProviderCapability as R, deviceStatusCapability as S, parseJsonObject as St, evaluateLinkExpression as T, resolveCapMount as Tt, platformProbeCapability as U, objectInputDeclaresAddonId as V, procedureAuthKey as W, storageCapability as X, snapshotCapability as Y, storageProviderCapability as Z, authProviderCapability as _, emitDownForOwnedCaps as _t, DeviceStatusSchema as a, DEVICE_SETTINGS_CONTRIBUTION_METHODS as at, deviceManagerCapability as b, hydrateSchema as bt, STREAM_PROFILE_META as c, DeviceRole as ct, UserRecordSchema as d, ReadinessTimeoutError as dt, userManagementCapability as et, addonPagesCapability as f, WELL_KNOWN_TAB_MAP as ft, applyTransform as g, createEvent as gt, alertsCapability as h, asString as ht, CAP_NAMES_WITH_STATUS as i, DATAPLANE_SECRET_HEADER as it, isObjectInput as j, isArrayOutputSchema as k, ScopedTokenSchema as l, DeviceType as lt, addonWidgetsCapability as m, asNumber as mt, AlertSchema as n, errMsg as nt, METHOD_ACCESS_MAP as o, DEVICE_STATUS_METHOD as ot, addonSettingsCapability as p, asJsonObject as pt, setByPath as q, ApiKeyRecordSchema as r, BaseAddon as rt, RUNTIME_DEFAULTS as s, DeviceFeature as st, ALL_CAPABILITY_DEFINITIONS as t, validateExpressionSource as tt, StorageLocationTypeSchema as u, ReadinessRegistry as ut, backupCapability as v, emitReadiness as vt, enumerateSchemaFields as w, readinessKey as wt, deviceStateCapability as x, isDeviceConfigCap as xt, buildStreamParamsConfigSchema as y, expandCapMethods as yt, nodePin as z };