@camstack/system 1.2.29 → 1.2.31

package/dist/builtins/storage-orchestrator/storage-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { $ as storageCapability, Et as parseJsonObject, Z as settingsStoreCapability, d as StorageLocationTypeSchema, ot as BaseAddon } from "../../dist-B7hOpr5i.mjs";
+import { $ as storageCapability, Et as parseJsonObject, Z as settingsStoreCapability, d as StorageLocationTypeSchema, ot as BaseAddon } from "../../dist-CNmXITJ-.mjs";
 import * as path$1 from "node:path";
 import * as fs from "node:fs/promises";
 import { buildStorageLocationRegistry } from "@camstack/system";
@@ -528,7 +528,7 @@ var StorageOrchestratorService = class {
 };
 //#endregion
 //#region src/builtins/storage-orchestrator/location-store.ts
-var STORAGE_LOCATIONS_TABLE = "storage_locations";
+var STORAGE_LOCATIONS = "storage_locations";
 /**
 * Reserved key under which the cluster `nodeId` (SP1) is persisted INSIDE
 * the `config` JSON blob. Storing it in the blob rather than a dedicated
@@ -541,125 +541,147 @@ var STORAGE_LOCATIONS_TABLE = "storage_locations";
 * API consumers and providers never see it.
 */
 var NODE_ID_CONFIG_KEY = "__nodeId";
