@camstack/types 1.2.260 → 1.2.261

package/dist/{sleep-BDYxE1ax.js → sleep-QxyLiUId.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),
@@ -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",
@@ -4949,6 +4965,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() {

package/dist/storage/atomic-write.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+export declare function writeFileAtomic(filePath: string, data: Uint8Array): Promise<void>;

package/dist/types/clip-model.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A CLIP model's feature-space contract — what every consumer of its vectors
+ * must agree on, carried BY THE MODEL rather than re-derived by each consumer.
+ *
+ * ## Why this lives on the catalog entry
+ *
+ * Until 2026-09-26 each fact was hard-coded where it was used: the text window
+ * (77) and pad id (0) in `text_encoder_inference.py`, the index name
+ * (`object-clip`) in the object-embedding store, the "is this a CLIP vector"
+ * test as `embeddingModelId.startsWith('mobileclip-')`, the search floor (0.2)
+ * in the cap default, and the dimension (512) behind a `getModelMeta` that fell
+ * back to MobileCLIP for any id it did not know. Every one of those is wrong for
+ * the next model, and each one failed SILENTLY for SigLIP2 in the 2026-09-26
+ * spike: vectors dropped before the store with no log, 768-d queries truncated
+ * to 512 and ranked as garbage, 97% of true matches under the 0.2 floor (D649).
+ *
+ * A model now declares its own contract here, and a model with no `clip` block
+ * is not a CLIP model to any consumer. That is also the seam Model Studio uses
+ * for a user-supplied CLIP model: its registry row carries the same block.
+ */
+import { z } from 'zod';
+/**
+ * `object-clip` (the historical MobileCLIP index, 512-d) or
+ * `object-clip-<model>`. Lower-case and dash-only so the sqlite-vec table name
+ * derived from it (`vec_` + non-word → `_`) cannot collide with another index's.
+ */
+export declare const CLIP_VECTOR_INDEX_PATTERN: RegExp;
+export declare const ClipModelMetaSchema: z.ZodObject<{
+    textModelId: z.ZodString;
+    embeddingDim: z.ZodNumber;
+    vectorIndex: z.ZodString;
+    tokenizerFile: z.ZodString;
+    contextLength: z.ZodNumber;
+    padId: z.ZodNumber;
+    searchMinScore: z.ZodNumber;
+}, z.core.$strip>;
+export type ClipModelMeta = z.infer<typeof ClipModelMetaSchema>;
+/**
+ * Model-relative search strictness. The operator picks how picky, the model
+ * says what that means in its own cosine band. On MobileCLIP (floor 0.2) these
+ * reproduce the admin UI's historical absolute presets 0.20 / 0.25 / 0.30.
+ */
+export declare const CLIP_SEARCH_STRICTNESS: readonly ["loose", "balanced", "strict"];
+export declare const ClipSearchStrictnessSchema: z.ZodEnum<{
+    loose: "loose";
+    balanced: "balanced";
+    strict: "strict";
+}>;
+export type ClipSearchStrictness = z.infer<typeof ClipSearchStrictnessSchema>;
+export declare const CLIP_STRICTNESS_FACTOR: Readonly<Record<ClipSearchStrictness, number>>;
+/** What a search asked for. Both absent ⇒ the model's own floor. */
+export interface ClipSearchFloorRequest {
+    /** An ABSOLUTE cosine floor. Wins when present — the caller named a number. */
+    readonly minScore?: number;
+    readonly strictness?: ClipSearchStrictness;
+}
+/**
+ * The cosine floor a search runs with.
+ *
+ * An explicit `minScore` is honoured verbatim: it is a number a caller chose,
+ * and silently rescaling it would make the same URL mean different things on
+ * two installs. Everything else is relative to the model.
+ */
+export declare function resolveClipSearchMinScore(meta: Pick<ClipModelMeta, 'searchMinScore'>, request: ClipSearchFloorRequest): number;

package/dist/types/models.d.ts

@@ -274,6 +274,15 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
         }>>;
         preserveOriginal: z.ZodBoolean;
     }, z.core.$strip>>;
+    clip: z.ZodOptional<z.ZodObject<{
+        textModelId: z.ZodString;
+        embeddingDim: z.ZodNumber;
+        vectorIndex: z.ZodString;
+        tokenizerFile: z.ZodString;
+        contextLength: z.ZodNumber;
+        padId: z.ZodNumber;
+        searchMinScore: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ModelCatalogEntry = z.infer<typeof ModelCatalogEntrySchema>;
 export interface DetectionModel {
@@ -515,6 +524,15 @@ export declare const ConvertResultSchema: z.ZodObject<{
             }>>;
             preserveOriginal: z.ZodBoolean;
         }, z.core.$strip>>;
+        clip: z.ZodOptional<z.ZodObject<{
+            textModelId: z.ZodString;
+            embeddingDim: z.ZodNumber;
+            vectorIndex: z.ZodString;
+            tokenizerFile: z.ZodString;
+            contextLength: z.ZodNumber;
+            padId: z.ZodNumber;
+            searchMinScore: z.ZodNumber;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         format: z.ZodEnum<{

package/package.json

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