@camstack/types 1.2.260 → 1.2.261

package/dist/interfaces/addon.d.ts

@@ -489,6 +489,17 @@ export interface AddonContext<TConfig = Record<string, unknown>> {
          * allowlisted engine-cascade holdouts are the only callers.
          */
         readAddonStore(): Promise<Record<string, unknown>>;
+        /**
+         * The same read, THREE-WAY: a stored blob, no blob, or a read that FAILED.
+         * `readAddonStore` folds a failure into `{}`, which a caller cannot tell
+         * from "never written"; this one does not (D651). Optional: a settings view
+         * that predates it answers nothing, and the caller must treat that as
+         * unreadable, never as empty.
+         *
+         * @internal Same rule as `readAddonStore`: addons reach it only through
+         * `BaseAddon.readStoredGlobalKey`.
+         */
+        readAddonStoreResult?(): Promise<AddonStoreRead>;
         /**
          * Write a patch into the addon store. Keys not in the patch are
          * preserved. Keys explicitly set to `null` are preserved as-is (they
@@ -1409,3 +1420,33 @@ export interface InternalAddonContext extends AddonContext {
     /** Resolve the preferred provider for a capability. Kernel-only. */
     resolveProvider<T = unknown>(capabilityName: string): T | null;
 }
+/**
+ * A three-way read of an addon's own store (D651). `missing` and `failed` are
+ * distinct on purpose: folding them is how a failed read becomes "defaults".
+ */
+export type AddonStoreRead = {
+    readonly kind: 'value';
+    readonly value: Readonly<Record<string, unknown>>;
+} | {
+    readonly kind: 'missing';
+} | {
+    readonly kind: 'failed';
+    readonly error: string;
+};
+/** One stored key of an addon's own store, read three-way (D651). */
+export type StoredKeyRead = 
+/** The key was written; `value` is what is stored. */
+{
+    readonly kind: 'present';
+    readonly value: unknown;
+}
+/** The store answered and the key was never written. */
+ | {
+    readonly kind: 'absent';
+}
+/** The store did not answer, or this node's settings view cannot say. */
+ | {
+    readonly kind: 'unreadable';
+    readonly reason: 'store-read-failed' | 'three-way-read-unavailable';
+    readonly error?: string;
+};

package/dist/interfaces/event-bus.d.ts

