@camstack/addon-pipeline 1.2.28 → 1.2.31

package/dist/{dist-DUHlZcWd.js → dist-BvFLZyhW.js}

@@ -1,4 +1,4 @@
-//#region ../types/dist/event-category-BLcNejAE.mjs
+//#region ../types/dist/event-category-Bz24uP1U.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -269,6 +269,19 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["DeviceStateChanged"] = "device.state-changed";
 	/**
+	* Frame occupancy for a camera CHANGED — a tracked object was gained or
+	* lost. Carries `{ deviceId, totalObjects, byClass, zones }`.
+	*
+	* Emitted only on a change, so a steady scene is silent. It exists so a
+	* client can stop polling `zoneAnalytics.getCurrentSnapshot`: that was the
+	* one live badge with no push signal at all, and it cost a request every
+	* four seconds per visible camera.
+	*
+	* Like every event it is telemetry and may be dropped ([D8]) — a consumer
+	* keeps a slow reconcile rather than trusting it alone.
+	*/
+	EventCategory["ZoneAnalyticsOccupancyChanged"] = "zone-analytics.occupancy-changed";
+	/**
 	* Cap event fired by every device that registers the `battery`
 	* capability. Mirrors the cap definition's `onStatusChanged`. Carries
 	* `{ deviceId, status: BatteryStatus }`. Subscribers (alert center,
@@ -9607,6 +9620,29 @@ var NcOccupancyConditionSchema = object({
 	count: number().int().min(0).default(1),
 	sustainSeconds: number().int().min(0).max(3600).default(15)
 });
+/**
+* Which zone-crossing DIRECTION a rule accepts (`ObjectEvent.zoneCrossing`).
+*
+* The values are not symmetric, and deliberately so — the absent value has to
+* mean exactly what every rule authored before this condition existed already
+* does:
+*  - `enter` — entries and every NON-crossing record (movement state,
+*    package, sensor). Exits are rejected. **This is the absent behaviour**:
+*    an operator who never asked for exits must not start receiving them.
+*  - `exit`  — ONLY an exit crossing. A record that is not a crossing at all
+*    fails closed, because "the car left the drive" is a question about a
+*    boundary, not about a detection.
+*  - `any`   — no direction filter; entries, exits and non-crossings alike.
+*
+* A rule asking for a direction should normally also scope `zones`, which the
+* engine evaluates against the crossed zone as well as the current membership
+* (an exit's membership no longer contains the zone it just left).
+*/
+var NcCrossingSchema = _enum([
+	"enter",
+	"exit",
+	"any"
+]);
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 var NcZoneConditionSchema = object({
 	ids: array(string().min(1)).min(1),
@@ -9631,6 +9667,13 @@ var NcConditionsSchema = object({
 	/** Veto zones — any hit fails the rule. */
 	zonesExclude: array(string().min(1)).optional(),
 	/**
+	* Zone-crossing direction. IMMEDIATE only — a crossing is a per-event fact
+	* and a closed track carries none, so a `track-end` rule asking for one
+	* fails closed (use `zones`, which tests `zonesVisited`). ABSENT = `enter`,
+	* which is exactly today's behaviour. See {@link NcCrossingSchema}.
+	*/
+	crossing: NcCrossingSchema.optional(),
+	/**
 	* Exact (case-insensitive) match on the record's collapsed `label`
 	* (identity name / plate text / subclass).
 	*/
@@ -9819,11 +9862,31 @@ var NcMediaPolicySchema = object({
 	*/
 	profile: CamProfileSchema.optional()
 });
+/**
+* Cooldown GRANULARITY over the subject's class — how much a fired
+* notification suppresses.
+*  - `shared` (default, and the absent value) — one window for the whole
+*    rule/scope: a cat silences the next dog for `cooldownSec`.
+*  - `per-class` — an independent window per detected class, so cat→dog fires
+*    at once and cat→cat still waits.
+*
+* AUDIO subjects are ALWAYS per-class regardless of this setting: a scream
+* must not be swallowed by a bark's window (the precedent this generalizes —
+* see `cooldownKey` in the rule engine).
+*/
+var NcThrottleGranularitySchema = _enum(["shared", "per-class"]);
 /** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
 var NcThrottleSchema = object({
 	cooldownSec: number().int().min(0).max(86400).default(60),
 	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
-	scope: _enum(["rule", "rule-device"]).default("rule-device")
+	scope: _enum(["rule", "rule-device"]).default("rule-device"),
+	/**
+	* Class granularity of the cooldown key. Optional rather than defaulted:
+	* a Zod default does NOT run on the addon→addon cap path, so a persisted
+	* rule authored before this field simply carries none — and the engine
+	* reads absent as `shared`, the pre-existing behaviour.
+	*/
+	granularity: NcThrottleGranularitySchema.optional()
 });
 /** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
 var NcRuleInputSchema = object({
@@ -9931,6 +9994,7 @@ var NcConditionDescriptorSchema = object({
 		"schedule",
 		"plateMatcher",
 		"packagePhase",
+		"crossingSelect",
 		"polygonDraw",
 		"occupancy"
 	]),
@@ -17092,7 +17156,10 @@ method(object({
 }), method(object({
 	deviceId: number(),
 	caps: array(string()).readonly().optional()
-}), record(string(), unknown().nullable()));
+}), record(string(), unknown().nullable())), method(object({
+	deviceIds: array(number()).readonly(),
+	caps: array(string()).readonly().optional()
+}), record(string(), record(string(), unknown().nullable())));
 method(object({ deviceId: number() }), record(string(), record(string(), unknown()))), method(object({
 	deviceId: number(),
 	capName: string()
@@ -18500,6 +18567,29 @@ var MotionEventSchema = object({
 * Absent on legacy rows ⇒ treat as `pipeline`.
 */
 var DetectionSourceSchema = _enum(["pipeline", "onboard"]);
+/**
+* The confirmed zone crossing that produced an object event. Present ONLY on
+* an event emitted BY a crossing (`zone.enter` / `zone.exit`); a movement-state
+* event (`object.entering` / `leaving` / `stationary` / `loitering`) and an
+* appearance event carry none, so a rule asking for a direction fails closed
+* on them.
+*
+* Exactly ONE crossing per event: the emitter turns each confirmed crossing
+* into its own event, so a frame in which a track enters A while leaving B
+* produces two events with two directions — never one ambiguous row.
+*
+* `zoneId` is load-bearing for an EXIT: the event's `zones` list is the
+* membership the box has NOW, and by definition it no longer contains the zone
+* that was just left. Without the id here, a zone-scoped rule could never match
+* the exit it asked for.
+*/
+var ZoneCrossingSchema = object({
+	direction: _enum(["enter", "exit"]),
+	/** Admin zone id crossed. */
+	zoneId: string(),
+	/** Zone display name at crossing time (falls back to the id). */
+	zoneName: string().optional()
+});
 var ObjectEventSchema = object({
 	...BaseEventFields,
 	kind: literal("object"),
@@ -18526,6 +18616,12 @@ var ObjectEventSchema = object({
 	zones: array(string()).readonly().optional(),
 	/** Omitted in slim projection. */
 	state: TrackStateSchema.optional(),
+	/**
+	* The zone crossing this event IS, when it is one. Absent on every other
+	* event kind (movement state, appearance, package) — see
+	* {@link ZoneCrossingSchema}. Omitted in slim projection.
+	*/
+	zoneCrossing: ZoneCrossingSchema.optional(),
 	/** Detection-frame dimensions in pixels — let consumers normalize the
 	*  pixel-space `bbox` onto a displayed image. Omitted in slim projection. */
 	frameWidth: number().optional(),
@@ -24041,6 +24137,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.getDeviceStatusAggregateBatch": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.getLinkedDevices": {
 		capName: "device-manager",
 		capScope: "system",

package/dist/{dist-CsKaXmP8.mjs → dist-Du7_SNiR.mjs}

@@ -1,4 +1,4 @@
-//#region ../types/dist/event-category-BLcNejAE.mjs
+//#region ../types/dist/event-category-Bz24uP1U.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -269,6 +269,19 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["DeviceStateChanged"] = "device.state-changed";
 	/**
+	* Frame occupancy for a camera CHANGED — a tracked object was gained or
+	* lost. Carries `{ deviceId, totalObjects, byClass, zones }`.
+	*
+	* Emitted only on a change, so a steady scene is silent. It exists so a
+	* client can stop polling `zoneAnalytics.getCurrentSnapshot`: that was the
+	* one live badge with no push signal at all, and it cost a request every
+	* four seconds per visible camera.
+	*
+	* Like every event it is telemetry and may be dropped ([D8]) — a consumer
+	* keeps a slow reconcile rather than trusting it alone.
+	*/
+	EventCategory["ZoneAnalyticsOccupancyChanged"] = "zone-analytics.occupancy-changed";
+	/**
 	* Cap event fired by every device that registers the `battery`
 	* capability. Mirrors the cap definition's `onStatusChanged`. Carries
 	* `{ deviceId, status: BatteryStatus }`. Subscribers (alert center,
@@ -9607,6 +9620,29 @@ var NcOccupancyConditionSchema = object({
 	count: number().int().min(0).default(1),
 	sustainSeconds: number().int().min(0).max(3600).default(15)
 });
+/**
+* Which zone-crossing DIRECTION a rule accepts (`ObjectEvent.zoneCrossing`).
+*
+* The values are not symmetric, and deliberately so — the absent value has to
+* mean exactly what every rule authored before this condition existed already
+* does:
+*  - `enter` — entries and every NON-crossing record (movement state,
+*    package, sensor). Exits are rejected. **This is the absent behaviour**:
+*    an operator who never asked for exits must not start receiving them.
+*  - `exit`  — ONLY an exit crossing. A record that is not a crossing at all
+*    fails closed, because "the car left the drive" is a question about a
+*    boundary, not about a detection.
+*  - `any`   — no direction filter; entries, exits and non-crossings alike.
+*
+* A rule asking for a direction should normally also scope `zones`, which the
+* engine evaluates against the crossed zone as well as the current membership
+* (an exit's membership no longer contains the zone it just left).
+*/
+var NcCrossingSchema = _enum([
+	"enter",
+	"exit",
+	"any"
+]);
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 var NcZoneConditionSchema = object({
 	ids: array(string().min(1)).min(1),
@@ -9631,6 +9667,13 @@ var NcConditionsSchema = object({
 	/** Veto zones — any hit fails the rule. */
 	zonesExclude: array(string().min(1)).optional(),
 	/**
+	* Zone-crossing direction. IMMEDIATE only — a crossing is a per-event fact
+	* and a closed track carries none, so a `track-end` rule asking for one
+	* fails closed (use `zones`, which tests `zonesVisited`). ABSENT = `enter`,
+	* which is exactly today's behaviour. See {@link NcCrossingSchema}.
+	*/
+	crossing: NcCrossingSchema.optional(),
+	/**
 	* Exact (case-insensitive) match on the record's collapsed `label`
 	* (identity name / plate text / subclass).
 	*/
@@ -9819,11 +9862,31 @@ var NcMediaPolicySchema = object({
 	*/
 	profile: CamProfileSchema.optional()
 });
+/**
+* Cooldown GRANULARITY over the subject's class — how much a fired
+* notification suppresses.
+*  - `shared` (default, and the absent value) — one window for the whole
+*    rule/scope: a cat silences the next dog for `cooldownSec`.
+*  - `per-class` — an independent window per detected class, so cat→dog fires
+*    at once and cat→cat still waits.
+*
+* AUDIO subjects are ALWAYS per-class regardless of this setting: a scream
+* must not be swallowed by a bark's window (the precedent this generalizes —
+* see `cooldownKey` in the rule engine).
+*/
+var NcThrottleGranularitySchema = _enum(["shared", "per-class"]);
 /** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
 var NcThrottleSchema = object({
 	cooldownSec: number().int().min(0).max(86400).default(60),
 	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
-	scope: _enum(["rule", "rule-device"]).default("rule-device")
+	scope: _enum(["rule", "rule-device"]).default("rule-device"),
+	/**
+	* Class granularity of the cooldown key. Optional rather than defaulted:
+	* a Zod default does NOT run on the addon→addon cap path, so a persisted
+	* rule authored before this field simply carries none — and the engine
+	* reads absent as `shared`, the pre-existing behaviour.
+	*/
+	granularity: NcThrottleGranularitySchema.optional()
 });
 /** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
 var NcRuleInputSchema = object({
@@ -9931,6 +9994,7 @@ var NcConditionDescriptorSchema = object({
 		"schedule",
 		"plateMatcher",
 		"packagePhase",
+		"crossingSelect",
 		"polygonDraw",
 		"occupancy"
 	]),
@@ -17092,7 +17156,10 @@ method(object({
 }), method(object({
 	deviceId: number(),
 	caps: array(string()).readonly().optional()
-}), record(string(), unknown().nullable()));
+}), record(string(), unknown().nullable())), method(object({
+	deviceIds: array(number()).readonly(),
+	caps: array(string()).readonly().optional()
+}), record(string(), record(string(), unknown().nullable())));
 method(object({ deviceId: number() }), record(string(), record(string(), unknown()))), method(object({
 	deviceId: number(),
 	capName: string()
@@ -18500,6 +18567,29 @@ var MotionEventSchema = object({
 * Absent on legacy rows ⇒ treat as `pipeline`.
 */
 var DetectionSourceSchema = _enum(["pipeline", "onboard"]);
+/**
+* The confirmed zone crossing that produced an object event. Present ONLY on
+* an event emitted BY a crossing (`zone.enter` / `zone.exit`); a movement-state
+* event (`object.entering` / `leaving` / `stationary` / `loitering`) and an
+* appearance event carry none, so a rule asking for a direction fails closed
+* on them.
+*
+* Exactly ONE crossing per event: the emitter turns each confirmed crossing
+* into its own event, so a frame in which a track enters A while leaving B
+* produces two events with two directions — never one ambiguous row.
+*
+* `zoneId` is load-bearing for an EXIT: the event's `zones` list is the
+* membership the box has NOW, and by definition it no longer contains the zone
+* that was just left. Without the id here, a zone-scoped rule could never match
+* the exit it asked for.
+*/
+var ZoneCrossingSchema = object({
+	direction: _enum(["enter", "exit"]),
+	/** Admin zone id crossed. */
+	zoneId: string(),
+	/** Zone display name at crossing time (falls back to the id). */
+	zoneName: string().optional()
+});
 var ObjectEventSchema = object({
 	...BaseEventFields,
 	kind: literal("object"),
@@ -18526,6 +18616,12 @@ var ObjectEventSchema = object({
 	zones: array(string()).readonly().optional(),
 	/** Omitted in slim projection. */
 	state: TrackStateSchema.optional(),
+	/**
+	* The zone crossing this event IS, when it is one. Absent on every other
+	* event kind (movement state, appearance, package) — see
+	* {@link ZoneCrossingSchema}. Omitted in slim projection.
+	*/
+	zoneCrossing: ZoneCrossingSchema.optional(),
 	/** Detection-frame dimensions in pixels — let consumers normalize the
 	*  pixel-space `bbox` onto a displayed image. Omitted in slim projection. */
 	frameWidth: number().optional(),
@@ -24041,6 +24137,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.getDeviceStatusAggregateBatch": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.getLinkedDevices": {
 		capName: "device-manager",
 		capScope: "system",

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-DUHlZcWd.js");
+const require_dist = require("../dist-BvFLZyhW.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { A as motionDetectionCapability, E as evaluateZoneRules, K as hydrateSchema, V as BaseAddon, W as DeviceType } from "../dist-CsKaXmP8.mjs";
+import { A as motionDetectionCapability, E as evaluateZoneRules, K as hydrateSchema, V as BaseAddon, W as DeviceType } from "../dist-Du7_SNiR.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/pipeline-runner/index.js

@@ -3,11 +3,13 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-DUHlZcWd.js");
+const require_dist = require("../dist-BvFLZyhW.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_worker_protocol = require("../worker-protocol-DextwlTX.js");
-const require_step_definitions = require("../step-definitions-Bo1hJQQw.js");
+const require_step_definitions = require("../step-definitions-gC-Ovglc.js");
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
 let node_child_process = require("node:child_process");
 let node_url = require("node:url");
 let sharp = require("sharp");
@@ -383,6 +385,51 @@ var Semaphore = class {
 		if (next) next();
 	}
 };
+var MotionWithoutInferenceDetector = class {
+	streak = /* @__PURE__ */ new Map();
+	reported = /* @__PURE__ */ new Set();
+	minIntervals;
+	constructor(minIntervals = 3) {
+		this.minIntervals = Math.max(1, minIntervals);
+	}
+	/**
+	* Feed one interval for one camera. Returns what, if anything, to say.
+	*
+	* A camera with NO motion is not evidence either way — it is simply quiet,
+	* and its streak is left untouched rather than reset, so an outage that
+	* spans a lull is still reported as one continuous stall.
+	*/
+	observe(deviceId, summary) {
+		if (summary.inferenceFrames > 0) {
+			const wasReported = this.reported.delete(deviceId);
+			const intervals = this.streak.get(deviceId) ?? 0;
+			this.streak.delete(deviceId);
+			return wasReported ? {
+				kind: "recovered",
+				intervals
+			} : { kind: "quiet" };
+		}
+		if (summary.motionFrames <= 0) return { kind: "quiet" };
+		const next = (this.streak.get(deviceId) ?? 0) + 1;
+		this.streak.set(deviceId, next);
+		if (next < this.minIntervals) return { kind: "quiet" };
+		if (this.reported.has(deviceId)) return { kind: "quiet" };
+		this.reported.add(deviceId);
+		return {
+			kind: "stalled",
+			intervals: next
+		};
+	}
+	/** Drop a camera's state — it was detached, so its streak means nothing. */
+	forget(deviceId) {
+		this.streak.delete(deviceId);
+		this.reported.delete(deviceId);
+	}
+	/** Cameras currently in a reported stall — the board's "motion, no inference". */
+	stalledDevices() {
+		return [...this.reported];
+	}
+};
 //#endregion
 //#region src/pipeline-runner/timing-sampler.ts
 var REPORT_INTERVAL_MS = 1e4;
@@ -395,6 +442,8 @@ var REPORT_INTERVAL_MS = 1e4;
 var PipelineTimingSampler = class {
 	detSamples = /* @__PURE__ */ new Map();
 	motSamples = /* @__PURE__ */ new Map();
+	/** See {@link MotionWithoutInferenceDetector} — the two-incident signature. */
+	motionStall = new MotionWithoutInferenceDetector();
 	audioSamples = /* @__PURE__ */ new Map();
 	/** Per-device cumulative dropped-frames readers (see {@link DroppedFramesSource}). */
 	droppedSources = /* @__PURE__ */ new Map();
@@ -526,6 +575,28 @@ var PipelineTimingSampler = class {
 				}
 			});
 		}
+		const devicesSeen = new Set([...this.detSamples.keys(), ...this.motSamples.keys()]);
+		for (const deviceId of devicesSeen) {
+			const verdict = this.motionStall.observe(deviceId, {
+				motionFrames: this.motSamples.get(deviceId)?.length ?? 0,
+				inferenceFrames: this.detSamples.get(deviceId)?.length ?? 0
+			});
+			if (verdict.kind === "stalled") this.log.warn("motion is flowing but NOTHING is being inferred", {
+				tags: { deviceId },
+				meta: {
+					intervals: verdict.intervals,
+					forSec: verdict.intervals * REPORT_INTERVAL_MS / 1e3,
+					motionFrames: this.motSamples.get(deviceId)?.length ?? 0
+				}
+			});
+			else if (verdict.kind === "recovered") this.log.info("inference resumed after a motion-without-inference stall", {
+				tags: { deviceId },
+				meta: {
+					intervals: verdict.intervals,
+					lastedSec: verdict.intervals * REPORT_INTERVAL_MS / 1e3
+				}
+			});
+		}
 		this.detSamples.clear();
 		for (const [deviceId, mot] of this.motSamples) {
 			if (mot.length === 0) continue;
@@ -658,6 +729,9 @@ function toFrameInput$1(frame) {
 * without spinning up Moleculer or the addon framework.
 */
 var PipelineRunner = class {
+	/** Abandoned inference calls that have not yet settled. A BURST reads as
+	*  one rising number instead of N unrelated lines. */
+	inflightTimeouts = 0;
 	config;
 	cameras = /* @__PURE__ */ new Map();
 	semaphore;
@@ -1144,16 +1218,33 @@ var PipelineRunner = class {
 			timer.unref?.();
 		});
 		try {
-			const outcome = await Promise.race([this.config.processFrame(deviceId, frameInput, executorHandle), expiry]);
+			const inflight = this.config.processFrame(deviceId, frameInput, executorHandle);
+			const outcome = await Promise.race([inflight, expiry]);
 			if (outcome === TIMED_OUT) {
 				release();
+				this.inflightTimeouts += 1;
 				this.logger?.warn("inference timed out — permit released, result discarded", {
 					tags: { deviceId },
 					meta: {
 						timeoutMs,
-						availablePermits: this.semaphore.available
+						availablePermits: this.semaphore.available,
+						outstandingTimeouts: this.inflightTimeouts
 					}
 				});
+				const deadlineAt = Date.now();
+				const noteSettled = (fate) => {
+					this.inflightTimeouts = Math.max(0, this.inflightTimeouts - 1);
+					this.logger?.info("inference: abandoned call settled after the deadline", {
+						tags: { deviceId },
+						meta: {
+							lateByMs: Date.now() - deadlineAt,
+							totalMs: timeoutMs + (Date.now() - deadlineAt),
+							fate,
+							outstandingTimeouts: this.inflightTimeouts
+						}
+					});
+				};
+				inflight.then(() => noteSettled("resolved"), () => noteSettled("rejected"));
 			}
 			return outcome;
 		} finally {
@@ -1251,6 +1342,40 @@ function summarizeDeviceLoad(attachedDeviceKeys) {
 	})).toSorted((a, b) => a.deviceKey.localeCompare(b.deviceKey));
 }
 //#endregion
+//#region src/pipeline-runner/hardware-capabilities.ts
+/**
+* The `hardware` block of `RunnerLocalLoad` — what this node can accelerate on.
+*
+* ## Why this file exists
+*
+* `getLocalLoad()` reported a hardcoded `hasGpu: false`. It was not a probe that
+* failed: when the hardware probe was moved off the runner (Phase 4) the field
+* was left as a literal, and it has answered "no GPU" ever since — including on
+* nodes actively running OpenVINO on their Intel iGPU. The admin UI renders a
+* "GPU" badge straight off it, and the orchestrator's hardware-aware balancing
+* reads it, so a stale `false` is a wrong answer, not a missing one.
+*
+* The probe is cheap and local (`ctx.kernel.inferenceEngine.resolveHardware()`
+* is deterministic per host, the same resolver the detection addon uses to pick
+* the node's default engine), and the runner shares a process with the
+* detection pipeline, so there is no cross-node ambiguity: this is THIS node.
+*/
+/**
+* Summarise a local hardware probe into the runner's reported capabilities.
+*
+* `hasGpu` is literal — a GPU, not "an accelerator". An NPU or a Coral is not a
+* GPU and does not set it; they surface per pool through `RunnerLocalLoad.devices`
+* (`openvino:npu`, `edgetpu:usb`, …), which is the finer-grained answer the
+* device balancer weights on. A null probe means "could not tell", which reports
+* as `false` — the same conservative floor the engine cascade takes.
+*/
+function summarizeRunnerHardware(hardware, cpuCores = node_os.cpus().length) {
+	return {
+		hasGpu: hardware?.gpu != null,
+		cpuCores
+	};
+}
+//#endregion
 //#region src/pipeline-runner/native-crop-tier.ts
 /**
 * Pure tier decision for `getNativeCrop`. A native HIT always resolves to the
@@ -2990,6 +3115,8 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 	* {@link MOTION_FRESHNESS_WINDOW_MS}.
 	*/
 	lastMotionFrameAt = /* @__PURE__ */ new Map();
+	/** Cached local accelerator probe — see {@link resolveLocalHardware}. */
+	localHardware = null;
 	constructor() {
 		super({ ...DEFAULT_CONFIG });
 	}
@@ -3843,12 +3970,26 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			avgInferenceTimeMs: metrics.avgInferenceTimeMs,
 			queueDepthTotal: metrics.queueDepth,
 			devices,
-			hardware: {
-				hasGpu: false,
-				inferenceBackend: void 0
-			}
+			hardware: summarizeRunnerHardware(await this.resolveLocalHardware())
 		};
 	}
+	/**
+	* THIS node's accelerators, probed once from the local kernel resolver and
+	* cached (the probe is deterministic per host, and `getLocalLoad` is polled).
+	* A throwing/absent resolver caches nothing and reports "could not tell" so a
+	* later poll retries.
+	*/
+	async resolveLocalHardware() {
+		if (this.localHardware) return this.localHardware;
+		try {
+			const hw = await this.ctx.kernel?.inferenceEngine?.resolveHardware();
+			this.localHardware = hw ?? null;
+			return this.localHardware;
+		} catch (err) {
+			this.ctx.logger.warn("local hardware probe failed — reporting no accelerator", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return null;
+		}
+	}
 	async getLocalMetrics() {
 		const m = this.runner?.getMetrics() ?? {
 			activeCameras: 0,