@camstack/addon-decoder-nodeav 1.1.17 → 1.2.0

package/dist/index.js

@@ -7084,6 +7084,17 @@ var ModelCatalogEntrySchema = object({
 		"imagenet",
 		"none"
 	]).optional(),
+	/**
+	* The model already applies softmax IN-GRAPH — its raw output is a
+	* probability distribution, not logits. When set, the `softmax`
+	* postprocessor must NOT re-apply softmax: re-softmaxing an already-normalised
+	* probability vector collapses it toward uniform (top-1 score craters far
+	* below its true value, making every confidence gate meaningless). Absent ⇒
+	* the output is raw logits and the postprocessor applies softmax (the normal
+	* case). Set on the Google AIY Birds `bird-classifier` (softmax baked into the
+	* TF graph). Threaded to the Python pool via `PoolModelConfig.outputProbabilities`.
+	*/
+	outputProbabilities: boolean().optional(),
 	preprocessMode: _enum(["letterbox", "resize"]).optional(),
 	/**
 	* Per-MODEL postprocessor override. Absent ⇒ the step's own
@@ -7643,6 +7654,160 @@ var EncodeProfileSchema = object({
 	*/
 	outputArgs: array(string()).optional()
 });
+var COCO_TO_MACRO = {
+	mapping: {
+		person: "person",
+		bicycle: "vehicle",
+		car: "vehicle",
+		motorcycle: "vehicle",
+		airplane: "vehicle",
+		bus: "vehicle",
+		train: "vehicle",
+		truck: "vehicle",
+		boat: "vehicle",
+		bird: "animal",
+		cat: "animal",
+		dog: "animal",
+		horse: "animal",
+		sheep: "animal",
+		cow: "animal",
+		elephant: "animal",
+		bear: "animal",
+		zebra: "animal",
+		giraffe: "animal",
+		suitcase: "package",
+		backpack: "package",
+		handbag: "package"
+	},
+	preserveOriginal: false
+};
+var AUDIO_MACRO_LABELS = [
+	{
+		id: "speech",
+		name: "Speech",
+		icon: "🗣️"
+	},
+	{
+		id: "scream",
+		name: "Scream / Shout",
+		icon: "😱"
+	},
+	{
+		id: "crying",
+		name: "Crying / Baby",
+		icon: "😢"
+	},
+	{
+		id: "laughter",
+		name: "Laughter",
+		icon: "😂"
+	},
+	{
+		id: "music",
+		name: "Music",
+		icon: "🎵"
+	},
+	{
+		id: "dog",
+		name: "Dog",
+		icon: "🐕"
+	},
+	{
+		id: "cat",
+		name: "Cat",
+		icon: "🐈"
+	},
+	{
+		id: "bird",
+		name: "Bird",
+		icon: "🐦"
+	},
+	{
+		id: "animal",
+		name: "Animal (other)",
+		icon: "🐾"
+	},
+	{
+		id: "alarm",
+		name: "Alarm / Siren",
+		icon: "🚨"
+	},
+	{
+		id: "doorbell",
+		name: "Doorbell / Knock",
+		icon: "🔔"
+	},
+	{
+		id: "glass_breaking",
+		name: "Glass Breaking",
+		icon: "💥"
+	},
+	{
+		id: "gunshot",
+		name: "Gunshot / Explosion",
+		icon: "💣"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle",
+		icon: "🚗"
+	},
+	{
+		id: "siren",
+		name: "Emergency Siren",
+		icon: "🚑"
+	},
+	{
+		id: "fire",
+		name: "Fire / Smoke",
+		icon: "🔥"
+	},
+	{
+		id: "water",
+		name: "Water",
+		icon: "💧"
+	},
+	{
+		id: "wind",
+		name: "Wind / Weather",
+		icon: "🌬️"
+	},
+	{
+		id: "door",
+		name: "Door",
+		icon: "🚪"
+	},
+	{
+		id: "footsteps",
+		name: "Footsteps",
+		icon: "👣"
+	},
+	{
+		id: "crowd",
+		name: "Crowd / Chatter",
+		icon: "👥"
+	},
+	{
+		id: "telephone",
+		name: "Telephone",
+		icon: "📞"
+	},
+	{
+		id: "engine",
+		name: "Engine / Motor",
+		icon: "⚙️"
+	},
+	{
+		id: "tools",
+		name: "Tools / Construction",
+		icon: "🔨"
+	},
+	{
+		id: "silence",
+		name: "Silence",
+		icon: "🤫"
+	}
+];
 var YAMNET_TO_MACRO = {
 	mapping: {
 		Speech: "speech",
@@ -7909,6 +8074,125 @@ var _macroLookup = /* @__PURE__ */ new Map();
 for (const [k, v] of Object.entries(YAMNET_TO_MACRO.mapping)) _macroLookup.set(k.toLowerCase(), v);
 for (const [k, v] of Object.entries(APPLE_SA_TO_MACRO.mapping)) _macroLookup.set(k.toLowerCase(), v);
 /**
+* Unified event-kind taxonomy — THE single source of truth for
+* `kind → { parentKind, category, level, color, iconId, labelKey, label,
+* icon }`.
+*
+* This dictionary folds together what used to be scattered across four
+* copies:
+*   - `capabilities/sensor-event-kinds.ts` (sensor cap colors)
+*   - `addon-post-analysis/.../services/event-kinds.ts`
+*     (MOTION/PERSON/VEHICLE… _COLOR constants)
+*   - `ui-library/composites/detection-colors.ts` (CLASS_COLORS)
+*   - `addon-post-analysis/shared/frame/box-drawer.ts` (DEFAULT_COLOR)
+*   - the COCO / audio class maps (macro ↔ sub relationships)
+*
+* The DATA (serializable — color/iconId/labelKey/parentKind) lives here in
+* `@camstack/types`. The UI-side mapping `iconId → lucide component` and
+* `labelKey → t()` lives in `@camstack/ui-library`. UIs never hardcode a
+* color or an icon: they read this dictionary (server descriptors carry the
+* fields inline; the client resolves color/icon/label from `iconId`/`kind`).
+*
+* Two levels only (v1 YAGNI): macro → sub. `person` is a leaf macro.
+*/
+var TAXONOMY_COLORS = {
+	motion: "#f59e0b",
+	audio: "#06b6d4",
+	person: "#22c55e",
+	vehicle: "#3b82f6",
+	animal: "#f97316",
+	package: "#a855f7",
+	sensor: "#8b5cf6",
+	control: "#10b981",
+	genericDetection: "#64748b"
+};
+var DETECTION_SUB_COLORS = {
+	car: "#f59e0b",
+	truck: "#d97706",
+	bus: "#b45309",
+	motorcycle: "#eab308",
+	bicycle: "#ca8a04",
+	airplane: "#60a5fa",
+	boat: "#2563eb",
+	train: "#1d4ed8",
+	bird: "#14b8a6",
+	dog: "#84cc16",
+	cat: "#f97316",
+	horse: "#a16207",
+	sheep: "#a3a3a3",
+	cow: "#78716c",
+	elephant: "#6b7280",
+	bear: "#7c2d12",
+	zebra: "#404040",
+	giraffe: "#d4a373"
+};
+function titleCase(id) {
+	return id.split(/[-_ ]/).filter((p) => p.length > 0).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join(" ");
+}
+var entries = /* @__PURE__ */ new Map();
+function macro(kind, category, color, iconId, label) {
+	entries.set(kind, {
+		kind,
+		parentKind: null,
+		level: "macro",
+		category,
+		color,
+		iconId,
+		labelKey: `eventKind.${kind}`,
+		label
+	});
+}
+function sub(kind, parentKind, category, color, iconId, label) {
+	entries.set(kind, {
+		kind,
+		parentKind,
+		level: "sub",
+		category,
+		color,
+		iconId,
+		labelKey: `eventKind.${kind}`,
+		label
+	});
+}
+macro("motion", "motion", TAXONOMY_COLORS.motion, "motion", "Motion");
+macro("audio", "audio", TAXONOMY_COLORS.audio, "audio", "Audio");
+macro("person", "detection", TAXONOMY_COLORS.person, "person", "Person");
+macro("vehicle", "detection", TAXONOMY_COLORS.vehicle, "vehicle", "Vehicle");
+macro("animal", "detection", TAXONOMY_COLORS.animal, "animal", "Animal");
+macro("package", "package", TAXONOMY_COLORS.package, "package", "Package");
+macro("sensor", "sensor", TAXONOMY_COLORS.sensor, "sensor", "Sensor");
+macro("control", "control", TAXONOMY_COLORS.control, "control", "Control");
+for (const [cocoClass, macroClass] of Object.entries(COCO_TO_MACRO.mapping)) {
+	if (macroClass !== "vehicle" && macroClass !== "animal") continue;
+	if (entries.has(cocoClass)) continue;
+	sub(cocoClass, macroClass, "detection", DETECTION_SUB_COLORS[cocoClass] ?? TAXONOMY_COLORS.genericDetection, cocoClass, titleCase(cocoClass));
+}
+sub("package-delivered", "package", "package", TAXONOMY_COLORS.package, "package", "Package delivered");
+sub("package-picked-up", "package", "package", TAXONOMY_COLORS.package, "package", "Package picked up");
+sub("contact", "sensor", "sensor", "#f59e0b", "door", "Contact");
+sub("motion-sensor", "sensor", "sensor", TAXONOMY_COLORS.sensor, "pir", "Motion sensor");
+sub("smoke", "sensor", "sensor", "#ef4444", "smoke", "Smoke");
+sub("flood", "sensor", "sensor", "#3b82f6", "water", "Water leak");
+sub("gas", "sensor", "sensor", "#ef4444", "gas", "Gas");
+sub("carbon-monoxide", "sensor", "sensor", "#dc2626", "smoke", "Carbon monoxide");
+sub("vibration", "sensor", "sensor", "#eab308", "vibration", "Vibration");
+sub("tamper", "sensor", "sensor", "#f97316", "tamper", "Tamper");
+sub("presence", "sensor", "sensor", "#22c55e", "presence", "Presence");
+sub("enum-sensor", "sensor", "sensor", TAXONOMY_COLORS.sensor, "generic", "Sensor state");
+sub("device-event", "sensor", "sensor", "#10b981", "button", "Device event");
+sub("lock", "control", "control", "#0ea5e9", "lock", "Lock");
+sub("switch", "control", "control", TAXONOMY_COLORS.control, "switch", "Switch");
+sub("siren", "control", "control", "#dc2626", "siren", "Siren");
+sub("button", "control", "control", "#10b981", "button", "Button");
+sub("doorbell", "control", "control", "#a855f7", "doorbell", "Doorbell");
+for (const l of AUDIO_MACRO_LABELS) {
+	const kind = `audio-${l.id}`;
+	if (entries.has(kind)) continue;
+	sub(kind, "audio", "audio", TAXONOMY_COLORS.audio, kind, l.name);
+}
+/** The complete taxonomy dictionary, keyed by kind. */
+var EVENT_TAXONOMY = Object.freeze(Object.fromEntries(entries));
+/**
 * Error types for the safe expression engine. Two distinct classes so callers
 * can tell a compile-time (grammar) failure from a runtime (evaluation)
 * failure — both are non-fatal to the host: read paths degrade to "skip link".
@@ -10824,10 +11108,7 @@ var ConfigUISchemaNullableBridge = custom();
 var InferenceCapabilitiesBridge = custom();
 var ModelAvailabilityListBridge = custom();
 var PipelineRunResultBridge = custom();
-method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngineChoiceSchema), method(PipelineEngineChoiceSchema, array(PipelineDefaultStepSchema)), method(_void(), PipelineEngineChoiceSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ nodeId: string() }), EngineProvisioningSchema), method(_void(), record(string(), object({
+method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngineChoiceSchema), method(PipelineEngineChoiceSchema, array(PipelineDefaultStepSchema)), method(object({ nodeId: string() }), EngineProvisioningSchema), method(_void(), record(string(), object({
 	modelId: string(),
 	settings: record(string(), unknown()).readonly()
 }))), method(object({ steps: record(string(), object({
@@ -10887,13 +11168,33 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	* (inputClasses ≠ null) are skipped and served per-track via
 	* pipelineRunner.runDetailSubtree (two-plane design).
 	*/
-	plane: _enum(["full", "frame"]).optional()
+	plane: _enum(["full", "frame"]).optional(),
+	/**
+	* Inference-device selector (Phase 2 multi-device). Format
+	* `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
+	* Omitted ⇒ the runner's default device (current single-engine
+	* behaviour). Selects WHICH device pool of the node runs the call.
+	*/
+	deviceKey: string().optional()
 }), PipelineRunResultBridge, { kind: "mutation" }), method(object({
 	engine: PipelineEngineChoiceSchema.optional(),
 	steps: array(PipelineStepInputSchema).min(1),
 	frames: array(FrameInputSchema).min(1).max(255),
 	deviceId: number().optional(),
-	sessionId: string().optional()
+	sessionId: string().optional(),
+	/**
+	* Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
+	* the batch to the Python pool's bench preprocess cache
+	* (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
+	* preprocessed ONCE and every later inference is a pure-inference cache
+	* hit — the sustained-throughput run measures inference, not
+	* decode+preprocess+infer. Omitted/0 for live frames (all different →
+	* full preprocess every call, correct). Fresh per sustained run;
+	* released via `uncacheFrame`.
+	*/
+	frameId: number().int().nonnegative().optional(),
+	/** Inference-device selector (Phase 2 multi-device); see runPipeline. */
+	deviceKey: string().optional()
 }), object({ results: array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }), method(object({
 	data: _instanceof(Uint8Array),
 	width: number().int().positive(),
@@ -10925,8 +11226,18 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	*  - `runtime`       — main camera-serving engine (no idle TTL).
 	*  - `warm-override` — benchmark/test override held in the warm
 	*                      cache; auto-disposed after the idle TTL.
+	*  - `device-pool`   — a concurrent per-device pool (Phase 2
+	*                      multi-device, keyed by `deviceKey`) resolved
+	*                      via `resolveDeviceFactory`. Runs alongside the
+	*                      `runtime` engine on a DIFFERENT accelerator
+	*                      (NPU / iGPU / Coral) — this is how the
+	*                      Engines tab shows all pools running at once.
 	*/
-	kind: _enum(["runtime", "warm-override"]),
+	kind: _enum([
+		"runtime",
+		"warm-override",
+		"device-pool"
+	]),
 	/** Native pid of the underlying Python pool (null when no pool). */
 	poolPid: number().nullable(),
 	/** ms since this factory was last used (null when not warm-tracked). */
@@ -11268,7 +11579,14 @@ var RunnerCameraConfigSchema = object({
 	* camera's detect node differs from its source-owner (P2d, gated by the
 	* `remoteSourcingNodes` rollout setting).
 	*/
-	frameSource: RunnerFrameSourceSchema.default({ kind: "local-broker" })
+	frameSource: RunnerFrameSourceSchema.default({ kind: "local-broker" }),
+	/**
+	* Inference-device selector for this camera's sessions (Phase 2 multi-device).
+	* Format `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`);
+	* omitted ⇒ the runner's default device. The engine itself stays node-local —
+	* this only selects WHICH device pool of that node runs the session.
+	*/
+	deviceKey: string().optional()
 });
 motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
 /**
@@ -11289,6 +11607,19 @@ var RunnerLocalLoadSchema = object({
 	avgInferenceTimeMs: number(),
 	/** Total queue depth across motion + detection queues. */
 	queueDepthTotal: number(),
+	/**
+	* Per-inference-device live load (multi-device C4). One entry per deviceKey
+	* this runner currently has attached cameras on, so the orchestrator's second
+	* `balance()` pass (over a node's devices) weights on real per-pool session
+	* counts. Empty on single-device / pre-multi-device runners. `queueDepthTotal`
+	* per device is 0 until the pool backlog gets a public accessor (follow-up).
+	*/
+	devices: array(object({
+		deviceKey: string(),
+		backend: string(),
+		attachedCameras: number(),
+		queueDepthTotal: number()
+	})).default([]),
 	/** Hardware capability flags reported by this node. */
 	hardware: object({
 		hasGpu: boolean(),
@@ -12764,6 +13095,8 @@ method(_void(), _void(), { kind: "mutation" }), method(_void(), _void(), { kind:
 	kind: "mutation",
 	auth: "admin"
 });
+DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
+new Set(Object.values(DeviceType));
 /**
 * `addon-pages` — system-scoped singleton aggregator cap. Public-facing
 * surface that admin-ui consumes through `useAddonPagesListPages()`.
@@ -15988,17 +16321,30 @@ var EventKindCategorySchema = _enum([
 	"audio",
 	"detection",
 	"sensor",
+	"control",
 	"custom",
 	"package"
 ]);
+/** Taxonomy level — macro (timeline lane) vs sub (events-page leaf). */
+var EventKindLevelSchema = _enum(["macro", "sub"]);
 var EventKindDescriptorSchema = object({
-	/** Stable kind id (e.g. 'motion', 'person', 'contact'). */
+	/** Stable kind id (e.g. 'motion', 'vehicle', 'car', 'lock'). */
 	kind: string(),
+	/** i18n key resolved on the UI side; `label` is the English fallback. */
+	labelKey: string(),
+	/** English fallback label (kept for clients that don't translate). */
 	label: string(),
 	/** Hex color for timeline/legend rendering. */
 	color: string(),
+	/** Dictionary id → lucide component on the UI side. */
+	iconId: string(),
+	/** Legacy closed-vocab glyph — fallback for `iconId`. */
 	icon: EventKindIconSchema,
 	category: EventKindCategorySchema,
+	/** Macro parent for this kind ('car' → 'vehicle'); null for a macro. */
+	parentKind: string().nullable(),
+	/** Derived from `parentKind`, explicit for the client tree. */
+	level: EventKindLevelSchema,
 	/** Which cap + device contributes this kind. For built-ins the camera
 	*  itself; for sensor kinds the LINKED source device. */
 	source: object({
@@ -16071,11 +16417,21 @@ var TrackAudioLabelSchema = object({
 	firstAt: number(),
 	lastAt: number()
 });
+/**
+* How a track was produced. `pipeline` (default / absent) = the spatial
+* detection+tracking pipeline. `sensor` = a SYNTHETIC track projected from a
+* linked sensor/control state change (no positions; carries a snapshot). The
+* spatial subsystems (tracker association, occupancy count, re-id/embedding,
+* resurrection) MUST skip `sensor` tracks — they have no bbox trajectory.
+*/
+var TrackSourceSchema = _enum(["pipeline", "sensor"]);
 var TrackSchema = object({
 	trackId: string(),
 	deviceId: number(),
 	className: string(),
 	label: string().optional(),
+	/** Track provenance. Absent ⇒ `pipeline` (legacy rows). */
+	source: TrackSourceSchema.optional(),
 	firstSeen: number(),
 	lastSeen: number(),
 	/** Frame-rate position history (subject to maxPositionHistory cap). */
@@ -16452,6 +16808,76 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	eventId: string(),
 	timestamp: number()
 });
+/**
+* Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
+* `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
+* caps into per-camera event-kind descriptors.
+*
+* The descriptor DATA (color / iconId / labelKey / parentKind / category)
+* is NOT duplicated here — every entry is derived from the single
+* `EVENT_TAXONOMY` dictionary (`catalogs/event-taxonomy.ts`). This file owns
+* ONLY the cap-name → taxonomy-kind mapping. Adding a new eventful sensor /
+* control cap means adding one line here (and a taxonomy entry); the anti-
+* drift guard `scripts/check-event-kind-coverage.ts` fails the build if an
+* eventful cap is missing.
+*/
+/** Map a taxonomy `iconId` onto the legacy closed `EventKindIcon` enum. */
+var LEGACY_ICON = {
+	motion: "motion",
+	audio: "audio",
+	person: "person",
+	vehicle: "vehicle",
+	animal: "animal",
+	package: "package",
+	door: "door",
+	pir: "pir",
+	smoke: "smoke",
+	water: "water",
+	button: "button",
+	generic: "generic",
+	gas: "smoke",
+	vibration: "generic",
+	tamper: "generic",
+	presence: "person",
+	lock: "generic",
+	siren: "generic",
+	switch: "generic",
+	doorbell: "button"
+};
+function legacyIcon(iconId) {
+	return LEGACY_ICON[iconId] ?? "generic";
+}
+/**
+* Cap name → taxonomy kind id. Covers EVERY eventful sensor / control cap.
+* The anti-drift guard cross-checks this against the eventful caps declared
+* in `packages/types/src/capabilities/*.cap.ts`.
+*/
+var CAP_TO_KIND = {
+	contact: "contact",
+	motion: "motion-sensor",
+	smoke: "smoke",
+	flood: "flood",
+	gas: "gas",
+	"carbon-monoxide": "carbon-monoxide",
+	vibration: "vibration",
+	tamper: "tamper",
+	presence: "presence",
+	"enum-sensor": "enum-sensor",
+	"event-emitter": "device-event",
+	"lock-control": "lock",
+	switch: "switch",
+	button: "button",
+	doorbell: "doorbell"
+};
+function buildDescriptor(capName, kind) {
+	const t = EVENT_TAXONOMY[kind];
+	if (t === void 0) throw new Error(`EVENT_KIND_BY_CAP: cap '${capName}' maps to unknown taxonomy kind '${kind}'`);
+	return {
+		...t,
+		icon: legacyIcon(t.iconId)
+	};
+}
+Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
 var CameraPipelineConfigSchema = object({
 	engine: PipelineEngineChoiceSchema.optional(),
 	steps: array(PipelineStepInputSchema).readonly(),
@@ -16470,13 +16896,11 @@ var PipelineTemplateSchema = object({
 	createdAt: string(),
 	updatedAt: string()
 });
-var AgentAddonConfigSchema = object({
-	enabled: boolean(),
+var DeviceStepConfigSchema = object({
 	modelId: string().optional(),
-	settings: record(string(), unknown()).readonly()
+	settings: record(string(), unknown()).optional()
 });
 var AgentPipelineSettingsSchema = object({
-	addonDefaults: record(string(), AgentAddonConfigSchema).readonly(),
 	maxCameras: number().int().nonnegative().nullable().default(null),
 	/** Per-node detection weight (relative share for the quota balancer). */
 	detectWeight: number().positive().optional(),
@@ -16500,7 +16924,22 @@ var AgentPipelineSettingsSchema = object({
 	* it already uses to reach the hub). Set this only when the auto-detected
 	* address is wrong (multi-homed host, NAT, custom interface).
 	*/
-	reachableHost: string().optional()
+	reachableHost: string().optional(),
+	/**
+	* Multi-device inference opt-in (Phase 4). Per-node map deviceKey → {enabled,
+	* weight, steps}. Absent / all-disabled ⇒ the node's single default
+	* accelerator (safe default); two+ enabled ⇒ the dispatcher balances
+	* detection sessions across them so they run CONCURRENTLY. `steps` is the
+	* per-(node,device) BASE provisioning (`stepId → {modelId?, settings?}`) —
+	* the default model/settings for every camera landing on that accelerator;
+	* a stepId absent ⇒ the step uses that device's format default.
+	*/
+	inferenceDevices: record(string(), object({
+		enabled: boolean(),
+		weight: number().positive().optional(),
+		maxSessions: number().int().positive().optional(),
+		steps: record(string(), DeviceStepConfigSchema).optional()
+	})).optional()
 });
 var CameraPipelineForAgentSchema = object({
 	steps: array(PipelineStepInputSchema).readonly(),
@@ -16510,14 +16949,13 @@ var CameraPipelineForAgentSchema = object({
 	}).nullable()
 });
 var CameraStepOverridePatchSchema = object({
-	enabled: boolean().optional(),
 	modelId: string().optional(),
 	settings: record(string(), unknown()).readonly().optional()
 });
 var CameraPipelineSettingsSchema = object({
 	pinnedAgentNodeId: string().optional(),
 	stepToggles: record(string(), boolean()).optional(),
-	stepOverridesByAgent: record(string(), record(string(), CameraStepOverridePatchSchema)).optional(),
+	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
 });
 /**
@@ -16731,6 +17169,44 @@ var CameraStatusSchema = object({
 	/** Unix timestamp (ms) when this snapshot was composed server-side. */
 	fetchedAt: number()
 });
+var NodeInferenceDeviceSchema = object({
+	/** Stable per-node device key, e.g. `openvino:npu`, `edgetpu:usb`, `cpu`. */
+	key: string(),
+	backend: string(),
+	device: string(),
+	format: _enum(MODEL_FORMATS),
+	/** Whether the node's live probe reports the device as usable right now. */
+	available: boolean(),
+	/**
+	* Whether this device participates in dispatch. AUTO default (spec C2):
+	* accelerators are opt-OUT (a discovered NPU/iGPU/Coral/ANE with no stored
+	* entry is `true`); CPU is opt-IN (`false` by default — the fallback pool,
+	* not a balanced target). An explicit stored value always wins; a stored-only
+	* (unavailable) key keeps its stored value.
+	*/
+	enabled: boolean(),
+	/** Relative balancer weight for the enabled device (default 1). */
+	weight: number(),
+	/** Per-device concurrent-session cap; null = unlimited (multi-device C4). */
+	maxSessions: number().nullable(),
+	/** Object-detection model the executor defaults to for this deviceKey. */
+	defaultModelId: string(),
+	/**
+	* Per-(node,device) BASE provisioning (C7.2/C7.4) — the RAW stored
+	* `stepId → {modelId?, settings?}` map from `inferenceDevices[key].steps`.
+	* Absent/empty ⇒ no base (every step uses its device format default). The
+	* UI cross-references `pipelineExecutor.getSchema` for the models actually
+	* available per format; this is the stored selection that becomes the
+	* default for EVERY camera landing on this accelerator.
+	*/
+	steps: record(string(), DeviceStepConfigSchema).optional()
+});
+var NodeInferenceDevicesSchema = object({
+	nodeId: string(),
+	/** False when the node's platform-probe was unreachable (no live device set). */
+	reachable: boolean(),
+	devices: array(NodeInferenceDeviceSchema).readonly()
+});
 method(object({
 	deviceId: number(),
 	agentNodeId: string()
@@ -16740,7 +17216,13 @@ method(object({
 }), method(object({ deviceId: number() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), object({ migrated: number() }), {
+}), method(object({
+	deviceId: number(),
+	deviceKey: string()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number() }), object({ deviceKey: string().nullable() })), method(_void(), object({ migrated: number() }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(_void(), array(PipelineAssignmentSchema).readonly()), method(object({ deviceId: number() }), PipelineAssignmentSchema.nullable()), method(_void(), array(AgentLoadSummarySchema).readonly()), method(_void(), GlobalMetricsSchema), method(object({ deviceId: number() }), CameraMetricsSchema.nullable()), method(object({ nodeId: string() }), CapabilityBindingsSchema), method(object({
@@ -16774,13 +17256,7 @@ method(object({
 }))), method(object({ agentNodeId: string() }), AgentPipelineSettingsSchema.nullable()), method(_void(), array(object({
 	nodeId: string(),
 	settings: AgentPipelineSettingsSchema
-})).readonly()), method(object({
-	agentNodeId: string(),
-	defaults: record(string(), AgentAddonConfigSchema)
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ agentNodeId: string() }), object({
+})).readonly()), method(object({ agentNodeId: string() }), object({
 	success: boolean(),
 	removed: boolean()
 }), {
@@ -16812,7 +17288,18 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ agentNodeId: string() }), object({
+}), method(object({
+	agentNodeId: string(),
+	inferenceDevices: record(string(), object({
+		enabled: boolean(),
+		weight: number().positive().optional(),
+		maxSessions: number().int().positive().optional(),
+		steps: record(string(), DeviceStepConfigSchema).optional()
+	}))
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ nodeId: string() }), NodeInferenceDevicesSchema), method(object({ agentNodeId: string() }), object({
 	success: literal(true),
 	/** Hardware-aware default detection model now in effect on the node (null when unresolvable). */
 	effectiveModelId: string().nullable(),
@@ -16828,9 +17315,10 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ deviceId: number() }), record(string(), record(string(), CameraStepOverridePatchSchema)).nullable()), method(object({
+}), method(object({ deviceId: number() }), record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).nullable()), method(object({
 	deviceId: number(),
 	agentNodeId: string(),
+	deviceKey: string(),
 	addonId: string(),
 	patch: CameraStepOverridePatchSchema.nullable()
 }), object({ success: literal(true) }), {
@@ -16867,14 +17355,13 @@ method(object({
 });
 /**
 * server-management — per-NODE singleton capability for a node's ROOT
-* package lifecycle (runtime-updatable node packages, phase 2: hub + docker
-* agents).
+* package lifecycle (runtime-updatable node packages).
 *
-* Each node's root package (`@camstack/server` on the hub, `@camstack/agent`
-* on agents) carries the whole software stack in its npm dep tree, so ONE
-* version describes the node. Updates install into
-* `<dataDir>/server-root/versions/<v>/` and apply on restart via the baked
-* starter (probation boot + auto-rollback to N-1).
+* Every node role runs the SAME root package (`@camstack/server`), which
+* carries the whole software stack in its npm dep tree, so ONE version
+* describes the node. Updates stage into `<dataDir>/server-root/` and apply
+* on restart via the baked starter (single-copy in-place swap — no probation,
+* no auto-rollback).
 *
 * Providers:
 *   - HUB: `ServerUpdateService` behind the `server-provided` mount
@@ -16982,7 +17469,8 @@ method(_void(), ServerPackageStatusSchema, { auth: "admin" }), method(_void(), S
 /** Explicit target version; omitted = latest from the registry. */
 version: string().optional() }), ServerUpdateActionResultSchema, {
 	kind: "mutation",
-	auth: "admin"
+	auth: "admin",
+	timeoutMs: 16 * 6e4
 }), method(_void(), ServerUpdateActionResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -18026,22 +18514,6 @@ var AddonAutoUpdateSchema = ChannelWithInheritSchema;
 var RestartAddonResultSchema = unknown();
 var InstallPackageResultSchema = unknown();
 var ReloadPackagesResultSchema = unknown();
-/**
-* Result of `updateFrameworkPackage`. The cap method returns BEFORE the
-* server restarts so the admin UI can react to the `restartingAt`
-* timestamp (shows reconnect overlay). The transition from
-* `fromVersion` to `toVersion` will be confirmed by a subsequent
-* `system.restart-completed` event after the new process boots.
-*
-* Spec: docs/superpowers/specs/2026-05-14-framework-live-update-design.md
-*/
-var UpdateFrameworkPackageResultSchema = object({
-	packageName: string(),
-	fromVersion: string(),
-	toVersion: string(),
-	/** Ms-epoch the server scheduled its self-restart. */
-	restartingAt: number()
-});
 var BulkUpdateItemStatusSchema = _enum([
 	"queued",
 	"updating",
@@ -18169,13 +18641,6 @@ method(_void(), array(AddonListItemSchema).readonly()), method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({
-	packageName: string().min(1),
-	version: string().optional(),
-	deferRestart: boolean().optional()
-}), UpdateFrameworkPackageResultSchema, {
-	kind: "mutation",
-	auth: "admin"
 }), method(object({ name: string() }), array(PackageVersionInfoSchema).readonly()), method(object({ addonId: string() }), RestartAddonResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -19041,10 +19506,10 @@ var TopologyCategorySchema = object({
 	addons: array(TopologyCategoryAddonSchema).readonly()
 });
 /**
-* The node's runtime-updatable ROOT package (`@camstack/server` on the hub,
-* `@camstack/agent` on agents) as reported by its `registerNode` manifest —
-* version visibility for the Server management surface. Nullable: offline
-* rows and pre-phase-2 nodes report none.
+* The node's runtime-updatable ROOT package (`@camstack/server` — the single
+* root package for every node role) as reported by its `registerNode`
+* manifest — version visibility for the Server management surface. Nullable:
+* offline rows and nodes that never reported one.
 */
 var TopologyRootPackageSchema = object({
 	name: string(),
@@ -19432,17 +19897,28 @@ var PlatformScoreSchema = object({
 	format: _enum([
 		"onnx",
 		"coreml",
-		"openvino"
+		"openvino",
+		"tflite"
 	]),
 	score: number(),
 	reason: string(),
 	available: boolean()
 });
+var InferenceDeviceDescriptorSchema = object({
+	key: string(),
+	backend: string(),
+	device: string(),
+	format: ModelFormatSchema,
+	runtime: literal("python"),
+	score: number(),
+	available: boolean()
+});
 var PlatformCapabilitiesSchema = object({
 	hardware: HardwareInfoSchema,
 	scores: array(PlatformScoreSchema).readonly(),
 	bestScore: PlatformScoreSchema,
-	pythonPath: string().nullable()
+	pythonPath: string().nullable(),
+	devices: array(InferenceDeviceDescriptorSchema).readonly()
 });
 var ModelRequirementSchema = object({
 	modelId: string(),
@@ -20321,12 +20797,6 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
-	"addons.updateFrameworkPackage": {
-		capName: "addons",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"addons.updatePackage": {
 		capName: "addons",
 		capScope: "system",
@@ -23099,12 +23569,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineExecutor.reprobeEngine": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineExecutor.runAudioTest": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -23255,6 +23719,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getNodeInferenceDevices": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getPipelineAssignment": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -23267,6 +23737,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getPipelineDevicePin": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.listAgentSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -23309,19 +23785,19 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentAddonDefaults": {
+	"pipelineOrchestrator.setAgentCapabilities": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentCapabilities": {
+	"pipelineOrchestrator.setAgentDetectWeight": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentDetectWeight": {
+	"pipelineOrchestrator.setAgentInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -23363,6 +23839,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setPipelineDevicePin": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.unassignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -24915,32 +25397,6 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
-var frameworkSwapPackageSchema = object({
-	name: string(),
-	stagedPath: string(),
-	backupPath: string(),
-	toVersion: string(),
-	fromVersion: string().nullable()
-});
-object({
-	jobId: string(),
-	taskId: string(),
-	packages: array(frameworkSwapPackageSchema),
-	requestedAtMs: number(),
-	schemaVersion: literal(1)
-});
-object({
-	jobId: string(),
-	taskId: string(),
-	backups: array(object({
-		name: string(),
-		backupPath: string(),
-		livePath: string()
-	})),
-	appliedAtMs: number(),
-	bootAttempts: number(),
-	schemaVersion: literal(1)
-});
 /**
 * Fixed-capacity ring buffer. When full, push() overwrites the oldest entry.
 * drain() returns up to maxCount items in FIFO order and removes them.