@@ -165,6 +165,16 @@ export interface PipelineAnalyticsFrameTrackedPayload {
      * a dropped frame just lets the session close slightly earlier.
      */
     readonly hasLiveTrack?: boolean;
+    /**
+     * How many objects the TRACKER holds on this frame — moving OR still,
+     * i.e. `result.tracked.length` (D652). Diagnostics only: it decides nothing.
+     * {@link hasLiveTrack} deliberately subtracts a still subject, so a session
+     * that closed on a parked car and one that closed on an empty street both
+     * saw `false` last; this count is what tells them apart on the orchestrator's
+     * close line (`liveTracks`). Absent ⇒ unknown (an older post-analysis),
+     * which the consumer reports as `null`, never as 0.
+     */
+    readonly liveTrackCount?: number;
     [key: string]: unknown;
 }
 /** Lifecycle phase of a tracked object: it appears (`start`), its best

package/dist/node.d.ts

@@ -13,6 +13,7 @@ export { FfmpegProcess } from './ffmpeg/process.js';
 export type { ChildCostClaimHandle, ChildCostClaimInput, ProcStatReader, } from './process/child-cost-registry.js';
 export { ChildCostRegistry, NO_COST_CLAIM, nodeProcStatReader, parseProcCpuSeconds, parseProcRssBytes, readProcessCost, } from './process/child-cost-registry.js';
 export { FilesystemStorageProvider } from './storage/filesystem-storage-provider.js';
+export { writeFileAtomic } from './storage/atomic-write.js';
 export type { PhysicalRoot, RealpathSync } from './storage/physical-root.js';
 export { containsOrEquals, physicalRootOf } from './storage/physical-root.js';
 export { canonicalHash } from './utils/canonical-hash.js';

package/dist/node.js

@@ -1744,6 +1744,69 @@ var ChildCostRegistry = class {
 	}
 };
 //#endregion
+//#region src/storage/atomic-write.ts
+/** Errors a Windows rename over a file another process has open can raise. */
+var WINDOWS_RENAME_BUSY = new Set([
+	"EPERM",
+	"EACCES",
+	"EBUSY"
+]);
+var WINDOWS_RENAME_RETRIES = 3;
+var WINDOWS_RENAME_RETRY_MS = 25;
+function errnoCode(err) {
+	return err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : void 0;
+}
+/**
+* Replace `filePath` with `data` so that a concurrent reader sees EITHER the
+* old complete file OR the new complete file — never a prefix (D654).
+*
+* A plain `writeFile` truncates the target and then writes it in chunks, so a
+* reader in between gets a torn file: a fixed-path single-instance media kind
+* (`lastFrame`, `lastSceneFrame`) is overwritten every roll while a
+* notification may be reading it. Here the bytes go to a temp file in the SAME
+* directory (same filesystem, so the rename cannot degrade to a copy), and a
+* `rename` swaps it in — atomic on POSIX. A reader that already opened the old
+* file keeps reading the old inode to the end.
+*
+* The temp name is DOT-prefixed so every directory scan that skips dot entries
+* (occupancy, D327) never counts it; it is removed on any failure. A process
+* killed between the write and the rename leaves one `.<name>.<uuid>.tmp`.
+*
+* Windows: a rename over a file another process holds open can fail with
+* EPERM/EACCES/EBUSY. It is retried briefly and then falls back to copying the
+* temp over the target — non-atomic, exactly the pre-D654 behaviour, rather
+* than losing the write.
+*
+* Cost: one extra `rename` (and, on failure, one `rm`) per write — a metadata
+* operation, independent of the payload size.
+*/
+async function writeFileAtomic(filePath, data) {
+	const tmp = node_path.join(node_path.dirname(filePath), `.${node_path.basename(filePath)}.${(0, node_crypto.randomUUID)()}.tmp`);
+	try {
+		await node_fs.promises.writeFile(tmp, data);
+		await renameOver(tmp, filePath);
+	} catch (err) {
+		await node_fs.promises.rm(tmp, { force: true }).catch(() => void 0);
+		throw err;
+	}
+}
+async function renameOver(tmp, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		await node_fs.promises.rename(tmp, filePath);
+		return;
+	} catch (err) {
+		const code = errnoCode(err);
+		if (!(process.platform === "win32" && code !== void 0 && WINDOWS_RENAME_BUSY.has(code))) throw err;
+		if (attempt < WINDOWS_RENAME_RETRIES) {
+			await new Promise((resolve) => setTimeout(resolve, WINDOWS_RENAME_RETRY_MS));
+			continue;
+		}
+		await node_fs.promises.copyFile(tmp, filePath);
+		await node_fs.promises.rm(tmp, { force: true });
+		return;
+	}
+}
+//#endregion
 //#region src/storage/filesystem-storage-provider.ts
 var STORAGE_LOCATION_TYPES = [
 	"data",
@@ -1817,14 +1880,16 @@ var FilesystemStorageProvider = class {
 			relativePath
 		});
 		await node_fs.promises.mkdir(node_path.dirname(filePath), { recursive: true });
-		if (Buffer.isBuffer(data)) await node_fs.promises.writeFile(filePath, data);
+		if (Buffer.isBuffer(data)) await writeFileAtomic(filePath, data);
 		else {
-			const writeStream = node_fs.createWriteStream(filePath);
-			await new Promise((resolve, reject) => {
-				data.pipe(writeStream);
-				writeStream.on("finish", resolve);
-				writeStream.on("error", reject);
-			});
+			const tmp = node_path.join(node_path.dirname(filePath), `.${node_path.basename(filePath)}.${(0, node_crypto.randomUUID)()}.tmp`);
+			try {
+				await (0, node_stream_promises.pipeline)(data, node_fs.createWriteStream(tmp));
+				await node_fs.promises.rename(tmp, filePath);
+			} catch (err) {
+				await node_fs.promises.rm(tmp, { force: true }).catch(() => void 0);
+				throw err;
+			}
 		}
 	}
 	async read({ location, relativePath }) {
@@ -2090,3 +2155,4 @@ exports.readProcessCost = readProcessCost;
 exports.resolveExportFingerprint = resolveExportFingerprint;
 exports.signExpiringUrl = signExpiringUrl;
 exports.verifyExpiringUrl = verifyExpiringUrl;
+exports.writeFileAtomic = writeFileAtomic;

package/dist/node.mjs

@@ -1721,6 +1721,69 @@ var ChildCostRegistry = class {
 	}
 };
 //#endregion
