@camstack/types 1.2.20 → 1.2.22

package/dist/index.js

@@ -964,14 +964,7 @@ var RecordingConfigSchema = zod.z.object({
 	* windows only — existing sheets are immutable, and each window's index
 	* carries its own tile dims so mixed-preset history renders correctly.
 	*/
-	scrubThumbnails: ScrubThumbnailPresetSchema.optional(),
-	/**
-	* OPT-IN thumbnail-strip generation for this camera: every keyframe of the
-	* low recording saved as a JPEG (the fast-drag scrub depth), a derived
-	* cache that eviction reclaims with the footage. Absent/false = no strips
-	* are written and scrub reads exact keyframes at every velocity.
-	*/
-	stripsEnabled: zod.z.boolean().optional()
+	scrubThumbnails: ScrubThumbnailPresetSchema.optional()
 }).strict();
 /**
 * Derive the {@link RecordingStorageModeSchema} summary from the authoritative
@@ -1060,7 +1053,7 @@ var OPS_LOG_DEFAULT_LIMIT = 200;
 /**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
 *
-* One shape shared by the recorder's `relocateFootage` (segments + strips) and
+* One shape shared by the recorder's `relocateFootage` (segments) and
 * pipeline-analytics' `relocateMedia` (event media blobs) so the admin Data
 * page renders both movers with one component. Jobs are in-RAM (a restart
 * forgets them — re-running is safe by construction: copy-if-absent, delete
@@ -1082,7 +1075,7 @@ var RelocateJobSchema = zod.z.object({
 	toLocationId: zod.z.string(),
 	/** Scoped device, or null = every device. */
 	deviceId: zod.z.number().nullable(),
-	/** What the job moves (owner-addon specific: segments/strips or media). */
+	/** What the job moves (owner-addon specific: segments or media). */
 	entities: zod.z.array(zod.z.string()),
 	filesMoved: zod.z.number().int(),
 	bytesMoved: zod.z.number().int(),
