@camstack/addon-provider-bosch 0.1.36 → 0.1.38

package/dist/{bosch-instances-BIvOtuzj.mjs → bosch-instances-CIuDwXQ8.mjs}

@@ -5981,7 +5981,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-D1jjWAr8.mjs
+//#region ../types/dist/sleep-DEZaLbiu.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6790,6 +6790,12 @@ function projectStore(store, perNodeKeys, nodeId) {
 	}
 	return out;
 }
+/** Every scope, in the order the guard and the docs list them. */
+var SCOPED_SETTINGS_SCOPES = [
+	"cluster",
+	"device-defaults",
+	"node"
+];
 /**
 * The address of one keychain value: `secret://<owner>/<scope>/<fieldPath>`.
 *
@@ -7681,6 +7687,13 @@ var BaseAddon = class {
 	*/
 	secretStatePaths = [];
 	_addonSecretTree = null;
+	/**
+	* D986 M4: the scoped schemas this addon declared, resolved once per capability
+	* (`loadScopedSchemas`) so the sync readers (`perNodeKeys`, the secret tree, the restart check)
+	* see them. Empty until loaded: the readers then fall back to {@link globalSettingsSchema}.
+	*/
+	_scopedByCap = /* @__PURE__ */ new Map();
+	_nodeKeysByCap = /* @__PURE__ */ new Map();
 	_deviceSecretTree = null;
 	/** Refs the last resolved config pointed at — a change to one re-resolves. */
 	_configSecretRefs = /* @__PURE__ */ new Set();
@@ -7750,6 +7763,7 @@ var BaseAddon = class {
 			this._ctx = context;
 			this._secretSettings = null;
 		}