+//#region src/storage/atomic-write.ts
+/** Errors a Windows rename over a file another process has open can raise. */
+var WINDOWS_RENAME_BUSY = new Set([
+	"EPERM",
+	"EACCES",
+	"EBUSY"
+]);
+var WINDOWS_RENAME_RETRIES = 3;
+var WINDOWS_RENAME_RETRY_MS = 25;
+function errnoCode(err) {
+	return err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : void 0;
+}
+/**
+* Replace `filePath` with `data` so that a concurrent reader sees EITHER the
+* old complete file OR the new complete file — never a prefix (D654).
+*
+* A plain `writeFile` truncates the target and then writes it in chunks, so a
+* reader in between gets a torn file: a fixed-path single-instance media kind
+* (`lastFrame`, `lastSceneFrame`) is overwritten every roll while a
+* notification may be reading it. Here the bytes go to a temp file in the SAME
+* directory (same filesystem, so the rename cannot degrade to a copy), and a
+* `rename` swaps it in — atomic on POSIX. A reader that already opened the old
+* file keeps reading the old inode to the end.
+*
+* The temp name is DOT-prefixed so every directory scan that skips dot entries
+* (occupancy, D327) never counts it; it is removed on any failure. A process
+* killed between the write and the rename leaves one `.<name>.<uuid>.tmp`.
+*
+* Windows: a rename over a file another process holds open can fail with
+* EPERM/EACCES/EBUSY. It is retried briefly and then falls back to copying the
+* temp over the target — non-atomic, exactly the pre-D654 behaviour, rather
+* than losing the write.
+*
+* Cost: one extra `rename` (and, on failure, one `rm`) per write — a metadata
+* operation, independent of the payload size.
+*/
+async function writeFileAtomic(filePath, data) {
+	const tmp = path$1.join(path$1.dirname(filePath), `.${path$1.basename(filePath)}.${randomUUID()}.tmp`);
+	try {
+		await fs.promises.writeFile(tmp, data);
+		await renameOver(tmp, filePath);
+	} catch (err) {
+		await fs.promises.rm(tmp, { force: true }).catch(() => void 0);
+		throw err;
+	}
+}
+async function renameOver(tmp, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		await fs.promises.rename(tmp, filePath);
+		return;
+	} catch (err) {
+		const code = errnoCode(err);
+		if (!(process.platform === "win32" && code !== void 0 && WINDOWS_RENAME_BUSY.has(code))) throw err;
+		if (attempt < WINDOWS_RENAME_RETRIES) {
+			await new Promise((resolve) => setTimeout(resolve, WINDOWS_RENAME_RETRY_MS));
+			continue;
+		}
+		await fs.promises.copyFile(tmp, filePath);
+		await fs.promises.rm(tmp, { force: true });
+		return;
+	}
+}
+//#endregion
 //#region src/storage/filesystem-storage-provider.ts
 var STORAGE_LOCATION_TYPES = [
 	"data",
@@ -1794,14 +1857,16 @@ var FilesystemStorageProvider = class {
 			relativePath
 		});
 		await fs.promises.mkdir(path$1.dirname(filePath), { recursive: true });
