@camstack/addon-pipeline 1.2.341 → 1.2.342

package/dist/{dist-PiNPe8uQ.js → dist-w_gA9z8W.js}

@@ -5379,7 +5379,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-C16NCZR2.mjs
+//#region ../types/dist/sleep-DAJ9Er57.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -7356,26 +7356,6 @@ var BOOT_RECOVERY_BACKOFF_MS = [
 	90 * 6e4
 ];
 /**
-* Type-safe JSON parsing helpers.
-*
-* `JSON.parse` is typed as `any` in lib.es5.d.ts, which triggers
-* `no-unsafe-*` ESLint rules and destroys downstream inference. These
-* wrappers return `unknown` — callers narrow structurally via type
-* guards, `typeof` checks, or helpers like `asRecord`/`asString`.
-*/
-/**
-* Parse JSON and return it as `unknown` — the only entry point for untrusted JSON.
-*
-* The optional generic overload `parseJsonUnknown<T>(text)` returns `T` for
-* call sites that know the shape at parse time (e.g. MQTT payloads with a
-* known protocol schema). This is a **type-level bridge only** — no runtime
-* validation is performed. Callers that need runtime validation should parse
-* as `unknown` and narrow via Zod or structural guards.
-*/
-function parseJsonUnknown(text) {
-	return JSON.parse(text);
-}
-/**
 * Promise-based timer helpers — used everywhere the codebase needs to
 * wait, back off, or schedule a retry. Before these helpers landed, each
 * call site re-implemented `new Promise(r => setTimeout(r, ms))` inline,
@@ -26630,21 +26610,6 @@ var PipelineDefaultStepSchema = lazy(() => object({
 	group: string().optional(),
 	settings: record(string(), unknown()).optional()
 }));
-var PipelineTemplateStepSchema = lazy(() => object({
-	addonId: string(),
-	enabled: boolean(),
-	modelId: string(),
-	children: array(PipelineTemplateStepSchema).readonly(),
-	settings: record(string(), unknown()).optional()
-}));
-var PipelineTemplateSchema$1 = object({
-	id: string(),
-	name: string(),
-	createdAt: string(),
-	updatedAt: string(),
-	engine: PipelineEngineChoiceSchema,
-	steps: array(PipelineTemplateStepSchema).readonly()
-});
 var PipelineModelOptionSchema = object({
 	id: string(),
 	name: string(),
@@ -26966,18 +26931,6 @@ var pipelineExecutorCapability = {
 			steps: array(PipelineStepInputSchema),
 			deviceKey: string().optional()
 		}), PipelineValidationResultSchema),
-		listTemplates: method(_void(), array(PipelineTemplateSchema$1).readonly()),
-		saveTemplate: method(object({
-			name: string(),
-			steps: array(PipelineTemplateStepSchema).readonly(),
-			engine: PipelineEngineChoiceSchema
-		}), PipelineTemplateSchema$1, { kind: "mutation" }),
-		updateTemplate: method(object({
-			id: string(),
-			name: string().optional(),
-			steps: array(PipelineTemplateStepSchema).readonly().optional()
-		}), PipelineTemplateSchema$1, { kind: "mutation" }),
-		deleteTemplate: method(object({ id: string() }), _void(), { kind: "mutation" }),
 		getCapabilities: method(_void(), InferenceCapabilitiesBridge),
 		getAddonModels: method(object({ addonId: string() }), ModelAvailabilityListBridge),
 		downloadModel: method(object({
@@ -27235,148 +27188,17 @@ var pipelineExecutorCapability = {
 	}
 };
 /**
-* Wire shapes of the Load balancing surface (D748): the session placement
-* policy, the atomic share write, the observed placement statistics, the
-* hardware share suggestion and the stale device pins.
-*/
-/**
-* How a new detection session picks its node and device.
-*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
-*    constant node order at a tie (D37). An idle node always ties at 0, so a
-*    weight only bites once a node already holds a session.
-*  - `share` — the share of PARALLEL sessions is held to the weights, and a
-*    full or drowning node yields to a free one (D748).
-*/
-var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
-var LoadBalancingSharesInputSchema = object({
-	/** nodeId → share (> 0). A node left out keeps its weight. */
-	nodes: record(string(), number().positive()).default({}),
-	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
-	devices: record(string(), record(string(), number().positive())).default({})
-});
-var PlacementStatsInputSchema = object({ 
-/** Window the observed shares are averaged over (default 1 h, max 24 h). */
-windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
-var PlacementDeviceStatsSchema = object({
-	deviceKey: string(),
-	/** Sessions running on this device now. */
-	sessionsNow: number(),
-	/** Sessions started on this device inside the window. */
-	sessionsStarted: number(),
-	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
-	observedShare: number().nullable()
-});
-var PlacementNodeStatsSchema = object({
-	nodeId: string(),
-	sessionsNow: number(),
-	sessionsStarted: number(),
-	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
-	observedShare: number().nullable(),
-	/** Most sessions this node ran at once inside the window. */
-	peakSessions: number(),
-	/** Sessions a share election handed elsewhere because this node was full or drowning. */
-	yieldsAway: number(),
-	devices: array(PlacementDeviceStatsSchema).readonly()
-});
-/** A camera's device pin that the session path cannot honour. */
-var StaleDevicePinSchema = object({
-	deviceId: number(),
-	deviceKey: string(),
-	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
-	reason: _enum(["disabled", "absent"])
-});
-var PlacementStatsSchema = object({
-	policy: SessionPlacementPolicySchema,
-	windowMs: number(),
-	/** How much of the window was actually observed (the hub keeps it in memory). */
-	observedForMs: number(),
-	sessionsNow: number(),
-	/** Most parallel sessions across the cluster inside the window. */
-	clusterPeakSessions: number(),
-	nodes: array(PlacementNodeStatsSchema).readonly(),
-	stalePins: array(StaleDevicePinSchema).readonly()
-});
-var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
-var SuggestedDeviceShareSchema = object({
-	deviceKey: string(),
-	/** Share of the node (0–100, rounded). */
-	share: number(),
-	modelId: string().nullable(),
-	/** Inferences per second at that model, from the measured table. */
-	fps: number().nullable(),
-	measured: boolean(),
-	/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
-	suggestedMaxSessions: number().nullable()
-});
-var SuggestedNodeShareSchema = object({
-	nodeId: string(),
-	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
-	share: number().nullable(),
-	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
-	capacitySessions: number(),
-	devices: array(SuggestedDeviceShareSchema).readonly(),
-	skippedReason: string().nullable()
-});
-var SuggestSharesResultSchema = object({
-	headroom: number(),
-	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
-	cameraFps: number(),
-	/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
-	iterations: number(),
-	nodes: array(SuggestedNodeShareSchema).readonly()
-});
-/**
-* Where the node and device shares come from (D750).
-*  - `auto` — computed by the system from the cluster's measured capacity at
-*    the Auto tune models, and recomputed whenever a node or device joins,
-*    leaves, is switched on or off, or changes model.
-*  - `manual` — the operator's stored sliders. A node or device that cannot
-*    take sessions gives its share to the others in proportion; the stored
-*    values are never rewritten for that.
-*/
-var ShareSourceSchema = _enum(["auto", "manual"]);
-var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
-object({
-	nodes: record(string(), number()),
-	devices: record(string(), record(string(), number()))
-});
-var EffectiveDeviceShareSchema = object({
-	deviceKey: string(),
-	/** Can take sessions now (enabled, available, can run the root). */
-	eligible: boolean(),
-	/** The share the source assigns, as a percentage of the node's devices. */
-	configuredPct: number(),
-	/** The share actually used, after an ineligible device's share went to the others. */
-	effectivePct: number()
-});
-var EffectiveNodeShareSchema = object({
-	nodeId: string(),
-	eligible: boolean(),
-	configuredPct: number(),
-	effectivePct: number(),
-	devices: array(EffectiveDeviceShareSchema).readonly()
-});
-var EffectiveSharesSchema = object({
-	source: ShareSourceSchema,
-	policy: SessionPlacementPolicySchema,
-	/** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
-	autoPending: boolean(),
-	/** When the automatic shares were last computed (ms epoch); null = never. */
-	computedAt: number().nullable(),
-	/** What made the system recompute them last. */
-	trigger: string().nullable(),
-	nodes: array(EffectiveNodeShareSchema).readonly(),
-	/** The relative weights the election reads (before eligibility). */
-	nodeWeights: record(string(), number()),
-	deviceWeights: record(string(), record(string(), number()))
-});
-/**
 * The wire shapes of the Auto tune plan and apply (D745), used by the
 * `pipeline-orchestrator` cap. The recommender's own types
-* (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
+* (`recommend.ts`) are the TS face of the same data; these
 * schemas are what crosses the cap boundary.
 */
 var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
+/** The operator's range for it. */
+var MIN_SESSIONS_PER_DEVICE_RANGE = {
+	min: 1,
+	max: 8
+};
 var HardwareClassIdSchema = _enum([
 	"intel-core-ultra",
 	"intel-n-series",
@@ -27394,8 +27216,9 @@ var AcceleratorKindSchema = _enum([
 ]);
 var RecommendationReasonSchema = discriminatedUnion("kind", [
 	object({
-		kind: literal("fits"),
-		utilisation: number()
+		kind: literal("capacity"),
+		sessions: number(),
+		minSessions: number()
 	}),
 	object({
 		kind: literal("tie-faster"),
@@ -27410,16 +27233,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 	}),
 	object({
 		kind: literal("no-fit-lightest"),
-		utilisation: number()
+		sessions: number(),
+		minSessions: number()
 	}),
 	object({
 		kind: literal("derived-latency"),
 		modelId: string()
 	}),
-	object({
-		kind: literal("estimated-load"),
-		observedForMs: number().nullable()
-	}),
 	object({ kind: literal("cpu-device") }),
 	object({ kind: literal("coral-untouched") }),
 	object({ kind: literal("device-disabled") }),
@@ -27435,28 +27255,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 		format: ModelFormatSchema$1
 	})
 ]);
-var DeviceDemandSchema = object({
-	nodeId: string(),
-	deviceKey: string(),
-	demandFps: number(),
-	maxCameraFps: number(),
-	alwaysOnCameras: number(),
-	onMotionSessions: number(),
-	onMotionSource: _enum([
-		"observed-24h",
-		"estimate",
-		"none"
-	]),
-	observedForMs: number().nullable(),
-	/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
-	placement: SessionPlacementPolicySchema
-});
 var DeviceModelChoiceSchema = object({
 	modelId: string(),
 	p50Ms: number(),
 	fps: number(),
 	measured: boolean(),
-	utilisation: number(),
+	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
+	capacitySessions: number(),
 	personRecall: number()
 });
 var DeviceRecommendationSchema = object({
@@ -27464,7 +27269,6 @@ var DeviceRecommendationSchema = object({
 	accelerator: AcceleratorKindSchema.nullable(),
 	enabled: boolean(),
 	available: boolean(),
-	demand: DeviceDemandSchema.nullable(),
 	chosen: DeviceModelChoiceSchema.nullable(),
 	reasons: array(RecommendationReasonSchema).readonly()
 });
@@ -27525,20 +27329,20 @@ var AutoTuneOptionsSchema = object({
 	/** Share of each accelerator's throughput kept free (0.3–0.5). */
 	headroom: number().min(.3).max(.5).default(.4),
 	/**
-	* What-if shares (D748): plan as if these node/device shares were stored
-	* and the policy were `share`. Absent = the stored shares under the stored
-	* policy. A what-if plan is for display; apply always re-plans from what
-	* is stored.
+	* The least number of parallel sessions every device must sustain at the
+	* camera rate with the headroom kept free (D755). The most accurate model
+	* that reaches it wins.
 	*/
-	shares: LoadBalancingSharesInputSchema.optional()
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
 var AutoTunePlanSchema = object({
 	/** Hash of everything the apply will write — the apply refuses a different one. */
 	planHash: string(),
 	family: literal("yolov9"),
 	headroom: number(),
-	/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
-	whatIf: boolean(),
+	minSessionsPerDevice: number(),
+	/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
+	cameraFps: number(),
 	generatedAt: number(),
 	nodes: array(NodeRecommendationSchema).readonly(),
 	nodeChanges: array(NodeDeviceChangeSchema).readonly(),
@@ -27548,7 +27352,8 @@ var AutoTunePlanSchema = object({
 });
 var AutoTuneApplyInputSchema = object({
 	planHash: string(),
-	headroom: number().min(.3).max(.5).default(.4)
+	headroom: number().min(.3).max(.5).default(.4),
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
 var AutoTunePhaseResultSchema = object({
 	phase: _enum([
@@ -27580,6 +27385,177 @@ var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
 		reason: _enum(["apply-in-progress"])
 	})
 ]);
+/**
+* Wire shapes of the Load balancing surface (D748): the session placement
+* policy, the atomic share write, the observed placement statistics, the
+* hardware share suggestion and the stale device pins.
+*/
+/**
+* How a new detection session picks its node and device.
+*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
+*    constant node order at a tie (D37). An idle node always ties at 0, so a
+*    weight only bites once a node already holds a session.
+*  - `share` — the share of PARALLEL sessions is held to the weights, and a
+*    full or drowning node yields to a free one (D748).
+*/
+var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
+var LoadBalancingSharesInputSchema = object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: record(string(), number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: record(string(), record(string(), number().positive())).default({})
+});
+var PlacementStatsInputSchema = object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = object({
+	deviceKey: string(),
+	/** Sessions running on this device now. */
+	sessionsNow: number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: number().nullable()
+});
+var PlacementNodeStatsSchema = object({
+	nodeId: string(),
+	sessionsNow: number(),
+	sessionsStarted: number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: number(),
+	devices: array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = object({
+	deviceId: number(),
+	deviceKey: string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: _enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: number(),
+	sessionsNow: number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: number(),
+	nodes: array(PlacementNodeStatsSchema).readonly(),
+	stalePins: array(StaleDevicePinSchema).readonly()
+});
+/**
+* Where an automatic share's capacity comes from (D755).
+*  - `hardware` — the static capacity of each device at its Auto tune model:
+*    the measured latency table for the node's hardware class.
+*  - `benchmark` — the node's own measured capacity (node benchmark results).
+*    A node with no results falls back to `hardware`, and says so.
+*/
+var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
+/** Why a node under the `benchmark` source was sized from hardware instead. */
+var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
+var SuggestSharesInputSchema = object({
+	headroom: number().min(.3).max(.5).default(.4),
+	/** Default `hardware`. */
+	source: CapacitySourceSchema.default("hardware")
+});
+var SuggestedDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Share of the node (0–100, rounded). */
+	share: number(),
+	modelId: string().nullable(),
+	/** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
+	fps: number().nullable(),
+	/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
+	measured: boolean(),
+	/**
+	* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
+	* or the benchmark's measured max sessions. Never enforced.
+	*/
+	suggestedMaxSessions: number().nullable()
+});
+var SuggestedNodeShareSchema = object({
+	nodeId: string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: number(),
+	devices: array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: string().nullable(),
+	/** What this node's capacity was read from; null when the node is skipped. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Set when the `benchmark` source was asked for and this node used `hardware`. */
+	capacityFallback: CapacityFallbackSchema.nullable()
+});
+var SuggestSharesResultSchema = object({
+	headroom: number(),
+	/** The source asked for; each node says what it actually used. */
+	source: CapacitySourceSchema,
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: number(),
+	/** The Auto tune capacity floor the models were picked at. */
+	minSessionsPerDevice: number(),
+	nodes: array(SuggestedNodeShareSchema).readonly()
+});
+/**
+* Where the node and device shares come from (D750, D755).
+*  - `hardware` (default) — computed by the system from each node's static
+*    capacity (its accelerators at their Auto tune models, from the measured
+*    latency table), recomputed whenever a node or device joins, leaves, is
+*    switched on or off, or changes model. No load input.
+*  - `benchmark` — the same, from each node's measured capacity (node
+*    benchmark results); a node without results falls back to `hardware`.
+*  - `manual` — the operator's stored sliders.
+* Either way a node or device that cannot take sessions gives its share to
+* the others in proportion; the stored values are never rewritten for that.
+*/
+var ShareSourceSchema = _enum([
+	"hardware",
+	"benchmark",
+	"manual"
+]);
+var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
+object({
+	nodes: record(string(), number()),
+	devices: record(string(), record(string(), number()))
+});
+var EffectiveDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Can take sessions now (enabled, available, can run the root). */
+	eligible: boolean(),
+	/** The share the source assigns, as a percentage of the node's devices. */
+	configuredPct: number(),
+	/** The share actually used, after an ineligible device's share went to the others. */
+	effectivePct: number()
+});
+var EffectiveNodeShareSchema = object({
+	nodeId: string(),
+	eligible: boolean(),
+	configuredPct: number(),
+	effectivePct: number(),
+	/** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Automatic `benchmark`: why this node used `hardware` instead. */
+	capacityFallback: CapacityFallbackSchema.nullable(),
+	devices: array(EffectiveDeviceShareSchema).readonly()
+});
+var EffectiveSharesSchema = object({
+	source: ShareSourceSchema,
+	policy: SessionPlacementPolicySchema,
+	/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
+	autoPending: boolean(),
+	/** When the automatic shares were last computed (ms epoch); null = never. */
+	computedAt: number().nullable(),
+	/** What made the system recompute them last. */
+	trigger: string().nullable(),
+	nodes: array(EffectiveNodeShareSchema).readonly(),
+	/** The relative weights the election reads (before eligibility). */
+	nodeWeights: record(string(), number()),
+	deviceWeights: record(string(), record(string(), number()))
+});
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -28870,14 +28846,6 @@ var CameraPipelineConfigSchema = object({
 		settings: record(string(), unknown()).readonly().optional()
 	}).nullable().optional()
 });
-var PipelineTemplateSchema = object({
-	id: string(),
-	name: string(),
-	description: string().optional(),
-	config: CameraPipelineConfigSchema,
-	createdAt: string(),
-	updatedAt: string()
-});
 var DeviceStepConfigSchema = object({
 	modelId: string().optional(),
 	settings: record(string(), unknown()).optional(),
@@ -28951,8 +28919,10 @@ var CameraStepOverridePatchSchema = object({
 	modelId: string().optional(),
 	settings: record(string(), unknown()).readonly().optional()
 });
+var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
 var CameraPipelineSettingsSchema = object({
 	stepToggles: record(string(), boolean()).optional(),
+	stepSettings: CameraStepSettingsSchema.optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
 });
@@ -29080,20 +29050,15 @@ var CameraBrokerStatusSchema = object({
 	webrtcSessions: number(),
 	rtspRestream: boolean()
 });
-/** Shared-memory ring statistics within the decoder block. */
-var CameraDecoderShmSchema = object({
-	framesWritten: number(),
-	getFrameHits: number(),
-	getFrameMisses: number(),
-	budgetMb: number()
-});
-/** Decoder block — null when the decoder stage is unreachable or inactive. */
-var CameraDecoderStatusSchema = object({
-	nodeId: string(),
-	formats: array(string()).readonly(),
-	sessionCount: number(),
-	shm: CameraDecoderShmSchema
-});
+/**
+* Decoder block — WHERE decode runs (co-located with the detection node by
+* construction); null when the camera has no detection node. It carries no
+* frame counter: the shared-memory plane whose counters it used to serve is
+* gone, and those fields read 0 forever. Whether frames actually flow is read
+* from `detection.actualFps` (frames delivered to and processed by the
+* detector), never from a counter nothing feeds.
+*/
+var CameraDecoderStatusSchema = object({ nodeId: string() });
 /** Motion block — null when motion detection is not active for this device. */
 var CameraMotionStatusSchema = object({
 	enabled: boolean(),
@@ -29516,6 +29481,13 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	addonId: string(),
+	settings: record(string(), unknown()).nullable()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	deviceId: number(),
 	agentNodeId: string(),
@@ -29539,25 +29511,7 @@ method(object({
 }), method(_void(), DiskReconcileJobSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), DiskReconcileJobSchema, { auth: "admin" }), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
-	name: string(),
-	description: string().optional(),
-	config: CameraPipelineConfigSchema
-}), PipelineTemplateSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	id: string(),
-	name: string().optional(),
-	description: string().optional(),
-	config: CameraPipelineConfigSchema.optional()
-}), PipelineTemplateSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ id: string() }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-});
+}), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
 /**
 * Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
 * `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
@@ -46123,12 +46077,6 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
-	"pipelineExecutor.deleteTemplate": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "delete"
-	},
 	"pipelineExecutor.downloadModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -46267,12 +46215,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineExecutor.listTemplates": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineExecutor.rearmInferenceDevice": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -46297,12 +46239,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineExecutor.saveTemplate": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineExecutor.setVideoPipelineSteps": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -46321,12 +46257,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineExecutor.updateTemplate": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineExecutor.validatePipeline": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -46357,12 +46287,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.deleteTemplate": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "delete"
-	},
 	"pipelineOrchestrator.getAgentLoad": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46513,12 +46437,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.listTemplates": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineOrchestrator.pauseForStorageMigration": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46573,12 +46491,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.saveTemplate": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentCapabilities": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46627,6 +46539,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setCameraStepSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setCameraStepToggle": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46681,12 +46599,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.updateTemplate": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineRunner.attachCamera": {
 		capName: "pipeline-runner",
 		capScope: "system",
@@ -52075,6 +51987,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraStepSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraStepToggle": [{
 		name: "deviceId",
 		form: "single",
@@ -55938,12 +55855,6 @@ Object.defineProperty(exports, "overlayClusterStepSettings", {
 		return overlayClusterStepSettings;
 	}
 });
-Object.defineProperty(exports, "parseJsonUnknown", {
-	enumerable: true,
-	get: function() {
-		return parseJsonUnknown;
-	}
-});
 Object.defineProperty(exports, "parseProcStatus", {
 	enumerable: true,
 	get: function() {