+		await this.loadScopedSchemas();
 		await this.resolveConfig();
 		if (secrets !== void 0) this._secretChangeUnsub = secrets.onChange((ref) => {
 			if (this._configSecretRefs.has(ref)) this.scheduleSecretReresolve(SECRET_CHANGE_DEBOUNCE_MS);
@@ -7759,6 +7773,7 @@ var BaseAddon = class {
 		const normalized = normalizeAddonInitResult(result);
 		const providers = normalized && "providers" in normalized && normalized.providers ? normalized.providers : [];
 		this._registeredCapNames = providers.map((p) => p.capability.name);
+		await this.loadScopedSchemas();
 		return normalized;
 	}
 	/**
@@ -7847,6 +7862,16 @@ var BaseAddon = class {
 	schema(schema) {
 		return schema;
 	}
+	/**
+	* The capability names whose scoped settings schemas ({@link clusterSettingsSchema},
+	* {@link nodeSettingsSchema}, {@link deviceDefaultsSchema}) this addon declares. Read BEFORE
+	* `onInitialize`, when the providers it registers are not known yet: the first config resolve
+	* must already know which keys are per node. Names the providers register at init are added
+	* once known.
+	*/
+	scopedSettingsCapabilities() {
+		return [];
+	}
 	/** Override to provide global-level settings UI schema. */
 	globalSettingsSchema(_cap) {
 		return null;
@@ -7890,7 +7915,8 @@ var BaseAddon = class {
 		return [];
 	}
 	async getGlobalSettings(overlay, cap, nodeId) {
-		const schema = this.globalSettingsSchema(cap);
+		await this.loadScopedSchemas(cap);
+		const schema = this.globalSettingsSchema(cap) ?? this.scopedFormSchema(cap);
 		if (!schema) return { sections: [] };
 		const projected = await this.readRawProjectedStore(nodeId, cap);
 		return hydrateSchema(schema, overlay ? await this.overlayKeepingMarkers(projected, overlay) : projected, { inlineSecretsAsViews: true });
@@ -7925,10 +7951,9 @@ var BaseAddon = class {
 	*
 	* Override it only when an `instanceMode: multiple` addon's instances differ: an NVR integration
 	* needs its connection fields, the default integration the addon's own sections. It is the
-	* SHAPE of the form only — the values live in `integrations.getSettings`, and the write path is
-	* unchanged (`integrations.setSettings` for an account integration).
+	* SHAPE of the form only — the values live on the instance record.
 	*/
-	async integrationSettingsSchema(_instance) {
+	async integrationFormSchema(_instance) {
 		return null;
 	}
 	/**
@@ -7974,7 +7999,7 @@ var BaseAddon = class {
 	* per-instance schema when it declares one, else its global schema (what they always showed).
 	*/
 	async getIntegrationFormSchema(instance, nodeId) {
-		const scoped = await this.integrationSettingsSchema(instance);
+		const scoped = await this.integrationFormSchema(instance);
 		if (scoped === null) return this.getGlobalSettings(void 0, void 0, nodeId);
 		return hydrateSchema(scoped, {}, { inlineSecretsAsViews: true });
 	}
@@ -8022,6 +8047,7 @@ var BaseAddon = class {
 	* resolved blob back is a no-op for every unchanged secret.
 	*/
 	async resolveGlobalStore(nodeId, cap) {
+		await this.loadScopedSchemas(cap);
 		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
 		return this.projectForNode(raw, nodeId, cap);
 	}
@@ -8032,6 +8058,7 @@ var BaseAddon = class {
 	}
 	/** The PROJECTED store with its markers — the form hydrate only (D798). */
 	async readRawProjectedStore(nodeId, cap) {
+		await this.loadScopedSchemas(cap);
 		const raw = await this.rawSettings()?.readAddonStore() ?? {};
 		return this.projectForNode(raw, nodeId, cap);
 	}
@@ -8134,6 +8161,7 @@ var BaseAddon = class {
 		await this.applyGlobalPatch(patch, nodeId);
 	}
 	async applyGlobalPatch(barePatch, nodeId) {
+		await this.loadScopedSchemas();
 		const keys = this.perNodeKeys();
 		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
 		const target = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
@@ -8147,7 +8175,8 @@ var BaseAddon = class {
 		await this.resolveConfig();
 		await this.onConfigChanged();
 		this.emitLifecycle(EventCategory.AddonUpdated, { level: "global" });
-		this.maybeAutoRestart(Object.keys(barePatch), this.globalSettingsSchema());
+		const legacy = this.globalSettingsSchema();
+		this.maybeAutoRestart(Object.keys(barePatch), [...legacy === null ? [] : [legacy], ...this.loadedScopedSchemas().map((entry) => entry.schema)]);
 	}
 	/**
 	* The set of field keys the global settings schema declares `perNode: true`
@@ -8155,14 +8184,67 @@ var BaseAddon = class {
 	* declarations). Empty set ⇒ every per-node code path is bypassed and the
 	* settings API behaves exactly like the legacy node-agnostic one.
 	*/
-	_perNodeKeysCache = /* @__PURE__ */ new Map();
+	/**
+	* Load the scoped schemas of every capability this addon declares (the override and the
+	* providers registered at init, plus `extraCap`) that is not loaded yet, then drop what was
+	* derived from the previous set. Idempotent.
+	*/
+	async loadScopedSchemas(extraCap) {
+		const caps = new Set([
+			...this.scopedSettingsCapabilities(),
+			...this._registeredCapNames,
+			...extraCap === void 0 ? [] : [extraCap]
+		]);
+		let added = false;
+		for (const cap of caps) {
+			if (this._scopedByCap.has(cap)) continue;
+			const loaded = [];
+			for (const scope of SCOPED_SETTINGS_SCOPES) {
+				const schema = await this.getScopedSettingsSchema(scope, cap);
+				if (schema !== null) loaded.push({
+					scope,
+					schema
+				});
+			}
+			this._scopedByCap.set(cap, loaded);
+			added = true;
+		}
+		if (!added) return;
+		this._nodeKeysByCap = /* @__PURE__ */ new Map();
+		this._addonSecretTree = null;
+	}
+	/**
+	* The form the settings API serves while an addon declares no {@link globalSettingsSchema}: the
+	* sections of its scoped schemas, so dropping the old hook does not blank the form.
+	*/
+	scopedFormSchema(cap) {
+		const byId = /* @__PURE__ */ new Map();
+		for (const entry of this.loadedScopedSchemas(cap)) for (const section of entry.schema.sections) if (!byId.has(section.id)) byId.set(section.id, section);
+		return byId.size === 0 ? null : { sections: [...byId.values()] };
+	}
+	/** Every loaded scoped schema of `cap`, or of every loaded capability. */
+	loadedScopedSchemas(cap) {
+		if (cap !== void 0) return this._scopedByCap.get(cap) ?? [];
+		return [...this._scopedByCap.values()].flat();
+	}
+	/**
+	* The field keys that are stored per node: every field of a {@link nodeSettingsSchema}, plus
+	* the fields the legacy {@link globalSettingsSchema} still marks `perNode: true`. Derived once
+	* per `cap` argument and memoized (schemas are static declarations). Empty set ⇒ every
+	* per-node code path is bypassed and the settings API behaves like the node-agnostic one.
+	* Call {@link loadScopedSchemas} first (the async seams do).
+	*/
 	perNodeKeys(cap) {
 		const cacheKey = cap ?? "";
-		const cached = this._perNodeKeysCache.get(cacheKey);
+		const cached = this._nodeKeysByCap.get(cacheKey);
 		if (cached) return cached;
-		const schema = this.globalSettingsSchema(cap);
-		const keys = new Set(schema ? schema.sections.flatMap((section) => collectPerNodeFieldKeys(section.fields)) : []);
-		this._perNodeKeysCache.set(cacheKey, keys);
+		const legacy = this.globalSettingsSchema(cap);
+		const keys = new Set(legacy ? legacy.sections.flatMap((section) => collectPerNodeFieldKeys(section.fields)) : []);
+		for (const { scope, schema } of this.loadedScopedSchemas(cap)) {
+			if (scope !== "node") continue;
+			for (const section of schema.sections) for (const key of collectValueFieldKeys(section.fields)) keys.add(key);
+		}
+		this._nodeKeysByCap.set(cacheKey, keys);
 		return keys;
 	}
 	/**
@@ -8172,10 +8254,9 @@ var BaseAddon = class {
 	* time to return its response before the addon is torn down and
 	* re-initialised by `AddonRegistryService.restartAddon`.
 	*/
-	maybeAutoRestart(patchKeys, schema) {
-		if (!schema) return;
+	maybeAutoRestart(patchKeys, schemas) {
 		const restartKeys = /* @__PURE__ */ new Set();
-		for (const section of schema.sections) for (const field of section.fields) {
+		for (const schema of schemas) for (const section of schema.sections) for (const field of section.fields) {
 			if (field.type === "separator" || field.type === "info") continue;
 			if (field.requiresRestart) restartKeys.add(field.key);
 		}
@@ -8371,12 +8452,14 @@ var BaseAddon = class {
 	* here, in the addon's own process, so the hub keeps no copy of it.
 	*/
 	async getDeclaredSettingsKeys() {
+		await this.loadScopedSchemas();
 		return { keys: [...this.declaredKeySet()].toSorted() };
 	}
 	declaredKeySet() {
 		const keys = new Set(Object.keys(this.defaults));
 		const schema = this.globalSettingsSchema();
 		if (schema) for (const section of schema.sections) for (const key of collectFieldKeys(section.fields)) keys.add(key);
+		for (const { schema: scoped } of this.loadedScopedSchemas()) for (const section of scoped.sections) for (const key of collectFieldKeys(section.fields)) keys.add(key);
 		for (const key of this._declaredStateKeys) keys.add(key);
 		for (const path of this.secretStatePaths) {
 			const root = path.split(/[.[]/, 1)[0];
@@ -8472,7 +8555,11 @@ var BaseAddon = class {
 	}
 	/** The addon store's secret tree: schema fields by TYPE, plus `secretStatePaths`. */
 	addonSecretTree() {
-		this._addonSecretTree ??= mergeSecretStatePaths(secretTreeFromSchema(this.globalSettingsSchema()), this.secretStatePaths);
+		if (this._addonSecretTree === null) {
+			const tree = new Map(secretTreeFromSchema(this.globalSettingsSchema()));
+			for (const { schema } of this.loadedScopedSchemas()) for (const [key, node] of secretTreeFromSchema(schema)) tree.set(key, node);
+			this._addonSecretTree = mergeSecretStatePaths(tree, this.secretStatePaths);
+		}
 		return this._addonSecretTree;
 	}
 	deviceSecretTree() {
@@ -8722,6 +8809,23 @@ function dropPerNodeFields(fields) {
 	}
 	return kept;
 }
+/** The keys of the value-holding fields, recursing into layout containers. */
+function collectValueFieldKeys(fields) {
+	const collected = [];
+	for (const field of fields) {
+		if (field.type === "group") {
+			collected.push(...collectValueFieldKeys(field.fields));
+			continue;
+		}
+		if (field.type === "sub-tabs") {
+			for (const tab of field.tabs) collected.push(...collectValueFieldKeys(tab.fields));
+			continue;
+		}
+		if (field.type === "separator" || field.type === "info") continue;
+		if ("key" in field && typeof field.key === "string") collected.push(field.key);
+	}
+	return collected;
+}
 function collectFieldKeys(fields) {
 	const collected = [];
 	for (const field of fields) {
@@ -11956,7 +12060,7 @@ object({
 	params: record(string(), union([string(), number()])).optional()
 });
 //#endregion
-//#region ../types/dist/composition-CRNwcFYY.mjs
+//#region ../types/dist/composition-pOHbTzRB.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -13428,12 +13532,22 @@ var RecordIntegrationInstances = class {
 		...this.hooks.description,
 		mintsId: true
 	};
-	instanceFormSchema = async ({ id }) => this.hooks.formSchema(id);
+	/**
+	* The record an id names. A caller holding the `integrations` registry id (the Integrations
+	* page) reaches a kind whose body links to it through `integrationId`; an id that is itself a
+	* record id answers as it is. An id that names nothing comes back unchanged.
+	*/
+	async resolveRecordId(id) {
+		if (await this.handle.get(id) !== null) return id;
+		const linked = (await this.handle.query({ limit: INSTANCES_LIST_MAX })).records.find((record) => record.data["integrationId"] === id);
+		return linked === void 0 ? id : linked.id;
+	}
+	instanceFormSchema = async ({ id }) => this.hooks.formSchema(id === null ? null : await this.resolveRecordId(id));
 	listInstances = async () => {
 		return (await this.handle.query({ limit: INSTANCES_LIST_MAX })).records.map((record) => this.viewOf(record));
 	};
 	getInstance = async ({ id }) => {
-		const record = await this.handle.get(id);
+		const record = await this.handle.get(await this.resolveRecordId(id));
 		return record === null ? null : this.viewOf(record);
 	};
 	/** Insert ONE row (`ifRev: 0`: an existing id is refused, never overwritten). */
@@ -13450,7 +13564,8 @@ var RecordIntegrationInstances = class {
 		await this.hooks.onChanged?.(minted, "created");
 		return { id: minted };
 	};
-	updateInstance = async ({ id, name, values }) => {
+	updateInstance = async ({ id: askedId, name, values }) => {
+		const id = await this.resolveRecordId(askedId);
 		const patch = {};
 		for (const [key, value] of Object.entries(values)) {
 			if (value === void 0) continue;
@@ -13485,7 +13600,10 @@ var RecordIntegrationInstances = class {
 			status: "unsupported",
 			error: "This integration declares no connection test"
 		};
-		return this.hooks.test(input);
+		return this.hooks.test(input.id === null ? input : {
+			...input,
+			id: await this.resolveRecordId(input.id)
+		});
 	};
 	/** The flat provider object to hand to `registerProvider`. */
 	toProvider() {
@@ -14664,20 +14782,28 @@ async function moveIntegrationRowsToRecords(ports, spec) {
 	};
 }
 /**
-* The addon-side ports of `moveIntegrationRowsToRecords` (planning#416): an addon runs the move
-* from its own process, so the legacy rows are reached through the hub (`ctx.api.integrations`:
-* `list`, `getSettings` - which answers the OWNER its secrets resolved - and `clearSettings`) and
-* the new record through the addon's own records handle. The hub deletes the rows and their
-* keychain values; the addon never touches the registry.
-*/
+* The addon-side ports of `moveIntegrationRowsToRecords` (planning#416). An addon runs the move
+* from its own process, so the leftover rows are reached through the migration-only door
+* (`migrations.readLegacyIntegrationRows` / `clearLegacyIntegrationRows`) on the hub's connection.
+* The door returns markers. This process is the owner, so it resolves and releases them with
+* `resolveSecretMarkers` — the same call the old settings door used — and only then asks the
+* door to delete the rows. The addon's own record kind is its records handle.
+*/
+async function resolvedRows(stored, secrets) {
+	if (secrets === null) return stored;
+	const { value, unresolved } = await resolveSecretMarkers(stored, secrets);
+	if (unresolved.length > 0) throw new Error(`${unresolved.length} secret(s) cannot be read from the keychain`);
+	return value;
+}
 function integrationRowsPortsOverApi(deps) {
+	const secrets = deps.secrets ?? null;
 	return {
 		warn: (message) => deps.log.warn(message),
 		listIntegrations: async (addonId) => (await deps.api.list()).filter((i) => i.addonId === addonId).map((i) => ({
 			id: i.id,
 			name: i.name
 		})),
-		readRows: (integrationId) => deps.api.getSettings({ id: integrationId }),
+		readRows: async (integrationId) => resolvedRows(await deps.api.readLegacyIntegrationRows({ integrationId }), secrets),
 		putRecord: async (id, body) => {
 			if (await deps.records.get(id) !== null) return "exists";
 			try {
@@ -14696,15 +14822,17 @@ function integrationRowsPortsOverApi(deps) {
 			await deps.records.delete(id);
 		},
 		clearRows: async (integrationId) => {
-			await deps.api.clearSettings({ id: integrationId });
+			const refs = collectSecretMarkerRefs(await deps.api.readLegacyIntegrationRows({ integrationId }));
+			if (refs.length > 0 && secrets !== null) await secrets.delete(refs);
+			await deps.api.clearLegacyIntegrationRows({ integrationId });
 		}
 	};
 }
 function defaultIntegrationApiOver(api) {
 	return {
 		list: () => api.integrations.list.query(),
-		getSettings: (input) => api.integrations.getSettings.query(input),
-		clearSettings: (input) => api.integrations.clearSettings.mutate(input),
+		readLegacyIntegrationRows: (input) => api.migrations.readLegacyIntegrationRows.query(input),
+		clearLegacyIntegrationRows: (input) => api.migrations.clearLegacyIntegrationRows.mutate(input),
 		listDevices: (addonId) => api.deviceManager.listAll.query({
 			addonId,
 			projection: "slim"
@@ -50390,6 +50518,9 @@ var RunningProposalEvidenceSchema = object({
 	runsFound: number().int().nonnegative(),
 	pausesFound: number().int().nonnegative(),
 	longestPauseMs: number().nonnegative(),
+	/** Episodes shorter than ~90 s (an anti-crease pulse, a display waking): never a run, never a pause. */
+	pulsesFound: number().int().nonnegative(),
+	longestPulseMs: number().nonnegative(),
 	idleFloorW: number(),
 	noiseCeilingW: number(),
 	plateauW: number(),
@@ -51983,7 +52114,14 @@ var DiscoveryCandidateSchema = object({
 	/** `stableId` of the gateway candidate this device was found BEHIND. */
 	parentStableId: string().optional(),
 	/** `false` = shown for context but not pickable. Default true. */
-	selectable: boolean().optional()
+	selectable: boolean().optional(),
+	/**
+	* Keys of the provider's creation form (`getChildCreationSchema`) this candidate
+	* cannot be adopted without — a key for an encrypted board, a pairing code. The
+	* admin asks for exactly these, on the creation form prefilled with
+	* `prefilledConfig`, before it adopts. Absent or empty = adopt as it is.
+	*/
+	needsParams: array(string()).optional()
 });
 /**
 * Flat device summary returned by `createDevice` / `adoptDiscoveredDevice`.
@@ -52111,7 +52249,11 @@ var deviceProviderCapability = {
 		* pick the right type instead of assuming Camera.
 		*/
 		getManualCreationType: method(object({}), object({ deviceType: _enum(DeviceType).nullable() })),
-		adoptDiscoveredDevice: method(object({ candidate: DiscoveryCandidateSchema }), DeviceSummarySchema, {
+		adoptDiscoveredDevice: method(object({
+			candidate: DiscoveryCandidateSchema,
+			/** The integration the operator adopts into; a provider with several instances needs it. */
+			integrationId: string().optional()
+		}), DeviceSummarySchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -52125,7 +52267,9 @@ var deviceProviderCapability = {
 		getChildCreationSchema: method(object({ type: _enum(DeviceType) }), CreationSchemaOutputSchema),
 		createDevice: method(object({
 			type: _enum(DeviceType),
-			config: record(string(), unknown())
+			config: record(string(), unknown()),
+			/** The integration the operator adds the device to; a provider with several instances needs it. */
+			integrationId: string().optional()
 		}), DeviceSummarySchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -56235,11 +56379,7 @@ var CreateIntegrationInputSchema = object({
 	info: record(string(), unknown()).optional(),
 	/** `stableId` of the discovery candidate the form was seeded from (D984). */
 	originStableId: string().optional(),
-	settings: record(string(), unknown()).optional(),
-	/** Keys of `settings` the form's schema declares secret (by type) — kept in
-	*  the keychain, not the table (D787). */
-	secretKeys: array(string()).optional(),
-	skipRestart: boolean().optional()
+	settings: record(string(), unknown()).optional()
 });
 var UpdateIntegrationInputSchema = object({
 	id: string(),
@@ -56260,22 +56400,6 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 }), method(object({ id: string() }), DeleteIntegrationResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ id: string() }), record(string(), unknown()), { auth: "admin" }), method(object({
-	id: string(),
-	settings: record(string(), unknown()),
-	/** Keys the form's schema declares secret (by type) — keychain-stored (D787). */
-	secretKeys: array(string()).optional(),
-	/** The integration's own addon applies the change in-process and asks the hub not to respawn it. */
-	skipRestart: boolean().optional()
-}), object({ success: boolean() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ id: string() }), object({
-	rows: number().int().nonnegative(),
-	secrets: number().int().nonnegative()
-}), {
-	kind: "mutation",
-	auth: "admin"
 }), method(_void(), array(AvailableIntegrationTypeSchema), { auth: "admin" }), method(object({
 	addonId: string(),
 	settings: record(string(), unknown())
@@ -59252,6 +59376,27 @@ method(object({}), object({ entries: array(MigrationLedgerEntrySchema) }), { aut
 }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ integrationId: string().min(1) }), record(string(), unknown()), { auth: "admin" }), method(object({ integrationId: string().min(1) }), object({
+	rows: number().int().nonnegative(),
+	secrets: number().int().nonnegative()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	integrationId: string().min(1),
+	patch: record(string(), unknown())
+}), object({ written: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	integrationId: string().min(1),
+	keys: array(string().min(1))
+}), object({
+	present: boolean(),
+	removed: record(string(), unknown())
+}), {
+	kind: "mutation",
+	auth: "admin"
 });
 method(object({
 	sourceUrl: string(),
@@ -80617,11 +80762,15 @@ function runningFromDishwasherOperation(operation, program, previous, fetchedAt,
 *  1. idle floor F = time-weighted median; noise ceiling N = highest value seen
 *     near F. A device that is not near one level most of the time has no floor.
 *  2. coarse activity = above max(2N, N + 5 W); consecutive stretches are episodes.
-*  3. gaps between episodes split in two by the largest log-scale jump (>= 3x):
-*     the short ones are pauses INSIDE a run (a soak), the long ones separate runs.
+*  3. an episode shorter than `PULSE_MAX_MS` is a PULSE (an anti-crease tumble, a
+*     display waking): it is neither a run nor a pause. Among the remaining
+*     episodes, gaps over `PAUSE_MAX_MS` always separate runs; the rest split in
+*     two by the largest log-scale jump (>= 3x): the short ones are pauses INSIDE
+*     a run (a soak), the long ones separate runs. A stretch under `MIN_RUN_MS`
+*     is no run.
 *  4. T = geometric mean of N and the plateau's 10th percentile, snapped to a
-*     grid a person would type; stop dwell covers the longest pause; start dwell
-*     covers the longest standby blip above T.
+*     grid a person would type; stop dwell covers the longest pause and the
+*     kind's floor; start dwell covers the longest pulse and standby blip above T.
 *  5. the numbers are proved by REPLAY through the real `dwell` evaluation: each
 *     run must hold exactly one true interval and nothing may flap outside.
 */
@@ -80632,6 +80781,10 @@ var MINUTE_MS$1 = 60 * SECOND_MS;
 30 * SECOND_MS;
 60 * SECOND_MS;
 20 * MINUTE_MS$1;
+90 * SECOND_MS;
+30 * MINUTE_MS$1;
+10 * MINUTE_MS$1;
+DeviceType.Dryer, 3 * MINUTE_MS$1, DeviceType.Dishwasher, 3 * MINUTE_MS$1, DeviceType.Washer, 10 * MINUTE_MS$1;
 10 * SECOND_MS;
 10 * SECOND_MS;
 DeviceFeature.FanSpeed, DeviceFeature.FanPreset, DeviceFeature.FanDirection, DeviceFeature.FanOscillating, DeviceFeature.CoverStoppable, DeviceFeature.CoverPositionable, DeviceFeature.CoverTilt, DeviceFeature.ValvePositionable, DeviceFeature.MediaPlayerVolume, DeviceFeature.ClimateFanMode;
@@ -81805,7 +81958,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 	* `deviceClasses` instead.
 	*/
 	async createDevice(input) {
-		const spec = await this.onCreateDevice(input.type, input.config);
+		const spec = await this.onCreateDevice(input.type, input.config, { ...input.integrationId !== void 0 ? { integrationId: input.integrationId } : {} });
 		const Class = this.deviceClasses[spec.meta.type];
 		if (!Class) throw new Error(`${this.providerName} provider: no device class registered for type "${spec.meta.type}" — add it to the deviceClasses map`);
 		const stableId = this.generateStableId(spec.meta.type, spec.config);
@@ -85916,13 +86069,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"integrations.clearSettings": {
-		capName: "integrations",
-		capScope: "system",
-		addonId: null,
-		access: "delete",
-		role: "admin"
-	},
 	"integrations.create": {
 		capName: "integrations",
 		capScope: "system",
@@ -85958,13 +86104,6 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"integrations.getSettings": {
-		capName: "integrations",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"integrations.list": {
 		capName: "integrations",
 		capScope: "system",
@@ -85972,13 +86111,6 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"integrations.setSettings": {
-		capName: "integrations",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"integrations.testConnection": {
 		capName: "integrations",
 		capScope: "system",
@@ -86973,6 +87105,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"migrations.clearLegacyIntegrationRows": {
+		capName: "migrations",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
 	"migrations.declareOwner": {
 		capName: "migrations",
 		capScope: "system",
@@ -86980,6 +87119,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"migrations.deleteLegacyIntegrationRowKeys": {
+		capName: "migrations",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
 	"migrations.dryRun": {
 		capName: "migrations",
 		capScope: "system",
@@ -87015,6 +87161,20 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"migrations.patchLegacyIntegrationRows": {
+		capName: "migrations",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"migrations.readLegacyIntegrationRows": {
+		capName: "migrations",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"migrations.restorePreMigration": {
 		capName: "migrations",
 		capScope: "system",
@@ -97408,6 +97568,15 @@ function rewriteLocation(location, currentUpstream, route) {
 /** Characters that may precede a URL that STARTS a value (never `=`, `?`, `&`, `%3D`). */
 var VALUE_START = String.raw`(?<=^|["'(\s>,\[{])`;
 /**
+* Subresource Integrity pins the bytes of a script or stylesheet. The proxy rewrites vendor
+* URLs inside those bytes (and re-serves them from another origin), so the hash can no longer
+* match and the browser refuses the file: the page renders with no script at all. The hub
+* already drops the CSP that would have enforced the same pin; the attribute goes with it.
+*/
+function stripIntegrity(html) {
+	return html.replace(/\s+integrity\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+}
+/**
 * Rewrite vendor URLs in a text body: absolute (`https://host/…`), protocol-relative
 * (`//host/…`) and JSON-escaped (`https:\/\/host\/…`) when they start a value; and, in
 * HTML/CSS, root-relative references (`href="/x"`, `url(/x)`) which would otherwise
@@ -97423,6 +97592,7 @@ function rewriteBody(body, kind, currentUpstream, route) {
 		const escaped = new RegExp(`${VALUE_START}(?:https?:)?\\\\/\\\\/${host}(?=\\\\/|["'?#\\s)\\]},<]|$)`, "g");
 		out = out.replace(escaped, escapedBase);
 	}
+	if (kind === "html") out = stripIntegrity(out);
 	const current = `${route.basePath}/${currentUpstream.host}/`;
 	const notMounted = `(?!/)(?!${escapeRegex(route.basePath.slice(1))}/)`;
 	if (kind === "html") {
@@ -98082,6 +98252,7 @@ function boschRowsMigration(spec) {
 function boschRowsPorts(deps) {
 	return integrationRowsPortsOverApi({
 		api: deps.api,
+		...deps.secrets !== void 0 ? { secrets: deps.secrets } : {},
 		records: deps.records.kind({
 			name: deps.kind.name,
 			declaration: deps.kind.declaration,