@camstack/types 1.2.40 → 1.2.42

package/dist/node.mjs

@@ -1,12 +1,13 @@
+import { t as canonicalHash } from "./canonical-hash-7nfBbEqR.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import { chmodSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import { basename, join } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
+import { execFileSync, spawn } from "node:child_process";
 //#region src/deps/binary-downloader.ts
 /**
 * Recursively find the first file named exactly `name` under `dir`. Used as the
@@ -577,39 +578,6 @@ var FilesystemStorageProvider = class {
 	}
 };
 //#endregion
-//#region src/utils/canonical-hash.ts
-/**
-* Deterministic SHA-256 hash of an arbitrary serialisable value. The
-* canonical form sorts object keys alphabetically at every depth so two
-* structurally-equal inputs with different key insertion orders produce
-* the same hash. Returns a 64-char lowercase hex digest.
-*
-* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
-* accessory-rebuild work when the upstream shape is byte-identical to
-* the last applied state — preventing user-visible "re-discovery"
-* notifications on every addon-runner respawn. Each respawn re-fires
-* `DeviceBindingsChanged` for every cap registration, which without
-* this guard would propagate redundant pushes.
-*
-* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
-* subscription. The proper fix is a single "device ready" lifecycle
-* barrier so exports react only when the full cap set has landed —
-* tracked separately for post-HA-integration work.
-*/
-function canonicalHash(value) {
-	const canonical = JSON.stringify(value, replaceWithSortedKeys);
-	return createHash("sha256").update(canonical ?? "").digest("hex");
-}
-function replaceWithSortedKeys(_key, value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const obj = value;
-		const out = {};
-		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
-		return out;
-	}
-	return value;
-}
-//#endregion
 //#region src/utils/export-reconciler.ts
 /**
 * Compute the stable 64-char lowercase-hex fingerprint of a device's
@@ -666,4 +634,269 @@ function resolveExportFingerprint(input) {
 	return input.persisted ?? input.fresh;
 }
 //#endregion
-export { FilesystemStorageProvider, PYTHON_VERSION, buildBinaryPath, canonicalDeviceFingerprint, canonicalHash, diffExportTargets, downloadBinary, ensureBinary, ensureFfmpeg, ensurePython, findInPath, getFfmpegDownloadUrl, getPlatformInfo, getPythonDownloadUrl, installPythonPackages, installPythonRequirements, resolveExportFingerprint };
+//#region src/ffmpeg/process.ts
+/**
+* `FfmpegProcess` — the ONE spawn/lifecycle wrapper for a live-media ffmpeg.
+*
+* Extracted from `TranscodeEgress.spawnAttempt`, which was already the most
+* complete of the repo's hand-rolled lifecycles: first-data deadline, hardware
+* →software retry, SIGTERM-then-SIGKILL. This generalises it and adds the two
+* things every copy was missing — a `tags: { deviceId }` on every line, and a
+* bounded restart — so a consumer gets them by construction instead of by
+* remembering.
+*
+* ## What it owns
+*
+* - spawn, with the argv from the ONE builder (`./invocation.js`);
+* - a FIRST-DATA deadline: an ffmpeg that starts but never emits is dead, and
+*   nothing downstream can tell that apart from a slow camera;
+* - HARDWARE→SOFTWARE retry, announced at `warn`. A silent downgrade on this
+*   hub is a flow bug, not a capability limit — see `docs/design/decode-path.md`;
+* - exit classification (`ok` / `signalled-by-us` / `crashed` / `no-output`);
+* - bounded restart with backoff, and a terminal give-up (never an infinite
+*   loop — the same rule `CrashSupervisor` enforces for runners, D6);
+* - SIGTERM then SIGKILL after a grace, gated on the child not having already
+*   exited.
+*
+* ## What it does NOT own
+*
+* The output PLUMBING. A consumer attaches to `stdout` / `stderr` itself,
+* because what the bytes mean is the consumer's business: the broker deframes
+* Annex-B into a restreamer, the WebRTC leg regroups access units, HomeKit
+* writes nothing to stdout at all (its output is two RTP sockets). A wrapper
+* that also owned the bytes would need a mode per consumer, which is the same
+* mistake as one builder per consumer.
+*/
+var DEFAULT_FIRST_DATA_TIMEOUT_MS = 8e3;
+var DEFAULT_RESTART_DELAY_MS = 1e3;
+var DEFAULT_STABLE_RUN_MS = 3e4;
+var DEFAULT_KILL_GRACE_MS = 500;
+var STDERR_TAIL_LINES = 12;
+var FfmpegProcess = class {
+	opts;
+	child = null;
+	stopped = false;
+	producedOutput = false;
+	consecutiveFailures = 0;
+	startedAtMs = 0;
+	stderrTail = [];
+	activeHwAccel;
+	triedSoftwareFallback = false;
+	firstDataTimer = null;
+	constructor(opts) {
+		this.opts = opts;
+		this.activeHwAccel = opts.decodeHwAccel;
+	}
+	/** Queryable tags on every line — `deviceId` is never optional. */
+	get logTags() {
+		return {
+			deviceId: this.opts.deviceId,
+			...this.opts.tags
+		};
+	}
+	get now() {
+		return (this.opts.now ?? Date.now)();
+	}
+	/** `true` while a child is running. */
+	isRunning() {
+		return this.child !== null && !this.stopped;
+	}
+	/** The backend the CURRENT child decodes with (`null` ⇒ software). */
+	activeDecodeHwAccel() {
+		return this.activeHwAccel;
+	}
+	/**
+	* Spawn the first child. Resolves as soon as it produces output; rejects if
+	* it dies or stays silent past the deadline AFTER the software retry has
+	* also been exhausted. A caller that wants fire-and-forget can ignore the
+	* promise — the restart loop runs regardless.
+	*/
+	start() {
+		return new Promise((resolve, reject) => {
+			this.spawnAttempt(resolve, reject);
+		});
+	}
+	spawnAttempt(onLive, onDead) {
+		if (this.stopped) return;
+		const args = [...this.opts.buildArgs(this.activeHwAccel)];
+		const spawnFn = this.opts.spawnFn ?? spawn;
+		const setTimeoutImpl = this.opts.setTimeoutFn ?? setTimeout;
+		this.opts.logger.info(`ffmpeg ${this.opts.role}: spawning`, {
+			tags: this.logTags,
+			meta: {
+				decodeHwAccel: this.activeHwAccel ?? "software",
+				attempt: this.consecutiveFailures + 1
+			}
+		});
+		let child;
+		try {
+			child = spawnFn(this.opts.binaryPath, args, { stdio: this.opts.stdio ?? [
+				"ignore",
+				"pipe",
+				"pipe"
+			] });
+		} catch (err) {
+			this.handleFailure("crashed", null, null, err, onLive, onDead);
+			return;
+		}
+		this.child = child;
+		this.startedAtMs = this.now;
+		this.producedOutput = false;
+		this.stderrTail = [];
+		let settled = false;
+		const timeoutMs = this.opts.firstDataTimeoutMs ?? DEFAULT_FIRST_DATA_TIMEOUT_MS;
+		if (timeoutMs > 0) this.firstDataTimer = setTimeoutImpl(() => {
+			if (settled || this.producedOutput || this.stopped) return;
+			settled = true;
+			this.opts.logger.warn(`ffmpeg ${this.opts.role}: no output within ${timeoutMs}ms`, {
+				tags: this.logTags,
+				meta: { decodeHwAccel: this.activeHwAccel ?? "software" }
+			});
+			this.killChild();
+			this.handleFailure("no-output", null, null, null, onLive, onDead);
+		}, timeoutMs);
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (line) => {
+			const text = String(line).trim();
+			if (text.length === 0) return;
+			this.stderrTail.push(text);
+			if (this.stderrTail.length > STDERR_TAIL_LINES) this.stderrTail.shift();
+			this.opts.logger.debug(`ffmpeg ${this.opts.role}`, {
+				tags: this.logTags,
+				meta: { line: text }
+			});
+		});
+		child.once("error", (err) => {
+			if (settled || this.stopped) return;
+			settled = true;
+			this.handleFailure("crashed", null, null, err, onLive, onDead);
+		});
+		child.once("exit", (code, signal) => {
+			this.clearFirstDataTimer();
+			if (this.child === child) this.child = null;
+			if (this.stopped) {
+				this.report("stopped", code, signal);
+				return;
+			}
+			if (settled && this.producedOutput) {
+				this.report("crashed", code, signal);
+				this.scheduleRestart(onLive, onDead);
+				return;
+			}
+			if (settled) return;
+			settled = true;
+			this.handleFailure(this.producedOutput ? "crashed" : "no-output", code, signal, null, onLive, onDead);
+		});
+		this.opts.onChild(child);
+		child.stdout?.once("data", () => {
+			this.producedOutput = true;
+			this.clearFirstDataTimer();
+			if (settled) return;
+			settled = true;
+			this.opts.logger.info(`ffmpeg ${this.opts.role}: live`, {
+				tags: this.logTags,
+				meta: { decodeHwAccel: this.activeHwAccel ?? "software" }
+			});
+			onLive();
+		});
+	}
+	/**
+	* A child failed before going live. Try SOFTWARE once if it was decoding in
+	* hardware — loudly — then fall through to the bounded restart.
+	*/
+	handleFailure(classification, code, signal, err, onLive, onDead) {
+		this.report(classification, code, signal, err);
+		if (this.activeHwAccel !== null && !this.triedSoftwareFallback && !this.stopped) {
+			this.triedSoftwareFallback = true;
+			this.opts.logger.warn(`ffmpeg ${this.opts.role}: hardware decode produced no output — retrying in SOFTWARE`, {
+				tags: this.logTags,
+				meta: {
+					decodeHwAccel: this.activeHwAccel,
+					classification,
+					code,
+					signal,
+					stderrTail: this.stderrTail
+				}
+			});
+			this.activeHwAccel = null;
+			this.spawnAttempt(onLive, onDead);
+			return;
+		}
+		this.consecutiveFailures += 1;
+		const maxRestarts = this.opts.maxRestarts ?? 0;
+		if (this.consecutiveFailures > maxRestarts || this.stopped) {
+			const reason = `ffmpeg ${this.opts.role} gave up after ${this.consecutiveFailures} attempt(s) (${classification}, code=${code} signal=${signal})`;
+			this.opts.logger.error(reason, {
+				tags: this.logTags,
+				meta: { stderrTail: this.stderrTail }
+			});
+			onDead(new Error(reason));
+			return;
+		}
+		this.scheduleRestart(onLive, onDead);
+	}
+	scheduleRestart(onLive, onDead) {
+		if (this.stopped) return;
+		const maxRestarts = this.opts.maxRestarts ?? 0;
+		if (maxRestarts === 0) return;
+		if (this.producedOutput && this.now - this.startedAtMs >= (this.opts.stableRunMs ?? DEFAULT_STABLE_RUN_MS)) this.consecutiveFailures = 0;
+		if (this.consecutiveFailures > maxRestarts) return;
+		(this.opts.setTimeoutFn ?? setTimeout)(() => {
+			if (this.stopped) return;
+			this.spawnAttempt(onLive, onDead);
+		}, (this.opts.restartDelayMs ?? DEFAULT_RESTART_DELAY_MS) * Math.min(this.consecutiveFailures + 1, 8));
+	}
+	report(classification, code, signal, err) {
+		const exit = {
+			classification,
+			code,
+			signal,
+			stderrTail: [...this.stderrTail],
+			decodeHwAccel: this.activeHwAccel
+		};
+		if (classification === "crashed" || classification === "no-output") this.opts.logger.warn(`ffmpeg ${this.opts.role} exited: ${classification}`, {
+			tags: this.logTags,
+			meta: {
+				code,
+				signal,
+				decodeHwAccel: this.activeHwAccel ?? "software",
+				error: err instanceof Error ? err.message : err === void 0 ? void 0 : String(err),
+				stderrTail: exit.stderrTail
+			}
+		});
+		this.opts.onExit?.(exit);
+	}
+	clearFirstDataTimer() {
+		if (this.firstDataTimer !== null) {
+			clearTimeout(this.firstDataTimer);
+			this.firstDataTimer = null;
+		}
+	}
+	/** Terminate for good. Idempotent; no restart follows. */
+	stop() {
+		if (this.stopped) return;
+		this.stopped = true;
+		this.clearFirstDataTimer();
+		this.killChild();
+	}
+	killChild() {
+		const child = this.child;
+		this.child = null;
+		if (!child) return;
+		if (child.exitCode !== null || child.signalCode !== null) return;
+		try {
+			child.kill("SIGTERM");
+		} catch {
+			return;
+		}
+		const grace = (this.opts.setTimeoutFn ?? setTimeout)(() => {
+			if (child.exitCode !== null || child.signalCode !== null) return;
+			try {
+				child.kill("SIGKILL");
+			} catch {}
+		}, this.opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS);
+		if (typeof grace === "object" && grace !== null && "unref" in grace) grace.unref();
+	}
+};
+//#endregion
+export { FfmpegProcess, FilesystemStorageProvider, PYTHON_VERSION, buildBinaryPath, canonicalDeviceFingerprint, canonicalHash, diffExportTargets, downloadBinary, ensureBinary, ensureFfmpeg, ensurePython, findInPath, getFfmpegDownloadUrl, getPlatformInfo, getPythonDownloadUrl, installPythonPackages, installPythonRequirements, resolveExportFingerprint };

