@camstack/types 1.1.33 → 1.1.35

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DmP-uxoe.js");
+const require_sleep = require("./sleep-DuN1nc6O.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 let zod = require("zod");
 //#region src/health/wiring-health.ts
@@ -132,10 +132,18 @@ var ModelVariantGroupSchema = zod.z.object({
 	precision: zod.z.enum(["fp32", "int8"]).optional(),
 	/**
 	* Speed-optimization axis. Omit ⇒ the standard build. `fast` marks a
-	* latency-optimized export (e.g. ReLU-activation / reduced-input variant)
-	* — the slot the future performance variants plug into.
+	* latency-optimized export (e.g. ReLU-activation variant) — the slot the
+	* future performance variants plug into.
 	*/
-	optimization: zod.z.enum(["standard", "fast"]).optional()
+	optimization: zod.z.enum(["standard", "fast"]).optional(),
+	/**
+	* Input-resolution axis (square input side, px). Omit ⇒ the family's native
+	* resolution (640 for yolo26). Reduced-input builds (320 / 256) are a big,
+	* cheap latency lever — especially on Apple ANE and the Intel N100 — at a
+	* small-object accuracy cost. Mirrors the model's `inputSize` but lifted onto
+	* the group so the selector can offer it as a variant axis.
+	*/
+	resolution: zod.z.number().int().positive().optional()
 });
 var ModelCatalogEntrySchema = zod.z.object({
 	id: zod.z.string(),
@@ -310,15 +318,17 @@ function buildModelVariantGroups(models) {
 					modelId: e.id,
 					precision,
 					optimization,
+					resolution: e.group?.resolution,
 					label: variantLabel(precision, optimization),
 					formats: entryFormats(e),
 					sizeMB: smallestSizeMB(e)
 				};
 			}).toSorted((a, b) => {
+				if (a.resolution !== b.resolution) return (b.resolution ?? Infinity) - (a.resolution ?? Infinity);
 				if (a.optimization !== b.optimization) return a.optimization === "fast" ? 1 : -1;
 				return PRECISION_ORDER.indexOf(a.precision) - PRECISION_ORDER.indexOf(b.precision);
 			});
-			const base = options.find((o) => o.precision === "fp32" && o.optimization === "standard") ?? options[0];
+			const base = options.find((o) => o.precision === "fp32" && o.optimization === "standard" && o.resolution === void 0) ?? options[0];
 			if (base === void 0) continue;
 			const baseEntry = entries.find((e) => e.id === base.modelId);
 			tierList.push({
@@ -358,6 +368,7 @@ function resolveVariantModelId(models, selection) {
 		if (m.group.family !== selection.family || m.group.tier !== selection.tier) continue;
 		if ((m.group.precision ?? "fp32") !== precision) continue;
 		if ((m.group.optimization ?? "standard") !== optimization) continue;
+		if (m.group.resolution !== selection.resolution) continue;
 		return m.id;
 	}
 	return null;
@@ -370,7 +381,8 @@ function describeModelVariant(models, modelId) {
 		family: entry.group.family,
 		tier: entry.group.tier,
 		precision: entry.group.precision ?? "fp32",
-		optimization: entry.group.optimization ?? "standard"
+		optimization: entry.group.optimization ?? "standard",
+		resolution: entry.group.resolution
 	};
 }
 //#endregion
@@ -1796,7 +1808,7 @@ async function runInferenceStep(fn, timeoutMs) {
 	const t0 = performance.now();
 	try {
 		return {
-			output: timeoutMs !== void 0 ? await withTimeout(fn(), timeoutMs) : await fn(),
+			output: timeoutMs !== void 0 ? await withTimeout$1(fn(), timeoutMs) : await fn(),
 			durationMs: roundMs(performance.now() - t0),
 			ok: true
 		};
@@ -1814,7 +1826,7 @@ function roundMs(ms) {
 	return Math.round(ms * 100) / 100;
 }
 /** Reject a promise if it exceeds the given timeout */
-function withTimeout(promise, ms) {
+function withTimeout$1(promise, ms) {
 	return new Promise((resolve, reject) => {
 		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Inference timeout after ${ms}ms`)), ms);
 		promise.then((v) => {
@@ -3776,6 +3788,111 @@ function createRuntimeStateBridge(params) {
 	};
 }
 //#endregion
+//#region src/device/reachability-poll.ts
+/**
+* Shared control-plane reachability poller for camera devices.
+*
+* `device.online` must reflect CONTROL-PLANE REACHABILITY — "can we talk to
+* the camera's management API right now" — NOT whether video happens to be
+* flowing through the stream broker. A camera that dials on-demand (no
+* consumer attached) is fully reachable yet has no active stream; driving
+* `online` from stream health falsely marks it OFFLINE.
+*
+* Every camera provider owns a cheap control-plane round-trip (Hikvision
+* ISAPI `getDeviceInfo`, Amcrest Dahua CGI `getDeviceInfo`, ONVIF
+* `getDeviceInformation`, RTSP `OPTIONS`/TCP-connect). Each provider passes
+* that round-trip as a `probe: () => Promise<boolean>` and this helper runs
+* the loop, applies hysteresis, and drives the device's `online` setter.
+*
+* Hysteresis rules (avoid flapping on a single dropped packet):
+*   - mark ONLINE immediately on the first successful probe;
+*   - mark OFFLINE only after {@link REACHABILITY_FAILURES_TO_OFFLINE}
+*     CONSECUTIVE failures.
+*
+* Robustness rules:
+*   - each probe is bounded by {@link REACHABILITY_PROBE_TIMEOUT_MS} so a hung
+*     control channel can't wedge the loop;
+*   - a single in-flight probe at a time — a slow probe never stacks up;
+*   - the loop never throws (a rejected/thrown probe counts as a failure);
+*   - `isEnabled()` gates each tick so a soft-disabled device isn't polled.
+*/
+/** Poll cadence — probe every camera's control plane on this interval. */
+var REACHABILITY_POLL_INTERVAL_MS = 3e4;
+/**
+* Consecutive failures required before flipping `online` to `false`.
+* ONLINE is asserted on the first success; OFFLINE waits for N misses so a
+* single transient timeout doesn't flap the flag.
+*/
+var REACHABILITY_FAILURES_TO_OFFLINE = 3;
+/** Per-probe timeout — an unreachable/hung control channel resolves as a miss. */
+var REACHABILITY_PROBE_TIMEOUT_MS = 1e4;
+/** Reject after `ms`; always clears its own timer. */
+async function withTimeout(promise, ms, label) {
+	let timer;
+	const timeout = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`${label} timed out after ${String(ms)}ms`)), ms);
+	});
+	try {
+		return await Promise.race([promise, timeout]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/**
+* Start the reachability poll loop. Returns a handle whose `stop()` clears the
+* timer and prevents any further ticks. Start on device activation, stop on
+* device teardown (`removeDevice`) so no timer leaks.
+*/
+function startReachabilityPoll(options) {
+	const intervalMs = options.intervalMs ?? 3e4;
+	const failuresToOffline = options.failuresToOffline ?? 3;
+	const probeTimeoutMs = options.probeTimeoutMs ?? 1e4;
+	const runImmediately = options.runImmediately ?? true;
+	let stopped = false;
+	let running = false;
+	let consecutiveFailures = 0;
+	let timer;
+	const tick = async () => {
+		if (stopped) return;
+		if (running) return;
+		if (options.isEnabled && !options.isEnabled()) return;
+		running = true;
+		try {
+			const reachable = await withTimeout(Promise.resolve().then(options.probe), probeTimeoutMs, "reachability probe");
+			if (stopped) return;
+			if (reachable) {
+				consecutiveFailures = 0;
+				options.setOnline(true);
+			} else registerFailure("probe resolved unreachable");
+		} catch (error) {
+			if (stopped) return;
+			registerFailure(error instanceof Error ? error.message : "probe threw");
+		} finally {
+			running = false;
+		}
+	};
+	const registerFailure = (reason) => {
+		consecutiveFailures += 1;
+		options.logger?.debug("reachability probe failed", {
+			reason,
+			consecutiveFailures,
+			failuresToOffline
+		});
+		if (consecutiveFailures >= failuresToOffline) options.setOnline(false);
+	};
+	timer = setInterval(() => {
+		tick();
+	}, intervalMs);
+	if (typeof timer === "object" && timer !== null && "unref" in timer) timer.unref();
+	if (runImmediately) tick();
+	return { stop: () => {
+		if (stopped) return;
+		stopped = true;
+		if (timer !== void 0) clearInterval(timer);
+		timer = void 0;
+	} };
+}
+//#endregion
 //#region src/notification/format-transcode.ts
 /** Strip a small, safe subset of Markdown down to plain text. */
 function markdownToText(md) {
@@ -7488,11 +7605,6 @@ var PipelineSchemaSchema = zod.z.object({
 	selectedEngine: PipelineEngineChoiceSchema,
 	slots: zod.z.array(PipelineSlotSchemaSchema).readonly()
 });
-var DetectorOutputSchema = zod.z.object({
-	detections: zod.z.array(SpatialDetectionSchema).readonly(),
-	inferenceMs: zod.z.number(),
-	modelId: zod.z.string()
-});
 var EngineProvisioningSchema = zod.z.object({
 	runtimeId: zod.z.enum([
 		"onnx",
@@ -7657,6 +7769,28 @@ var pipelineExecutorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Clear THIS node's executor-side PER-DEVICE settings stores (the
+		* per-camera step overrides the object-detection root reads via
+		* `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
+		* generated cap-router strips it (default `nodeIdMode: 'routing'`) and
+		* dispatches to that node, so the provider method runs ON the target
+		* node and receives no `nodeId`.
+		*
+		* This is the slimmed executor leg of the orchestrator's
+		* `resetNodePipelineDefaults` flow (which owns the real reset: node
+		* addonDefaults pins + per-camera orchestrator overrides). The legacy
+		* `resetToDefault` — which reset a persisted global step-tree seed
+		* nothing in the live per-camera path read — was removed together with
+		* that seed.
+		*/
+		clearDeviceOverrides: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({
+			success: zod.z.literal(true),
+			clearedDevices: zod.z.number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		getSchema: require_sleep.method(zod.z.void(), PipelineSchemaSchema),
 		getGlobalSteps: require_sleep.method(zod.z.void(), zod.z.array(PipelineDefaultStepSchema).readonly().nullable()),
 		getGlobalPipelineConfig: require_sleep.method(zod.z.void(), PipelineConfigBridge),
@@ -7698,11 +7832,6 @@ var pipelineExecutorCapability = {
 			modelId: zod.z.string(),
 			format: ModelFormatSchema$1
 		}), zod.z.object({ success: zod.z.literal(true) }), { kind: "mutation" }),
-		detect: require_sleep.method(zod.z.object({
-			addonId: zod.z.string(),
-			frame: FrameInputSchema,
-			config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-		}), DetectorOutputSchema),
 		/**
 		* Stateless single-frame execution. Callers (runner, benchmark) pass
 		* the complete `engine` + `steps` tree; the executor holds no state
@@ -12426,6 +12555,7 @@ function createSystemProxy(api) {
 			getEngineProvisioning: (input) => dispatch("pipelineExecutor", "getEngineProvisioning", "query", input),
 			getVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "getVideoPipelineSteps", "query", input),
 			setVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "setVideoPipelineSteps", "mutation", input),
+			clearDeviceOverrides: (input) => dispatch("pipelineExecutor", "clearDeviceOverrides", "mutation", input),
 			getSchema: (input) => dispatch("pipelineExecutor", "getSchema", "query", input),
 			getGlobalSteps: (input) => dispatch("pipelineExecutor", "getGlobalSteps", "query", input),
 			getGlobalPipelineConfig: (input) => dispatch("pipelineExecutor", "getGlobalPipelineConfig", "query", input),
@@ -12439,7 +12569,6 @@ function createSystemProxy(api) {
 			getAddonModels: (input) => dispatch("pipelineExecutor", "getAddonModels", "query", input),
 			downloadModel: (input) => dispatch("pipelineExecutor", "downloadModel", "mutation", input),
 			deleteModel: (input) => dispatch("pipelineExecutor", "deleteModel", "mutation", input),
-			detect: (input) => dispatch("pipelineExecutor", "detect", "query", input),
 			cacheFrameInPool: (input) => dispatch("pipelineExecutor", "cacheFrameInPool", "mutation", input),
 			inferCached: (input) => dispatch("pipelineExecutor", "inferCached", "mutation", input),
 			uncacheFrame: (input) => dispatch("pipelineExecutor", "uncacheFrame", "mutation", input),
@@ -12463,7 +12592,6 @@ function createSystemProxy(api) {
 			getCapabilityBindings: (input) => dispatch("pipelineOrchestrator", "getCapabilityBindings", "query", input),
 			setCapabilityBinding: (input) => dispatch("pipelineOrchestrator", "setCapabilityBinding", "mutation", input),
 			getIngestOwner: (input) => dispatch("pipelineOrchestrator", "getIngestOwner", "query", input),
-			getDecoderAssignments: (input) => dispatch("pipelineOrchestrator", "getDecoderAssignments", "query", input),
 			getAudioNodeLoad: (input) => dispatch("pipelineOrchestrator", "getAudioNodeLoad", "query", input),
 			getAgentSettings: (input) => dispatch("pipelineOrchestrator", "getAgentSettings", "query", input),
 			listAgentSettings: (input) => dispatch("pipelineOrchestrator", "listAgentSettings", "query", input),
@@ -12473,6 +12601,7 @@ function createSystemProxy(api) {
 			setAgentDetectWeight: (input) => dispatch("pipelineOrchestrator", "setAgentDetectWeight", "mutation", input),
 			setAgentCapabilities: (input) => dispatch("pipelineOrchestrator", "setAgentCapabilities", "mutation", input),
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
+			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
 			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			listTemplates: (input) => dispatch("pipelineOrchestrator", "listTemplates", "query", input),
 			saveTemplate: (input) => dispatch("pipelineOrchestrator", "saveTemplate", "mutation", input),
@@ -13258,7 +13387,9 @@ var AddonPageDeclarationSchema$1 = zod.z.object({
 	icon: zod.z.string(),
 	path: zod.z.string(),
 	remoteName: zod.z.string(),
-	bundle: zod.z.string()
+	bundle: zod.z.string(),
+	section: zod.z.string().optional(),
+	sectionLabel: zod.z.string().optional()
 });
 var AddonPageInfoSchema = zod.z.object({
 	addonId: zod.z.string(),
@@ -13305,7 +13436,18 @@ var AddonPageDeclarationSchema = zod.z.object({
 	* the static-file route can compute an mtime-based cache-buster URL
 	* without a separate filesystem stat.
 	*/
-	bundle: zod.z.string()
+	bundle: zod.z.string(),
+	/**
+	* Sidebar section this page docks into. Well-known ids: `'detection'`,
+	* `'cluster'`, `'administration'` — the page renders inside that group.
+	* Any OTHER string creates (or joins) a custom section rendered after
+	* the built-in groups; its label comes from `sectionLabel` (first
+	* declaration wins), falling back to the id. Absent → the legacy
+	* "Addon Pages" group.
+	*/
+	section: zod.z.string().optional(),
+	/** Display label for a CUSTOM `section` id (ignored for well-known ids). */
+	sectionLabel: zod.z.string().optional()
 });
 var addonPagesSourceCapability = {
 	name: "addon-pages-source",
@@ -17461,7 +17603,12 @@ var AgentPipelineSettingsSchema = zod.z.object({
 	detectWeight: zod.z.number().positive().optional(),
 	/** Node is eligible to run the detection pipeline (decode + inference). */
 	detect: zod.z.boolean().optional(),
-	/** Node is eligible to host decoder sessions. */
+	/**
+	* DEPRECATED AND IGNORED. Decode is always co-located with its frame
+	* consumer, so decode eligibility IS detect eligibility. Kept optional in
+	* the schema ONLY so persisted stores written before the removal still
+	* parse — no code reads it and no write path emits it.
+	*/
 	decode: zod.z.boolean().optional(),
 	/** Node is eligible to run audio-analyzer sessions. */
 	audio: zod.z.boolean().optional(),
@@ -17522,25 +17669,6 @@ var PipelineAssignmentSchema = zod.z.object({
 	assignedAt: zod.z.number()
 });
 /**
-* Decoder placement record. Symmetric to `PipelineAssignmentSchema` but for
-* the decoder-node placement domain (`balanceDecoder` decision: manual pin
-* → co-located with pipeline → capacity).
-*/
-var DecoderAssignmentSchema = zod.z.object({
-	deviceId: zod.z.number(),
-	/** Moleculer node id of the decoder provider currently responsible for this camera. */
-	decoderNodeId: zod.z.string(),
-	/** True when the assignment was set manually via `assignDecoder`, false when chosen by the balancer. */
-	pinned: zod.z.boolean(),
-	/** Why this assignment was made — useful for debugging the decoder balancer. */
-	reason: zod.z.enum([
-		"manual",
-		"co-located",
-		"capacity",
-		"hardware-affinity"
-	])
-});
-/**
 * Per-agent load summary surfaced to the load balancer + dashboards.
 * Aggregated from each runner's `getLocalLoad` cap call.
 */
@@ -17827,21 +17955,6 @@ var pipelineOrchestratorCapability = {
 		* present. Defaults to `{ ownerNodeId: 'hub' }`.
 		*/
 		getIngestOwner: require_sleep.method(zod.z.void(), IngestOwnerSchema),
-		/** Pin a device's decoder to a specific node. */
-		assignDecoder: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			nodeId: zod.z.string()
-		}), zod.z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Clear a device's decoder pin (revert to auto). */
-		unassignDecoder: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Get every camera's decoder placement. */
-		getDecoderAssignments: require_sleep.method(zod.z.void(), zod.z.array(DecoderAssignmentSchema).readonly()),
 		/** Pin a device's audio analysis to a specific cluster node. */
 		assignAudio: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
@@ -17873,23 +17986,6 @@ var pipelineOrchestratorCapability = {
 			pinned: zod.z.boolean(),
 			assignedAt: zod.z.number()
 		}))),
-		/**
-		* Get one camera's decoder placement (computed if not yet pinned).
-		*
-		* ADVISORY today: reports the orchestrator's decoder preference only.
-		* Actual decode placement is broker-owned (local-node pin + frame-plane
-		* co-location guard). Reserved to become the binding source/decoder-owner
-		* control in the stream-LB epic (Phase 2).
-		*
-		* `pipelineNodeId` is the node already chosen to run inference for
-		* this camera. When provided, the balancer prefers co-location with
-		* it; omitted → falls back to the last known assignment in the
-		* `assignments` map and finally to 'hub'.
-		*/
-		getDecoderAssignment: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			pipelineNodeId: zod.z.string().optional()
-		}), DecoderAssignmentSchema),
 		/** Read one agent's settings. Null when not yet seeded. */
 		getAgentSettings: require_sleep.method(zod.z.object({ agentNodeId: zod.z.string() }), AgentPipelineSettingsSchema.nullable()),
 		/** Enumerate every agent's settings (hub + remote runners). */
@@ -17959,14 +18055,15 @@ var pipelineOrchestratorCapability = {
 		* `enabledDecoderNodes`, `enabledAudioNodes`, `remoteSourcingNodes`).
 		* Each flag is optional in the patch: omit a flag to leave it unchanged,
 		* pass `null` to reset it to the node default (`hub` → capable, every
-		* other node → not). Detection/decode/audio eligibility is derived from
-		* these flags across the cluster; changing them re-derives the enabled
-		* sets and reconciles dispatch immediately.
+		* other node → not). Detection/audio eligibility is derived from these
+		* flags across the cluster; changing them re-derives the enabled sets
+		* and reconciles dispatch immediately. There is NO separate decode flag:
+		* decode is always co-located with its frame consumer, so decode
+		* eligibility IS detect eligibility.
 		*/
 		setAgentCapabilities: require_sleep.method(zod.z.object({
 			agentNodeId: zod.z.string(),
 			detect: zod.z.boolean().nullable().optional(),
-			decode: zod.z.boolean().nullable().optional(),
 			audio: zod.z.boolean().nullable().optional(),
 			ingest: zod.z.boolean().nullable().optional()
 		}), zod.z.object({ success: zod.z.literal(true) }), {
@@ -17989,6 +18086,34 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Reset one node's pipeline to its hardware-aware defaults — the HONEST
+		* reset (replaces the executor's legacy `resetToDefault`, which cleared a
+		* dead persisted step-tree seed nothing in the live path read):
+		*   (a) strips every `modelId` pin from that node's
+		*       `agentSettings.addonDefaults` (cells revert to Auto — the node
+		*       resolves its own hardware-aware format default at runtime);
+		*   (b) clears per-camera step overrides scoped to that node
+		*       (`stepOverridesByAgent[node]` + the wholesale
+		*       `pipelineByAgent[node]` escape hatch);
+		*   (c) clears the executor-side per-device settings stores on that node
+		*       (`pipelineExecutor.clearDeviceOverrides`);
+		*   (d) hot-reloads every camera assigned to the node.
+		*
+		* Returns the EFFECTIVE post-reset object-detection model for the node
+		* (the executor's pure hardware-aware default) so the UI can report what
+		* will actually run — not a value that never reaches the live path.
+		*/
+		resetNodePipelineDefaults: require_sleep.method(zod.z.object({ agentNodeId: zod.z.string() }), zod.z.object({
+			success: zod.z.literal(true),
+			/** Hardware-aware default detection model now in effect on the node (null when unresolvable). */
+			effectiveModelId: zod.z.string().nullable(),
+			/** Number of cameras whose node-scoped overrides were cleared. */
+			clearedCameraOverrides: zod.z.number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), CameraPipelineSettingsSchema.nullable()),
 		/** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
@@ -25960,23 +26085,23 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineExecutor.deleteModel": {
+	"pipelineExecutor.clearDeviceOverrides": {
 		capName: "pipeline-executor",
 		capScope: "system",
 		addonId: null,
 		access: "delete"
 	},
-	"pipelineExecutor.deleteTemplate": {
+	"pipelineExecutor.deleteModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
 		addonId: null,
 		access: "delete"
 	},
-	"pipelineExecutor.detect": {
+	"pipelineExecutor.deleteTemplate": {
 		capName: "pipeline-executor",
 		capScope: "system",
 		addonId: null,
-		access: "view"
+		access: "delete"
 	},
 	"pipelineExecutor.downloadModel": {
 		capName: "pipeline-executor",
@@ -26182,12 +26307,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.assignDecoder": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.assignPipeline": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -26266,18 +26385,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.getDecoderAssignment": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"pipelineOrchestrator.getDecoderAssignments": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineOrchestrator.getGlobalMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -26326,6 +26433,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineOrchestrator.resetNodePipelineDefaults": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineOrchestrator.resolvePipeline": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -26398,12 +26511,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.unassignDecoder": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.unassignPipeline": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -28665,12 +28772,10 @@ exports.DayNightSettingsPatchSchema = DayNightSettingsPatchSchema;
 exports.DayNightStatusSchema = DayNightStatusSchema;
 exports.DecodedAudioChunkSchema = require_sleep.DecodedAudioChunkSchema;
 exports.DecodedFrameSchema = require_sleep.DecodedFrameSchema;
-exports.DecoderAssignmentSchema = DecoderAssignmentSchema;
 exports.DecoderSessionConfigSchema = DecoderSessionConfigSchema;
 exports.DecoderStatsSchema = DecoderStatsSchema;
 exports.DeleteIntegrationResultSchema = DeleteIntegrationResultSchema;
 exports.DetectionSourceSchema = DetectionSourceSchema;
-exports.DetectorOutputSchema = DetectorOutputSchema;
 exports.DeviceCodeSeveritySchema = DeviceCodeSeveritySchema;
 exports.DeviceConfig = DeviceConfig;
 exports.DeviceDiscoveryStatusSchema = DeviceDiscoveryStatusSchema;
@@ -28874,6 +28979,9 @@ exports.PtzPositionSchema = PtzPositionSchema;
 exports.PtzPresetSchema = PtzPresetSchema;
 exports.PtzStatusSchema = PtzStatusSchema;
 exports.QueryFilterSchema = QueryFilterSchema;
+exports.REACHABILITY_FAILURES_TO_OFFLINE = REACHABILITY_FAILURES_TO_OFFLINE;
+exports.REACHABILITY_POLL_INTERVAL_MS = REACHABILITY_POLL_INTERVAL_MS;
+exports.REACHABILITY_PROBE_TIMEOUT_MS = REACHABILITY_PROBE_TIMEOUT_MS;
 exports.RECOGNITION_TYPES = RECOGNITION_TYPES;
 exports.RESERVED_BINDING_NAMES = RESERVED_BINDING_NAMES;
 exports.RUNTIME_DEFAULTS = RUNTIME_DEFAULTS;
@@ -29254,6 +29362,7 @@ exports.smokeCapability = smokeCapability;
 exports.smtpProviderCapability = smtpProviderCapability;
 exports.snapshotCapability = snapshotCapability;
 exports.ssoBridgeCapability = ssoBridgeCapability;
+exports.startReachabilityPoll = startReachabilityPoll;
 exports.storageCapability = storageCapability;
 exports.storageEvictableCapability = storageEvictableCapability;
 exports.storageProviderCapability = storageProviderCapability;