-		if (Buffer.isBuffer(data)) await fs.promises.writeFile(filePath, data);
+		if (Buffer.isBuffer(data)) await writeFileAtomic(filePath, data);
 		else {
-			const writeStream = fs.createWriteStream(filePath);
-			await new Promise((resolve, reject) => {
-				data.pipe(writeStream);
-				writeStream.on("finish", resolve);
-				writeStream.on("error", reject);
-			});
+			const tmp = path$1.join(path$1.dirname(filePath), `.${path$1.basename(filePath)}.${randomUUID()}.tmp`);
+			try {
+				await pipeline(data, fs.createWriteStream(tmp));
+				await fs.promises.rename(tmp, filePath);
+			} catch (err) {
+				await fs.promises.rm(tmp, { force: true }).catch(() => void 0);
+				throw err;
+			}
 		}
 	}
 	async read({ location, relativePath }) {
@@ -2033,4 +2098,4 @@ function resolveExportFingerprint(input) {
 	return input.persisted ?? input.fresh;
 }
 //#endregion
-export { ChildCostRegistry, FFMPEG_RELEASE, FfmpegProcess, FilesystemStorageProvider, Fmp4FragmentChild, Fmp4FragmentPlane, NO_COST_CLAIM, PYTHON_VERSION, buildBinaryPath, canonicalDeviceFingerprint, canonicalHash, containsOrEquals, diffExportTargets, downloadBinary, ensureBinary, ensureFfmpeg, ensurePython, findInPath, getFfmpegArtifact, getFfmpegDownloadUrl, getPlatformInfo, getPythonDownloadUrl, installPythonPackages, installPythonRequirements, nodeProcStatReader, parseFfmpegCapabilities, parseProcCpuSeconds, parseProcRssBytes, physicalRootOf, probeFfmpegBinary, readProcessCost, resolveExportFingerprint, signExpiringUrl, verifyExpiringUrl };
+export { ChildCostRegistry, FFMPEG_RELEASE, FfmpegProcess, FilesystemStorageProvider, Fmp4FragmentChild, Fmp4FragmentPlane, NO_COST_CLAIM, PYTHON_VERSION, buildBinaryPath, canonicalDeviceFingerprint, canonicalHash, containsOrEquals, diffExportTargets, downloadBinary, ensureBinary, ensureFfmpeg, ensurePython, findInPath, getFfmpegArtifact, getFfmpegDownloadUrl, getPlatformInfo, getPythonDownloadUrl, installPythonPackages, installPythonRequirements, nodeProcStatReader, parseFfmpegCapabilities, parseProcCpuSeconds, parseProcRssBytes, physicalRootOf, probeFfmpegBinary, readProcessCost, resolveExportFingerprint, signExpiringUrl, verifyExpiringUrl, writeFileAtomic };

package/dist/pipeline/cluster-model-scope.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Why the orchestrator cannot say which model the operator chose for a
+ * cluster-scoped step (D651).
+ */
+export declare const CLUSTER_MODEL_CHOICE_UNREADABLE_REASONS: readonly ["owner-not-ready", "store-read-failed", "three-way-read-unavailable", "invalid-stored", "not-cluster-scoped"];
 /**
  * How a step's model is chosen.
  *
@@ -66,13 +71,58 @@ export declare function isClusterScopedStep(stepId: string): boolean;
 export type ClusterStepModels = Readonly<Record<string, string>>;
 /** The cluster row when nobody has configured one — today's catalog defaults. */
 export declare const DEFAULT_CLUSTER_STEP_MODELS: ClusterStepModels;
+/**
+ * What ONE stored `clusterModel:<stepId>` value means (D651 fix round 4).
+ *
+ *  - `absent` — nobody chose. The key was never written, or the settings form
+ *    cleared it: a select clears a field with a `null` patch, and `hydrateSchema`
+ *    reads a stored `null` as `value ?? default` on every hydrated surface, so
+ *    `null` and `''` are the same statement as "never written".
+ *  - `chosen` — a non-empty string, taken VERBATIM. Not checked against the
+ *    step's `options`: the runtime pins an id the catalog does not list on
+ *    purpose (`cluster-model-resolution.ts`: a custom encoder from
+ *    `custom-model-registry` is the operator's own compatibility problem), and
+ *    the dropdown is guarded separately by `scripts/check-cluster-model-scope.ts`.
+ *    An owner that called such an id invalid while the runner ran it would give
+ *    the same stored key two meanings — the defect this function removes.
+ *  - `invalid` — anything else (a number, an object). The form cannot write it;
+ *    it is a hand edit or a corrupted row.
+ *
+ * Both readers of the key go through this function: the runner's
+ * {@link readClusterStepModels} and the owner's `decideClusterModelChoice`
+ * (addon-pipeline-orchestrator). They differ only in what they DO with
+ * `invalid`: a live row is total, so the runner falls to the catalog default
+ * and says so in its log (`ClusterModelSource`); a pass that would rewrite an
+ * index on it refuses (`invalid-stored`).
+ */
+export type StoredClusterModelInterpretation = {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'chosen';
+    readonly modelId: string;
+} | {
+    readonly kind: 'invalid';
+    readonly value: unknown;
+};
+export declare function interpretStoredClusterModel(raw: unknown): StoredClusterModelInterpretation;
+/** One stored cluster model value the interpretation rejected. */
+export interface InvalidClusterStepModelEntry {
+    readonly stepId: string;
+    readonly value: unknown;
+}
+/**
+ * The cluster-scoped steps whose stored value is `invalid` under
+ * {@link interpretStoredClusterModel} — for the runtime's log line, so the
+ * default it runs on such a row is never run in silence.
+ */
+export declare function invalidClusterStepModelEntries(config: Readonly<Record<string, unknown>>): readonly InvalidClusterStepModelEntry[];
 /**
  * Narrow a FLAT settings record to the cluster row.
  *
  * Per-FIELD fallback, deliberately (same rule as `readDetailCropConvention`): a
- * junk face model must not also discard a valid clip model. An absent, empty or
- * non-string value resolves to the step's catalog default — the historical
- * behaviour — never to a blank id, because a blank id downstream becomes
+ * junk face model must not also discard a valid clip model. An `absent` or
+ * `invalid` value ({@link interpretStoredClusterModel}) resolves to the step's
+ * catalog default — never to a blank id, because a blank id downstream becomes
  * "substitute the format default", which is precisely the substitution this
  * scope exists to forbid.
  */
@@ -98,6 +148,12 @@ export interface HydratedClusterView {
  * (addon mid-boot) is the defaults.
  */
 export declare function pickClusterStepModels(view: HydratedClusterView | null): ClusterStepModels;
+/**
+ * The `invalid` stored cluster model values a hydrated view carries — what the
+ * runtime logs when it runs a default on a row it could not read as a choice.
+ * A `null` view (owner mid-boot) carries nothing to judge.
+ */
+export declare function pickInvalidClusterStepModels(view: HydratedClusterView | null): readonly InvalidClusterStepModelEntry[];
 /**
  * The cluster model for `stepId`, or `null` when the step is node-scoped.
  *

package/dist/{sleep-BaRu0bS5.mjs → sleep-BXv0ZcRa.mjs}

@@ -917,6 +917,40 @@ var BaseAddon = class {
 		const node = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
 		return keys.size > 0 ? projectStore(raw, keys, node) : raw;
 	}
+	/**
+	* Whether ONE global key of this addon's store was written, read three-way
+	* (D651). For a question a hydrated view cannot answer: `getGlobalSettings`
+	* reports `value ?? default`, so "the operator chose the default" and "nobody
+	* chose" look the same, and a failed read looks like both. A `perNode` key is
+	* not supported here: its stored name is scoped.
+	*/
+	async readStoredGlobalKey(key) {
+		const read = this._ctx?.settings?.readAddonStoreResult;
+		if (read === void 0) return {
+			kind: "unreadable",
+			reason: "three-way-read-unavailable"
+		};
+		let result;
+		try {
+			result = await read.call(this._ctx?.settings);
+		} catch (err) {
+			return {
+				kind: "unreadable",
+				reason: "store-read-failed",
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+		if (result.kind === "failed") return {
+			kind: "unreadable",
+			reason: "store-read-failed",
+			error: result.error
+		};
+		if (result.kind === "missing" || !Object.prototype.hasOwnProperty.call(result.value, key)) return { kind: "absent" };
+		return {
+			kind: "present",
+			value: result.value[key]
+		};
+	}
 	async updateGlobalSettings(patch, nodeId) {
 		const keys = this.perNodeKeys();
 		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
@@ -3560,6 +3594,11 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceLiveContribution: (input) => dispatch("camera-grid-layout", "cameraGridLayout", "getDeviceLiveContribution", "query", input),
 			applyDeviceSettingsPatch: (input) => dispatch("camera-grid-layout", "cameraGridLayout", "applyDeviceSettingsPatch", "mutation", input)
 		},
+		cameraPipelineConfig: {
+			getDeviceSettingsContribution: (input) => dispatch("camera-pipeline-config", "cameraPipelineConfig", "getDeviceSettingsContribution", "query", input),
+			getDeviceLiveContribution: (input) => dispatch("camera-pipeline-config", "cameraPipelineConfig", "getDeviceLiveContribution", "query", input),
+			applyDeviceSettingsPatch: (input) => dispatch("camera-pipeline-config", "cameraPipelineConfig", "applyDeviceSettingsPatch", "mutation", input)
+		},
 		cameraStreams: {
 			getCameraStreams: (input) => dispatch("camera-streams", "cameraStreams", "getCameraStreams", "query", input),
 			getBrokerStreams: (input) => dispatch("camera-streams", "cameraStreams", "getBrokerStreams", "query", input),
@@ -3619,6 +3658,12 @@ function createDeviceProxy(api, binding, opts) {
 			releaseDevice: (input) => dispatch("device-discovery", "deviceDiscovery", "releaseDevice", "mutation", input),
 			getStatus: (input) => dispatch("device-discovery", "deviceDiscovery", "getStatus", "query", input)
 		},
+		deviceExtension: {
+			listSources: (input) => dispatch("device-extension", "deviceExtension", "listSources", "query", input),
+			listSlots: (input) => dispatch("device-extension", "deviceExtension", "listSlots", "query", input),
+			listCandidates: (input) => dispatch("device-extension", "deviceExtension", "listCandidates", "query", input),
+			setSlot: (input) => dispatch("device-extension", "deviceExtension", "setSlot", "mutation", input)
+		},
 		deviceOps: {
 			getStreamSources: (input) => dispatch("device-ops", "deviceOps", "getStreamSources", "query", input),
 			getConfigEntries: (input) => dispatch("device-ops", "deviceOps", "getConfigEntries", "query", input),
@@ -3737,30 +3782,6 @@ function createDeviceProxy(api, binding, opts) {
 			getStatus: (input) => dispatch("navigation", "navigation", "getStatus", "query", input)
 		},
 		networkLink: { getStatus: (input) => dispatch("network-link", "networkLink", "getStatus", "query", input) },
-		notificationRules: {
-			listRules: (input) => dispatch("notification-rules", "notificationRules", "listRules", "query", input),
-			getRule: (input) => dispatch("notification-rules", "notificationRules", "getRule", "query", input),
-			createRule: (input) => dispatch("notification-rules", "notificationRules", "createRule", "mutation", input),
-			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),
-			getClipRetentionAsks: (input) => dispatch("notification-rules", "notificationRules", "getClipRetentionAsks", "query", 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),
-			previewStateSummary: (input) => dispatch("notification-rules", "notificationRules", "previewStateSummary", "mutation", input),
-			getConditionCatalog: (input) => dispatch("notification-rules", "notificationRules", "getConditionCatalog", "query", input),
-			getTemplateCatalog: (input) => dispatch("notification-rules", "notificationRules", "getTemplateCatalog", "query", input),
-			previewTemplate: (input) => dispatch("notification-rules", "notificationRules", "previewTemplate", "mutation", input),
-			getHistory: (input) => dispatch("notification-rules", "notificationRules", "getHistory", "query", input),
-			getRuleLastRuns: (input) => dispatch("notification-rules", "notificationRules", "getRuleLastRuns", "query", input),
-			resolveArtifactUrl: (input) => dispatch("notification-rules", "notificationRules", "resolveArtifactUrl", "query", input),
-			listSnoozes: (input) => dispatch("notification-rules", "notificationRules", "listSnoozes", "query", input),
-			createSnooze: (input) => dispatch("notification-rules", "notificationRules", "createSnooze", "mutation", input),
-			cancelSnooze: (input) => dispatch("notification-rules", "notificationRules", "cancelSnooze", "mutation", input),
-			getAlarmConfig: (input) => dispatch("notification-rules", "notificationRules", "getAlarmConfig", "query", input),
-			setAlarmConfig: (input) => dispatch("notification-rules", "notificationRules", "setAlarmConfig", "mutation", input)
-		},
 		notifier: {
 			send: (input) => dispatch("notifier", "notifier", "send", "mutation", input),
 			cancel: (input) => dispatch("notifier", "notifier", "cancel", "mutation", input),
@@ -4018,11 +4039,6 @@ function createDeviceProxy(api, binding, opts) {
 			updateDeviceSettings: (input) => dispatchSystem("addonSettings", "updateDeviceSettings", "mutation", input)
 		},
 		audioAnalyzer: { detachDevice: (input) => dispatchSystem("audioAnalyzer", "detachDevice", "mutation", input) },
-		cameraPipelineConfig: {
-			getDeviceSettingsContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatchSystem("cameraPipelineConfig", "applyDeviceSettingsPatch", "mutation", input)
-		},
 		deviceAdoption: { getStatus: (input) => dispatchSystem("deviceAdoption", "getStatus", "query", input) },
 		deviceExport: {
 			getDeviceSettingsContribution: (input) => dispatchSystem("deviceExport", "getDeviceSettingsContribution", "query", input),
@@ -4072,7 +4088,6 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceLiveContribution: (input) => dispatchSystem("deviceManager", "getDeviceLiveContribution", "query", input),
 			applyDeviceSettingsPatch: (input) => dispatchSystem("deviceManager", "applyDeviceSettingsPatch", "mutation", input)
 		},
-		deviceProvider: { reloadDevice: (input) => dispatchSystem("deviceProvider", "reloadDevice", "mutation", input) },
 		deviceState: {
 			getSnapshot: (input) => dispatchSystem("deviceState", "getSnapshot", "query", input),
 			getCapSlice: (input) => dispatchSystem("deviceState", "getCapSlice", "query", input),
@@ -4086,6 +4101,7 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceStats: (input) => dispatchSystem("networkQuality", "getDeviceStats", "query", input),
 			reportClientStats: (input) => dispatchSystem("networkQuality", "reportClientStats", "mutation", input)
 		},
+		notificationRules: { setDeviceMuted: (input) => dispatchSystem("notificationRules", "setDeviceMuted", "mutation", input) },
 		osdManager: {
 			getDeviceOsd: (input) => dispatchSystem("osdManager", "getDeviceOsd", "query", input),
 			getSourceCatalog: (input) => dispatchSystem("osdManager", "getSourceCatalog", "query", input),
@@ -4108,7 +4124,6 @@ function createDeviceProxy(api, binding, opts) {
 			assignAudio: (input) => dispatchSystem("pipelineOrchestrator", "assignAudio", "mutation", input),
 			unassignAudio: (input) => dispatchSystem("pipelineOrchestrator", "unassignAudio", "mutation", input),
 			getAudioAssignment: (input) => dispatchSystem("pipelineOrchestrator", "getAudioAssignment", "query", input),
-			getAudioAssignments: (input) => dispatchSystem("pipelineOrchestrator", "getAudioAssignments", "query", input),
 			getCameraSettings: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSettings", "query", input),
 			setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
 			getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
@@ -4180,7 +4195,7 @@ function createDeviceProxy(api, binding, opts) {
 * can answer "may a rule actuate this?" without importing the schema barrel
 * (~144MB RSS per runner, D28).
 *
-* Coverage: 87 device-scoped capabilities.
+* Coverage: 88 device-scoped capabilities.
 */
 var DEVICE_SCOPED_CAPS = new Set([
 	"accessories",
@@ -4210,6 +4225,7 @@ var DEVICE_SCOPED_CAPS = new Set([
 	"detection-pipeline",
 	"device-admin-link",
 	"device-discovery",
+	"device-extension",
 	"device-ops",
 	"device-status",
 	"doorbell",
@@ -4433,4 +4449,4 @@ function sleepCancellable(ms, signal) {
 	});
 }
 //#endregion
-export { AudioStreamPickSchema as $, DeviceType as A, DATAPLANE_SECRET_HEADER as At, optionalMethod as B, WELL_KNOWN_TAB_MAP as Bt, customAction as C, parseProfileBrokerId as Ct, ChargingStatus as D, PEER_BYTES_STALL_MS as Dt, deviceCustomAction as E, PEER_BYTES_MAX_OUTSTANDING as Et, PROVIDER_PIN_FIELD as F, createDurableState as Ft, readNodePin as G, AUDIO_CHUNK_FORMATS as Gt, systemMethod as H, collectHydratedFieldValues as Ht, event as I, createEvent as It, ReadinessTimeoutError as J, isAudioChunkFormat as Jt, toNodeId as K, audioChunkBytesPerSample as Kt, expandCapMethods as L, emitReadiness as Lt, DEFAULT_RUNTIME_STATE_DURABILITY as M, DisposerChain as Mt, DEVICE_SETTINGS_CONTRIBUTION_METHODS as N, BaseAddon as Nt, DeviceFeature as O, PEER_BYTES_TICKET_TTL_MS as Ot, DEVICE_STATUS_METHOD as P, normalizeAddonInitResult as Pt, AudioChunkFormatSchema as Q, isDeviceConfigCap as R, isEvent as Rt, DEVICE_CHILDREN_BATCH_MAX as S, makeSourceBrokerId as St, describeCustomActions as T, PEER_BYTES_CHUNK_BYTES as Tt, CAP_NODE_PIN_CONTEXT_KEY as U, hydrateSchema as Ut, resolveCapMount as V, collectHydratedFieldEntries as Vt, nodePin as W, resolveHydratedFieldValue as Wt, readinessKey as X, emitDownForOwnedCaps as Y, scopeKey as Z, createMirrorSource as _, SubscribeAudioChunksInputSchema as _t, asJsonObject as a, CamStreamResolutionSchema as at, deviceOpsCapability as b, SubscribeFramesResultSchema as bt, parseJsonArray as c, DecodedFrameSchema as ct, BOOT_RECOVERY_BACKOFF_MS as d, FrameHandleSchema as dt, BrokerStatsSchema as et, DEVICE_SCOPED_CAPS as f, ProfileRtspEntrySchema as ft, createLazyTrpcSource as g, StreamSourceSchema as gt, createEventBusSliceSource as h, StreamSourceEntrySchema$1 as ht, asJsonArray as i, CamStreamKindSchema as it, adminUiCapability as j, SHARE_VIEW_KINDS as jt, DeviceRole as k, PeerBytesTicketSchema as kt, parseJsonObject as l, EncodedPacketSchema as lt, createDeviceProxy as m, ProfileSlotStatusSchema as mt, sleepCancellable as n, CAM_PROFILE_ORDER as nt, asNumber as o, CameraStreamSchema as ot, isDeviceScopedCap as p, ProfileSlotSchema as pt, ReadinessRegistry as q, expandAudioChunkToF32le as qt, asBoolean as r, CamProfileSchema as rt, asString as s, DecodedAudioChunkSchema as st, sleep as t, BrokerStatusSchema as tt, parseJsonUnknown as u, FrameHandleFormatSchema as ut, createSliceHandle as v, SubscribeAudioChunksResultSchema as vt, defineCustomActions as w, selectAssignedProfileSlots as wt, viewerUiCapability as x, makeProfileBrokerId as xt, RawStateResultSchema as y, SubscribeFramesInputSchema as yt, method as z, WELL_KNOWN_TABS as zt };
+export { AudioStreamPickSchema as $, DeviceType as A, DATAPLANE_SECRET_HEADER as At, optionalMethod as B, WELL_KNOWN_TABS as Bt, customAction as C, parseProfileBrokerId as Ct, ChargingStatus as D, PEER_BYTES_STALL_MS as Dt, deviceCustomAction as E, PEER_BYTES_MAX_OUTSTANDING as Et, PROVIDER_PIN_FIELD as F, normalizeNodeId as Ft, readNodePin as G, resolveHydratedFieldValue as Gt, systemMethod as H, collectHydratedFieldEntries as Ht, event as I, createDurableState as It, ReadinessTimeoutError as J, expandAudioChunkToF32le as Jt, toNodeId as K, AUDIO_CHUNK_FORMATS as Kt, expandCapMethods as L, createEvent as Lt, DEFAULT_RUNTIME_STATE_DURABILITY as M, DisposerChain as Mt, DEVICE_SETTINGS_CONTRIBUTION_METHODS as N, BaseAddon as Nt, DeviceFeature as O, PEER_BYTES_TICKET_TTL_MS as Ot, DEVICE_STATUS_METHOD as P, normalizeAddonInitResult as Pt, AudioChunkFormatSchema as Q, isDeviceConfigCap as R, emitReadiness as Rt, DEVICE_CHILDREN_BATCH_MAX as S, makeSourceBrokerId as St, describeCustomActions as T, PEER_BYTES_CHUNK_BYTES as Tt, CAP_NODE_PIN_CONTEXT_KEY as U, collectHydratedFieldValues as Ut, resolveCapMount as V, WELL_KNOWN_TAB_MAP as Vt, nodePin as W, hydrateSchema as Wt, readinessKey as X, emitDownForOwnedCaps as Y, isAudioChunkFormat as Yt, scopeKey as Z, createMirrorSource as _, SubscribeAudioChunksInputSchema as _t, asJsonObject as a, CamStreamResolutionSchema as at, deviceOpsCapability as b, SubscribeFramesResultSchema as bt, parseJsonArray as c, DecodedFrameSchema as ct, BOOT_RECOVERY_BACKOFF_MS as d, FrameHandleSchema as dt, BrokerStatsSchema as et, DEVICE_SCOPED_CAPS as f, ProfileRtspEntrySchema as ft, createLazyTrpcSource as g, StreamSourceSchema as gt, createEventBusSliceSource as h, StreamSourceEntrySchema$1 as ht, asJsonArray as i, CamStreamKindSchema as it, adminUiCapability as j, SHARE_VIEW_KINDS as jt, DeviceRole as k, PeerBytesTicketSchema as kt, parseJsonObject as l, EncodedPacketSchema as lt, createDeviceProxy as m, ProfileSlotStatusSchema as mt, sleepCancellable as n, CAM_PROFILE_ORDER as nt, asNumber as o, CameraStreamSchema as ot, isDeviceScopedCap as p, ProfileSlotSchema as pt, ReadinessRegistry as q, audioChunkBytesPerSample as qt, asBoolean as r, CamProfileSchema as rt, asString as s, DecodedAudioChunkSchema as st, sleep as t, BrokerStatusSchema as tt, parseJsonUnknown as u, FrameHandleFormatSchema as ut, createSliceHandle as v, SubscribeAudioChunksResultSchema as vt, defineCustomActions as w, selectAssignedProfileSlots as wt, viewerUiCapability as x, makeProfileBrokerId as xt, RawStateResultSchema as y, SubscribeFramesInputSchema as yt, method as z, isEvent as zt };