package/dist/pipeline/detail-crop.d.ts

@@ -0,0 +1,122 @@
+/**
+ * THE detail-crop convention — the single derivation of the rectangle a
+ * detail/enrichment step (clip-embedding, face-detection, plate-detection…)
+ * is fed.
+ *
+ * ## Why this is one module and not two constants
+ *
+ * `object-clip` is ONE vector index, and cosine similarity is only meaningful
+ * between vectors produced from the same crop convention. Two encode paths
+ * write into it — the live detail plane and the embedding rebuild — and they
+ * used to derive their crops independently: `DETAIL_CROP_PADDING_RATIO = 0.15`
+ * with no squaring on one side, `DEFAULT_CROP_MARGIN = 0.2` with squaring on
+ * by default on the other. Every rebuild therefore poured a second, silently
+ * incomparable feature space into the index it exists to keep consistent.
+ *
+ * So the rectangle is derived HERE, once, from ONE convention value. Both
+ * paths now reach this function through `pipelineRunner.runDetailSubtree` —
+ * the runner is the only process that cuts (see `detail-subtree.ts`), and the
+ * convention is a cluster-global `pipeline-orchestrator` setting. There is
+ * deliberately no per-node or per-device scope: a per-accelerator crop margin
+ * would reintroduce the same split, merely relocated.
+ *
+ * ## The default IS the live convention
+ *
+ * {@link DEFAULT_DETAIL_CROP_CONVENTION} reproduces what the live path has
+ * been storing (0.15, no squaring). Anything else would invalidate every
+ * vector already in the index on the day it shipped. Changing the convention
+ * is legitimate — that is what the operator knob is for — but it must be
+ * followed by a rebuild, which is now guaranteed to produce crops from this
+ * same function.
+ */
+import { z } from 'zod';
+/**
+ * Store identity of the convention in `pipeline-orchestrator`'s GLOBAL
+ * (cluster-wide) settings.
+ *
+ * These live here rather than in the orchestrator because the reader is a
+ * different addon — the pipeline runner, over the hub-routed `addon-settings`
+ * cap. Addons never import each other, so a key owned by the writer would have
+ * to be hand-copied by the reader, and a hand-copied key is how a setting
+ * silently stops arriving while both sides still look correct.
+ */
+export declare const DETAIL_CROP_SECTION_ID = "detail-crop";
+export declare const DETAIL_CROP_PADDING_KEY = "detailCropPaddingRatio";
+export declare const DETAIL_CROP_SQUARE_KEY = "detailCropSquare";
+/** A `{x,y,w,h}` rectangle in FRAME-space pixels. */
+export interface DetailCropRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+/**
+ * Operator-tunable crop convention. Single-valued and cluster-wide — see the
+ * module docblock for why it cannot be scoped per node or per device.
+ */
+export declare const DetailCropConventionSchema: z.ZodObject<{
+    paddingRatio: z.ZodNumber;
+    square: z.ZodBoolean;
+}, z.core.$strip>;
+export type DetailCropConvention = z.infer<typeof DetailCropConventionSchema>;
+/**
+ * The convention in force when nobody has configured one — byte-for-byte the
+ * behaviour of the pre-unification LIVE path (`DETAIL_CROP_PADDING_RATIO`).
+ */
+export declare const DEFAULT_DETAIL_CROP_CONVENTION: DetailCropConvention;
+/**
+ * Narrow a FLAT settings record to the convention.
+ *
+ * Per-FIELD fallback, deliberately: a junk padding must not also discard a
+ * valid squaring choice. An absent or invalid value resolves to
+ * {@link DEFAULT_DETAIL_CROP_CONVENTION} — the historical live behaviour —
+ * rather than to a clamped number nobody chose, so a bad read can never
+ * quietly change what the stored vectors mean.
+ */
+export declare function readDetailCropConvention(config: Readonly<Record<string, unknown>>): DetailCropConvention;
+/** One section of an `addon-settings.getGlobalSettings` payload. */
+export interface HydratedSettingsSection {
+    readonly fields: readonly unknown[];
+}
+/**
+ * Minimal structural view of `ConfigUISchemaWithValues` — only what the
+ * convention extraction walks. Structural on purpose: the reader is an addon
+ * that must not depend on the writer's schema type.
+ */
+export interface HydratedSettingsView {
+    readonly sections: readonly HydratedSettingsSection[];
+}
+/**
+ * Extract the convention from an `addon-settings.getGlobalSettings` payload.
+ *
+ * Walks EVERY section rather than looking inside {@link DETAIL_CROP_SECTION_ID}
+ * alone: the keys are unique across the addon's schema, and a section rename
+ * must not silently revert the whole cluster to the default. A `null` payload
+ * (addon mid-boot) is the default convention.
+ */
+export declare function pickDetailCropConvention(view: HydratedSettingsView | null): DetailCropConvention;
+/** Slider bounds for the operator-facing padding knob (orchestrator settings UI). */
+export declare const DETAIL_CROP_PADDING_FIELD: {
+    readonly min: 0;
+    readonly max: 1;
+    readonly step: 0.05;
+    readonly default: number;
+};
+/**
+ * Derive the crop rectangle for one parent detection.
+ *
+ * Order: pad by `paddingRatio` of the box's own size → optionally square in
+ * pixel space around the padded centre → keep it inside the frame. Pure:
+ * always returns a new rect and never mutates `bbox`.
+ *
+ * Edge handling differs by mode, on purpose:
+ *
+ * - **unsquared** — TRUNCATED at the frame border, byte-for-byte what the live
+ *   path has always done (`padAndClampFrameBbox`). A subject against the edge
+ *   gets a slightly smaller window. Changing this would silently reinterpret
+ *   every edge-touching vector already in the index.
+ * - **squared** — SLID inward instead, because a truncated square is not
+ *   square and squaring exists precisely to preserve the aspect the model
+ *   sees. It only shrinks when the square is larger than the frame itself.
+ */
+export declare function deriveDetailCropRect(bbox: DetailCropRect, frameWidth: number, frameHeight: number, convention: DetailCropConvention): DetailCropRect;

