@camstack/types 1.2.260 → 1.2.262

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/pipeline/step-format-runnable.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The ONE answer to "can a pool of `format` run this step?" (D657).
+ *
+ * A step can run on a format when the model it NAMES ships a build for that
+ * format, or when a NON-legacy model of the step does (the format-default
+ * resolution picks among those). A `legacy` build is a catalog stub kept for
+ * explicit selection — the Coral face SSD has no working postprocessor — so it
+ * makes a format runnable only when it is the model named.
+ *
+ * Every placement decision reads this: the orchestrator's provisioning gate
+ * (`addonHasCompatibleModel`), the executor's dispatch gate
+ * (`collectZeroBuildIssues`) and the runner's device jump
+ * (`buildSubtreeCanRun`). Three rules for this question existed before; two of
+ * them counted the legacy stub and one did not, so the runner jumped a face
+ * step off the Coral while the executor loaded it there, and the root's load
+ * failed with it.
+ *
+ * Lives in the bare `@camstack/types` entry, which every addon bundles
+ * (`self-contained` externals), so it travels with a `camstack deploy`.
+ */
+/** The catalog facts one model contributes: its id, its builds, and whether it is a legacy stub. */
+export interface FormatRunnableModel {
+    readonly id: string;
+    readonly legacy?: boolean;
+    readonly formats: Readonly<Record<string, unknown>>;
+}
+/**
+ * Can a pool of `format` run a step whose catalog is `models`, given the model
+ * the step names (`null`/absent = unpinned, the format default)?
+ */
+export declare function stepModelRunsOnFormat(models: readonly FormatRunnableModel[], modelId: string | null | undefined, format: string): boolean;

package/dist/{sleep-BDYxE1ax.js → sleep-8K9gue-H.js}

@@ -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),
@@ -3629,12 +3674,7 @@ function createDeviceProxy(api, binding, opts) {
 			getRawState: (input) => dispatch("device-ops", "deviceOps", "getRawState", "query", input)
 		},
 		deviceStatus: { getStatus: (input) => dispatch("device-status", "deviceStatus", "getStatus", "query", input) },
-		doorbell: {
-			getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input),
-			getDeviceSettingsContribution: (input) => dispatch("doorbell", "doorbell", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatch("doorbell", "doorbell", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatch("doorbell", "doorbell", "applyDeviceSettingsPatch", "mutation", input)
-		},
+		doorbell: { getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input) },
 		enumSensor: { getStatus: (input) => dispatch("enum-sensor", "enumSensor", "getStatus", "query", input) },
 		eventEmitter: { getStatus: (input) => dispatch("event-emitter", "eventEmitter", "getStatus", "query", input) },
 		fanControl: {
@@ -3737,30 +3777,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 +4034,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),
@@ -4067,12 +4078,8 @@ function createDeviceProxy(api, binding, opts) {
 			updateDeviceField: (input) => dispatchSystem("deviceManager", "updateDeviceField", "mutation", input),
 			updateDeviceFieldsBatch: (input) => dispatchSystem("deviceManager", "updateDeviceFieldsBatch", "mutation", input),
 			testField: (input) => dispatchSystem("deviceManager", "testField", "mutation", input),
-			getDeviceStatusAggregate: (input) => dispatchSystem("deviceManager", "getDeviceStatusAggregate", "query", input),
-			getDeviceSettingsContribution: (input) => dispatchSystem("deviceManager", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatchSystem("deviceManager", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatchSystem("deviceManager", "applyDeviceSettingsPatch", "mutation", input)
+			getDeviceStatusAggregate: (input) => dispatchSystem("deviceManager", "getDeviceStatusAggregate", "query", 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 +4093,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 +4116,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 +4187,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 +4217,7 @@ var DEVICE_SCOPED_CAPS = new Set([
 	"detection-pipeline",
 	"device-admin-link",
 	"device-discovery",
+	"device-extension",
 	"device-ops",
 	"device-status",
 	"doorbell",
@@ -4949,6 +4957,12 @@ Object.defineProperty(exports, "normalizeAddonInitResult", {
 		return normalizeAddonInitResult;
 	}
 });
+Object.defineProperty(exports, "normalizeNodeId", {
+	enumerable: true,
+	get: function() {
+		return normalizeNodeId;
+	}
+});
 Object.defineProperty(exports, "optionalMethod", {
 	enumerable: true,
 	get: function() {