@@ -1096,7 +1089,7 @@ var RelocateFootageInputSchema = zod.z.object({
 	deviceId: zod.z.number().optional(),
 	fromLocationId: zod.z.string(),
 	toLocationId: zod.z.string(),
-	entities: zod.z.array(zod.z.enum(["segments", "strips"])).optional(),
+	entities: zod.z.array(zod.z.enum(["segments"])).optional(),
 	/** Copy throttle in MB/s (default 40) — the drain is a background chore,
 	*  never allowed to starve live writers. */
 	throttleMbps: zod.z.number().min(1).max(1e3).optional()
@@ -14928,6 +14921,8 @@ function createSystemProxy(api) {
 			insert: (input) => dispatch("settingsStore", "insert", "mutation", input),
 			update: (input) => dispatch("settingsStore", "update", "mutation", input),
 			delete: (input) => dispatch("settingsStore", "delete", "mutation", input),
+			deleteWhere: (input) => dispatch("settingsStore", "deleteWhere", "mutation", input),
+			updateWhere: (input) => dispatch("settingsStore", "updateWhere", "mutation", input),
 			count: (input) => dispatch("settingsStore", "count", "query", input),
 			histogram: (input) => dispatch("settingsStore", "histogram", "query", input),
 			isEmpty: (input) => dispatch("settingsStore", "isEmpty", "query", input),
@@ -17431,6 +17426,353 @@ var decoderCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/settings-store.cap.ts
+/**
+* Query filter for settings-store collections.
+*/
+var QueryFilterSchema = zod.z.object({
+	where: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+	whereIn: zod.z.record(zod.z.string(), zod.z.array(zod.z.unknown())).optional(),
+	whereBetween: zod.z.record(zod.z.string(), zod.z.tuple([zod.z.unknown(), zod.z.unknown()])).optional(),
+	orderBy: zod.z.object({
+		field: zod.z.string(),
+		direction: zod.z.enum(["asc", "desc"])
+	}).optional(),
+	limit: zod.z.number().optional(),
+	offset: zod.z.number().optional()
+});
+/**
+* The predicate half of a filter, for BULK MUTATIONS.
+*
+* Deliberately not `QueryFilterSchema`: `orderBy` / `limit` / `offset` have no
+* meaning for a statement that rewrites a set, and accepting them would invite
+* a caller to believe `limit` bounds the damage. Every field is optional here
+* only so the shape stays composable — the implementation REJECTS a filter
+* that compiles to no predicate, because that is the whole collection.
+*/
+var MutationFilterSchema = zod.z.object({
+	where: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+	whereIn: zod.z.record(zod.z.string(), zod.z.array(zod.z.unknown())).optional(),
+	whereBetween: zod.z.record(zod.z.string(), zod.z.tuple([zod.z.unknown(), zod.z.unknown()])).optional()
+});
+/** A single stored record: `{ id, data }`. */
+var SettingsRecordSchema = zod.z.object({
+	id: zod.z.string(),
+	data: zod.z.record(zod.z.string(), zod.z.unknown())
+});
+/**
+* Column declaration for a structured (SQL-backed) collection.
+*
+* Logical types — the backend translates each to the matching SQLite
+* storage class and handles per-type marshaling:
+*   - `TEXT` / `INTEGER` / `REAL` — native SQLite types, pass-through
+*   - `JSON`    — TEXT under the hood; serialised on write, parsed on read
+*   - `BOOLEAN` — INTEGER 0/1 under the hood; coerced both directions
+*/
+var CollectionColumnSchema = zod.z.object({
+	name: zod.z.string(),
+	type: zod.z.enum([
+		"TEXT",
+		"INTEGER",
+		"REAL",
+		"JSON",
+		"BOOLEAN"
+	]),
+	primaryKey: zod.z.boolean().optional(),
+	notNull: zod.z.boolean().optional(),
+	unique: zod.z.boolean().optional()
+});
+var CollectionIndexSchema = zod.z.object({
+	name: zod.z.string(),
+	columns: zod.z.array(zod.z.string()).readonly(),
+	unique: zod.z.boolean().optional()
+});
+/**
+* settings-store — singleton capability for addon-scoped persistence.
+*
+* Every method operates within a `collection`. An optional `namespace`
+* field provides access to additional data spaces beyond the default
+* addon settings — useful for business data (events, tracks, faces, etc.).
+*
+* **Scoping is the CALLER's, and it is opt-in.** The table is
+* `namespace ? `${namespace}:${collection}` : collection` — nothing
+* consults the identity of the caller. An earlier version of this comment
+* claimed the implementation prefixes every collection with the calling
+* addon's ID and that "addons never see each other's data"; that was never
+* true, and this same file contradicted it under `declareCollection`. What
+* exists is `addon-context-factory`, which passes `namespace: addonId` ON
+* THE ADDON'S BEHALF for the `addon-settings` / `addon-devices` paths only.
+* Business collections use bare names, and any caller may name any
+* namespace, or none. Making the door enforce it is tracked separately —
+* it renames tables, so it needs a migration.
+*
+*   - `{ collection: 'addon-settings' }` → table `addon-settings`
+*   - `{ namespace: 'my-addon', collection: 'addon-settings' }` →
+*     table `my-addon:addon-settings`
+*
+* Served by the **storage-orchestrator** builtin, which dispatches to the
+* `data-store-provider` engine registered for the collection
+* (`sqlite-settings`, a SQLite WAL backend, today). One addon owns the
+* data door; engines sit behind it
+* ([D44](../../../../docs/decisions/adr-0044.md)).
+* Addons access it via `ctx.api.settingsStore.*`.
+*/
+var settingsStoreCapability = {
+	name: "settings-store",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		/** Get a single value by key from a collection. */
+		get: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			key: zod.z.string()
+		}), zod.z.unknown()),
+		/** Set a value by key in a collection (upsert). */
+		set: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			key: zod.z.string(),
+			value: zod.z.unknown()
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Get all entries matching an optional filter. */
+		query: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: QueryFilterSchema.optional()
+		}), zod.z.array(SettingsRecordSchema).readonly()),
+		/** Insert a new record. */
+		insert: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			record: SettingsRecordSchema
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Update an existing record by ID. */
+		update: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			id: zod.z.string(),
+			data: zod.z.record(zod.z.string(), zod.z.unknown())
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Delete a record by key/ID. */
+		delete: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			key: zod.z.string()
+		}), zod.z.void(), { kind: "mutation" }),
+		/**
+		* Delete every record matching `filter`, in ONE statement, returning how
+		* many rows went. This exists because its absence made every retention
+		* path in the system an N+1 drain loop: `delete` takes a key, so a sweep
+		* had to SELECT a page of full rows — every column, including the fat
+		* ones — purely to learn their ids, then issue one call per row.
+		*
+		* **The filter is required and must resolve.** A predicate naming
+		* something the collection cannot express is an ERROR here, not a
+		* widening as it is on `query`, and a filter with no predicates is an
+		* error rather than "every row". Deleting a whole collection is a
+		* legitimate intent, but it must be asked for by name — not reached by
+		* an empty object.
+		*/
+		deleteWhere: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: MutationFilterSchema
+		}), zod.z.object({ deleted: zod.z.number().int() }), { kind: "mutation" }),
+		/**
+		* Apply `data` to every record matching `filter`, in one statement,
+		* returning how many rows changed. Same filter contract as
+		* {@link deleteWhere} — an unresolvable predicate is an error.
+		*/
+		updateWhere: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: MutationFilterSchema,
+			data: zod.z.record(zod.z.string(), zod.z.unknown())
+		}), zod.z.object({ updated: zod.z.number().int() }), { kind: "mutation" }),
+		/** Count entries in a collection, optionally filtered. */
+		count: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: QueryFilterSchema.optional()
+		}), zod.z.number()),
+		/** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
+		histogram: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			field: zod.z.string(),
+			bucketSize: zod.z.number().int().positive(),
+			origin: zod.z.number().int(),
+			filter: QueryFilterSchema.optional()
+		}), zod.z.array(zod.z.object({
+			bucket: zod.z.number().int(),
+			count: zod.z.number().int()
+		})).readonly()),
+		/** Check if a collection is empty. */
+		isEmpty: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string()
+		}), zod.z.boolean()),
+		/**
+		* Declare a typed (SQL-backed) collection with explicit columns +
+		* indexes. Idempotent: re-declaring an existing collection with the
+		* same shape is a no-op; shape changes (new columns, new indexes)
+		* are applied additively. Subsequent `insert` / `update` / `delete`
+		* / `query` calls on this collection use typed columns instead of
+		* JSON-blob storage — `record.data` fields are spread across
+		* columns, `query.filter.where` matches real columns (no
+		* `json_extract` overhead), `orderBy` uses column indexes.
+		*
+		* Addons call this in `onInitialize` before their first read/write.
+		* Collection names should be namespaced by addon (e.g.
+		* `pipeline-analytics:object-events`) to avoid cross-addon
+		* clashes — no automatic prefix is added.
+		*/
+		declareCollection: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			columns: zod.z.array(CollectionColumnSchema).readonly(),
+			indexes: zod.z.array(CollectionIndexSchema).readonly().optional()
+		}), zod.z.void(), { kind: "mutation" })
+	}
+};
+//#endregion
+//#region src/capabilities/data-store-provider.cap.ts
+/**
+* What one engine says about itself. The orchestrator uses `kind` to pick
+* a registrant for a collection; `engineId` is what a log line names when
+* a call is routed or refused.
+*/
+var EngineInfoSchema = zod.z.object({
+	engineId: zod.z.string(),
+	/**
+	* `relational` — rows, columns, indexes, the surface `settings-store`
+	* has always described. `vector` — an embedding store answering
+	* similarity queries. A registrant declares exactly one; an engine that
+	* does both registers twice, because "both" would make the routing
+	* decision ambiguous at exactly the point it must not be.
+	*/
+	kind: zod.z.enum(["relational", "vector"]),
+	displayName: zod.z.string()
+});
+/**
+* data-store-provider — the engine contract behind the data door.
+*
+* The sibling of `storage-provider`, for rows instead of bytes. The
+* orchestrator (singleton `settings-store` cap, owned by the
+* storage-orchestrator builtin) dispatches every call to the registrant
+* that serves the collection.
+*
+* `internal: true` — consumed only by the orchestrator. Public consumers
+* go through `settings-store`; they never see this cap, and an engine
+* never sees a caller.
+*
+* Design notes:
+*   - **Stateless dispatch.** Every method carries its own
+*     `namespace` + `collection`, so an engine keeps no per-caller state
+*     and the orchestrator forwards the payload verbatim. Scoping is a
+*     property of the input, not of the connection — see the note on
+*     `settings-store` about what that does and does not guarantee.
+*   - **One registrant today** (`sqlite-settings`). The collection shape
+*     exists so a second engine is a registration rather than a second
+*     door ([D44](../../../../docs/decisions/adr-0044.md)).
+*
+* The method set is deliberately identical to `settings-store`'s: the
+* orchestrator is a router, not a translator. A capability the door
+* gains, an engine must be able to answer.
+*/
+var dataStoreProviderCapability = {
+	name: "data-store-provider",
+	scope: "system",
+	mode: "collection",
+	internal: true,
+	methods: {
+		/** Self-description — how the orchestrator picks a registrant. */
+		getEngineInfo: require_sleep.method(zod.z.void(), EngineInfoSchema),
+		/** Get a single value by key from a collection. */
+		get: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			key: zod.z.string()
+		}), zod.z.unknown()),
+		/** Set a value by key in a collection (upsert). */
+		set: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			key: zod.z.string(),
+			value: zod.z.unknown()
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Get all entries matching an optional filter. */
+		query: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: QueryFilterSchema.optional()
+		}), zod.z.array(SettingsRecordSchema).readonly()),
+		/** Insert a new record. */
+		insert: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			record: SettingsRecordSchema
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Update an existing record by ID. */
+		update: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			id: zod.z.string(),
+			data: zod.z.record(zod.z.string(), zod.z.unknown())
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Delete a record by key/ID. */
+		delete: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			key: zod.z.string()
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Delete every record matching `filter`, in one statement. */
+		deleteWhere: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: MutationFilterSchema
+		}), zod.z.object({ deleted: zod.z.number().int() }), { kind: "mutation" }),
+		/** Apply `data` to every record matching `filter`, in one statement. */
+		updateWhere: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: MutationFilterSchema,
+			data: zod.z.record(zod.z.string(), zod.z.unknown())
+		}), zod.z.object({ updated: zod.z.number().int() }), { kind: "mutation" }),
+		/** Count entries in a collection, optionally filtered. */
+		count: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			filter: QueryFilterSchema.optional()
+		}), zod.z.number()),
+		/** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
+		histogram: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			field: zod.z.string(),
+			bucketSize: zod.z.number().int().positive(),
+			origin: zod.z.number().int(),
+			filter: QueryFilterSchema.optional()
+		}), zod.z.array(zod.z.object({
+			bucket: zod.z.number().int(),
+			count: zod.z.number().int()
+		})).readonly()),
+		/** Check if a collection is empty. */
+		isEmpty: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string()
+		}), zod.z.boolean()),
+		/** Declare a typed (SQL-backed) collection with columns + indexes. */
+		declareCollection: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			collection: zod.z.string(),
+			columns: zod.z.array(CollectionColumnSchema).readonly(),
+			indexes: zod.z.array(CollectionIndexSchema).readonly().optional()
+		}), zod.z.void(), { kind: "mutation" })
+	}
+};
+//#endregion
 //#region src/capabilities/detection-pipeline.cap.ts
 /**
 * detection-pipeline — device-scoped facade over the system
@@ -21913,6 +22255,52 @@ var ServerUpdateStateSchema = zod.z.enum([
 	"pending-restart",
 	"awaiting-confirmation"
 ]);
+/**
+* Verdict of comparing the node's IMMUTABLE baked seed (the Docker image / the
+* desktop app bundle) against the release the deployment contract would
+* deliver today. `applyServerUpdate` swaps the data-root closure and NEVER
+* touches the image, so `runningVersion` can be perfectly current while the
+* container is weeks old, from a renamed repository nothing rebuilds — which
+* is exactly what happened on 2026-08-02 (hub on `camstack-server:intel-1.1.74`
+* while every existing surface said "up to date"). The seed version is the one
+* image fingerprint a container can see from inside (no docker socket).
+*
+*  - `in-sync`       — seed equals the current release; the node runs the
+*                      contract image.
+*  - `behind-patch`  — same release series, older patch: the image predates
+*                      the current release. Normal between deliberate image
+*                      refreshes, but the starter/entrypoint are still old.
+*  - `behind-series` — the seed's major/minor predates the current release
+*                      series. The shape of a pinned tag or a dead image
+*                      repository; a `docker pull` may fix nothing.
+*  - `ahead`         — seed newer than the best-known release (stale registry
+*                      check).
+*  - `unknown`       — no seed (dev workspace) or nothing to compare against
+*                      yet.
+*/
+var ImageContractStateSchema = zod.z.enum([
+	"in-sync",
+	"behind-patch",
+	"behind-series",
+	"ahead",
+	"unknown"
+]);
+var ImageContractSchema = zod.z.object({
+	state: ImageContractStateSchema,
+	/** The baked seed closure version — the image/app-bundle fingerprint. */
+	seedVersion: zod.z.string().nullable(),
+	/** Best-known version the deployment contract delivers today. */
+	contractVersion: zod.z.string().nullable(),
+	/**
+	* Where `contractVersion` came from: a real registry check (`registry`), or
+	* the node's own running version (`running` — a node can never run code
+	* newer than the newest release, so `seed < running` proves image staleness
+	* even before any registry check has run).
+	*/
+	contractSource: zod.z.enum(["registry", "running"]).nullable(),
+	/** One operator-grade sentence: this node runs image X; the contract says Y. */
+	message: zod.z.string()
+});
 var ServerRollbackInfoSchema = zod.z.object({
 	/** The version that failed (or was manually rolled back). */
 	fromVersion: zod.z.string(),
@@ -21949,7 +22337,12 @@ var ServerPackageStatusSchema = zod.z.object({
 	* versions are being IGNORED. Surfaced as a warning in the UI.
 	*/
 	stateFileCorrupt: zod.z.boolean(),
-	lastCheckedAtMs: zod.z.number().nullable()
+	lastCheckedAtMs: zod.z.number().nullable(),
+	/**
+	* Seed-vs-contract verdict (see {@link ImageContractSchema}). Optional for
+	* version skew: an older provider's payload simply omits it.
+	*/
+	imageContract: ImageContractSchema.optional()
 });
 var ServerUpdateCheckResultSchema = zod.z.object({
 	packageName: zod.z.string(),
@@ -22004,160 +22397,6 @@ version: zod.z.string().optional() }), ServerUpdateActionResultSchema, {
 	mount: { kind: "server-provided" }
 };
 //#endregion
-//#region src/capabilities/settings-store.cap.ts
-/**
-* Query filter for settings-store collections.
-*/
-var QueryFilterSchema = zod.z.object({
-	where: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-	whereIn: zod.z.record(zod.z.string(), zod.z.array(zod.z.unknown())).optional(),
-	whereBetween: zod.z.record(zod.z.string(), zod.z.tuple([zod.z.unknown(), zod.z.unknown()])).optional(),
-	orderBy: zod.z.object({
-		field: zod.z.string(),
-		direction: zod.z.enum(["asc", "desc"])
-	}).optional(),
-	limit: zod.z.number().optional(),
-	offset: zod.z.number().optional()
-});
-/** A single stored record: `{ id, data }`. */
-var SettingsRecordSchema = zod.z.object({
-	id: zod.z.string(),
-	data: zod.z.record(zod.z.string(), zod.z.unknown())
-});
-/**
-* Column declaration for a structured (SQL-backed) collection.
-*
-* Logical types — the backend translates each to the matching SQLite
-* storage class and handles per-type marshaling:
-*   - `TEXT` / `INTEGER` / `REAL` — native SQLite types, pass-through
-*   - `JSON`    — TEXT under the hood; serialised on write, parsed on read
-*   - `BOOLEAN` — INTEGER 0/1 under the hood; coerced both directions
-*/
-var CollectionColumnSchema = zod.z.object({
-	name: zod.z.string(),
-	type: zod.z.enum([
-		"TEXT",
-		"INTEGER",
-		"REAL",
-		"JSON",
-		"BOOLEAN"
-	]),
-	primaryKey: zod.z.boolean().optional(),
-	notNull: zod.z.boolean().optional(),
-	unique: zod.z.boolean().optional()
-});
-var CollectionIndexSchema = zod.z.object({
-	name: zod.z.string(),
-	columns: zod.z.array(zod.z.string()).readonly(),
-	unique: zod.z.boolean().optional()
-});
-/**
-* settings-store — singleton capability for addon-scoped persistence.
-*
-* Every method operates within a `collection`. An optional `namespace`
-* field provides access to additional data spaces beyond the default
-* addon settings — useful for business data (events, tracks, faces, etc.).
-*
-* Scoping: the implementation prefixes every collection with the calling
-* addon's ID automatically. Addons never see each other's data.
-*
-*   - No namespace (default): `"addon-settings"` → `"<addonId>:addon-settings"`
-*   - With namespace: `{ namespace: 'events', collection: 'detections' }` →
-*     `"<addonId>:events:detections"`
-*
-* Implemented by `@camstack/system/builtins/sqlite-settings` (SQLite WAL backend).
-* Addons access it via `ctx.api.settingsStore.*`.
-*/
-var settingsStoreCapability = {
-	name: "settings-store",
-	scope: "system",
-	mode: "singleton",
-	methods: {
-		/** Get a single value by key from a collection. */
-		get: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			key: zod.z.string()
-		}), zod.z.unknown()),
-		/** Set a value by key in a collection (upsert). */
-		set: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			key: zod.z.string(),
-			value: zod.z.unknown()
-		}), zod.z.void(), { kind: "mutation" }),
-		/** Get all entries matching an optional filter. */
-		query: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			filter: QueryFilterSchema.optional()
-		}), zod.z.array(SettingsRecordSchema).readonly()),
-		/** Insert a new record. */
-		insert: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			record: SettingsRecordSchema
-		}), zod.z.void(), { kind: "mutation" }),
-		/** Update an existing record by ID. */
-		update: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			id: zod.z.string(),
-			data: zod.z.record(zod.z.string(), zod.z.unknown())
-		}), zod.z.void(), { kind: "mutation" }),
-		/** Delete a record by key/ID. */
-		delete: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			key: zod.z.string()
-		}), zod.z.void(), { kind: "mutation" }),
-		/** Count entries in a collection, optionally filtered. */
-		count: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			filter: QueryFilterSchema.optional()
-		}), zod.z.number()),
-		/** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
-		histogram: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			field: zod.z.string(),
-			bucketSize: zod.z.number().int().positive(),
-			origin: zod.z.number().int(),
-			filter: QueryFilterSchema.optional()
-		}), zod.z.array(zod.z.object({
-			bucket: zod.z.number().int(),
-			count: zod.z.number().int()
-		})).readonly()),
-		/** Check if a collection is empty. */
-		isEmpty: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string()
-		}), zod.z.boolean()),
-		/**
-		* Declare a typed (SQL-backed) collection with explicit columns +
-		* indexes. Idempotent: re-declaring an existing collection with the
-		* same shape is a no-op; shape changes (new columns, new indexes)
-		* are applied additively. Subsequent `insert` / `update` / `delete`
-		* / `query` calls on this collection use typed columns instead of
-		* JSON-blob storage — `record.data` fields are spread across
-		* columns, `query.filter.where` matches real columns (no
-		* `json_extract` overhead), `orderBy` uses column indexes.
-		*
-		* Addons call this in `onInitialize` before their first read/write.
-		* Collection names should be namespaced by addon (e.g.
-		* `pipeline-analytics:object-events`) to avoid cross-addon
-		* clashes — no automatic prefix is added.
-		*/
-		declareCollection: require_sleep.method(zod.z.object({
-			namespace: zod.z.string().optional(),
-			collection: zod.z.string(),
-			columns: zod.z.array(CollectionColumnSchema).readonly(),
-			indexes: zod.z.array(CollectionIndexSchema).readonly().optional()
-		}), zod.z.void(), { kind: "mutation" })
-	}
-};
-//#endregion
 //#region src/capabilities/smtp-provider.cap.ts
 /**
 * `smtp-provider` — pluggable email delivery surface.
@@ -25925,7 +26164,7 @@ var recordingCapability = {
 			auth: "admin"
 		}),
 		/**
-		* Move footage (segments and/or strips) from one recordings location to
+		* Move footage (recorded segments) from one recordings location to
 		* another — the drain workflow's mover (entity-routing spec Phase 4).
 		* Throttled copy → size-verify → delete source → index refresh; resumable
 		* by construction (copy-if-absent). Single-flight: one job at a time.
@@ -26840,6 +27079,7 @@ var CAPABILITY_NAMES = {
 	control: "control",
 	cover: "cover",
 	customModelRegistry: "custom-model-registry",
+	dataStoreProvider: "data-store-provider",
 	dayNight: "day-night",
 	decoder: "decoder",
 	detectionPipeline: "detection-pipeline",
@@ -27097,6 +27337,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "customModelRegistry",
 		name: "custom-model-registry"
 	},
+	{
+		key: "dataStoreProvider",
+		name: "data-store-provider"
+	},
 	{
 		key: "dayNight",
 		name: "day-night"
@@ -27569,6 +27813,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	controlCapability,
 	coverCapability,
 	customModelRegistryCapability,
+	dataStoreProviderCapability,
 	dayNightCapability,
 	decoderCapability,
 	detectionPipelineCapability,
@@ -28578,6 +28823,84 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"dataStoreProvider.count": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.declareCollection": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"dataStoreProvider.delete": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"dataStoreProvider.deleteWhere": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"dataStoreProvider.get": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.getEngineInfo": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.histogram": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.insert": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"dataStoreProvider.isEmpty": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.query": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.set": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"dataStoreProvider.update": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"dataStoreProvider.updateWhere": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dayNight.getOptions": {
 		capName: "day-night",
 		capScope: "device",
@@ -31656,6 +31979,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"settingsStore.deleteWhere": {
+		capName: "settings-store",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"settingsStore.get": {
 		capName: "settings-store",
 		capScope: "system",
@@ -31698,6 +32027,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"settingsStore.updateWhere": {
+		capName: "settings-store",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"smtpProvider.getStatus": {
 		capName: "smtp-provider",
 		capScope: "system",
@@ -32745,6 +33080,7 @@ var KNOWN_CAP_NAMES = [
 	"control",
 	"cover",
 	"custom-model-registry",
+	"data-store-provider",
 	"day-night",
 	"decoder",
 	"device-adoption",
@@ -32907,6 +33243,7 @@ var SYSTEM_CAP_NAMES = [
 	"backup",
 	"broker",
 	"custom-model-registry",
+	"data-store-provider",
 	"decoder",
 	"device-adoption",
 	"device-export",
@@ -33727,6 +34064,7 @@ exports.DEVICE_SETTINGS_CONTRIBUTION_METHODS = require_sleep.DEVICE_SETTINGS_CON
 exports.DEVICE_STATUS_METHOD = require_sleep.DEVICE_STATUS_METHOD;
 exports.DEVICE_TYPE_CONTROL_KIND = DEVICE_TYPE_CONTROL_KIND;
 exports.DEVICE_TYPE_INFO = DEVICE_TYPE_INFO;
+exports.DataStoreEngineInfoSchema = EngineInfoSchema;
 exports.DayNightModeSchema = DayNightModeSchema;
 exports.DayNightOptionsSchema = DayNightOptionsSchema;
 exports.DayNightSettingsPatchSchema = DayNightSettingsPatchSchema;
@@ -33816,6 +34154,8 @@ exports.HistoryResolutionEnum = HistoryResolutionEnum;
 exports.HumidifierStatusSchema = HumidifierStatusSchema;
 exports.HumiditySensorStatusSchema = HumiditySensorStatusSchema;
 exports.HvacModeSchema = HvacModeSchema;
+exports.ImageContractSchema = ImageContractSchema;
+exports.ImageContractStateSchema = ImageContractStateSchema;
 exports.ImageRotateSchema = ImageRotateSchema;
 exports.ImageSettingsOptionsSchema = ImageSettingsOptionsSchema;
 exports.ImageSettingsPatchSchema = ImageSettingsPatchSchema;
@@ -33913,6 +34253,7 @@ exports.MotionZonePatchSchema = MotionZonePatchSchema;
 exports.MotionZoneRegionSchema = MotionZoneRegionSchema;
 exports.MotionZoneStatusSchema = MotionZoneStatusSchema;
 exports.MqttBrokerStatusSchema = StatusSchema;
+exports.MutationFilterSchema = MutationFilterSchema;
 exports.NC_BASE_CONDITION_KEYS = NC_BASE_CONDITION_KEYS;
 exports.NC_CONDITION_CATALOG = NC_CONDITION_CATALOG;
 exports.NC_HISTORY_LIMIT_DEFAULT = NC_HISTORY_LIMIT_DEFAULT;
@@ -34284,6 +34625,7 @@ exports.createSliceHandle = require_sleep.createSliceHandle;
 exports.createSystemProxy = createSystemProxy;
 exports.customAction = customAction;
 exports.customModelRegistryCapability = customModelRegistryCapability;
+exports.dataStoreProviderCapability = dataStoreProviderCapability;
 exports.dayNightCapability = dayNightCapability;
 exports.decoderCapability = decoderCapability;
 exports.defaultDeviceFor = defaultDeviceFor;