package/dist/{sleep-CXimb854.mjs → sleep-BmNKsY7v.mjs}

@@ -3103,6 +3103,8 @@ function createDeviceProxy(api, binding, opts) {
 			updateRule: (input) => dispatch("notification-rules", "notificationRules", "updateRule", "mutation", input),
 			deleteRule: (input) => dispatch("notification-rules", "notificationRules", "deleteRule", "mutation", input),
 			setRuleEnabled: (input) => dispatch("notification-rules", "notificationRules", "setRuleEnabled", "mutation", input),
+			listDeviceMutes: (input) => dispatch("notification-rules", "notificationRules", "listDeviceMutes", "query", input),
+			setDeviceMuted: (input) => dispatch("notification-rules", "notificationRules", "setDeviceMuted", "mutation", input),
 			testRule: (input) => dispatch("notification-rules", "notificationRules", "testRule", "mutation", input),
 			getConditionCatalog: (input) => dispatch("notification-rules", "notificationRules", "getConditionCatalog", "query", input),
 			getHistory: (input) => dispatch("notification-rules", "notificationRules", "getHistory", "query", input),
@@ -3153,6 +3155,7 @@ function createDeviceProxy(api, binding, opts) {
 			pruneTracksBefore: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneTracksBefore", "mutation", input),
 			wipeAllAnalytics: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "wipeAllAnalytics", "mutation", input),
 			deleteTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteTracks", "mutation", input),
+			setTrackFlags: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "setTrackFlags", "mutation", input),
 			getEventStoreFootprint: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventStoreFootprint", "query", input),
 			pruneEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEvents", "mutation", input),
 			deleteDeviceEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteDeviceEvents", "mutation", input),