-var STORAGE_LOCATIONS_SCHEMA = {
-	columns: [
-		{
-			name: "id",
-			type: "TEXT",
-			primaryKey: true
-		},
-		{
-			name: "type",
-			type: "TEXT",
-			notNull: true
-		},
-		{
-			name: "display_name",
-			type: "TEXT",
-			notNull: true
-		},
-		{
-			name: "provider_id",
-			type: "TEXT",
-			notNull: true
-		},
-		{
-			name: "config",
-			type: "TEXT",
-			notNull: true,
-			defaultValue: "{}"
-		},
-		{
-			name: "is_default",
-			type: "INTEGER",
-			notNull: true,
-			defaultValue: 0
-		},
-		{
-			name: "is_system",
-			type: "INTEGER",
-			notNull: true,
-			defaultValue: 0
-		},
-		{
-			name: "created_at",
-			type: "INTEGER",
-			notNull: true
-		},
-		{
-			name: "updated_at",
-			type: "INTEGER",
-			notNull: true
-		}
-	],
-	indexes: [{
-		name: "idx_storage_locations_type",
-		columns: ["type"]
-	}]
-};
 /**
-* SQLite-backed implementation of `ILocationStore` — uses the
-* `settings-store` cap's structured-table surface (`ensureTable` /
-* `tableInsert` / `tableUpdate` / `tableDelete` / `tableQuery`). Wired
-* to the live `ISettingsBackend` provider obtained from
-* `kernel.capabilityRegistry.getSingleton('settings-store')`.
-*
-* The cap-router surface (`ctx.api.settingsStore.*`) does NOT expose
-* the `tableXxx` methods — they're only on the raw `ISettingsBackend`.
-* Same constraint that drives `IntegrationRegistry` to take a direct
-* provider reference instead of going through the cap.
+* `config` is declared `JSON`, so the store hands the surface an object and
+* gets an object back. There is deliberately NO `node_id` column — `nodeId`
+* rides inside the blob under a reserved key (see {@link NODE_ID_CONFIG_KEY}),
+* because a newly-declared column would put this table through
+* `declareCollection`'s destructive rebuild and wipe operator customizations
+* such as `recordings:default`'s `minFreePercent`.
+*/
+var STORAGE_LOCATIONS_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true
+	},
+	{
+		name: "type",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "display_name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "provider_id",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "config",
+		type: "JSON",
+		notNull: true,
+		defaultValue: "{}"
+	},
+	{
+		name: "is_default",
+		type: "INTEGER",
+		notNull: true,
+		defaultValue: 0
+	},
+	{
+		name: "is_system",
+		type: "INTEGER",
+		notNull: true,
+		defaultValue: 0
+	},
+	{
+		name: "created_at",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "updated_at",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+var STORAGE_LOCATIONS_INDEXES = [{
+	name: "idx_storage_locations_type",
+	columns: ["type"]
+}];
+/**
+* `ILocationStore` on the `settings-store` collection surface — the same door
+* every other consumer uses. It holds the `data-store-provider` engine object
+* directly (not the `settings-store` singleton) because since D44 the
+* storage-orchestrator IS that singleton, and asking the registry for it would
+* route this table back through the orchestrator itself.
 */
 var SqliteLocationStore = class {
-	backend;
-	tableEnsured = false;
-	constructor(backend) {
-		this.backend = backend;
+	store;
+	declared = false;
+	constructor(store) {
+		this.store = store;
 	}
 	/**
-	* Lazy `ensureTable` — keeps the constructor cheap and async-free.
-	* Called from every mutation/read path; the backend's `ensureTable`
-	* is itself idempotent (additive migration), so repeated calls are
-	* effectively no-ops after the first.
+	* Lazy `declareCollection` — keeps the constructor cheap and async-free.
+	* Called from every mutation/read path; `declareCollection` is idempotent
+	* (and additive on shape changes), so repeated calls collapse to a no-op.
 	*/
-	async ensureTable() {
-		if (this.tableEnsured) return;
-		if (!this.backend.ensureTable) throw new Error("SqliteLocationStore: settings backend does not implement ensureTable — expected the SQLite settings backend, got a backend without structured-table support");
-		await this.backend.ensureTable(STORAGE_LOCATIONS_TABLE, STORAGE_LOCATIONS_SCHEMA);
-		this.tableEnsured = true;
+	async ensureDeclared() {
+		if (this.declared) return;
+		await this.store.declareCollection({
+			collection: STORAGE_LOCATIONS,
+			columns: STORAGE_LOCATIONS_COLUMNS,
+			indexes: STORAGE_LOCATIONS_INDEXES
+		});
+		this.declared = true;
 	}
 	async loadAll() {
-		await this.ensureTable();
-		if (!this.backend.tableQuery) return [];
-		const rows = await this.backend.tableQuery(STORAGE_LOCATIONS_TABLE, { orderBy: {
-			field: "created_at",
-			direction: "asc"
-		} });
+		await this.ensureDeclared();
+		const rows = await this.store.query({
+			collection: STORAGE_LOCATIONS,
+			filter: { orderBy: {
+				field: "created_at",
+				direction: "asc"
+			} }
+		});
 		const out = [];
 		for (const row of rows) {
-			const mapped = mapRowToLocation(row);
+			const mapped = mapRowToLocation(row.data);
 			if (mapped) out.push(mapped);
 		}
 		return out;
 	}
 	/**
-	* Replace-or-insert. Implemented as `delete` + `insert` rather than
-	* the conditional `tableUpdate` path because the orchestrator
-	* serializes every mutation through the in-memory map before
-	* dispatching to the store — there's no contention to lose, and the
-	* delete-then-insert path is unconditionally simpler.
+	* Replace-or-insert. Implemented as delete + insert rather than a
+	* conditional update because the orchestrator serializes every mutation
+	* through the in-memory map before dispatching to the store — there's no
+	* contention to lose, and delete-then-insert is unconditionally simpler.
 	*/
 	async upsert(loc) {
-		await this.ensureTable();
-		if (!this.backend.tableDelete || !this.backend.tableInsert) throw new Error("SqliteLocationStore: backend missing tableDelete/tableInsert");
-		await this.backend.tableDelete(STORAGE_LOCATIONS_TABLE, { id: loc.id });
-		await this.backend.tableInsert(STORAGE_LOCATIONS_TABLE, mapLocationToRow(loc));
+		await this.ensureDeclared();
+		await this.store.deleteWhere({
+			collection: STORAGE_LOCATIONS,
+			filter: { where: { id: loc.id } }
+		});
+		await this.store.insert({
+			collection: STORAGE_LOCATIONS,
+			record: {
+				id: loc.id,
+				data: mapLocationToRow(loc)
+			}
+		});
 	}
 	async delete(id) {
-		await this.ensureTable();
-		if (!this.backend.tableDelete) throw new Error("SqliteLocationStore: backend missing tableDelete");
-		await this.backend.tableDelete(STORAGE_LOCATIONS_TABLE, { id });
+		await this.ensureDeclared();
+		await this.store.deleteWhere({
+			collection: STORAGE_LOCATIONS,
+			filter: { where: { id } }
+		});
 	}
 };
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readConfig(raw) {
+	if (isPlainObject(raw)) return { ...raw };
+	if (typeof raw === "string" && raw.length > 0) return parseJsonObject(raw) ?? {};
+	return {};
+}
 function mapLocationToRow(loc) {
 	const storedConfig = loc.nodeId !== void 0 ? {
 		...loc.config,
@@ -670,7 +692,7 @@ function mapLocationToRow(loc) {
 		type: loc.type,
 		display_name: loc.displayName,
 		provider_id: loc.providerId,
-		config: JSON.stringify(storedConfig),
+		config: storedConfig,
 		is_default: loc.isDefault ? 1 : 0,
 		is_system: loc.isSystem ? 1 : 0,
 		created_at: loc.createdAt,
@@ -678,11 +700,9 @@ function mapLocationToRow(loc) {
 	};
 }
 /**
-* Decode a row read from the structured table. Returns `null` when the
-* row's `type` doesn't parse against the Zod enum — the caller skips
-* the row and logs. Defensive against schema drift across upgrades
-* (e.g. an older build wrote a since-removed `recordings-archive`
-* type and the new build no longer recognises it).
+* Decode a row read from the collection. Returns `null` when the row's `type`
+* fails the id-format schema or the row has no id — a corrupt row (hand-edited,
+* partial migration) is skipped rather than taking the boot read down with it.
 */
 function mapRowToLocation(row) {
 	const typeRaw = row["type"];
@@ -691,8 +711,7 @@ function mapRowToLocation(row) {
 	const type = parsedType.data;
 	const id = String(row["id"] ?? "");
 	if (!id) return null;
-	const configRaw = row["config"];
-	const storedConfig = typeof configRaw === "string" && configRaw.length > 0 ? parseJsonObject(configRaw) ?? {} : {};
+	const storedConfig = readConfig(row["config"]);
 	const nodeIdRaw = storedConfig[NODE_ID_CONFIG_KEY];
 	const nodeId = typeof nodeIdRaw === "string" && nodeIdRaw.length > 0 ? nodeIdRaw : void 0;
 	const config = { ...storedConfig };
@@ -763,6 +782,8 @@ function createDataStoreDispatch(getEngines) {
 		insert: async (input) => (await engine()).insert(input),
 		update: async (input) => (await engine()).update(input),
 		delete: async (input) => (await engine()).delete(input),
+		deleteWhere: async (input) => (await engine()).deleteWhere(input),
+		updateWhere: async (input) => (await engine()).updateWhere(input),
 		count: async (input) => (await engine()).count(input),
 		histogram: async (input) => (await engine()).histogram(input),
 		isEmpty: async (input) => (await engine()).isEmpty(input),
@@ -1201,26 +1222,16 @@ var StorageOrchestratorAddon = class extends BaseAddon {
 	* addon *is* that singleton, so asking the registry for it would hand
 	* the orchestrator its own dispatcher and route its location table back
 	* through itself.
-	*
-	* The `ensureTable` / `tableInsert` reach-around below is the B2 bypass,
-	* still open: those six methods live on the concrete backend and on no
-	* cap. Promoting them to the door is a separate task; until then this
-	* holds the engine object directly, which only works because the engine
-	* is in-process on this node.
 	*/
 	resolveLocationStore(quiet = false) {
 		const reg = this.ctx.kernel.capabilityRegistry;
 		if (!reg) return null;
-		const backend = reg.getCollection(DATA_STORE_PROVIDER_CAP_NAME)[0];
-		if (!backend) {
+		const engine = reg.getCollection(DATA_STORE_PROVIDER_CAP_NAME)[0];
+		if (!engine) {
 			if (!quiet) this.ctx.logger.warn("storage-orchestrator: no data-store-provider engine yet — running in-memory until one registers");
 			return null;
 		}
-		if (!backend.ensureTable || !backend.tableInsert) {
-			if (!quiet) this.ctx.logger.warn("storage-orchestrator: settings backend lacks structured-table support — running in-memory only");
-			return null;
-		}
-		return new SqliteLocationStore(backend);
+		return new SqliteLocationStore(engine);
 	}
 	/**
 	* Late-wire the persistence store once a `data-store-provider` engine

package/dist/builtins/system-config/system-config.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CPmFYLqq.js");
+const require_dist = require("../../dist-CDv5YTHQ.js");
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/system-config/system-config.addon.mjs

@@ -1,4 +1,4 @@
-import { Ct as hydrateSchema, at as errMsg, ot as BaseAddon } from "../../dist-B7hOpr5i.mjs";
+import { Ct as hydrateSchema, at as errMsg, ot as BaseAddon } from "../../dist-CNmXITJ-.mjs";
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/winston-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CPmFYLqq.js");
+const require_dist = require("../../dist-CDv5YTHQ.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/builtins/winston-logging/index.mjs

@@ -1,4 +1,4 @@
-import { B as logDestinationCapability, ot as BaseAddon } from "../../dist-B7hOpr5i.mjs";
+import { B as logDestinationCapability, ot as BaseAddon } from "../../dist-CNmXITJ-.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";

package/dist/{dist-CPmFYLqq.js → dist-CDv5YTHQ.js}

@@ -14544,6 +14544,20 @@ var QueryFilterSchema = zod.z.object({
 	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(),
@@ -14569,7 +14583,18 @@ var CollectionColumnSchema = zod.z.object({
 	]),
 	primaryKey: zod.z.boolean().optional(),
 	notNull: zod.z.boolean().optional(),
-	unique: zod.z.boolean().optional()
+	unique: zod.z.boolean().optional(),
+	/**
+	* Column DEFAULT. Required for B2: the four `ensureTable` consumers declare
+	* columns like `enabled INTEGER NOT NULL DEFAULT 1`, and without this the
+	* collection surface simply cannot express their existing tables — which is
+	* why they were still on the uncapped `table*` API.
+	*/
+	defaultValue: zod.z.union([
+		zod.z.string(),
+		zod.z.number(),
+		zod.z.boolean()
+	]).optional()
 });
 var CollectionIndexSchema = zod.z.object({
 	name: zod.z.string(),
@@ -14649,6 +14674,36 @@ var settingsStoreCapability = {
 			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: 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: 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: method(zod.z.object({
 			namespace: zod.z.string().optional(),
@@ -14784,6 +14839,19 @@ var dataStoreProviderCapability = {
 			collection: zod.z.string(),
 			key: zod.z.string()
 		}), zod.z.void(), { kind: "mutation" }),
+		/** Delete every record matching `filter`, in one statement. */
+		deleteWhere: 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: 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: method(zod.z.object({
 			namespace: zod.z.string().optional(),
@@ -24963,6 +25031,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"dataStoreProvider.deleteWhere": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"dataStoreProvider.get": {
 		capName: "data-store-provider",
 		capScope: "system",
@@ -25011,6 +25085,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"dataStoreProvider.updateWhere": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dayNight.getOptions": {
 		capName: "day-night",
 		capScope: "device",
@@ -28089,6 +28169,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",
@@ -28131,6 +28217,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",

package/dist/{dist-B7hOpr5i.mjs → dist-CNmXITJ-.mjs}

@@ -14544,6 +14544,20 @@ var QueryFilterSchema = z.object({
 	limit: z.number().optional(),
 	offset: 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 = z.object({
+	where: z.record(z.string(), z.unknown()).optional(),
+	whereIn: z.record(z.string(), z.array(z.unknown())).optional(),
+	whereBetween: z.record(z.string(), z.tuple([z.unknown(), z.unknown()])).optional()
+});
 /** A single stored record: `{ id, data }`. */
 var SettingsRecordSchema = z.object({
 	id: z.string(),
@@ -14569,7 +14583,18 @@ var CollectionColumnSchema = z.object({
 	]),
 	primaryKey: z.boolean().optional(),
 	notNull: z.boolean().optional(),
-	unique: z.boolean().optional()
+	unique: z.boolean().optional(),
+	/**
+	* Column DEFAULT. Required for B2: the four `ensureTable` consumers declare
+	* columns like `enabled INTEGER NOT NULL DEFAULT 1`, and without this the
+	* collection surface simply cannot express their existing tables — which is
+	* why they were still on the uncapped `table*` API.
+	*/
+	defaultValue: z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	]).optional()
 });
 var CollectionIndexSchema = z.object({
 	name: z.string(),
@@ -14649,6 +14674,36 @@ var settingsStoreCapability = {
 			collection: z.string(),
 			key: z.string()
 		}), 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: method(z.object({
+			namespace: z.string().optional(),
+			collection: z.string(),
+			filter: MutationFilterSchema
+		}), z.object({ deleted: 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: method(z.object({
+			namespace: z.string().optional(),
+			collection: z.string(),
+			filter: MutationFilterSchema,
+			data: z.record(z.string(), z.unknown())
+		}), z.object({ updated: z.number().int() }), { kind: "mutation" }),
 		/** Count entries in a collection, optionally filtered. */
 		count: method(z.object({
 			namespace: z.string().optional(),
@@ -14784,6 +14839,19 @@ var dataStoreProviderCapability = {
 			collection: z.string(),
 			key: z.string()
 		}), z.void(), { kind: "mutation" }),
+		/** Delete every record matching `filter`, in one statement. */
+		deleteWhere: method(z.object({
+			namespace: z.string().optional(),
+			collection: z.string(),
+			filter: MutationFilterSchema
+		}), z.object({ deleted: z.number().int() }), { kind: "mutation" }),
+		/** Apply `data` to every record matching `filter`, in one statement. */
+		updateWhere: method(z.object({
+			namespace: z.string().optional(),
+			collection: z.string(),
+			filter: MutationFilterSchema,
+			data: z.record(z.string(), z.unknown())
+		}), z.object({ updated: z.number().int() }), { kind: "mutation" }),
 		/** Count entries in a collection, optionally filtered. */
 		count: method(z.object({
 			namespace: z.string().optional(),
@@ -24963,6 +25031,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"dataStoreProvider.deleteWhere": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"dataStoreProvider.get": {
 		capName: "data-store-provider",
 		capScope: "system",
@@ -25011,6 +25085,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"dataStoreProvider.updateWhere": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dayNight.getOptions": {
 		capName: "day-night",
 		capScope: "device",
@@ -28089,6 +28169,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",
@@ -28131,6 +28217,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",