@@ -3388,6 +3391,8 @@ function createDeviceProxy(api, binding, opts) {
 			setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 			setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 			resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
+			getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
+			setCameraSwitch: (input) => dispatchSystem("pipelineOrchestrator", "setCameraSwitch", "mutation", input),
 			getCameraStatus: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStatus", "query", input),
 			getDeviceSettingsContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceLiveContribution", "query", input),

package/dist/{sleep-DTce7-ch.js → sleep-Cvi1JxZp.js}

@@ -3103,6 +3103,8 @@ function createDeviceProxy(api, binding, opts) {
 			updateRule: (input) => dispatch("notification-rules", "notificationRules", "updateRule", "mutation", input),
 			deleteRule: (input) => dispatch("notification-rules", "notificationRules", "deleteRule", "mutation", input),
 			setRuleEnabled: (input) => dispatch("notification-rules", "notificationRules", "setRuleEnabled", "mutation", input),
+			listDeviceMutes: (input) => dispatch("notification-rules", "notificationRules", "listDeviceMutes", "query", input),
+			setDeviceMuted: (input) => dispatch("notification-rules", "notificationRules", "setDeviceMuted", "mutation", input),
 			testRule: (input) => dispatch("notification-rules", "notificationRules", "testRule", "mutation", input),
 			getConditionCatalog: (input) => dispatch("notification-rules", "notificationRules", "getConditionCatalog", "query", input),
 			getHistory: (input) => dispatch("notification-rules", "notificationRules", "getHistory", "query", input),
@@ -3153,6 +3155,7 @@ function createDeviceProxy(api, binding, opts) {
 			pruneTracksBefore: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneTracksBefore", "mutation", input),
 			wipeAllAnalytics: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "wipeAllAnalytics", "mutation", input),
 			deleteTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteTracks", "mutation", input),
+			setTrackFlags: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "setTrackFlags", "mutation", input),
 			getEventStoreFootprint: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventStoreFootprint", "query", input),
 			pruneEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEvents", "mutation", input),
 			deleteDeviceEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteDeviceEvents", "mutation", input),
@@ -3388,6 +3391,8 @@ function createDeviceProxy(api, binding, opts) {
 			setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 			setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 			resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
+			getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
+			setCameraSwitch: (input) => dispatchSystem("pipelineOrchestrator", "setCameraSwitch", "mutation", input),
 			getCameraStatus: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStatus", "query", input),
 			getDeviceSettingsContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceLiveContribution", "query", input),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.40",
+  "version": "1.2.42",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",