@camstack/addon-decoder-nodeav 1.2.121 → 1.2.123

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-//#region ../types/dist/event-category-B_0XEcLF.mjs
+//#region ../types/dist/event-category-DaIZi00R.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -78,6 +78,13 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["AddonLoadFailed"] = "addon.load-failed";
 	/**
+	* A keychain value was stored or removed (D787). Carries the ref, its
+	* owner and the new version — NEVER the value. A process holding the ref
+	* drops its cached copy and the owning `BaseAddon` re-resolves its config.
+	* Telemetry (D8): a process that misses it still revalidates by version.
+	*/
+	EventCategory["KeychainChanged"] = "keychain.changed";
+	/**
 	* Addon recovered from a previous failure. Emitted when an addon
 	* transitions from `failed` back to `healthy` (typically via the
 	* monitor's auto-retry loop, or after manual `addons.retryLoad`).
@@ -5370,7 +5377,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-BNeXenvr.mjs
+//#region ../types/dist/sleep-DwAQ9sqX.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -5449,6 +5456,97 @@ function buildAlawTable() {
 }
 buildUlawTable();
 buildAlawTable();
+/** Is this field's stored value a credential? */
+function isSecretConfigField(field) {
+	if (field.type === "password") return true;
+	return "secret" in field && field.secret === true;
+}
+/**
+* Is this field's value stored in the KEYCHAIN (D787)? Every secret field is,
+* by its TYPE, unless it opts out with `storage: 'inline'` — never by its name.
+*/
+function isKeychainStoredField(field) {
+	if (!isSecretConfigField(field)) return false;
+	if (field.type === "textarea" && field.isJson === true) return false;
+	return !("storage" in field && field.storage === "inline");
+}
+/**
+* What a settings blob holds where a secret used to be.
+*
+* A keychain-stored field never holds its value. It holds a self-describing
+* MARKER, `{"$secret":"secret://…","v":1}` — an object, never a string, so no
+* code can mistake it for a credential and no form can send it to a camera as
+* a password. The empty state is `null` / absent, never `''`.
+*
+* The same shapes travel to and from the admin UI:
+*
+*  - read: `hydrateSchema` hands a secret field a {@link SecretFieldView}
+*    (`{ $secret, v, set: true }`) or `null` — the browser learns whether a
+*    value is set, never the value.
+*  - write: an untouched field submits the view back unchanged (KEEP); a typed
+*    value is a plain non-empty string (CHANGE); the Clear button submits
+*    {@link SECRET_CLEAR} (CLEAR). `''`, `null` and the legacy redaction tokens
+*    are KEEP — an empty string is what a defaults-fallback pushes back, and
+*    treating it as "clear" is how a save destroyed a stored credential before.
+*
+* Pure and browser-safe.
+*/
+var SECRET_CLEAR = { $secretClear: true };
+/** The `'***'` token D634 redaction writes for non-admins. */
+var LEGACY_DEVICE_REDACTION = "***";
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function makeSecretMarker(ref) {
+	return {
+		$secret: ref,
+		v: 1
+	};
+}
+/** A stored marker: an object whose `$secret` is a non-empty string. */
+function isSecretMarker(value) {
+	if (!isRecord$2(value)) return false;
+	const ref = value["$secret"];
+	return typeof ref === "string" && ref.length > 0;
+}
+function isSecretClear(value) {
+	return isRecord$2(value) && value["$secretClear"] === true;
+}
+/**
+* The UI view of a stored secret field value: a marker becomes "set", inline
+* plaintext becomes "set (inline)", nothing becomes `null`. A value never
+* survives this function.
+*/
+function toSecretFieldView(stored) {
+	if (isSecretMarker(stored)) return {
+		$secret: stored.$secret,
+		v: 1,
+		set: true
+	};
+	if (typeof stored === "string" && stored.length > 0) return {
+		$secret: null,
+		v: 1,
+		set: true,
+		inline: true
+	};
+	return null;
+}
+/**
+* Classify an incoming value for a secret path. Only a non-empty string that is
+* not a redaction token sets a value; only {@link SECRET_CLEAR} clears.
+* Everything else — a marker (ours or anyone's), a UI view, `''`, `null`,
+* `undefined`, a redaction token, a non-string — keeps what is stored.
+*/
+function classifySecretWrite(incoming) {
+	if (isSecretClear(incoming)) return { kind: "clear" };
+	if (typeof incoming !== "string") return { kind: "keep" };
+	if (incoming.length === 0) return { kind: "keep" };
+	if (incoming === "__camstack_redacted__" || incoming === LEGACY_DEVICE_REDACTION) return { kind: "keep" };
+	return {
+		kind: "set",
+		value: incoming
+	};
+}
 Object.fromEntries([
 	{
 		id: "overview",
@@ -5620,33 +5718,19 @@ Object.fromEntries([
 function isValuelessField(field) {
 	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button";
 }
-/**
-* Merge a `ConfigUISchema` with a raw `values` record into a
-* `ConfigUISchemaWithValues`. Used by every `get*Settings` backend endpoint
-* before returning to the admin UI. Groups are walked recursively.
-*
-* For each leaf field:
-*   - structural fields (`separator`, `info`, `button`) pass through unchanged
-*   - other fields get `value = values[key] ?? field.default ?? null`
-*
-* Unknown keys in `values` (keys not declared in the schema) are silently
-* ignored — they don't contribute to the output. Missing keys fall back to
-* the schema default or `null`. This mirrors the old backend behaviour where
-* `FormBuilder` rendered `values[key] ?? field.default`.
-*/
-function hydrateSchema(schema, values) {
+function hydrateSchema(schema, values, options = {}) {
 	return {
 		...schema.tabs ? { tabs: [...schema.tabs] } : {},
 		sections: schema.sections.map((section) => ({
 			...section,
-			fields: section.fields.map((field) => hydrateField(field, values))
+			fields: section.fields.map((field) => hydrateField(field, values, options))
 		}))
 	};
 }
-function hydrateField(field, values) {
+function hydrateField(field, values, options) {
 	if (isValuelessField(field)) return field;
 	if (field.type === "group") {
-		const hydratedChildren = field.fields.map((child) => hydrateField(child, values));
+		const hydratedChildren = field.fields.map((child) => hydrateField(child, values, options));
 		return {
 			...field,
 			fields: hydratedChildren
@@ -5655,7 +5739,7 @@ function hydrateField(field, values) {
 	if (field.type === "sub-tabs") {
 		const hydratedTabs = field.tabs.map((tab) => ({
 			...tab,
-			fields: tab.fields.map((child) => hydrateField(child, values))
+			fields: tab.fields.map((child) => hydrateField(child, values, options))
 		}));
 		return {
 			...field,
@@ -5665,6 +5749,33 @@ function hydrateField(field, values) {
 	const key = field.key;
 	const storedValue = Object.prototype.hasOwnProperty.call(values, key) ? values[key] : void 0;
 	const defaultValue = field.default;
+	const asView = (v) => isSecretMarker(v) || options.inlineSecretsAsViews === true && v !== void 0;
+	if (isKeychainStoredField(field) && asView(storedValue)) return {
+		...field,
+		value: toSecretFieldView(storedValue)
+	};
+	if (isKeychainStoredField(field) && options.inlineSecretsAsViews === true) return {
+		...field,
+		value: null
+	};
+	if (field.type === "editable-array" && Array.isArray(storedValue)) {
+		const secretItemKeys = field.itemFields.filter((item) => "key" in item && isKeychainStoredField(item)).map((item) => "key" in item ? item.key : "");
+		if (secretItemKeys.length > 0) {
+			const rows = storedValue.map((row) => {
+				if (row === null || typeof row !== "object" || Array.isArray(row)) return row;
+				const out = { ...row };
+				for (const k of secretItemKeys) {
+					const v = Reflect.get(row, k);
+					if (asView(v)) out[k] = toSecretFieldView(v);
+				}
+				return out;
+			});
+			return {
+				...field,
+				value: rows
+			};
+		}
+	}
 	if (field.multiple) {
 		const stored = Array.isArray(storedValue) ? storedValue : storedValue !== void 0 && storedValue !== null ? [storedValue] : [];
 		const itemFallback = field.multiple.itemDefault !== void 0 ? field.multiple.itemDefault : defaultValue !== void 0 ? defaultValue : typeOf(field) === "string" ? "" : null;
@@ -5907,6 +6018,778 @@ function projectStore(store, perNodeKeys, nodeId) {
 	}
 	return out;
 }
+var GLOBAL_SCOPE = { kind: "global" };
+/** The scope every addon-wide (not per-node, not per-device) setting lives in. */
+function globalSecretScope() {
+	return GLOBAL_SCOPE;
+}
+function encodeSegment(value) {
+	return encodeURIComponent(value);
+}
+function decodeSegment(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return null;
+	}
+}
+/**
+* The field path of a value inside an array item, addressed by the item's id:
+* `arrayItemFieldPath('providers', 'authentik', 'clientSecret')` →
+* `providers[authentik].clientSecret`.
+*/
+function arrayItemFieldPath(arrayKey, itemId, fieldKey) {
+	return `${arrayKey}[${encodeSegment(itemId)}].${fieldKey}`;
+}
+function parseScope(segments) {
+	switch (segments[0]) {
+		case "global": return {
+			scope: GLOBAL_SCOPE,
+			used: 1
+		};
+		case "node": {
+			const nodeId = segments[1] !== void 0 ? decodeSegment(segments[1]) : null;
+			return nodeId === null || nodeId.length === 0 ? null : {
+				scope: {
+					kind: "node",
+					nodeId
+				},
+				used: 2
+			};
+		}
+		case "device": {
+			const raw = segments[1];
+			if (raw === void 0 || !/^\d+$/.test(raw)) return null;
+			return {
+				scope: {
+					kind: "device",
+					deviceId: Number(raw)
+				},
+				used: 2
+			};
+		}
+		case "integration": {
+			const id = segments[1] !== void 0 ? decodeSegment(segments[1]) : null;
+			return id === null || id.length === 0 ? null : {
+				scope: {
+					kind: "integration",
+					integrationId: id
+				},
+				used: 2
+			};
+		}
+		case "row": {
+			const collection = segments[1] !== void 0 ? decodeSegment(segments[1]) : null;
+			const rowId = segments[2] !== void 0 ? decodeSegment(segments[2]) : null;
+			if (collection === null || rowId === null || collection.length === 0 || rowId.length === 0) return null;
+			return {
+				scope: {
+					kind: "row",
+					collection,
+					rowId
+				},
+				used: 3
+			};
+		}
+		default: return null;
+	}
+}
+/** Take a ref apart; `null` when it is not a well-formed ref. */
+function parseSecretRef(ref) {
+	if (!ref.startsWith("secret://")) return null;
+	const segments = ref.slice(9).split("/");
+	const owner = segments[0] !== void 0 ? decodeSegment(segments[0]) : null;
+	if (owner === null || owner.length === 0) return null;
+	const parsed = parseScope(segments.slice(1));
+	if (parsed === null) return null;
+	const fieldPath = segments.slice(1 + parsed.used).join("/");
+	if (fieldPath.length === 0) return null;
+	return {
+		owner,
+		scope: parsed.scope,
+		fieldPath
+	};
+}
+/** A write to a secret path could not be stored in the keychain, so it was refused. */
+var KeychainWriteRefusedError = class extends Error {
+	fieldPath;
+	constructor(fieldPath, cause) {
+		super(`secret "${fieldPath}" was not saved: the keychain could not store it (${cause instanceof Error ? cause.message : String(cause)}). Nothing was written.`);
+		this.fieldPath = fieldPath;
+		this.name = "KeychainWriteRefusedError";
+	}
+};
+var KEEP = { kind: "keep" };
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function defaultMintId() {
+	return globalThis.crypto.randomUUID();
+}
+/** Every marker ref anywhere under `value`. */
+function collectSecretMarkerRefs(value, out = []) {
+	if (isSecretMarker(value)) {
+		out.push(value.$secret);
+		return out;
+	}
+	if (Array.isArray(value)) for (const item of value) collectSecretMarkerRefs(item, out);
+	else if (isRecord$1(value)) for (const child of Object.values(value)) collectSecretMarkerRefs(child, out);
+	return out;
+}
+async function storedValueEquals(secrets, marker, candidate) {
+	const resolved = (await secrets.resolve([marker.$secret]))[marker.$secret];
+	return resolved?.kind === "value" && resolved.value === candidate;
+}
+async function writeLeaf(ctx, incoming, stored, fieldPath) {
+	const intent = classifySecretWrite(incoming);
+	const ref = ctx.secrets.ref(ctx.scope, fieldPath);
+	const storedIsOurs = isSecretMarker(stored) && stored.$secret === ref;
+	if (intent.kind === "keep") return KEEP;
+	if (intent.kind === "set" && !ctx.operatorWrite && typeof stored === "string" && stored === intent.value) return KEEP;
+	if (intent.kind === "clear") {
+		if (storedIsOurs) ctx.deletes.push(ref);
+		return {
+			kind: "value",
+			value: null
+		};
+	}
+	if (storedIsOurs && await storedValueEquals(ctx.secrets, stored, intent.value)) return {
+		kind: "value",
+		value: stored
+	};
+	try {
+		await ctx.secrets.put(ref, intent.value);
+	} catch (err) {
+		throw new KeychainWriteRefusedError(fieldPath, err);
+	}
+	return {
+		kind: "value",
+		value: makeSecretMarker(ref)
+	};
+}
+/** Apply a member result onto `out`: KEEP restores the stored member, or removes it. */
+function applyMember(out, key, result, storedParent) {
+	if (result.kind === "value") {
+		out[key] = result.value;
+		return;
+	}
+	if (Object.prototype.hasOwnProperty.call(storedParent, key)) out[key] = storedParent[key];
+	else delete out[key];
+}
+async function writeMembers(ctx, children, incoming, stored, pathOf) {
+	const out = { ...incoming };
+	for (const [member, node] of children) applyMember(out, member, await writeNode(ctx, node, incoming[member], stored[member], pathOf(member)), stored);
+	return out;
+}
+function rowId(row, idKey) {
+	const raw = row[idKey];
+	if (typeof raw === "string" && raw.length > 0) return raw;
+	if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+	return null;
+}
+async function writeArray(ctx, node, incoming, stored, fieldPath) {
+	const storedRows = Array.isArray(stored) ? stored.filter(isRecord$1) : [];
+	if (!Array.isArray(incoming)) {
+		ctx.deletes.push(...collectSecretMarkerRefs(storedRows));
+		return {
+			kind: "value",
+			value: incoming
+		};
+	}
+	const storedById = /* @__PURE__ */ new Map();
+	for (const row of storedRows) {
+		const id = rowId(row, node.idKey);
+		if (id !== null) storedById.set(id, row);
+	}
+	const kept = /* @__PURE__ */ new Set();
+	const rows = [];
+	for (const row of incoming) {
+		if (!isRecord$1(row)) {
+			rows.push(row);
+			continue;
+		}
+		const id = rowId(row, node.idKey) ?? ctx.mintId();
+		kept.add(id);
+		const withId = {
+			...row,
+			[node.idKey]: row[node.idKey] ?? id
+		};
+		if (rowId(withId, node.idKey) === null) withId[node.idKey] = id;
+		const storedRow = storedById.get(id) ?? {};
+		rows.push(await writeMembers(ctx, node.item, withId, storedRow, (member) => arrayItemFieldPath(fieldPath, id, member)));
+	}
+	for (const [id, row] of storedById) if (!kept.has(id)) ctx.deletes.push(...collectSecretMarkerRefs(row));
+	return {
+		kind: "value",
+		value: rows
+	};
+}
+async function writeNode(ctx, node, incoming, stored, fieldPath) {
+	switch (node.kind) {
+		case "leaf": return writeLeaf(ctx, incoming, stored, fieldPath);
+		case "array": return writeArray(ctx, node, incoming, stored, fieldPath);
+		case "object": {
+			if (!isRecord$1(incoming)) {
+				if (incoming === void 0) return KEEP;
+				ctx.deletes.push(...collectSecretMarkerRefs(stored));
+				return {
+					kind: "value",
+					value: incoming
+				};
+			}
+			const storedObj = isRecord$1(stored) ? stored : {};
+			return {
+				kind: "value",
+				value: await writeMembers(ctx, node.children, incoming, storedObj, (m) => `${fieldPath}.${m}`)
+			};
+		}
+	}
+}
+/** Split a perNode-scoped key (`key@nodeId`). */
+function splitNodeKey(key) {
+	const at = key.indexOf("@");
+	return at <= 0 ? {
+		base: key,
+		nodeId: null
+	} : {
+		base: key.slice(0, at),
+		nodeId: key.slice(at + 1)
+	};
+}
+/** Rewrite a settings patch so no secret value reaches the blob. See the file doc. */
+async function transformSecretWrite(input) {
+	const deletes = [];
+	const base = {
+		secrets: input.secrets,
+		mintId: input.mintId ?? defaultMintId,
+		deletes,
+		operatorWrite: input.operatorWrite === true
+	};
+	const out = {};
+	for (const [key, incoming] of Object.entries(input.patch)) {
+		const { base: baseKey, nodeId } = splitNodeKey(key);
+		const node = input.tree.get(baseKey);
+		if (node === void 0) {
+			out[key] = incoming;
+			continue;
+		}
+		const scope = nodeId !== null && nodeId.length > 0 ? {
+			kind: "node",
+			nodeId
+		} : input.scope ?? globalSecretScope();
+		const result = await writeNode({
+			...base,
+			scope
+		}, node, incoming, input.stored[key], baseKey);
+		if (result.kind === "value") out[key] = result.value;
+	}
+	return {
+		patch: out,
+		afterWrite: async () => {
+			if (deletes.length === 0) return { orphaned: [] };
+			try {
+				await input.secrets.delete([...new Set(deletes)]);
+				return { orphaned: [] };
+			} catch {
+				return { orphaned: [...new Set(deletes)] };
+			}
+		}
+	};
+}
+/** Is `ref` one of `owner`'s refs? */
+function isSecretRefOwnedBy(ref, owner) {
+	return parseSecretRef(ref)?.owner === owner;
+}
+/**
+* Replace every marker in `value` with its keychain value. Returns the SAME
+* reference when there is no marker (no allocation, no keychain call).
+*/
+async function resolveSecretMarkers(value, secrets, options = {}) {
+	const keepMarker = options.unresolved === "keep-marker";
+	const owner = options.ownedBy;
+	const inScope = (ref) => owner === void 0 || isSecretRefOwnedBy(ref, owner);
+	const refs = collectSecretMarkerRefs(value).filter(inScope);
+	if (refs.length === 0) return {
+		value,
+		unresolved: []
+	};
+	const answers = await secrets.resolve(refs);
+	const unresolved = [];
+	for (const ref of new Set(refs)) {
+		const answer = answers[ref];
+		if (answer === void 0) unresolved.push({
+			ref,
+			reason: "not-initialized"
+		});
+		else if (answer.kind === "unavailable") unresolved.push({
+			ref,
+			reason: answer.reason
+		});
+		else if (answer.kind === "missing" || answer.kind === "forbidden") unresolved.push({
+			ref,
+			reason: answer.kind
+		});
+	}
+	const substitute = (v) => {
+		if (isSecretMarker(v)) {
+			if (!inScope(v.$secret)) return {
+				keep: true,
+				value: v
+			};
+			const answer = answers[v.$secret];
+			if (answer?.kind === "value") return {
+				keep: true,
+				value: answer.value
+			};
+			return keepMarker ? {
+				keep: true,
+				value: v
+			} : {
+				keep: false,
+				value: void 0
+			};
+		}
+		if (Array.isArray(v)) {
+			const items = [];
+			for (const item of v) {
+				const s = substitute(item);
+				if (s.keep) items.push(s.value);
+			}
+			return {
+				keep: true,
+				value: items
+			};
+		}
+		if (isRecord$1(v)) {
+			const out = {};
+			for (const [k, child] of Object.entries(v)) {
+				const s = substitute(child);
+				if (s.keep) out[k] = s.value;
+			}
+			return {
+				keep: true,
+				value: out
+			};
+		}
+		return {
+			keep: true,
+			value: v
+		};
+	};
+	return {
+		value: substitute(value).value,
+		unresolved
+	};
+}
+/** An addon tried to replace a stored secret it could not read. Nothing was written. */
+var SecretOverwriteRefusedError = class extends Error {
+	ref;
+	reason;
+	constructor(ref, reason) {
+		super(`secret ${ref} was not replaced: its stored value cannot be read right now (${reason}), and an addon may not overwrite a secret it cannot see. Nothing was written.`);
+		this.ref = ref;
+		this.reason = reason;
+		this.name = "SecretOverwriteRefusedError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolvedValue(pass, marker) {
+	const answer = pass.answers[marker.$secret];
+	return answer?.kind === "value" ? answer.value : null;
+}
+async function atMarker(pass, incoming, stored) {
+	if (incoming === null) return stored;
+	if (typeof incoming !== "string") return incoming;
+	if (incoming === resolvedValue(pass, stored)) return stored;
+	const intent = classifySecretWrite(incoming);
+	if (intent.kind !== "set") return stored;
+	const ref = stored.$secret;
+	if (!isSecretRefOwnedBy(ref, pass.secrets.owner)) return incoming;
+	const answer = pass.answers[ref];
+	if ((answer === void 0 || answer.kind === "unavailable" || answer.kind === "forbidden") && !pass.operatorWrite) throw new SecretOverwriteRefusedError(ref, answer === void 0 ? "not-initialized" : answer.kind === "unavailable" ? answer.reason : answer.kind);
+	try {
+		await pass.secrets.put(ref, intent.value);
+	} catch (err) {
+		throw new KeychainWriteRefusedError(ref, err);
+	}
+	pass.changedRefs.push(ref);
+	return stored;
+}
+function inArray(pass, incoming, stored) {
+	return incoming.map((item, index) => {
+		const twin = stored[index];
+		if (isSecretMarker(twin)) return typeof item === "string" && item === resolvedValue(pass, twin) ? twin : item;
+		if (isRecord(item) && isRecord(twin)) return inArrayRow(pass, item, twin);
+		if (Array.isArray(item) && Array.isArray(twin)) return inArray(pass, item, twin);
+		return item;
+	});
+}
+function inArrayRow(pass, incoming, stored) {
+	const out = { ...incoming };
+	for (const [key, value] of Object.entries(incoming)) {
+		const twin = stored[key];
+		if (isSecretMarker(twin)) {
+			if (typeof value === "string" && value === resolvedValue(pass, twin)) out[key] = twin;
+		} else if (isRecord(value) && isRecord(twin)) out[key] = inArrayRow(pass, value, twin);
+		else if (Array.isArray(value) && Array.isArray(twin)) out[key] = inArray(pass, value, twin);
+	}
+	return out;
+}
+async function walk(pass, incoming, stored) {
+	if (isSecretMarker(stored)) return atMarker(pass, incoming, stored);
+	if (Array.isArray(incoming) && Array.isArray(stored)) return inArray(pass, incoming, stored);
+	if (!isRecord(incoming) || !isRecord(stored)) return incoming;
+	const out = { ...incoming };
+	for (const [key, value] of Object.entries(incoming)) out[key] = await walk(pass, value, stored[key]);
+	return out;
+}
+/** Restore markers a write-back carries as values. See the file doc. */
+async function restoreUnchangedSecrets(input) {
+	const refs = [];
+	for (const key of Object.keys(input.patch)) collectSecretMarkerRefs(input.stored[key], refs);
+	const owned = refs.filter((ref) => isSecretRefOwnedBy(ref, input.secrets.owner));
+	if (owned.length === 0) return {
+		patch: input.patch,
+		changedRefs: []
+	};
+	const pass = {
+		secrets: input.secrets,
+		answers: await input.secrets.resolve([...new Set(owned)]),
+		operatorWrite: input.operatorWrite,
+		changedRefs: []
+	};
+	const out = {};
+	for (const [key, value] of Object.entries(input.patch)) out[key] = await walk(pass, value, input.stored[key]);
+	return {
+		patch: out,
+		changedRefs: pass.changedRefs
+	};
+}
+/** Structural equality over JSON-shaped values (key order does not matter). */
+function isJsonEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((v, i) => isJsonEqual(v, b[i]));
+	if (isRecord(a) && isRecord(b)) {
+		const keys = Object.keys(a);
+		if (keys.length !== Object.keys(b).length) return false;
+		return keys.every((k) => Object.prototype.hasOwnProperty.call(b, k) && isJsonEqual(a[k], b[k]));
+	}
+	return false;
+}
+/** The patch without the keys whose value already equals the stored one. */
+function dropUnchangedKeys(patch, stored) {
+	const out = {};
+	for (const [key, value] of Object.entries(patch)) {
+		if (Object.prototype.hasOwnProperty.call(stored, key) && isJsonEqual(value, stored[key])) continue;
+		out[key] = value;
+	}
+	return out;
+}
+/** The top-level keys of a blob that hold at least one of `owner`'s markers. */
+function markerKeysOf(blob, owner) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const [key, value] of Object.entries(blob)) if (collectSecretMarkerRefs(value).some((ref) => isSecretRefOwnedBy(ref, owner))) keys.add(key);
+	return keys;
+}
+function nodeFromStored(value, owner) {
+	if (isSecretMarker(value)) return isSecretRefOwnedBy(value.$secret, owner) ? { kind: "leaf" } : null;
+	if (!isRecord(value)) return null;
+	const children = /* @__PURE__ */ new Map();
+	for (const [key, child] of Object.entries(value)) {
+		const node = nodeFromStored(child, owner);
+		if (node !== null) children.set(key, node);
+	}
+	return children.size > 0 ? {
+		kind: "object",
+		children
+	} : null;
+}
+/**
+* The declared secret tree, widened by every place the STORED blob holds a
+* marker under one of `keys` — so a marker the schema no longer declares (or
+* never declared: Wyze before b4906cec6) still gets the save path's
+* KEEP / SET / CLEAR semantics instead of being overwritten by whatever the
+* addon writes. Markers inside arrays are not added: a row has no id field to
+* match by unless the schema declares one. Only `owner`'s markers count: a
+* builtin that keeps another addon's marker (device-manager) never takes it
+* over.
+*/
+function widenTreeWithStoredMarkers(declared, stored, keys, owner) {
+	const added = /* @__PURE__ */ new Map();
+	for (const key of keys) {
+		const at = key.indexOf("@");
+		const base = at > 0 ? key.slice(0, at) : key;
+		if (declared.has(base) || added.has(base)) continue;
+		const node = nodeFromStored(stored[key], owner);
+		if (node !== null) added.set(base, node);
+	}
+	return added.size === 0 ? declared : new Map([...declared, ...added]);
+}
+/** The blob as stored now; a failed read REFUSES the write instead of guessing. */
+async function readStoredAddonBlob(raw) {
+	const threeWay = raw.readAddonStoreResult;
+	if (threeWay === void 0) return raw.readAddonStore();
+	const result = await threeWay.call(raw);
+	if (result.kind === "failed") throw new Error(`settings write refused: the stored blob could not be read (${result.error})`);
+	return result.kind === "missing" ? {} : result.value;
+}
+function touchesTree(tree, patch) {
+	if (tree.size === 0) return false;
+	for (const key of Object.keys(patch)) {
+		const at = key.indexOf("@");
+		if (tree.has(at > 0 ? key.slice(0, at) : key)) return true;
+	}
+	return false;
+}
+/**
+* Which top-level keys of each store held markers when last seen. `undefined`
+* for a store not seen yet: its first write reads it, to be safe.
+*/
+var MarkerKeyIndex = class {
+	owner;
+	byStore = /* @__PURE__ */ new Map();
+	constructor(owner) {
+		this.owner = owner;
+	}
+	seen(store, blob) {
+		this.byStore.set(store, markerKeysOf(blob, this.owner));
+	}
+	wrote(store, patch) {
+		const keys = this.byStore.get(store);
+		if (keys === void 0) return;
+		const now = markerKeysOf(patch, this.owner);
+		for (const key of Object.keys(patch)) if (now.has(key)) keys.add(key);
+		else keys.delete(key);
+	}
+	mayHoldMarkers(store, patch) {
+		const keys = this.byStore.get(store);
+		if (keys === void 0) return true;
+		return Object.keys(patch).some((key) => keys.has(key));
+	}
+};
+function createHandle(raw, opts) {
+	const chains = /* @__PURE__ */ new Map();
+	const serialize = (key, fn) => {
+		const next = (chains.get(key) ?? Promise.resolve()).then(fn, fn);
+		const tail = next.catch(() => void 0);
+		chains.set(key, tail);
+		tail.then(() => {
+			if (chains.get(key) === tail) chains.delete(key);
+		});
+		return next;
+	};
+	const index = new MarkerKeyIndex(opts.secrets.owner);
+	const resolveRead = async (store, blob) => {
+		index.seen(store, blob);
+		const { value, unresolved } = await resolveSecretMarkers(blob, opts.secrets, {
+			unresolved: "keep-marker",
+			ownedBy: opts.secrets.owner
+		});
+		if (unresolved.length > 0) opts.onUnresolved?.(unresolved);
+		return value;
+	};
+	const write = async (store, declared, scope, patch, readStored, rawWrite) => {
+		if (!touchesTree(declared, patch) && !index.mayHoldMarkers(store, patch)) {
+			await rawWrite(patch);
+			index.wrote(store, patch);
+			return { changed: true };
+		}
+		return serialize(store, async () => {
+			const stored = await readStored();
+			index.seen(store, stored);
+			const operatorWrite = opts.isOperatorWrite?.() === true;
+			const restored = await restoreUnchangedSecrets({
+				patch,
+				stored,
+				secrets: opts.secrets,
+				operatorWrite
+			});
+			const result = await transformSecretWrite({
+				tree: widenTreeWithStoredMarkers(declared, stored, Object.keys(restored.patch), opts.secrets.owner),
+				secrets: opts.secrets,
+				patch: restored.patch,
+				stored,
+				...scope !== void 0 ? { scope } : {},
+				operatorWrite
+			});
+			const effective = dropUnchangedKeys(result.patch, stored);
+			const wroteBlob = Object.keys(effective).length > 0;
+			if (wroteBlob) {
+				await rawWrite(effective);
+				index.wrote(store, effective);
+			}
+			const { orphaned } = await result.afterWrite();
+			if (orphaned.length > 0) opts.onOrphaned(orphaned);
+			return { changed: wroteBlob || restored.changedRefs.length > 0 };
+		});
+	};
+	const writeAddon = (patch) => write("addon", opts.addonTree(), void 0, patch, () => readStoredAddonBlob(raw), (p) => raw.writeAddonStore(p));
+	const readAddonStoreResult = raw.readAddonStoreResult;
+	const readAddonStoreKeyResult = raw.readAddonStoreKeyResult;
+	const readDeviceStoreBatch = raw.readDeviceStoreBatch;
+	const overrides = {
+		readAddonStore: async () => resolveRead("addon", await raw.readAddonStore()),
+		...readAddonStoreResult !== void 0 ? { readAddonStoreResult: async () => {
+			const result = await readAddonStoreResult.call(raw);
+			return result.kind === "value" ? {
+				kind: "value",
+				value: await resolveRead("addon", result.value)
+			} : result;
+		} } : {},
+		...readAddonStoreKeyResult !== void 0 ? { readAddonStoreKeyResult: async (key) => {
+			const result = await readAddonStoreKeyResult.call(raw, key);
+			if (result.kind !== "present") return result;
+			const { value, unresolved } = await resolveSecretMarkers({ [key]: result.value }, opts.secrets, {
+				unresolved: "keep-marker",
+				ownedBy: opts.secrets.owner
+			});
+			if (unresolved.length > 0) opts.onUnresolved?.(unresolved);
+			return {
+				kind: "present",
+				value: value[key]
+			};
+		} } : {},
+		readDeviceStore: async (deviceId) => resolveRead(`device:${deviceId}`, await raw.readDeviceStore(deviceId)),
+		...readDeviceStoreBatch !== void 0 ? { readDeviceStoreBatch: async (deviceIds) => {
+			const rows = await readDeviceStoreBatch.call(raw, deviceIds);
+			const out = /* @__PURE__ */ new Map();
+			for (const [deviceId, blob] of rows) out.set(deviceId, await resolveRead(`device:${deviceId}`, blob));
+			return out;
+		} } : {},
+		writeAddonStore: async (patch) => {
+			await writeAddon(patch);
+		},
+		writeDeviceStore: async (deviceId, patch) => {
+			await write(`device:${deviceId}`, opts.deviceTree(), {
+				kind: "device",
+				deviceId
+			}, patch, () => raw.readDeviceStore(deviceId), (p) => raw.writeDeviceStore(deviceId, p));
+		}
+	};
+	return {
+		settings: new Proxy(raw, { get(target, prop, receiver) {
+			if (typeof prop === "string" && Object.prototype.hasOwnProperty.call(overrides, prop)) return Reflect.get(overrides, prop);
+			const value = Reflect.get(target, prop, receiver);
+			return typeof value === "function" ? value.bind(target) : value;
+		} }),
+		raw: {
+			readAddonStore: async () => {
+				const blob = await raw.readAddonStore();
+				index.seen("addon", blob);
+				return blob;
+			},
+			readDeviceStore: async (deviceId) => {
+				const blob = await raw.readDeviceStore(deviceId);
+				index.seen(`device:${deviceId}`, blob);
+				return blob;
+			}
+		},
+		writeAddonStore: writeAddon
+	};
+}
+/** The context the addon sees, plus the private raw view and write outcome. */
+function createSecretAwareContext(context, opts) {
+	const raw = context.settings;
+	if (raw === void 0) return {
+		context,
+		handle: null
+	};
+	const handle = createHandle(raw, opts);
+	return {
+		context: new Proxy(context, { get(target, prop, receiver) {
+			if (prop === "settings") return handle.settings;
+			return Reflect.get(target, prop, receiver);
+		} }),
+		handle
+	};
+}
+var LEAF = { kind: "leaf" };
+var DEFAULT_ITEM_ID_KEY = "id";
+function collectFields(fields, out) {
+	for (const field of fields) {
+		if (field.type === "group") {
+			collectFields(field.fields, out);
+			continue;
+		}
+		if (field.type === "sub-tabs") {
+			for (const tab of field.tabs) collectFields(tab.fields, out);
+			continue;
+		}
+		if (field.type === "editable-array") {
+			const item = /* @__PURE__ */ new Map();
+			for (const itemField of field.itemFields) if ("key" in itemField && isKeychainStoredField(itemField)) item.set(itemField.key, LEAF);
+			if (item.size > 0) out.set(field.key, {
+				kind: "array",
+				idKey: field.itemIdKey ?? DEFAULT_ITEM_ID_KEY,
+				item
+			});
+			continue;
+		}
+		if (!("key" in field) || typeof field.key !== "string") continue;
+		if (isKeychainStoredField(field)) out.set(field.key, LEAF);
+	}
+}
+/** The secret tree a settings schema declares. */
+function secretTreeFromSchema(schema) {
+	const out = /* @__PURE__ */ new Map();
+	if (schema === null) return out;
+	for (const section of schema.sections) collectFields(section.fields, out);
+	return out;
+}
+/** Parse `a.b[id].c` into segments; throws on a malformed path (a declaration bug). */
+function parseSecretStatePath(path) {
+	const segments = [];
+	for (const raw of path.split(".")) {
+		const m = /^([^[\]]+)(?:\[([^[\]]+)\])?$/.exec(raw);
+		if (m === null || m[1] === void 0) throw new Error(`secretStatePaths: malformed path "${path}"`);
+		segments.push(m[2] !== void 0 ? {
+			key: m[1],
+			idKey: m[2]
+		} : { key: m[1] });
+	}
+	if (segments.length === 0) throw new Error(`secretStatePaths: empty path`);
+	if (segments[segments.length - 1]?.idKey !== void 0) throw new Error(`secretStatePaths: "${path}" ends on an array — name the member that is secret`);
+	return segments;
+}
+function insert(into, segments) {
+	const [head, ...rest] = segments;
+	if (head === void 0) return;
+	if (rest.length === 0) {
+		into.set(head.key, LEAF);
+		return;
+	}
+	const existing = into.get(head.key);
+	if (head.idKey !== void 0) {
+		const item = new Map(existing?.kind === "array" ? existing.item : []);
+		insert(item, rest);
+		into.set(head.key, {
+			kind: "array",
+			idKey: head.idKey,
+			item
+		});
+		return;
+	}
+	const children = new Map(existing?.kind === "object" ? existing.children : []);
+	insert(children, rest);
+	into.set(head.key, {
+		kind: "object",
+		children
+	});
+}
+/** Add hidden-state paths (`secretStatePaths`) to a schema-derived tree. */
+function mergeSecretStatePaths(tree, paths) {
+	if (paths.length === 0) return tree;
+	const out = new Map(tree);
+	for (const path of paths) insert(out, parseSecretStatePath(path));
+	return out;
+}
+/** First retry of a secret the keychain could not serve; doubles to {@link SECRET_RETRY_MAX_MS}. */
+var SECRET_RETRY_FIRST_MS = 5e3;
+var SECRET_RETRY_MAX_MS = 5 * 6e4;
+/** Coalesces a burst of `keychain.changed` events into one re-resolve. */
+var SECRET_CHANGE_DEBOUNCE_MS = 250;
 /**
 * Base class for CamStack addons. Eliminates settings boilerplate:
 *
@@ -5976,6 +6859,33 @@ var BaseAddon = class {
 	settingsStoreReady = false;
 	/** Default config values. Provided via constructor. */
 	defaults;
+	/**
+	* Hidden-state paths that hold secrets (D787) — values the addon writes
+	* itself (`updateGlobalSettings`, `state()`) that no form field declares.
+	* Stored in the keychain exactly like a `password` field. Syntax:
+	* `'snapshotSigningKey'`, `'identity.pincode'`, `'tokens[userId].accessToken'`
+	* (`key[<id field>]` addresses array items by id, never by index).
+	*/
+	secretStatePaths = [];
+	_addonSecretTree = null;
+	_deviceSecretTree = null;
+	/** Refs the last resolved config pointed at — a change to one re-resolves. */
+	_configSecretRefs = /* @__PURE__ */ new Set();
+	_unresolvedSecrets = [];
+	_secretRetryTimer = null;
+	_secretRetryDelayMs = SECRET_RETRY_FIRST_MS;
+	_secretChangeTimer = null;
+	_secretChangeUnsub = null;
+	/** >0 while an OPERATOR's settings write is being applied. */
+	_operatorWriteDepth = 0;
+	/**
+	* The keychain-aware settings handle (D798). Its `raw` view is the ONLY way
+	* to the marker-bearing blobs and stays private to this class: the form
+	* hydrate and config resolution need markers, addon code never does.
+	*/
+	_secretSettings = null;
+	/** Refs an addon-facing read could not resolve — each is logged once per process. */
+	_loggedUnresolvedReads = /* @__PURE__ */ new Set();
 	constructor(defaults) {
 		this.defaults = defaults;
 		this._config = { ...defaults };
@@ -6011,8 +6921,26 @@ var BaseAddon = class {
 		return this._config;
 	}
 	async initialize(context) {
-		this._ctx = context;
+		const secrets = context.secrets;
+		if (secrets !== void 0) {
+			const { context: wrapped, handle } = createSecretAwareContext(context, {
+				secrets,
+				addonTree: () => this.addonSecretTree(),
+				deviceTree: () => this.deviceSecretTree(),
+				onOrphaned: (refs) => context.logger.warn("keychain refs dropped by a settings write could not be deleted", { meta: { refs: [...refs] } }),
+				isOperatorWrite: () => this._operatorWriteDepth > 0,
+				onUnresolved: (unresolved) => this.logUnresolvedRead(unresolved)
+			});
+			this._ctx = wrapped;
+			this._secretSettings = handle;
+		} else {
+			this._ctx = context;
+			this._secretSettings = null;
+		}
 		await this.resolveConfig();
+		if (secrets !== void 0) this._secretChangeUnsub = secrets.onChange((ref) => {
+			if (this._configSecretRefs.has(ref)) this.scheduleSecretReresolve(SECRET_CHANGE_DEBOUNCE_MS);
+		});
 		const result = await this.onInitialize();
 		this.emitLifecycle(EventCategory.AddonStarted);
 		const normalized = normalizeAddonInitResult(result);
@@ -6045,6 +6973,12 @@ var BaseAddon = class {
 	*/
 	async onHubReachable() {}
 	async shutdown() {
+		this._secretChangeUnsub?.();
+		this._secretChangeUnsub = null;
+		if (this._secretRetryTimer !== null) clearTimeout(this._secretRetryTimer);
+		if (this._secretChangeTimer !== null) clearTimeout(this._secretChangeTimer);
+		this._secretRetryTimer = null;
+		this._secretChangeTimer = null;
 		this.emitLifecycle(EventCategory.AddonStopped);
 		if (this.autoEmitReadiness) this.emitReadinessForProviders("down");
 		await this.onShutdown();
@@ -6119,11 +7053,8 @@ var BaseAddon = class {
 	async getGlobalSettings(overlay, cap, nodeId) {
 		const schema = this.globalSettingsSchema(cap);
 		if (!schema) return { sections: [] };
-		const projected = await this.resolveGlobalStore(nodeId, cap);
-		return hydrateSchema(schema, overlay ? {
-			...projected,
-			...overlay
-		} : projected);
+		const projected = await this.readRawProjectedStore(nodeId, cap);
+		return hydrateSchema(schema, overlay ? await this.overlayKeepingMarkers(projected, overlay) : projected, { inlineSecretsAsViews: true });
 	}
 	/**
 	* The integration-level view of this addon's settings: exactly the sections
@@ -6168,11 +7099,11 @@ var BaseAddon = class {
 			});
 		}
 		if (sections.length === 0) return null;
-		const projected = await this.resolveGlobalStore(nodeId);
+		const projected = await this.readRawProjectedStore(nodeId);
 		return hydrateSchema({
 			...schema,
 			sections
-		}, projected);
+		}, projected, { inlineSecretsAsViews: true });
 	}
 	/**
 	* The raw addon store PROJECTED onto the target node's bare per-node keys:
@@ -6185,12 +7116,50 @@ var BaseAddon = class {
 	* the store for custom option logic (option narrowing, value snapping) to
 	* read it per-node — never `ctx.settings.readAddonStore()` directly.
 	* `nodeId` omitted ⇒ the local node (node-blind injection from ctx).
+	*
+	* Keychain values come back RESOLVED (D798): a secret reads as its value,
+	* never as a `{ $secret }` marker. One the keychain cannot serve right now
+	* stays a marker — "stored, unavailable" (`isSecretMarker()` is true, and it
+	* is listed in {@link unresolvedSecrets}) — never `''` and never absent, so
+	* it cannot be mistaken for "nothing stored, mint a new one". Writing the
+	* resolved blob back is a no-op for every unchanged secret.
 	*/
 	async resolveGlobalStore(nodeId, cap) {
 		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
+		return this.projectForNode(raw, nodeId, cap);
+	}
+	projectForNode(store, nodeId, cap) {
 		const keys = this.perNodeKeys(cap);
 		const node = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
-		return keys.size > 0 ? projectStore(raw, keys, node) : raw;
+		return keys.size > 0 ? projectStore(store, keys, node) : store;
+	}
+	/** The PROJECTED store with its markers — the form hydrate only (D798). */
+	async readRawProjectedStore(nodeId, cap) {
+		const raw = await this.rawSettings()?.readAddonStore() ?? {};
+		return this.projectForNode(raw, nodeId, cap);
+	}
+	/**
+	* `{ ...stored, ...overlay }`, except that an overlay member equal to the
+	* RESOLVED stored one keeps the stored (marker-bearing) member — so a form
+	* hydrated from a resolved overlay still shows a secret as "set", never as
+	* its value.
+	*/
+	async overlayKeepingMarkers(stored, overlay) {
+		const secrets = this._ctx?.secrets;
+		const merged = {
+			...stored,
+			...overlay
+		};
+		if (secrets === void 0 || collectSecretMarkerRefs(stored).length === 0) return merged;
+		const { value: resolved } = await resolveSecretMarkers(stored, secrets, {
+			unresolved: "keep-marker",
+			ownedBy: secrets.owner
+		});
+		for (const key of Object.keys(overlay)) {
+			if (collectSecretMarkerRefs(stored[key]).length === 0) continue;
+			if (isJsonEqual(overlay[key], resolved[key])) merged[key] = stored[key];
+		}
+		return merged;
 	}
 	/**
 	* Whether ONE global key of this addon's store was written, read three-way
@@ -6226,18 +7195,58 @@ var BaseAddon = class {
 			value: result.value[key]
 		};
 	}
+	/**
+	* The OPERATOR's write — a settings form or an admin API call, dispatched by
+	* the kernel. Identical to {@link updateGlobalSettings}, except that a secret
+	* the operator sends is stored as sent even when it equals a pre-keychain
+	* inline value: the operator re-entering a password is a change, an addon
+	* writing back what it read is not (D787).
+	*/
+	async updateGlobalSettingsAsOperator(patch, nodeId) {
+		this._operatorWriteDepth++;
+		try {
+			await this.applyGlobalPatch(patch, nodeId);
+		} finally {
+			this._operatorWriteDepth--;
+		}
+	}
 	async updateGlobalSettings(patch, nodeId) {
+		await this.applyGlobalPatch(patch, nodeId);
+	}
+	/**
+	* REMOVE stored secrets — their keychain values and their markers (D787).
+	*
+	* Writing `''` to a secret field KEEPS what is stored (an empty string is
+	* what a defaults fallback writes back, and it must never destroy a
+	* credential), so code that means "forget this token" says so here. Without
+	* a keychain (an older kernel) it writes `''`, as such code always did.
+	*/
+	async clearSecrets(keys, nodeId) {
+		const tree = this.addonSecretTree();
+		const keychain = this._ctx?.secrets !== void 0;
+		const stored = keychain ? await this.readAddonStoreWithRetry() : {};
+		const patch = {};
+		for (const key of keys) {
+			const keychainStored = tree.has(key) || collectSecretMarkerRefs(stored[key]).length > 0;
+			patch[key] = keychain && keychainStored ? SECRET_CLEAR : "";
+		}
+		await this.applyGlobalPatch(patch, nodeId);
+	}
+	async applyGlobalPatch(barePatch, nodeId) {
 		const keys = this.perNodeKeys();
 		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
 		const target = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
-		const barePatch = patch;
 		const scoped = keys.size > 0 ? scopePatch(barePatch, keys, target) : barePatch;
-		await this._ctx?.settings?.writeAddonStore(scoped);
+		const handle = this._secretSettings;
+		if (handle !== null) {
+			const { changed } = await handle.writeAddonStore(scoped);
+			if (!changed) return;
+		} else await this._ctx?.settings?.writeAddonStore(scoped);
 		if (target !== localNode) return;
 		await this.resolveConfig();
 		await this.onConfigChanged();
 		this.emitLifecycle(EventCategory.AddonUpdated, { level: "global" });
-		this.maybeAutoRestart(patch, this.globalSettingsSchema());
+		this.maybeAutoRestart(Object.keys(barePatch), this.globalSettingsSchema());
 	}
 	/**
 	* The set of field keys the global settings schema declares `perNode: true`
@@ -6262,7 +7271,7 @@ var BaseAddon = class {
 	* time to return its response before the addon is torn down and
 	* re-initialised by `AddonRegistryService.restartAddon`.
 	*/
-	maybeAutoRestart(patch, schema) {
+	maybeAutoRestart(patchKeys, schema) {
 		if (!schema) return;
 		const restartKeys = /* @__PURE__ */ new Set();
 		for (const section of schema.sections) for (const field of section.fields) {
@@ -6270,13 +7279,13 @@ var BaseAddon = class {
 			if (field.requiresRestart) restartKeys.add(field.key);
 		}
 		if (restartKeys.size === 0) return;
-		if (!Object.keys(patch).some((k) => restartKeys.has(k))) return;
+		if (!patchKeys.some((k) => restartKeys.has(k))) return;
 		const ctx = this._ctx;
 		if (!ctx) return;
 		const addonId = ctx.id;
 		setImmediate(() => {
 			ctx.api.addons?.restartAddon?.mutate({ addonId }).then(() => {
-				ctx.logger.info("addon auto-restart triggered by restart-required setting change", { meta: { changedFields: Object.keys(patch).filter((k) => restartKeys.has(k)) } });
+				ctx.logger.info("addon auto-restart triggered by restart-required setting change", { meta: { changedFields: patchKeys.filter((k) => restartKeys.has(k)) } });
 			}).catch((err) => {
 				ctx.logger.error("addon auto-restart failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 			});
@@ -6285,7 +7294,7 @@ var BaseAddon = class {
 	async getDeviceSettings(deviceId) {
 		const schema = this.deviceSettingsSchema();
 		if (!schema) return { sections: [] };
-		return hydrateSchema(schema, await this._ctx?.settings?.readDeviceStore(deviceId) ?? {});
+		return hydrateSchema(schema, await this.rawSettings()?.readDeviceStore(deviceId) ?? {}, { inlineSecretsAsViews: true });
 	}
 	async updateDeviceSettings(deviceId, patch) {
 		await this._ctx?.settings?.writeDeviceStore(deviceId, patch);
@@ -6415,7 +7424,7 @@ var BaseAddon = class {
 	* selection at boot (absent scoped key ⇒ the constructor default wins).
 	*/
 	async resolveConfig() {
-		const stored = await this.readAddonStoreWithRetry();
+		const stored = await this.resolveStoredSecrets(await this.readAddonStoreWithRetry());
 		const perNode = this.perNodeKeys();
 		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
 		const resolved = { ...this.defaults };
@@ -6440,7 +7449,7 @@ var BaseAddon = class {
 			key,
 			schema,
 			fallback,
-			read: () => this.readAddonStoreWithRetry(),
+			read: async () => this.resolveStoredSecrets(await this.readAddonStoreWithRetry()),
 			write: async (patch) => {
 				await this._ctx?.settings?.writeAddonStore(patch);
 			},
@@ -6457,7 +7466,7 @@ var BaseAddon = class {
 			key,
 			schema,
 			fallback,
-			read: async () => await this._ctx?.settings?.readDeviceStore(deviceId) ?? {},
+			read: async () => this.resolveStoredSecrets(await this.rawSettings()?.readDeviceStore(deviceId) ?? {}, false),
 			write: async (patch) => {
 				await this._ctx?.settings?.writeDeviceStore(deviceId, patch);
 			},
@@ -6469,6 +7478,87 @@ var BaseAddon = class {
 			} })
 		});
 	}
+	/** The addon store's secret tree: schema fields by TYPE, plus `secretStatePaths`. */
+	addonSecretTree() {
+		this._addonSecretTree ??= mergeSecretStatePaths(secretTreeFromSchema(this.globalSettingsSchema()), this.secretStatePaths);
+		return this._addonSecretTree;
+	}
+	deviceSecretTree() {
+		this._deviceSecretTree ??= secretTreeFromSchema(this.deviceSettingsSchema());
+		return this._deviceSecretTree;
+	}
+	/**
+	* Secrets of this addon's stored config that could not be resolved on the
+	* last read, with why. Non-empty means the addon is running WITHOUT them —
+	* an addon whose function needs one should report itself degraded rather
+	* than start on an empty credential.
+	*/
+	get unresolvedSecrets() {
+		return this._unresolvedSecrets;
+	}
+	/**
+	* Substitute every keychain marker in a stored blob with its value. With no
+	* keychain (no `ctx.secrets`) or no marker, the blob comes back unchanged.
+	* An unresolvable value is LEFT OUT (never `''`), logged by ref — never by
+	* value — and, when the cause can pass, retried with backoff. Nothing is
+	* ever written back from here.
+	*/
+	async resolveStoredSecrets(blob, trackForConfig = true) {
+		const secrets = this._ctx?.secrets;
+		if (secrets === void 0) return blob;
+		const refs = collectSecretMarkerRefs(blob);
+		if (trackForConfig) this._configSecretRefs = new Set(refs);
+		if (refs.length === 0) {
+			if (trackForConfig) this._unresolvedSecrets = [];
+			return blob;
+		}
+		const { value, unresolved } = await resolveSecretMarkers(blob, secrets);
+		if (trackForConfig) {
+			this._unresolvedSecrets = unresolved;
+			if (unresolved.length > 0) {
+				this._ctx?.logger?.error?.("secret unavailable — running without it, will retry", { meta: { secrets: unresolved.map((u) => ({
+					ref: u.ref,
+					reason: u.reason
+				})) } });
+				if (unresolved.some((u) => u.reason !== "missing" && u.reason !== "forbidden")) {
+					this.scheduleSecretReresolve(this._secretRetryDelayMs);
+					this._secretRetryDelayMs = Math.min(this._secretRetryDelayMs * 2, SECRET_RETRY_MAX_MS);
+				}
+			} else this._secretRetryDelayMs = SECRET_RETRY_FIRST_MS;
+		}
+		return value;
+	}
+	/**
+	* The marker-bearing settings reads (D798) — private on purpose. Without a
+	* keychain the context's own view is already raw.
+	*/
+	rawSettings() {
+		return this._secretSettings?.raw ?? this._ctx?.settings;
+	}
+	/** An addon-facing read met markers it could not resolve: say so once per ref. */
+	logUnresolvedRead(unresolved) {
+		const fresh = unresolved.filter((u) => !this._loggedUnresolvedReads.has(u.ref));
+		if (fresh.length === 0) return;
+		for (const u of fresh) this._loggedUnresolvedReads.add(u.ref);
+		this._ctx?.logger?.warn?.("settings read: a stored secret is unavailable — it reads as its marker, not as a value", { meta: { secrets: fresh.map((u) => ({
+			ref: u.ref,
+			reason: u.reason
+		})) } });
+	}
+	/** Re-resolve the config (a keychain-only change, or a retry) and apply it. */
+	scheduleSecretReresolve(delayMs) {
+		const timerOf = delayMs === SECRET_CHANGE_DEBOUNCE_MS ? "_secretChangeTimer" : "_secretRetryTimer";
+		if (this[timerOf] !== null) return;
+		const timer = setTimeout(() => {
+			this[timerOf] = null;
+			if (this._ctx === null) return;
+			this.resolveConfig().then(() => this.onConfigChanged()).catch((err) => {
+				this._ctx?.logger?.error?.("re-resolving secrets failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			});
+		}, delayMs);
+		timer.unref?.();
+		this[timerOf] = timer;
+	}
 	/**
 	* Wrap `ctx.settings.readAddonStore()` with a short retry budget so a
 	* transient settings-store outage (mid-restart of sqlite-settings, tsx-watch
@@ -6481,7 +7571,7 @@ var BaseAddon = class {
 	* `{}` (defaults) — the addon's first successful patch will rehydrate.
 	*/
 	async readAddonStoreWithRetry() {
-		const settings = this._ctx?.settings;
+		const settings = this.rawSettings();
 		if (!settings) return {};
 		const delaysMs = [
 			150,
@@ -8226,6 +9316,16 @@ var CompositionSchema = object({
 		seen.add(feature.cap);
 	});
 });
+var NodeColorIdSchema = _enum([
+	"node-a",
+	"node-b",
+	"node-c",
+	"node-d",
+	"node-e",
+	"node-f",
+	"node-g",
+	"node-h"
+]);
 new Set([
 	"track",
 	"face",
@@ -8717,6 +9817,278 @@ var CameraSwitchGroupSchema = object({
 	fetchedAt: number()
 });
 /**
+* The trainer contract — what the hub hands the cloud trainer and what it
+* gets back (cloud training, D805+).
+*
+* The trainer (`hf/camstack-trainer`, published as the Hugging Face repo
+* `camstack/camstack-trainer`) is a separate AGPL program the hub never
+* imports: `job.json` goes in, files come out, and progress is `CAMSTACK_EVENT`
+* lines on stdout. These schemas are the hub's half of that boundary; the
+* trainer's pydantic models (and the JSON Schemas generated from them under
+* `hf/camstack-trainer/schemas/`) are the other half. A change here is a
+* change there, in the same piece of work.
+*
+* No `.default()` anywhere: defaults do not run on the addon cap path, so the
+* orchestrator fills every field of a job spec explicitly.
+*/
+var TRAINING_JOB_SCHEMA = "camstack.training/v1";
+var TRAINING_RESULT_SCHEMA = "camstack.training-result/v1";
+/** What the trainer can export. Edge TPU is a later, separate image. */
+var TrainingExportSchema = _enum([
+	"onnx",
+	"openvino-fp16",
+	"openvino-int8",
+	"coreml-fp16"
+]);
+var FloorsSchema = record(string(), number().min(0).max(1));
+object({
+	schema: literal(TRAINING_JOB_SCHEMA),
+	jobKey: string().uuid(),
+	target: object({
+		kind: literal("detector"),
+		step: literal("object-detection")
+	}),
+	base: object({
+		modelId: string().min(1),
+		/** Ultralytics weights id, e.g. `yolov9m.pt`. */
+		weights: string().min(1),
+		imgsz: number().int().positive()
+	}),
+	baseline: object({
+		modelId: string().min(1),
+		/** The baseline ONNX the holdout comparison runs; public mirror URL. */
+		onnxUrl: string().url(),
+		imgsz: number().int().positive(),
+		floors: FloorsSchema
+	}),
+	dataset: object({
+		versionId: string().min(1),
+		annotationHash: string(),
+		/** sha256 of the uploaded archive; the trainer refuses a mismatch (exit 65). */
+		sha256: string().regex(/^[0-9a-f]{64}$/)
+	}),
+	split: object({
+		holdoutCameras: array(number().int()),
+		/** When no camera is held out: the last N days of every camera. */
+		holdoutLastDays: number().int().nonnegative(),
+		valFraction: number().min(0).max(.5),
+		seed: number().int()
+	}),
+	hyper: object({
+		epochs: number().int().positive(),
+		batch: number().int().positive(),
+		lr0: number().positive(),
+		/** Layers frozen from the start of the backbone; 0 = none. */
+		freeze: number().int().nonnegative(),
+		patience: number().int().nonnegative(),
+		seed: number().int()
+	}),
+	replay: object({
+		source: literal("coco2017"),
+		count: number().int().nonnegative()
+	}),
+	exports: array(TrainingExportSchema).min(1),
+	calibration: object({ maxFrames: number().int().positive() }),
+	floors: object({
+		minSupport: number().int().positive(),
+		clamp: number().min(0).max(1)
+	}),
+	int8Gate: object({ maxMap50Drop: number().min(0).max(1) }),
+	catalog: object({
+		id: string().regex(/^[a-z0-9][a-z0-9-]{2,80}$/),
+		name: string().min(1).max(160)
+	})
+});
+/** One regular file of the bundle. An mlpackage contributes one row per member. */
+var TrainingResultFileSchema = object({
+	path: string().min(1),
+	bytes: number().int().nonnegative(),
+	sha256: string().regex(/^[0-9a-f]{64}$/),
+	format: _enum([
+		"onnx",
+		"openvino",
+		"coreml",
+		"pt"
+	]),
+	variant: _enum(["base", "int8"])
+});
+var DraftFormatSchema = object({
+	/** RELATIVE path inside the bundle; the hub rewrites it to `camstack-local://`. */
+	url: string().min(1),
+	sizeMB: number().nonnegative(),
+	isDirectory: boolean().optional(),
+	files: array(string()).optional(),
+	runtimes: array(literal("python")).optional(),
+	revision: string().min(1)
+});
+/** The trainer's half of a catalog entry; the hub completes it (labels, licence, group). */
+var TrainingCatalogDraftSchema = object({
+	id: string().min(1),
+	name: string().min(1),
+	description: string(),
+	labels: array(unknown()),
+	inputSize: object({
+		width: number().int().positive(),
+		height: number().int().positive()
+	}),
+	preprocessMode: literal("letterbox"),
+	defaultClassFloors: FloorsSchema,
+	formats: object({
+		onnx: DraftFormatSchema.optional(),
+		openvino: DraftFormatSchema.optional(),
+		coreml: DraftFormatSchema.optional()
+	})
+});
+/** One class of one model's holdout report (the eval harness's summary). */
+var TrainingEvalClassSchema = object({
+	positives: number().int(),
+	floor: number().nullable(),
+	tp: number().int(),
+	fp: number().int(),
+	fn: number().int(),
+	precision: number().nullable(),
+	recall: number().nullable(),
+	ap50: number().nullable(),
+	recallByCamera: record(string(), number().nullable()).optional(),
+	recallByLight: record(string(), number().nullable()).optional(),
+	fpByCamera: record(string(), number()).optional(),
+	smallFound: number().int().optional(),
+	smallTotal: number().int().optional()
+}).passthrough();
+var TrainingEvalReportSchema = object({
+	frames: number().int(),
+	classes: record(string(), TrainingEvalClassSchema)
+}).passthrough();
+/**
+* A succeeded result carries every block; a failed one carries the error and
+* whatever was known by then — the other blocks are ABSENT, not null. The
+* orchestrator checks the blocks it needs before it trusts a success.
+*/
+var TrainingResultSchema = object({
+	schema: literal(TRAINING_RESULT_SCHEMA),
+	jobKey: string(),
+	status: _enum(["succeeded", "failed"]),
+	error: object({
+		stage: string(),
+		code: string(),
+		message: string()
+	}).nullable(),
+	trainer: object({
+		version: string(),
+		revision: string()
+	}),
+	toolchain: record(string(), string().nullable()),
+	dataset: object({
+		versionId: string(),
+		annotationHash: string(),
+		sha256: string(),
+		frames: object({
+			train: number().int(),
+			val: number().int(),
+			holdout: number().int()
+		}),
+		holdoutCameras: array(number().int()),
+		replayImages: number().int()
+	}).optional(),
+	training: object({
+		epochsRun: number().int(),
+		bestEpoch: number().int(),
+		bestMap50: number(),
+		bestMap50_95: number(),
+		seconds: number()
+	}).optional(),
+	evaluation: object({
+		holdoutFrames: number().int(),
+		baseline: TrainingEvalReportSchema.nullable(),
+		candidate: TrainingEvalReportSchema.nullable(),
+		candidateInt8: TrainingEvalReportSchema.nullable(),
+		recallDeltaByCamera: record(string(), record(string(), number())).nullable(),
+		map50: record(string(), number().nullable())
+	}).optional(),
+	floors: object({
+		baseline: FloorsSchema,
+		candidate: FloorsSchema,
+		candidateInt8: FloorsSchema.nullable(),
+		notes: array(string())
+	}).optional(),
+	int8: object({
+		kept: boolean(),
+		map50Fp16: number().nullable(),
+		map50Int8: number().nullable(),
+		reason: string().nullable()
+	}).optional(),
+	exportsDropped: array(object({
+		export: string(),
+		reason: string()
+	})).optional(),
+	files: array(TrainingResultFileSchema).optional(),
+	bundle: object({
+		path: literal("bundle.tar"),
+		bytes: number().int().nonnegative(),
+		sha256: string().regex(/^[0-9a-f]{64}$/)
+	}).nullable().optional(),
+	catalogDraft: object({
+		base: TrainingCatalogDraftSchema,
+		int8: TrainingCatalogDraftSchema.nullable()
+	}).nullable().optional(),
+	licence: string()
+});
+var TrainingStageSchema = _enum([
+	"prepare",
+	"replay",
+	"train",
+	"eval",
+	"export",
+	"package"
+]);
+var EventBase = {
+	v: literal(1),
+	ts: number()
+};
+discriminatedUnion("type", [
+	object({
+		...EventBase,
+		type: literal("stage"),
+		stage: TrainingStageSchema
+	}),
+	object({
+		...EventBase,
+		type: literal("epoch"),
+		epoch: number().int(),
+		epochs: number().int(),
+		boxLoss: number().nullable().optional(),
+		map50: number().nullable().optional(),
+		map50_95: number().nullable().optional(),
+		etaSec: number().nullable().optional()
+	}),
+	object({
+		...EventBase,
+		type: literal("metric"),
+		name: string(),
+		value: number()
+	}),
+	object({
+		...EventBase,
+		type: literal("artifact"),
+		path: string(),
+		bytes: number(),
+		sha256: string()
+	}),
+	object({
+		...EventBase,
+		type: literal("done"),
+		status: _enum(["succeeded", "failed"]),
+		resultSha256: string().nullable().optional()
+	}),
+	object({
+		...EventBase,
+		type: literal("error"),
+		stage: string(),
+		code: string(),
+		message: string()
+	})
+]);
+/**
 * What the gate decided about a birth, from the CALLER's point of view.
 *
 * Deliberately not `ConfirmationVerdict`: `undecided` is not a birth decision
@@ -11044,7 +12416,9 @@ var AddonHttpRouteSchema = object({
 		"authenticated",
 		"admin"
 	]).optional(),
-	description: string().optional()
+	description: string().optional(),
+	/** The hub limits this route per client address before the handler runs. */
+	rateLimit: _enum(["auth"]).optional()
 });
 /**
 * Cross-process route invocation envelope. The hub captures the
@@ -11786,6 +13160,37 @@ var BackupDestinationInfoSchema = object({
 	lastError: string().optional()
 });
 /**
+* How an archive is encrypted (operator decision 2026-10-09): to a backup
+* PUBLIC key the hub holds, so only the operator's secret key opens it.
+* Absent on a plain `.tar.gz` — every archive made before encryption, or
+* with it off — which restores without a key.
+*/
+var BackupArchiveEncryptionSchema = object({
+	/** `x25519-hkdf-aes256gcm-stream-v1`. */
+	scheme: string(),
+	/** 16 hex — the backup key whose secret restores this archive. */
+	keyId: string()
+});
+/**
+* The backup encryption setting. The hub keeps PUBLIC keys only: the active
+* one new archives are encrypted to, and the retired ones older archives
+* still need. The secret key is shown once, at `setupEncryption`.
+*/
+var BackupEncryptionStatusSchema = object({
+	enabled: boolean(),
+	active: object({
+		keyId: string(),
+		publicKey: string(),
+		createdAt: number()
+	}).nullable(),
+	/** Every key ever set up, newest first. */
+	keys: array(object({
+		keyId: string(),
+		createdAt: number(),
+		retiredAt: number().nullable()
+	})).readonly()
+});
+/**
 * Per-archive entry returned by `backup.listArchives({ destinationId })`.
 * Same shape the destination drill-in renders. Sourced from the per-
 * location `manifests.json` (no per-archive tarball read required).
@@ -11797,7 +13202,9 @@ var BackupArchiveEntrySchema = object({
 	sizeBytes: number(),
 	label: string().optional(),
 	/** Top-level locations included in the archive (db, addons, tls, …). */
-	locations: array(string()).readonly()
+	locations: array(string()).readonly(),
+	/** Present when the archive is encrypted; restore then needs that key. */
+	encryption: BackupArchiveEncryptionSchema.optional()
 });
 var BackupEntrySchema = object({
 	id: string(),
@@ -11806,7 +13213,8 @@ var BackupEntrySchema = object({
 	label: string().optional(),
 	createdAt: number(),
 	sizeBytes: number(),
-	locations: array(string()).optional()
+	locations: array(string()).optional(),
+	encryption: BackupArchiveEncryptionSchema.optional()
 });
 var ArchiveEntrySchema = object({
 	path: string(),
@@ -11995,10 +13403,40 @@ method(_void(), array(BackupDestinationInfoSchema).readonly(), { auth: "admin" }
 	* this list and skips entries whose path doesn't start with
 	* any of them.
 	*/
-	locations: array(string()).optional()
+	locations: array(string()).optional(),
+	/**
+	* The backup SECRET key, for an encrypted archive (ignored for a plain
+	* one). The archive is decrypted into the hub's private staging
+	* before the restart; the key is not stored. A wrong or missing key
+	* is refused before the archive is downloaded.
+	*/
+	backupSecretKey: string().optional()
 }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(_void(), BackupEncryptionStatusSchema, { auth: "admin" }), method(object({}), object({
+	keyId: string(),
+	secretKey: string(),
+	publicKey: string(),
+	createdAt: number(),
+	replacedKeyId: string().nullable()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), object({ disabledKeyId: string().nullable() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ backupSecretKey: string() }), object({
+	valid: boolean(),
+	keyId: string().nullable(),
+	/** The hub knows this key (active or retired). */
+	known: boolean(),
+	/** It is the key new archives are encrypted to. */
+	active: boolean(),
+	error: string().optional()
+}), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	destinationId: string(),
 	backupId: string()
@@ -13622,7 +15060,60 @@ var CustomModelDescriptorSchema = object({
 	stepId: string(),
 	entry: ModelCatalogEntrySchema
 });
-method(_void(), array(CustomModelDescriptorSchema).readonly(), { auth: "admin" });
+/** One regular file of an imported bundle, as the producer measured it. */
+var ModelBundleFileSchema = object({
+	/** Relative path inside the bundle tar; an mlpackage member is `<x>.mlpackage/<member>`. */
+	path: string().min(1),
+	bytes: number().int().nonnegative(),
+	sha256: string().regex(/^[0-9a-f]{64}$/)
+});
+var ImportModelBundleInputSchema = object({
+	/** The registry provider that keeps the model (Model Studio). */
+	addonId: string(),
+	stepId: string().min(1),
+	/**
+	* The catalog rows to register, complete, every format URL already
+	* `camstack-local://<modelId>/<file>` naming a file of the bundle. One
+	* bundle may carry several rows (a base and its INT8 variant).
+	*/
+	entries: array(ModelCatalogEntrySchema).min(1).max(4),
+	/** The bundle tar, offered by the producer over `ctx.peerBytes` (same host). */
+	bundle: object({
+		ticket: PeerBytesTicketSchema,
+		bytes: number().int().positive(),
+		sha256: string().regex(/^[0-9a-f]{64}$/)
+	}),
+	/** Every file the tar must hold; anything missing, extra or different is refused. */
+	files: array(ModelBundleFileSchema).min(1).max(64),
+	/** Convert missing engine formats and push the model to every agent afterwards. */
+	distribute: boolean()
+});
+var ImportModelBundleResultSchema = discriminatedUnion("kind", [object({
+	kind: literal("imported"),
+	modelIds: array(string()).readonly(),
+	distributed: array(object({
+		modelId: string(),
+		nodeId: string(),
+		format: _enum(MODEL_FORMATS),
+		ok: boolean(),
+		error: string().optional()
+	})).readonly()
+}), object({
+	kind: literal("refused"),
+	reason: _enum([
+		"transfer-failed",
+		"checksum-mismatch",
+		"bundle-mismatch",
+		"invalid-entry",
+		"id-taken"
+	]),
+	detail: string()
+})]);
+method(_void(), array(CustomModelDescriptorSchema).readonly(), { auth: "admin" }), method(ImportModelBundleInputSchema, ImportModelBundleResultSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 30 * 6e4
+});
 /**
 * Query filter for settings-store collections.
 */
@@ -14006,6 +15497,253 @@ id: union([string(), number()]) }), {
 	auth: "admin"
 });
 /**
+* `keychain` — the hub's encrypted store of secret values (D787).
+*
+* Settings blobs never hold a secret: they hold a marker
+* `{"$secret":"secret://<owner>/<scope>/<fieldPath>","v":1}` and the value
+* lives here, AES-256-GCM under a data key that a master key wraps. This cap
+* is the OWNER's door to its own values: every method is owner-checked
+* against the CALLER, never against anything the caller claims.
+*
+* Who the caller is: the transport stamps `callerAddonId` into the args of a
+* call that crossed a process (the parent `LocalChildRegistry` from the UDS
+* connection, the agent from its child's connection carried in
+* `$hub-cap-fwd`'s envelope). A stamp always overwrites; a wire call with no
+* stamp has its claim stripped. Only a hub in-process caller may state its own
+* identity — `ctx.secrets` does that with the addon id closed over. This is
+* identity against BUGS and misrouting, not against a malicious addon (every
+* runner is the same OS user): see the threat model in
+* `docs/design/2026-10-08-secrets-keychain.md`.
+*
+* `callerAddonId` is deliberately NOT in any input schema: the tRPC router
+* parses the input, so a session can never supply it, and the internal mount
+* floors every method to admin anyway (D240).
+*
+* Internal: addons reach it through `ctx.secrets`, never directly.
+*/
+/** Why a value cannot be served right now. Never folded into "missing". */
+var KeychainUnavailableReasonSchema = _enum([
+	"key-missing",
+	"wrong-key",
+	"key-file-unreadable",
+	"store-unavailable",
+	"not-initialized",
+	"decrypt-failed"
+]);
+var KeychainStateSchema = discriminatedUnion("state", [object({ state: literal("ready") }), object({
+	state: literal("locked"),
+	reason: KeychainUnavailableReasonSchema
+})]);
+var KeychainResolveEntrySchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("value"),
+		value: string(),
+		version: number().int()
+	}),
+	object({ kind: literal("missing") }),
+	object({
+		kind: literal("unavailable"),
+		reason: KeychainUnavailableReasonSchema
+	}),
+	object({ kind: literal("forbidden") })
+]);
+var KeychainResolveResultSchema = record(string(), KeychainResolveEntrySchema);
+/** Metadata of one stored value — never the value. */
+var KeychainSecretMetaSchema = object({
+	ref: string(),
+	owner: string(),
+	/** Formatted scope (`global`, `node/<id>`, `device/<id>`, …). */
+	scope: string(),
+	fieldPath: string(),
+	version: number().int(),
+	createdAt: number(),
+	updatedAt: number(),
+	/** `addon:<id>` | `user:<id>` | `system`. */
+	updatedBy: string(),
+	/** Coarse — written at most once an hour per ref. `null` = never read. */
+	lastReadAt: number().nullable()
+});
+var RefListSchema = array(string().min(1)).max(512);
+method(object({
+	ref: string().min(1),
+	value: string().min(1)
+}), object({
+	ref: string(),
+	version: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ refs: RefListSchema }), KeychainResolveResultSchema, { auth: "admin" }), method(object({ refs: RefListSchema }), object({ deleted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), array(KeychainSecretMetaSchema).readonly(), { auth: "admin" }), method(object({}), KeychainStateSchema, { auth: "admin" });
+var KeychainKeySourceSchema = object({
+	kind: _enum([
+		"config-file",
+		"previous-config-file",
+		"platform",
+		"default-file"
+	]),
+	/** File sources only — a path is not a secret. */
+	path: string().optional(),
+	/**
+	* True when a whole-volume backup of the data directory carries this key
+	* next to the database it protects (the default file). The page warns.
+	*/
+	sharesBackupWithDatabase: boolean()
+});
+/**
+* One keychain reset, as the Secrets page reports it until the operator
+* acknowledges it. Never a value: refs, counts and table names only.
+*/
+var KeychainResetRecordSchema = object({
+	id: string(),
+	at: number(),
+	/** `user:<id>` or {@link KEYCHAIN_RESET_TRIGGER_ACTOR}. */
+	actor: string(),
+	/** Why the keychain was locked when it was reset; `null` when it was not locked. */
+	lockedReason: string().nullable(),
+	/** Values moved into the archive table (ciphertext under the lost key). */
+	archived: number().int(),
+	/** `keychain:secrets-orphaned-<ts>`, or `null` when nothing was stored. */
+	archivedCollection: string().nullable(),
+	/**
+	* `keychain:keys-orphaned-<ts>`: the wrapped data keys of the archive, kept
+	* so the archive can still be opened if the lost master key turns up.
+	*/
+	archivedKeysCollection: string().nullable(),
+	/**
+	* `system-settings` keys whose marker the reset cleared — the cluster
+	* secret's: a marker left pointing at an archived value would refuse every
+	* agent forever (D797).
+	*/
+	clearedSettingsKeys: array(string()).readonly(),
+	/** When an operator dismissed the notice on the Secrets page; `null` until then. */
+	acknowledgedAt: number().nullable()
+});
+var KeychainStatusSchema = object({
+	keychain: KeychainStateSchema,
+	/** The source of the master key in use; `null` while locked. */
+	keySource: KeychainKeySourceSchema.nullable(),
+	/** The source configured to be primary — differs from `keySource` while a rotation is pending. */
+	configuredSource: KeychainKeySourceSchema,
+	/** Short fingerprint of the master key in use (`HMAC(KEK, label)`, 16 hex). */
+	fingerprint: string().nullable(),
+	activeKeyId: string().nullable(),
+	/**
+	* The keychain unlocked with a NON-primary source: the configured primary
+	* key is not the one that wraps the data key yet. `rotateMasterKey` moves it.
+	*/
+	rotationPending: boolean(),
+	/** Wrapped copies of the data key under a previous master key, kept until purged. */
+	retiredWraps: number().int(),
+	recoveryKeyDownloadedAt: number().nullable(),
+	secretCount: number().int(),
+	/** The most recent reset, acknowledged or not; `null` when the keychain was never reset. */
+	lastReset: KeychainResetRecordSchema.nullable()
+});
+/**
+* Whether a stored value is still pointed at by its owner's settings.
+* `unknown` is a first-class answer: a scope whose blob could not be read is
+* never reported as an orphan (and never deleted as one).
+*/
+var KeychainSecretUsageSchema = _enum([
+	"in-use",
+	"orphan",
+	"unknown"
+]);
+var KeychainAdminSecretSchema = KeychainSecretMetaSchema.extend({ usage: KeychainSecretUsageSchema });
+var KeychainAuditActionSchema = _enum([
+	"put",
+	"delete",
+	"reveal",
+	"rotate-master-key",
+	"purge-retired-keys",
+	"download-recovery-key",
+	"delete-orphans",
+	"reset",
+	"acknowledge-reset",
+	"initialize"
+]);
+var KeychainAuditEntrySchema = object({
+	id: string(),
+	at: number(),
+	action: KeychainAuditActionSchema,
+	/** `addon:<id>` | `user:<id>` | `system` | `trigger-file`. */
+	actor: string(),
+	ref: string().nullable(),
+	detail: string().nullable()
+});
+var KEYCHAIN_RESET_CONFIRMATION = "RESET KEYCHAIN";
+/**
+* Secrets the HUB itself holds (owner `system`) that no settings form shows:
+* `jwt-signing-key` — the session signing key (D797). It is always "in use",
+* never an orphan; it is generated on a fresh hub and replaced only through
+* {@link keychainAdminCapability.methods.setSystemSecret}.
+*/
+var SystemHeldSecretNameSchema = _enum(["jwt-signing-key"]);
+method(object({}), KeychainStatusSchema, { auth: "admin" }), method(object({}), array(KeychainAdminSecretSchema).readonly(), { auth: "admin" }), method(object({ limit: number().int().min(1).max(500).optional() }), array(KeychainAuditEntrySchema).readonly(), { auth: "admin" }), method(object({ ref: string().min(1) }), object({
+	value: string(),
+	version: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({
+	name: SystemHeldSecretNameSchema,
+	value: string().min(16)
+}), object({
+	ref: string(),
+	version: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({ refs: array(string().min(1)).max(1e3) }), object({
+	deleted: array(string()).readonly(),
+	kept: array(object({
+		ref: string(),
+		usage: KeychainSecretUsageSchema
+	})).readonly()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({}), object({
+	fingerprint: string(),
+	keySource: KeychainKeySourceSchema
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({}), object({ purged: number().int() }), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({}), object({
+	key: string(),
+	fingerprint: string(),
+	keySource: KeychainKeySourceSchema
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({ confirm: literal(KEYCHAIN_RESET_CONFIRMATION) }), object({
+	archivedCollection: string().nullable(),
+	archived: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({}), object({
+	reset: KeychainResetRecordSchema.nullable(),
+	pendingReentry: array(KeychainSecretMetaSchema).readonly()
+}), { auth: "admin" }), method(object({}), object({ acknowledged: boolean() }), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+});
+/**
 * Stable UI option list for the `hwaccel` setting. Decoder addons
 * reuse this for `globalSettingsSchema()` so the dropdown is
 * identical everywhere. Order: auto → off → common backends by
@@ -14903,6 +16641,10 @@ var DeviceInfoSchema = object({
 	isCamera: boolean(),
 	/** Current config values — serializable snapshot */
 	config: record(string(), unknown()),
+	/** Paths inside `config` the device's schema declares secret (D783) —
+	*  what the non-admin redaction withholds. Paths, never values. Absent
+	*  when the owning runner has not reported them. */
+	secretConfigPaths: array(string()).optional(),
 	/** Hardware + identity blob (manufacturer / model / firmware / sn /
 	*  uid / mac / …). Populated by drivers; editable via setMetadata. */
 	metadata: record(string(), unknown()).nullable().optional(),
@@ -15108,12 +16850,22 @@ var DeviceRegisterPayloadSchema = object({
 	*  call (workers re-register on init), so probe-driven updates
 	*  (e.g. PTZ flag flipping after the abilities probe) propagate. */
 	features: array(string()).optional(),
-	config: record(string(), unknown())
+	config: record(string(), unknown()),
+	/** Config paths the device's own schema DECLARES secret
+	*  (`.meta({ secret: true })` — dotted, `[]` for array items, e.g.
+	*  `connection.password`). Re-published on every register; the non-admin
+	*  redaction withholds them at any depth (D783). Optional: an older runner
+	*  omits it and the keyword backstop applies. */
+	secretConfigPaths: array(string()).optional()
 });
 var DeviceRemovePayloadSchema = object({ deviceId: number() });
 var DevicePersistConfigPayloadSchema = object({
 	deviceId: number(),
-	data: record(string(), unknown())
+	data: record(string(), unknown()),
+	/** The paths the device's schema declares secret (D783), when the caller
+	*  knows them — those values are kept in the keychain, not the blob (D787).
+	*  Absent: the paths the device last reported at `registerDevice` apply. */
+	secretConfigPaths: array(string()).optional()
 });
 /** What a migration actually did, per switch. `unreachable` is a first-class
 *  answer: a camera that could not be asked is not a camera that was silenced. */
@@ -16431,14 +18183,14 @@ var LlmProfileSchema = object({
 /** ConfigUISchema tree passed through untyped on the wire (the
 *  notification-output `ConfigSchemaPassthrough` precedent at
 *  notification-output.cap.ts:151); the exported TS type re-tightens it. */
-var ConfigSchemaPassthrough$1 = unknown();
+var ConfigSchemaPassthrough$3 = unknown();
 var LlmProfileKindDescriptorSchema = object({
 	kind: LlmProfileKindSchema,
 	label: string(),
 	icon: string(),
 	/** Stamped by each provider so the concat-fanned catalog stays routable. */
 	addonId: string(),
-	configSchema: ConfigSchemaPassthrough$1
+	configSchema: ConfigSchemaPassthrough$3
 });
 var LlmDefaultSelectorSchema = union([object({ consumer: string() }), object({ purpose: _enum(["text", "vision"]) })]);
 var LlmDefaultSchema = object({
@@ -16716,7 +18468,7 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 * `login-method` — collection cap through which auth addons contribute
 * their pre-auth login surfaces to the login page. This is the SINGLE,
 * generic mechanism that supersedes the dead `auth.listProviders` reader:
-* every auth addon (OIDC, magic-link, WebAuthn/passkey) registers a
+* every auth addon (OIDC, WebAuthn/passkey) registers a
 * `login-method` provider and the PUBLIC `auth.listLoginMethods`
 * procedure aggregates them for the unauthenticated login page.
 *
@@ -16724,8 +18476,7 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 *
 *  - `redirect` — a declarative button. The login page renders a generic
 *    button that navigates to `startUrl` (an addon-owned HTTP route).
-*    Covers OIDC (`/addon/auth-oidc/<id>/start`) and magic-link with
-*    ZERO shell-side JS. A future SSO addon plugs in the same way — the
+*    Covers OIDC (`/addon/auth-oidc/<id>/start`) with ZERO shell-side JS. A future SSO addon plugs in the same way — the
 *    login page needs NO change.
 *
 *  - `widget` — a Module-Federation widget the login page mounts (via
@@ -16744,8 +18495,8 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 *    decision.
 *
 * Every contribution carries a `stage`:
-*  - `primary`        — shown on the first credentials screen (OIDC /
-*                       magic-link buttons; a future usernameless passkey).
+*  - `primary`        — shown on the first credentials screen (OIDC
+*                       buttons; a usernameless passkey).
 *  - `second-factor`  — shown AFTER the password leg, gated on the
 *                       returned `factors` (passkey-as-2FA today).
 *
@@ -16767,7 +18518,14 @@ var LoginMethodContributionSchema = discriminatedUnion("kind", [
 		icon: string().optional(),
 		/** Addon-owned HTTP route the button navigates to (GET). */
 		startUrl: string(),
-		stage: LoginStageEnum
+		stage: LoginStageEnum,
+		/**
+		* The provider names an external identity a signed-in user can link to
+		* their own account (D782): `auth.listLinkableProviders` /
+		* `beginExternalLink` offer exactly the redirect methods that set this,
+		* whatever their id. Absent / false — a login button only.
+		*/
+		linkable: boolean().optional()
 	}),
 	object({
 		kind: literal("widget"),
@@ -17553,7 +19311,7 @@ var TargetKindCapsSchema = object({
 * the union is large and not meant for runtime validation here; the exported
 * `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
 */
-var ConfigSchemaPassthrough = unknown();
+var ConfigSchemaPassthrough$2 = unknown();
 var TargetKindSchema = object({
 	kind: string(),
 	label: string(),
@@ -17590,7 +19348,7 @@ var TargetKindSchema = object({
 	* its raster path, which is the safe default for an unknown image.
 	*/
 	iconMediaType: string().optional(),
-	configSchema: ConfigSchemaPassthrough,
+	configSchema: ConfigSchemaPassthrough$2,
 	/**
 	* The config keys that decide WHERE this kind's secrets are sent (server,
 	* base URL, instance, chat, recipient). A save that changes any of them
@@ -20582,8 +22340,7 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 * `super_admin` — collapsed onto the single boolean because every
 * non-admin caller is governed by the same scope-check rules; the
 * distinction was only ever used to route role-specific procedures
-* which we no longer have. Agents are admin sessions issued via
-* `createServiceToken`; CLI / webhook integrations are `cst_*` tokens
+* which we no longer have. CLI / webhook integrations are `cst_*` tokens
 * with `isAdmin: false` + an explicit scope list.
 */
 /** Per-method access flavour. Materialised on every cap method via codegen. */
@@ -20890,6 +22647,61 @@ var OauthIntegrationDescriptorSchema = object({
 });
 method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" });
 /**
+* `oidc-connections` — CRUD for IdP rows under `auth-oidc` (D828 sibling).
+*
+* One hub-only singleton (`auth-oidc`). The Settings UI is a DataTable +
+* ItemFormDialog; there is no `editable-array` in `globalSettingsSchema`.
+* Operator-chosen `id` is the URL slug (`/addon/auth-oidc/<id>/…`) and is
+* immutable after create.
+*/
+var ConfigSchemaPassthrough$1 = unknown();
+var OidcConnectionSchema = object({
+	id: string().min(1),
+	displayName: string(),
+	icon: string(),
+	issuerUrl: string(),
+	clientId: string(),
+	/** Client id + secret present — never the secret value. */
+	configured: boolean(),
+	/**
+	* Values for the connection form schema. `clientSecret` is a keychain
+	* {@link SecretFieldView} or `null` / `''`, never plaintext (D789).
+	*/
+	formValues: record(string(), unknown()).optional()
+});
+/**
+* Patch one connection. Omitted or empty `clientSecret` keeps the stored
+* secret (D787). `{ $secretClear: true }` clears it. `id` is never renamed.
+*/
+var OidcConnectionUpdateInputSchema = object({
+	id: string().min(1),
+	displayName: string().min(1),
+	icon: string().optional(),
+	issuerUrl: string().optional(),
+	clientId: string().optional(),
+	clientSecret: union([string(), object({ $secretClear: literal(true) })]).optional(),
+	redirectUri: string().optional(),
+	scopes: string().optional(),
+	usernameClaim: _enum([
+		"preferred_username",
+		"email",
+		"sub"
+	]).optional()
+});
+method(object({}), ConfigSchemaPassthrough$1, { auth: "admin" }), method(object({}), array(OidcConnectionSchema).readonly(), { auth: "admin" }), method(object({
+	id: string().min(1).regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "id must be a lowercase slug"),
+	displayName: string().min(1)
+}), object({ id: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(OidcConnectionUpdateInputSchema, object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ id: string().min(1) }), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * What started a camera's onboard motion (D672). `camera` is the camera's own
 * firmware; `sensor` is a device the operator ATTACHED to it. Absent on the
 * wire means the camera: only the camera-sensors bridge ever says `sensor`.
@@ -22085,8 +23897,23 @@ var RetrainMacroClassSchema = _enum([
 ]);
 /** A subject to learn, or a phantom to unlearn (taught by OMISSION). */
 var RetrainAnnotationKindSchema = _enum(["subject", "model_error"]);
-/** Did a human draw this box, or did the assist propose it? */
-var RetrainAnnotationSourceSchema = _enum(["operator", "assist"]);
+/**
+* Where a box came from. A machine-sourced box is a DRAFT on the page until
+* the operator confirms it; once saved it keeps its source as provenance.
+*
+* - `operator` — drawn by hand.
+* - `assist`   — proposed by a detector run on the copy (the camera's own
+*   model, or a larger teacher model).
+* - `pipeline` — the box the live pipeline actually drew on that frame, read
+*   back from the track store (never a re-run).
+* - `llm`      — proposed by a vision-capable LLM profile.
+*/
+var RetrainAnnotationSourceSchema = _enum([
+	"operator",
+	"assist",
+	"pipeline",
+	"llm"
+]);
 /** Normalised `[0,1]` rectangle against the FULL frame — the canonical form. */
 var RetrainBboxSchema = object({
 	x: number(),
@@ -22104,7 +23931,8 @@ var RetrainBboxSchema = object({
 */
 var RetrainAnnotationSchema = object({
 	id: string(),
-	trackId: string(),
+	/** The frame's track. Absent on a recording still, which has none. */
+	trackId: string().optional(),
 	deviceId: number(),
 	/** The COPY in retrain storage — never the source track's media key. */
 	mediaKey: string(),
@@ -22153,18 +23981,63 @@ var RetrainFrameCandidateSchema = object({
 	*  fail, whatever became of the original. */
 	copied: boolean()
 });
+/**
+* One box the live pipeline drew on a copied frame — what a correction starts
+* from. Derived when the frame is listed, from the track store: the subject
+* box recorded on the source media row when there is one, else the track
+* position nearest the frame's capture time. Never stored as an annotation
+* until the operator confirms it.
+*/
+var RetrainPipelineBoxSchema = object({
+	/** Normalised `[0,1]` against the full frame. */
+	bbox: RetrainBboxSchema,
+	macroClass: RetrainMacroClassSchema,
+	label: string().optional(),
+	subLabel: string().optional(),
+	/** The detection score of the position used, when it was recorded. */
+	score: number().optional(),
+	/** The root model that produced the track, when it was recorded. */
+	modelId: string().optional(),
+	trackId: string(),
+	/** `subject-box`: recorded on this very frame. `position`: the track's
+	*  position nearest the capture time, `deltaMs` away. */
+	basis: _enum(["subject-box", "position"]),
+	deltaMs: number()
+});
+/**
+* Where a retrain frame came from: a TRACK's stored media (copy-on-select),
+* or the RECORDING at an instant — the frame a model saw nothing in has no
+* track at all.
+*/
+var RetrainFrameOriginSchema = _enum(["track", "recording"]);
 /** A frame the dataset OWNS: bytes copied at selection time. */
 var RetrainFrameSchema = object({
 	frameId: string(),
 	deviceId: number(),
-	trackId: string(),
-	/** Provenance only. It may already point at nothing — that is expected. */
-	sourceMediaId: number().int(),
+	origin: RetrainFrameOriginSchema,
+	/** The track it was copied from. Absent on a recording still. */
+	trackId: string().optional(),
+	/** Provenance only. It may already point at nothing — that is expected.
+	*  Absent on a recording still. */
+	sourceMediaId: number().int().optional(),
+	/** A recording still: the playhead instant it was taken at. */
+	epochMs: number().optional(),
 	sourceKind: MediaFileKindEnum,
 	sizeBytes: number().int(),
 	width: number().int(),
 	height: number().int(),
-	copiedAt: number()
+	copiedAt: number(),
+	/** When the CAMERA captured the frame. Absent on a copy taken before D785. */
+	capturedAt: number().optional(),
+	/** The operator's "every subject in this frame is boxed". Detector
+	*  evaluation keeps only complete frames: an unboxed subject would count as
+	*  a false positive. */
+	complete: boolean(),
+	/** The boxes the pipeline drew on this frame. Present on list answers;
+	*  empty when nothing the track store holds can be placed on it. */
+	pipelineBoxes: array(RetrainPipelineBoxSchema).readonly().optional(),
+	/** The named collections this frame belongs to. Present on list answers. */
+	collectionIds: array(string()).readonly().optional()
 });
 /** Why a copy-on-select could not be honoured — named, never a silent skip. */
 var RetrainCopyRefusalSchema = _enum([
@@ -22185,6 +24058,101 @@ var RetrainFrameListSchema = object({
 	/** What the page pre-selects — the native key frame when one survives. */
 	autoPickMediaId: number().int().optional()
 });
+/** Exclusive partition of a corpus copy's annotation progress (design §4.2). */
+var RetrainFrameWorkStateSchema = _enum([
+	"unannotated",
+	"annotated",
+	"complete"
+]);
+/**
+* Filters for paginated corpus list, KPI, and matching export (design §4.4).
+* Every narrowing field is ANDed; omitted fields impose no constraint.
+*/
+var RetrainCorpusFilterSchema = object({
+	workState: RetrainFrameWorkStateSchema.optional(),
+	deviceIds: array(number()).max(500).optional(),
+	/** When set, only frames in this named collection. */
+	collectionId: string().optional(),
+	/** Frames that carry at least one saved annotation in one of these classes. */
+	classes: array(RetrainMacroClassSchema).optional(),
+	page: number().int().positive().default(1),
+	pageSize: number().int().positive().max(100).default(50)
+});
+var RetrainCorpusPageSchema = object({
+	frames: array(RetrainFrameSchema.extend({ workState: RetrainFrameWorkStateSchema })).readonly(),
+	total: number().int().nonnegative(),
+	page: number().int().positive(),
+	pageSize: number().int().positive()
+});
+var RetrainCorpusKpiCameraRowSchema = object({
+	deviceId: number(),
+	unannotated: number().int().nonnegative(),
+	annotated: number().int().nonnegative(),
+	complete: number().int().nonnegative(),
+	/** This camera's `complete` count divided by corpus `total`, in `[0,1]`.
+	*  `null` when the corpus is empty (no ratio). */
+	pctOfCorpus: number().min(0).max(1).nullable()
+});
+var RetrainCorpusKpiSchema = object({
+	total: number().int().nonnegative(),
+	unannotated: number().int().nonnegative(),
+	annotated: number().int().nonnegative(),
+	complete: number().int().nonnegative(),
+	cameras: array(RetrainCorpusKpiCameraRowSchema).readonly()
+});
+/**
+* Which frames an annotated export carries. Every field narrows; an empty
+* filter is every annotated copy. `frameIds` is the primitive a job or
+* download uses; `batchId` re-selects what an earlier export carried
+* (`exportedInBatch`). Frozen dataset versions were removed — live selection
+* resolves to `frameIds` at plan/start.
+*/
+var RetrainExportFilterSchema = object({
+	deviceIds: array(number()).optional(),
+	frameIds: array(string()).max(2e4).optional(),
+	/** Only frames in at least one of these named collections. */
+	collectionIds: array(string()).max(200).optional(),
+	/** Single collection (Frames filter bar). ANDed with `collectionIds` when both set. */
+	collectionId: string().optional(),
+	batchId: string().optional(),
+	/** Only frames the operator marked complete (all subjects boxed). */
+	completeOnly: boolean().optional(),
+	/** Exclusive work-state partition (`workStateOf`); same as the corpus list. */
+	workState: RetrainFrameWorkStateSchema.optional(),
+	/** Frames with at least one saved annotation in one of these classes. */
+	classes: array(RetrainMacroClassSchema).optional()
+});
+/**
+* `frames`: the full frame copies, boxes in `annotations.json`.
+* `crops`: additionally one JPEG per subject, cut with the runtime detail-crop
+* convention — the classifier layout.
+*/
+var RetrainExportLayoutSchema = _enum(["frames", "crops"]);
+/**
+* Where `writeRetrainArchive` streams the tar: one HTTP request whose body is
+* the archive, sent chunk by chunk. Covers a presigned PUT and a provider
+* addon's data-plane upload route alike. Headers are sent verbatim and never
+* logged.
+*/
+var RetrainArchiveTargetSchema = object({
+	kind: literal("http"),
+	method: _enum(["PUT", "POST"]),
+	url: string().url(),
+	headers: record(string(), string()).optional()
+});
+var RetrainArchiveResultSchema = object({
+	batchId: string(),
+	frames: number().int(),
+	crops: number().int(),
+	annotations: number().int(),
+	/** Frames planned but not shipped (unreadable copy, path too long). */
+	missing: number().int(),
+	bytes: number().int(),
+	/** sha256 of the exact bytes sent. */
+	sha256: string(),
+	/** The target's HTTP status. */
+	status: number().int()
+});
 /** What the operator asked the assist to look for. */
 var RetrainAssistSubjectSchema = discriminatedUnion("kind", [object({
 	kind: literal("package"),
@@ -22214,6 +24182,180 @@ var RetrainAssistResultSchema = discriminatedUnion("kind", [object({
 	reason: string(),
 	detail: string().optional()
 })]);
+/** A named set over the retrain corpus — membership only, it owns no pixels. */
+var RetrainCollectionSchema = object({
+	id: string(),
+	name: string(),
+	createdAt: number(),
+	frameCount: number().int()
+});
+var RetrainCollectionCreateResultSchema = discriminatedUnion("kind", [object({
+	kind: literal("created"),
+	collection: RetrainCollectionSchema
+}), object({
+	kind: literal("refused"),
+	reason: _enum(["empty-name", "duplicate-name"])
+})]);
+var RetrainCollectionRenameResultSchema = discriminatedUnion("kind", [object({
+	kind: literal("renamed"),
+	collection: RetrainCollectionSchema
+}), object({
+	kind: literal("refused"),
+	reason: _enum([
+		"empty-name",
+		"duplicate-name",
+		"unknown-collection"
+	])
+})]);
+/**
+* The outcome of adding the frame at a recording instant. Every refusal is
+* named: `still-unavailable` (not recording, a gap, or an undecodable frame —
+* `detail` says which), `still-busy` (the recorder is at its decode bound; try
+* again), `unreadable-image`, `write-failed`, `unknown-collection`.
+*/
+var AddRetrainFrameFromRecordingResultSchema = discriminatedUnion("kind", [object({
+	kind: literal("added"),
+	collectionId: string(),
+	frame: RetrainFrameSchema,
+	/** The moment was already in the dataset; nothing was decoded. */
+	reused: boolean()
+}), object({
+	kind: literal("refused"),
+	reason: _enum([
+		"unknown-collection",
+		"still-unavailable",
+		"still-busy",
+		"unreadable-image",
+		"write-failed"
+	]),
+	detail: string().optional()
+})]);
+/** A vision LLM profile the AI assist may use, and where it sends the frame. */
+var RetrainAssistProfileSchema = object({
+	id: string(),
+	name: string(),
+	model: string(),
+	kind: string(),
+	/** `true` when the frame would leave the house (a cloud vendor, or an
+	*  endpoint that is not on the local network). The page confirms each such
+	*  run, and the provider refuses one without `allowCloud`. */
+	leavesHouse: boolean()
+});
+/** A box the AI assist proposed: a draft, plus the model's own reason. */
+var RetrainLlmProposalSchema = RetrainAnnotationDraftSchema.extend({ reason: string() });
+/** What the AI assist said about a box that was already on the canvas. */
+var RetrainLlmReviewSchema = object({
+	/** The `ref` the page sent the box under. */
+	ref: string(),
+	verdict: _enum([
+		"confirmed",
+		"wrong-class",
+		"not-an-object",
+		"uncertain"
+	]),
+	suggestedClass: RetrainMacroClassSchema.optional(),
+	reason: string()
+});
+/**
+* The AI assist's answer. `proposed` carries drafts (`source: 'llm'`, the
+* model and its confidence) and reviews; items the model got wrong (a box off
+* the frame, an unasked class, an unknown ref) are dropped and counted in
+* `rejected`. A whole answer that is not the schema is `malformed-answer`.
+*/
+var RetrainLlmAssistResultSchema = discriminatedUnion("kind", [object({
+	kind: literal("proposed"),
+	profileId: string(),
+	model: string(),
+	/** The frame was sent outside the house for this answer. */
+	leftHouse: boolean(),
+	proposals: array(RetrainLlmProposalSchema).readonly(),
+	reviews: array(RetrainLlmReviewSchema).readonly(),
+	rejected: number().int()
+}), object({
+	kind: literal("refused"),
+	reason: _enum([
+		"unknown-frame",
+		"unreadable-frame",
+		"unknown-profile",
+		"profile-disabled",
+		"no-vision",
+		"cloud-not-confirmed",
+		"llm-error",
+		"malformed-answer"
+	]),
+	detail: string().optional()
+})]);
+/** What a dataset version is cut from. Every field narrows. */
+var RetrainDatasetSelectionSchema = object({
+	deviceIds: array(number()).readonly().optional(),
+	collectionIds: array(string()).max(200).readonly().optional(),
+	frameIds: array(string()).max(2e4).readonly().optional()
+});
+/** The counts a dataset is judged by. */
+var RetrainDatasetStatsSchema = object({
+	frames: number().int(),
+	completeFrames: number().int(),
+	/** `completeFrames / frames`, 0..1. */
+	completeness: number(),
+	/** Boxes to learn (model errors excluded). */
+	subjects: number().int(),
+	modelErrors: number().int(),
+	/** Complete frames with no subject. */
+	hardNegatives: number().int(),
+	/** Subjects per class × camera × day/night. */
+	cells: array(object({
+		macroClass: string(),
+		deviceId: number(),
+		lighting: _enum([
+			"day",
+			"night",
+			"unknown"
+		]),
+		subjects: number().int(),
+		frames: number().int()
+	})).readonly(),
+	cameras: array(object({
+		deviceId: number(),
+		frames: number().int(),
+		completeFrames: number().int()
+	})).readonly()
+});
+object({
+	id: string(),
+	name: string(),
+	createdAt: number(),
+	selection: RetrainDatasetSelectionSchema,
+	layout: RetrainExportLayoutSchema,
+	completeOnly: boolean(),
+	frameCount: number().int(),
+	annotationHash: string(),
+	manifestSchema: string(),
+	stats: RetrainDatasetStatsSchema
+});
+/**
+* Live training corpus criteria — same shape as `TrainingCorpusSelection` on
+* the training cap. Resolved here so plan/start and the annotated export share
+* one definition of "the frames" (`buildRetrainExportPlan`).
+*/
+var RetrainTrainingCorpusSelectionSchema = object({
+	collectionIds: array(string()).min(1),
+	workState: _enum([
+		"complete",
+		"annotated_or_complete",
+		"any_annotated"
+	]).default("complete")
+});
+var RetrainTrainingCorpusResolveResultSchema = discriminatedUnion("kind", [object({
+	kind: literal("resolved"),
+	frameIds: array(string()).max(2e4).readonly(),
+	stats: RetrainDatasetStatsSchema,
+	annotationHash: string(),
+	layout: RetrainExportLayoutSchema
+}), object({
+	kind: literal("refused"),
+	reason: _enum(["unknown-collection", "no-frames"]),
+	detail: string()
+})]);
 /** The outcome of a lifecycle move owned by the retrain page. */
 var RetrainTransitionResultSchema = object({
 	trackId: string(),
@@ -22919,6 +25061,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), array(RetrainTrackSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
+}), method(RetrainCorpusFilterSchema, RetrainCorpusPageSchema, {
+	kind: "query",
+	auth: "admin"
+}), method(object({}), RetrainCorpusKpiSchema, {
+	kind: "query",
+	auth: "admin"
 }), method(object({ trackId: string() }), RetrainFrameListSchema, {
 	kind: "query",
 	auth: "admin"
@@ -22931,7 +25079,7 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	auth: "admin"
 }), method(object({
 	deviceId: number(),
-	trackId: string(),
+	trackId: string().optional(),
 	frameId: string()
 }), object({
 	removed: boolean(),
@@ -22948,7 +25096,8 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	auth: "admin"
 }), method(object({
 	deviceId: number(),
-	trackId: string(),
+	/** The frame's track, when it has one — checked against the frame. */
+	trackId: string().optional(),
 	frameId: string(),
 	subject: RetrainAssistSubjectSchema,
 	/** Which node runs it. Absent ⇒ wherever an unowned call lands. */
@@ -22956,12 +25105,16 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), RetrainAssistResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
+}), method(object({
+	trackId: string().optional(),
+	frameIds: array(string()).max(2e3).optional()
+}), array(RetrainAnnotationSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
 }), method(object({
 	deviceId: number(),
-	trackId: string(),
+	/** The frame's track, when it has one — checked against the frame. */
+	trackId: string().optional(),
 	frameId: string(),
 	annotations: array(RetrainAnnotationDraftSchema)
 }), array(RetrainAnnotationSchema).readonly(), {
@@ -22979,7 +25132,106 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), RetrainTransitionResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
+}), method(RetrainExportFilterSchema.extend({ layout: RetrainExportLayoutSchema.optional() }), object({ url: string() }), {
+	kind: "query",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	trackId: string().optional(),
+	frameId: string(),
+	complete: boolean()
+}), RetrainFrameSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	filter: RetrainExportFilterSchema,
+	layout: RetrainExportLayoutSchema,
+	target: RetrainArchiveTargetSchema
+}), RetrainArchiveResultSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 60 * 6e4
+}), method(object({
+	filter: RetrainExportFilterSchema,
+	layout: RetrainExportLayoutSchema
+}), object({
+	ticket: PeerBytesTicketSchema,
+	frames: number().int(),
+	annotations: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
+}), method(object({}), array(RetrainAssistProfileSchema).readonly(), {
+	kind: "query",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	trackId: string().optional(),
+	frameId: string(),
+	profileId: string(),
+	classes: array(RetrainMacroClassSchema).min(1),
+	boxes: array(object({
+		ref: string(),
+		bbox: RetrainBboxSchema,
+		macroClass: RetrainMacroClassSchema,
+		label: string().optional()
+	})).max(50),
+	allowCloud: boolean()
+}), RetrainLlmAssistResultSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 18e4
+}), method(object({ name: string().max(120) }), RetrainCollectionCreateResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), array(RetrainCollectionSchema).readonly(), {
+	kind: "query",
+	auth: "admin"
+}), method(RetrainTrainingCorpusSelectionSchema, RetrainTrainingCorpusResolveResultSchema, {
+	kind: "query",
+	auth: "admin",
+	timeoutMs: 6e4
+}), method(object({
+	id: string(),
+	name: string().max(120)
+}), RetrainCollectionRenameResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ id: string() }), object({
+	deleted: boolean(),
+	removedFrames: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	collectionId: string(),
+	deviceId: number(),
+	epochMs: number()
+}), AddRetrainFrameFromRecordingResultSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 6e4
+}), method(object({
+	collectionId: string(),
+	frameIds: array(string()).min(1).max(500)
+}), object({
+	added: number().int(),
+	alreadyMember: number().int(),
+	unknownFrameIds: array(string()).readonly()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	collectionId: string(),
+	frameId: string()
+}), object({
+	removed: boolean(),
+	deletedFrame: boolean()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ collectionId: string() }), array(RetrainFrameSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
 }), method(object({
@@ -23556,11 +25808,14 @@ var HardwareClassIdSchema = _enum([
 	"intel-n-series",
 	"apple-m-base",
 	"apple-m-pro",
+	"amd-phoenix",
 	"unknown"
 ]);
 var AcceleratorKindSchema = _enum([
 	"intel-npu",
 	"intel-igpu",
+	"amd-igpu",
+	"amd-npu",
 	"x86-cpu",
 	"arm-cpu",
 	"apple-ane",
@@ -23605,13 +25860,31 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("no-family-build"),
 		format: ModelFormatSchema$1
+	}),
+	object({
+		kind: literal("kept-custom-pin"),
+		modelId: string(),
+		deviceKey: string()
 	})
 ]);
+/** Why a device is left exactly as it is, whatever the plan would pick (D786). */
+var KeptReasonSchema = _enum(["custom-pin"]);
+/**
+* Where a choice's latency came from (D791): this node's own benchmark
+* result, or the hardware-class table. Measured on the node beats the table.
+*/
+var LatencySourceSchema = discriminatedUnion("kind", [object({ kind: literal("table") }), object({
+	kind: literal("node-benchmark"),
+	resultId: string(),
+	measuredAtMs: number()
+})]);
 var DeviceModelChoiceSchema = object({
 	modelId: string(),
 	p50Ms: number(),
 	fps: number(),
 	measured: boolean(),
+	/** Absent on a plan from before D791 — read as the table. */
+	source: LatencySourceSchema.optional(),
 	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
 	capacitySessions: number(),
 	personRecall: number()
@@ -23622,6 +25895,8 @@ var DeviceRecommendationSchema = object({
 	enabled: boolean(),
 	available: boolean(),
 	chosen: DeviceModelChoiceSchema.nullable(),
+	/** Present when the device is kept as is: Apply writes nothing on it. */
+	kept: KeptReasonSchema.optional(),
 	reasons: array(RecommendationReasonSchema).readonly()
 });
 var NodeRecommendationSchema = object({
@@ -23675,6 +25950,17 @@ var AutoTuneWarningSchema = discriminatedUnion("kind", [
 		kind: literal("coral-enabled"),
 		nodeId: string(),
 		deviceKey: string()
+	}),
+	object({
+		kind: literal("custom-pin-kept"),
+		nodeId: string(),
+		deviceKey: string().nullable(),
+		deviceId: number().nullable(),
+		modelId: string()
+	}),
+	object({
+		kind: literal("custom-registry-unreadable"),
+		error: string()
 	})
 ]);
 var AutoTuneOptionsSchema = object({
@@ -23853,13 +26139,14 @@ var SuggestSharesResultSchema = object({
 	nodes: array(SuggestedNodeShareSchema).readonly()
 });
 /**
-* Where the node and device shares come from (D750, D755).
-*  - `hardware` (default) — computed by the system from each node's static
-*    capacity (its accelerators at their Auto tune models, from the measured
-*    latency table), recomputed whenever a node or device joins, leaves, is
-*    switched on or off, or changes model. No load input.
-*  - `benchmark` — the same, from each node's measured capacity (node
-*    benchmark results); a node without results falls back to `hardware`.
+* Where the node and device shares come from (D750, D755, D791).
+*  - `benchmark` (default since D791) — each node's capacity as its own node
+*    benchmark measured it; a node without fresh results is sized from
+*    `hardware` and says so. Measured on the node beats the table.
+*  - `hardware` — computed from each node's static capacity only (its
+*    accelerators at their Auto tune models, from the latency table).
+*  Both are recomputed whenever a node or device joins, leaves, is switched
+*  on or off, changes model, or a benchmark result is written. No load input.
 *  - `manual` — the operator's stored sliders.
 * Either way a node or device that cannot take sessions gives its share to
 * the others in proportion; the stored values are never rewritten for that.
@@ -23908,6 +26195,362 @@ var EffectiveSharesSchema = object({
 	nodeWeights: record(string(), number()),
 	deviceWeights: record(string(), record(string(), number()))
 });
+/**
+* Wire shapes of the node benchmark (D791): the operator's plan, the
+* preflight the confirmation shows, the run the orchestrator owns, what the
+* measuring runner reports, and the result rows Auto tune and the automatic
+* shares read.
+*
+* ONE node at a time, owned by the pipeline orchestrator. While a run is
+* active the cluster is in BENCHMARK MODE for that node: it is not a
+* detection candidate, camera pins naming it are ignored so its sessions move
+* elsewhere, and both come back when the mode ends — after a crash or a hub
+* restart too (a persisted manifest, reconciled against the registry).
+*
+* Two measurements, both on the node, driven by its own runner (frames never
+* cross a process at frame rate, D9):
+*  - `device` — one accelerator × one candidate detector, root only, open
+*    loop: how many streams at the camera rate it carries inside the frame
+*    interval;
+*  - `pipeline` — the chosen detector plus the operator's detail steps
+*    (faces, plates, classifiers, CLIP…), on varied frames from the bench
+*    clip: how many parallel sessions the node carries before latency, drops,
+*    CPU, RAM or the event loop give out.
+*/
+/** Defaults and bounds, one place. */
+var NODE_BENCHMARK_DEFAULTS = {
+	fpsPerStream: 10,
+	budgetMinutes: 45,
+	minBudgetMinutes: 10,
+	maxBudgetMinutes: 120,
+	/** A result older than this no longer beats the table. */
+	staleAfterDays: 30,
+	/** Warm-in per ramp step (not accounted). */
+	settleSec: 5,
+	/** Accounted window per ramp step. */
+	measureSec: 20,
+	/** Longest the drain may take before the run is refused. */
+	drainTimeoutSec: 120,
+	/** Candidate models per device in one run. */
+	maxModelsPerDevice: 6
+};
+/** The two measurements a run can make. */
+var NodeBenchmarkPhaseSchema = _enum(["device", "pipeline"]);
+var NodeBenchmarkDevicePlanSchema = object({
+	/** `<backend>:<device>` — `openvino:npu`, `coreml:all`, `cpu`. */
+	deviceKey: string().min(1),
+	/**
+	* Root detector candidates for the `device` measurement, in the order
+	* measured. The FIRST is the one the `pipeline` measurement runs.
+	*/
+	modelIds: array(string().min(1)).min(1).max(NODE_BENCHMARK_DEFAULTS.maxModelsPerDevice)
+});
+/** What the operator confirmed. */
+var NodeBenchmarkPlanSchema = object({
+	nodeId: string().min(1),
+	devices: array(NodeBenchmarkDevicePlanSchema).min(1),
+	/** Which measurements run. At least one. */
+	phases: array(NodeBenchmarkPhaseSchema).min(1).default(["device", "pipeline"]),
+	/**
+	* Detail steps (catalog step ids under the root: faces, plates,
+	* classifiers, CLIP…) the `pipeline` measurement enables. The root
+	* detector always runs.
+	*/
+	steps: array(string().min(1)).default([]),
+	/** Offered rate of one stream / session. */
+	fpsPerStream: number().int().min(1).max(30).default(NODE_BENCHMARK_DEFAULTS.fpsPerStream),
+	/** Hard deadline: the mode ends and the cluster is restored when it passes. */
+	budgetMinutes: number().int().min(NODE_BENCHMARK_DEFAULTS.minBudgetMinutes).max(NODE_BENCHMARK_DEFAULTS.maxBudgetMinutes).default(NODE_BENCHMARK_DEFAULTS.budgetMinutes),
+	/** Keep the models the run downloaded (default: delete what was not installed before). */
+	keepDownloadedModels: boolean().default(false),
+	/** Start although the other nodes' capacity does not cover the sessions running now. */
+	acceptInsufficientHeadroom: boolean().default(false)
+});
+var NodeBenchmarkRefusalSchema = object({
+	kind: _enum([
+		"benchmark-active",
+		"node-offline",
+		"unknown-device",
+		"no-phase",
+		"insufficient-headroom"
+	]),
+	detail: string(),
+	overridable: boolean()
+});
+/** A camera whose detection leaves the node for the run. */
+var NodeBenchmarkMovingCameraSchema = object({
+	deviceId: number(),
+	/** Placed on the node now (a standing attach or a running session). */
+	placedOnNode: boolean(),
+	/** A node pin naming this node, ignored for the run. */
+	pinnedToNode: boolean()
+});
+/** A camera that cannot leave: no other node can obtain its frames. */
+var NodeBenchmarkStayingCameraSchema = object({
+	deviceId: number(),
+	reason: literal("only-frame-source")
+});
+var NodeBenchmarkPreflightSchema = object({
+	nodeId: string(),
+	online: boolean(),
+	moving: array(NodeBenchmarkMovingCameraSchema).readonly(),
+	/** Keep running on the node during the run; the result is flagged contaminated. */
+	staying: array(NodeBenchmarkStayingCameraSchema).readonly(),
+	estimatedDurationMs: number(),
+	/** The run ends and the cluster is restored at the latest after this long. */
+	budgetMs: number(),
+	phases: array(NodeBenchmarkPhaseSchema).readonly(),
+	steps: array(string()).readonly(),
+	devices: array(NodeBenchmarkDevicePlanSchema).readonly(),
+	/** Parallel sessions the cluster runs now, and what the other nodes can carry. */
+	headroom: object({
+		sessionsNow: number(),
+		otherNodesCapacitySessions: number().nullable()
+	}),
+	refusals: array(NodeBenchmarkRefusalSchema).readonly(),
+	canStart: boolean()
+});
+/** Where the measuring runner is. */
+var NodeBenchProgressSchema = object({
+	phase: _enum([
+		"preparing",
+		"device",
+		"pipeline",
+		"cleanup"
+	]),
+	deviceKey: string().nullable(),
+	modelId: string().nullable(),
+	/** Streams (device) or sessions (pipeline) of the step running now. */
+	load: number().nullable(),
+	cellsDone: number(),
+	cellsTotal: number(),
+	message: string()
+});
+/** What limited a ramp. `none` = the ramp ran out of steps still passing. */
+var NodeBenchLimitSchema = _enum([
+	"p95",
+	"drops",
+	"errors",
+	"stall",
+	"cpu",
+	"ram",
+	"none"
+]);
+var NodeBenchRampStepSchema = object({
+	load: number(),
+	pass: boolean(),
+	p95Ms: number(),
+	dropRatio: number(),
+	/** Completed frames per second over the accounted window. */
+	fps: number(),
+	cpuPct: number().nullable(),
+	ramFreePct: number().nullable(),
+	failReasons: array(string()).readonly()
+});
+var NodeBenchCellSchema = discriminatedUnion("phase", [object({
+	phase: literal("device"),
+	deviceKey: string(),
+	modelId: string(),
+	/** Single-stream latency (the K = 1 step). */
+	p50Ms: number(),
+	p95Ms: number(),
+	p99Ms: number(),
+	/** Frames per second sustained at the last passing step. */
+	fps: number(),
+	/** Streams at the camera rate the device carried inside the frame interval; 0 = not even one. */
+	kMax: number(),
+	limitedBy: NodeBenchLimitSchema,
+	/** First call (model load + warm-up). */
+	warmupMs: number(),
+	ramp: array(NodeBenchRampStepSchema).readonly()
+}), object({
+	phase: literal("pipeline"),
+	deviceKey: string(),
+	modelId: string(),
+	steps: array(string()).readonly(),
+	/** Parallel sessions at the camera rate the node carried; 0 = not even one. */
+	maxSessions: number(),
+	limitedBy: NodeBenchLimitSchema,
+	/** Detail steps that produced at least one result on the clip — a step that never fired measured nothing. */
+	stepsFired: array(string()).readonly(),
+	warmupMs: number(),
+	ramp: array(NodeBenchRampStepSchema).readonly()
+})]);
+/**
+* What a result was measured ON. A result whose fingerprint no longer matches
+* the node no longer beats the table.
+*/
+var NodeBenchFingerprintSchema = object({
+	pipelineVersion: string().nullable(),
+	cpuModel: string().nullable(),
+	ramGb: number().nullable(),
+	os: string().nullable(),
+	/** Per device: the pool the cells ran on (runtime + tuning). */
+	pools: record(string(), object({
+		runtime: string(),
+		numWorkers: number(),
+		concurrency: number(),
+		batchMode: string()
+	})).default({})
+});
+/** The frames the run used. */
+var NodeBenchClipSchema = object({
+	/** `camstack-bench-v1` or `reference-images` (the fallback when the clip is not reachable). */
+	id: string(),
+	revision: string().nullable(),
+	frames: number(),
+	width: number(),
+	height: number()
+});
+var NodeBenchRunnerInputSchema = object({
+	runId: string().min(1),
+	devices: array(NodeBenchmarkDevicePlanSchema).min(1),
+	phases: array(NodeBenchmarkPhaseSchema).min(1),
+	/** The full detail step tree root for the `pipeline` measurement is built on the node from these ids. */
+	steps: array(string()).default([]),
+	fpsPerStream: number().int().min(1).max(30),
+	/** The runner stops on its own past this instant, whatever the hub does. */
+	deadlineAtMs: number(),
+	settleSec: number().min(0).max(60).default(NODE_BENCHMARK_DEFAULTS.settleSec),
+	measureSec: number().min(2).max(300).default(NODE_BENCHMARK_DEFAULTS.measureSec),
+	keepDownloadedModels: boolean().default(false)
+});
+var NodeBenchRunnerStateSchema = _enum([
+	"running",
+	"done",
+	"failed",
+	"aborted"
+]);
+var NodeBenchRunnerStatusSchema = object({
+	runId: string(),
+	nodeId: string(),
+	state: NodeBenchRunnerStateSchema,
+	progress: NodeBenchProgressSchema.nullable(),
+	/** Every finished cell so far — a run stopped half way keeps what it measured. */
+	cells: array(NodeBenchCellSchema).readonly(),
+	fingerprint: NodeBenchFingerprintSchema.nullable(),
+	clip: NodeBenchClipSchema.nullable(),
+	/** Cameras seen running on the node during the run (they share its pools). */
+	activeCameraIds: array(number()).readonly(),
+	/** Models the run downloaded and then deleted (not installed before). */
+	deletedModels: array(string()).readonly(),
+	error: string().nullable(),
+	startedAtMs: number(),
+	finishedAtMs: number().nullable()
+});
+var NodeBenchmarkStateSchema = _enum([
+	"draining",
+	"measuring",
+	"restoring",
+	"done",
+	"failed",
+	"aborted"
+]);
+/** Why a run ended. */
+var NodeBenchmarkEndReasonSchema = _enum([
+	"completed",
+	"operator-abort",
+	"deadline",
+	"node-lost",
+	"runner-lost",
+	"hub-restart",
+	"drain-timeout",
+	"failed"
+]);
+var NodeBenchmarkRunSchema = object({
+	runId: string(),
+	nodeId: string(),
+	state: NodeBenchmarkStateSchema,
+	plan: NodeBenchmarkPlanSchema,
+	startedAtMs: number(),
+	deadlineAtMs: number(),
+	finishedAtMs: number().nullable(),
+	endReason: NodeBenchmarkEndReasonSchema.nullable(),
+	error: string().nullable(),
+	/** Cameras moved off the node for the run. */
+	moved: array(number()).readonly(),
+	/** Cameras that stayed (their only frame source is the node). */
+	staying: array(number()).readonly(),
+	/** Something else ran on the node's pools during the run. */
+	contaminated: boolean(),
+	progress: NodeBenchProgressSchema.nullable(),
+	resultIds: array(string()).readonly()
+});
+/** `getNodeBenchmarkStatus`: the active run (or the last one), and whether benchmark mode is on. */
+var NodeBenchmarkStatusSchema = object({
+	/** The node the cluster is in benchmark mode for; null = none. */
+	modeNodeId: string().nullable(),
+	run: NodeBenchmarkRunSchema.nullable()
+});
+/**
+* One stored measurement — the only authority Auto tune and the automatic
+* shares read measured capacity from. Written by the orchestrator when a run
+* ends, never by anyone else.
+*/
+var NodeBenchmarkResultSchema = object({
+	id: string(),
+	runId: string(),
+	nodeId: string(),
+	cell: NodeBenchCellSchema,
+	fpsPerStream: number(),
+	fingerprint: NodeBenchFingerprintSchema.nullable(),
+	clip: NodeBenchClipSchema.nullable(),
+	/** Other work shared the node's pools (a camera that could not move, or the hub's own duties). */
+	contaminated: boolean(),
+	stayingCameras: array(number()).readonly(),
+	/** The run ended early; the cell itself completed. */
+	partialRun: boolean(),
+	measuredAtMs: number()
+});
+var ListNodeBenchmarkResultsInputSchema = object({
+	nodeId: string().optional(),
+	deviceKey: string().optional()
+});
+/** A result with its standing today: does it still beat the table? */
+var NodeBenchmarkResultViewSchema = NodeBenchmarkResultSchema.extend({
+	/** `fresh` beats the table; `stale` falls back to it; `superseded` = a newer row covers the same cell. */
+	standing: _enum([
+		"fresh",
+		"stale",
+		"superseded"
+	]),
+	staleWhy: _enum([
+		"age",
+		"runtime",
+		"pool-tuning"
+	]).nullable()
+});
+object({
+	runId: string(),
+	nodeId: string(),
+	startedAtMs: number(),
+	deadlineAtMs: number(),
+	plan: NodeBenchmarkPlanSchema,
+	moved: array(number()).readonly(),
+	staying: array(number()).readonly()
+});
+/** Candidate detectors per device, for the plan editor. */
+var NodeBenchmarkCandidatesSchema = object({
+	nodeId: string(),
+	reachable: boolean(),
+	devices: array(object({
+		deviceKey: string(),
+		enabled: boolean(),
+		available: boolean(),
+		/** Ordered: what Auto tune would pick first, then the rest of the family by accuracy. */
+		suggested: array(string()).readonly(),
+		/** Every root detector the device has a build for. */
+		all: array(string()).readonly(),
+		/** The model the device runs now, when pinned. */
+		currentModelId: string().nullable()
+	})).readonly(),
+	/** Detail steps the node's catalog offers under the root (for the `pipeline` measurement). */
+	steps: array(object({
+		id: string(),
+		name: string(),
+		slot: string()
+	})).readonly()
+});
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -24996,7 +27639,16 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
 }), ParkedTrackFrameSchema.nullable()), method(object({
 	deviceId: number(),
 	trackId: string()
-}), object({ released: number().int().nonnegative() }), { kind: "mutation" });
+}), object({ released: number().int().nonnegative() }), { kind: "mutation" }), method(NodeBenchRunnerInputSchema, object({
+	accepted: literal(true),
+	runId: string()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ runId: string() }), NodeBenchRunnerStatusSchema.nullable(), { auth: "admin" }), method(object({ runId: string() }), object({ aborted: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+});
 var CameraPipelineConfigSchema = object({
 	engine: PipelineEngineChoiceSchema.optional(),
 	steps: array(PipelineStepInputSchema).readonly(),
@@ -25053,6 +27705,8 @@ var AgentPipelineSettingsSchema = object({
 	* address is wrong (multi-homed host, NAT, custom interface).
 	*/
 	reachableHost: string().optional(),
+	/** Hub-persisted UI colour (`--color-node-*` theme tokens). */
+	color: NodeColorIdSchema.optional(),
 	/**
 	* Multi-device inference opt-in (Phase 4). Per-node map deviceKey → {enabled,
 	* weight, steps}. Absent / all-disabled ⇒ the node's single default
@@ -25602,8 +28256,9 @@ method(object({
 	auth: "admin"
 }), method(object({
 	agentNodeId: string(),
-	reachableHost: string().nullable()
-}), object({ success: literal(true) }), {
+	reachableHost: string().nullable().optional(),
+	color: NodeColorIdSchema.nullable().optional()
+}).refine((v) => v.reachableHost !== void 0 || v.color !== void 0, { message: "reachableHost or color required" }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -25635,6 +28290,21 @@ method(object({
 }), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(NodeBenchmarkPlanSchema, NodeBenchmarkPreflightSchema, { auth: "admin" }), method(NodeBenchmarkPlanSchema, discriminatedUnion("kind", [object({
+	kind: literal("started"),
+	runId: string()
+}), object({
+	kind: literal("refused"),
+	preflight: NodeBenchmarkPreflightSchema
+})]), {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), NodeBenchmarkStatusSchema, { auth: "admin" }), method(object({ runId: string() }), object({ aborted: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ nodeId: string() }), NodeBenchmarkCandidatesSchema, { auth: "admin" }), method(ListNodeBenchmarkResultsInputSchema, array(NodeBenchmarkResultViewSchema).readonly(), { auth: "admin" }), method(object({ id: string() }), object({ deleted: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
 	deviceId: number(),
 	addonId: string(),
@@ -26040,8 +28710,8 @@ version: string().optional() }), ServerUpdateActionResultSchema, {
 * `smtp-provider` — pluggable email delivery surface.
 *
 * Collection cap: a deployment may install multiple SMTP relays (e.g.
-* one for transactional / one for notifications). Consumers (magic-link,
-* notifier addons, …) walk the collection and pick the first
+* one for transactional / one for notifications). Consumers (notifier
+* addons, …) walk the collection and pick the first
 * ready provider OR target a specific addonId.
 *
 * The shape stays small on purpose — `sendEmail` is enough for the
@@ -26220,7 +28890,7 @@ targets: array(object({
 })));
 /**
 * `sso-bridge` — internal hub-only cap that lets SSO-style auth
-* providers (OIDC, SAML, magic-link, …) mint an HMAC-signed token
+* providers (OIDC, SAML, …) mint an HMAC-signed token
 * carrying the post-callback claims before redirecting back to
 * `/api/auth/sso/finish`.
 *
@@ -26271,7 +28941,26 @@ var SsoBridgeClaimsSchema = object({
 	* editing a descriptor must not retroactively extend or shorten a link the
 	* operator already consented to.
 	*/
-	refreshTtl: union([number().int().positive(), literal("never")]).optional()
+	refreshTtl: union([number().int().positive(), literal("never")]).optional(),
+	/**
+	* Opaque handle of a hub-side LINK intent (D782). Set by an OIDC callback
+	* that was started from a signed-in user's "Link" button: the finish then
+	* links this identity to the intent's user instead of signing anyone in.
+	* The handle carries no user id — the hub resolves it, single-use.
+	*/
+	linkIntent: string().optional(),
+	/**
+	* Verified `iss` of the id_token behind an OIDC login bridge (D782). A
+	* subject is unique only per issuer, so a link is bound to it.
+	*/
+	issuer: string().optional(),
+	/**
+	* SHA-256 (hex) of the `camstack_sso_state` cookie the IdP `/start` set in
+	* the browser that began this sign-in. `/api/auth/sso/finish` requires the
+	* request to present the matching cookie — a login bridge is useless in
+	* any other browser.
+	*/
+	browserBinding: string().optional()
 });
 method(object({
 	claims: SsoBridgeClaimsSchema,
@@ -28177,7 +30866,22 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
 	* field their hints were silently stripped by the schema and the
 	* adaptive ladder started blind on the client's display size.
 	*/
-	hints: webrtcClientHintsSchema.optional()
+	hints: webrtcClientHintsSchema.optional(),
+	/**
+	* Talk-back (D771): relay the PEER's audio to the device's speaker
+	* through the `intercom` cap's push-talk triple. When `true` and the
+	* offer lets the peer send audio, the answer's audio is `sendrecv`
+	* and every inbound frame goes to `intercom.pushTalkAudio` for this
+	* `deviceId`; absent/false answers `sendonly`, as for every viewer.
+	*
+	* TRUSTED-CALLER ONLY. Set by the Alexa export for an Echo on a camera
+	* with `intercom`, when the linked user may control that camera. The
+	* hub STRIPS it from every request-bound call (a browser), exactly as
+	* it overwrites `relayOnly` — a viewer's talk permission is the
+	* intercom cap's own surface (share tokens gate it there), and this
+	* flag must not become a second door to the camera's speaker.
+	*/
+	talkback: boolean().optional()
 }), object({
 	sessionId: string(),
 	sdpAnswer: string()
@@ -28601,7 +31305,7 @@ var CustomActionInputSchema = object({
 	action: string().min(1),
 	input: unknown()
 });
-method(_void(), array(AddonListItemSchema).readonly()), method(object({
+method(object({ nodeId: string().optional() }).optional(), array(AddonListItemSchema).readonly()), method(object({
 	addonId: string(),
 	limit: number().min(1).max(500).default(100),
 	level: LogLevelSchema$2.optional()
@@ -30689,6 +33393,9 @@ var CreateIntegrationInputSchema = object({
 	enabled: boolean().optional(),
 	info: record(string(), unknown()).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()
 });
 var UpdateIntegrationInputSchema = object({
@@ -30712,7 +33419,9 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 	auth: "admin"
 }), method(object({ id: string() }), record(string(), unknown()), { auth: "admin" }), method(object({
 	id: string(),
-	settings: record(string(), unknown())
+	settings: record(string(), unknown()),
+	/** Keys the form's schema declares secret (by type) — keychain-stored (D787). */
+	secretKeys: array(string()).optional()
 }), object({ success: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
@@ -32143,7 +34852,13 @@ var TopologyNodeSchema = object({
 	})).readonly(),
 	processes: array(TopologyProcessSchema).readonly(),
 	categories: array(TopologyCategorySchema).readonly(),
-	rootPackage: TopologyRootPackageSchema.nullable()
+	rootPackage: TopologyRootPackageSchema.nullable(),
+	/**
+	* How an online AGENT reaches the hub (mesh mTLS Release A): `tls` once it has
+	* completed a mutual-TLS handshake, `clear` otherwise. Absent for the hub,
+	* for offline rows and when the hub cannot tell.
+	*/
+	meshTransport: _enum(["tls", "clear"]).optional()
 });
 var CapUsageEdgeSchema = object({
 	callerAddonId: string(),
@@ -32483,6 +35198,7 @@ var OsdNamedTemplateSchema = object({
 });
 /** Where a slot's value comes from. */
 var OsdSourceSchema = discriminatedUnion("kind", [
+	object({ kind: literal("none") }),
 	object({
 		kind: literal("static"),
 		text: string().max(64)
@@ -32609,6 +35325,13 @@ method(object({ deviceId: number().int() }), object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number().int(),
+	slotId: string().min(1),
+	enabled: boolean()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	sourceDeviceId: number().int(),
 	targetDeviceId: number().int()
@@ -32989,7 +35712,15 @@ var GpuInfoSchema = object({
 	name: string(),
 	memoryMB: number().optional()
 });
-var NpuInfoSchema = object({ type: _enum(["apple-ane", "intel-npu"]) });
+var NpuInfoSchema = object({
+	type: _enum([
+		"apple-ane",
+		"intel-npu",
+		"amd-xdna"
+	]),
+	name: string().optional(),
+	generation: _enum(["xdna1", "xdna2"]).optional()
+});
 var CoralInfoSchema = object({
 	type: literal("coral-edgetpu"),
 	bus: string().optional()
@@ -36171,16 +38902,6 @@ var ApiKeySummarySchema = object({
 	createdAt: number(),
 	lastUsedAt: number().optional()
 });
-var CreateApiKeyInputSchema = object({
-	label: string(),
-	isAdmin: boolean().default(false),
-	allowedProviders: union([array(string()), literal("*")]).optional(),
-	allowedDevices: record(string(), union([array(string()), literal("*")])).optional()
-});
-var CreateApiKeyResultSchema = object({
-	token: string(),
-	record: ApiKeySummarySchema
-});
 var ScopedTokenSummarySchema = object({
 	id: string(),
 	userId: string(),
@@ -36221,6 +38942,32 @@ var TotpStatusSchema = object({
 	/** Null when no row exists OR the row is still pending confirmation. */
 	confirmedAt: number().nullable()
 });
+/**
+* user-management — singleton capability for user accounts, API keys,
+* and scoped tokens.
+*
+* v2 model: every method gated by `auth: 'admin'`. Admin-only delegation
+* — the subset check on `setUserScopes` / `createScopedToken` is moot
+* because non-admins never reach these. If/when we open non-admin
+* delegation, structural caller-scope subset check goes inside the
+* provider.
+*/
+var ExternalIdentitySchema = object({
+	/** Login-method id of the provider instance, e.g. `auth-oidc/authentik`. */
+	provider: string(),
+	/** The IdP's stable subject (`sub`) for this account. */
+	subject: string(),
+	/** The verified `iss` of the IdP the identity was linked under — `sub` is unique only per issuer. */
+	issuer: string(),
+	userId: string(),
+	/** What the IdP called the account at link time (username / email) — display only. */
+	label: string().optional(),
+	linkedAt: number()
+});
+var ExternalIdentityKeySchema = object({
+	provider: string().min(1),
+	subject: string().min(1)
+});
 method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserInputSchema, UserSummarySchema, {
 	kind: "mutation",
 	auth: "admin",
@@ -36253,17 +39000,10 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserI
 }), UserSummarySchema.extend({ passwordHash: string() }).nullable(), {
 	kind: "mutation",
 	access: "view"
-}), method(_void(), array(ApiKeySummarySchema), { auth: "admin" }), method(CreateApiKeyInputSchema, CreateApiKeyResultSchema, {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({ id: string() }), object({ success: literal(true) }), {
+}), method(_void(), array(ApiKeySummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin",
 	access: "delete"
-}), method(object({ token: string() }), ApiKeySummarySchema.nullable(), {
-	kind: "mutation",
-	access: "view"
 }), method(CreateScopedTokenInputSchema, CreateScopedTokenResultSchema, {
 	kind: "mutation",
 	auth: "admin",
@@ -36334,7 +39074,14 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserI
 	userId: string(),
 	username: string(),
 	scopes: array(TokenScopeSchema)
-}).nullable(), { access: "view" }), method(_void(), array(OauthSessionSummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: boolean() }), {
+}).nullable(), { access: "view" }), method(object({ userId: string() }), array(ExternalIdentitySchema), { auth: "admin" }), method(ExternalIdentityKeySchema, object({
+	userId: string(),
+	issuer: string()
+}).nullable(), { auth: "admin" }), method(ExternalIdentityKeySchema.extend({ userId: string() }), object({ success: boolean() }), {
+	kind: "mutation",
+	auth: "admin",
+	access: "delete"
+}), method(_void(), array(OauthSessionSummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: boolean() }), {
 	kind: "mutation",
 	auth: "admin",
 	access: "delete"
@@ -36725,6 +39472,563 @@ DeviceType.Camera, method(object({
 	detection: array(ZoneRuleSchema).readonly(),
 	package: array(ZoneRuleSchema).readonly()
 });
+/**
+* `training-provider` — ONE cloud that can run the CamStack trainer.
+*
+* A thin, mockable translation layer: it knows how to run a container with a
+* GPU, move a dataset in, read the job's stdout and hand artefacts back. It
+* knows nothing about datasets, splits, floors, cost policy or Model Studio —
+* those are the `training` orchestrator's (D805). Every rule written there
+* once is what makes a second provider (RunPod, a local NVIDIA node) a new
+* manifest entry and nothing else.
+*
+* Collection of provider **types** (addons). Each addon owns zero or more
+* **entries** (credentials + defaults). Concat-fans: `describe`,
+* `describeTypes`, `listEntries`, `listJobs`. Single-row work is keyed by
+* `entryId`; callers also pass the owning `addonId` as the collection
+* selector (broker posture). Every method is `admin`: these spend money.
+*
+* Every cloud object a provider creates is tagged with the orchestrator's
+* `jobKey`, so a retried submit finds the job it already started instead of
+* starting a second GPU, and `listJobs` can find orphans.
+*
+* Bytes never ride a cap field: the dataset arrives as a `ctx.peerBytes`
+* ticket the producer (pipeline-analytics) minted, and artefacts leave as a
+* ticket the provider mints (D613).
+*/
+var TrainingGpuOptionSchema = object({
+	id: string(),
+	label: string(),
+	/** List price, USD per GPU-hour, before any region multiplier. */
+	usdPerHour: number().nonnegative(),
+	vramGb: number().nonnegative()
+});
+var TrainingRegionOptionSchema = object({
+	/** `''` = any region (the provider's choice). */
+	id: string(),
+	label: string(),
+	priceMultiplier: number().positive()
+});
+/**
+* The provider's per-entry settings, as the orchestrator reads them. They
+* live on the PROVIDER addon's entry (operator decision 2026-10-08: they
+* depend on the user's account), never hard-coded in the orchestrator.
+*/
+var TrainingProviderDefaultsSchema = object({
+	gpuType: string(),
+	region: string(),
+	costCapUsd: number().nonnegative(),
+	maxRuntimeSec: number().int().positive(),
+	/** Hours a FAILED job's cloud dataset is kept for debugging; 0 = delete at once. */
+	failedDatasetGraceHours: number().nonnegative()
+});
+/**
+* Entry form schema for a provider type — same seam as notification
+* `TargetKind.configSchema` (`z.unknown()` at the wire; callers tighten to
+* {@link ConfigUISchema}). Drives `ConfigFormBuilder` on Training → Providers.
+*/
+var ConfigSchemaPassthrough = unknown();
+/** One creatable provider type, for the Add-entry dialog. */
+var TrainingProviderTypeSchema = object({
+	typeId: string(),
+	label: string(),
+	/** Path under the addon package (e.g. `assets/training-modal/icon.svg`). */
+	iconAsset: string(),
+	/** Owning `training-provider` addon — collection selector for createEntry. */
+	addonId: string(),
+	/**
+	* Fields for one entry of this type (credentials + defaults). Absent on a
+	* type that only needs a name. Password fields are keychain-backed on the
+	* provider addon (`secretStatePaths`), not D634 plaintext.
+	*/
+	configSchema: ConfigSchemaPassthrough.optional()
+});
+/** One configured account / workspace under a provider type. */
+var TrainingProviderEntrySchema = object({
+	entryId: string(),
+	typeId: string(),
+	name: string(),
+	addonId: string(),
+	/** Credentials are present — never the values. */
+	configured: boolean()
+});
+var TrainingProviderDescriptorSchema = object({
+	addonId: string(),
+	entryId: string(),
+	typeId: string(),
+	/** Operator-chosen entry name. */
+	name: string(),
+	iconAsset: string(),
+	/** `modal`, `runpod`, `fake`, … — same as typeId for current providers. */
+	kind: string(),
+	label: string(),
+	gpuTypes: array(TrainingGpuOptionSchema).readonly(),
+	regions: array(TrainingRegionOptionSchema).readonly(),
+	maxDatasetBytes: number().int().positive(),
+	maxRuntimeSec: number().int().positive(),
+	freeTierNote: string().optional(),
+	/** Where the data goes, in one sentence the confirm dialog repeats. */
+	dataResidencyNote: string(),
+	/** Credentials are present — never the values. */
+	configured: boolean(),
+	defaults: TrainingProviderDefaultsSchema,
+	/**
+	* Values for {@link TrainingProviderTypeSchema}'s `configSchema` — password
+	* fields are keychain {@link SecretFieldView} or `null` / `''` (create),
+	* never plaintext. Same hydrate contract as settings forms (D789).
+	*/
+	formValues: record(string(), unknown()).optional()
+});
+/**
+* Patch one entry's name, credentials and defaults. Pin with owning `{ addonId }`.
+* An omitted or empty `tokenSecret` means KEEP the stored secret (D787).
+* `{ $secretClear: true }` clears it.
+*/
+var TrainingProviderUpdateEntryInputSchema = object({
+	entryId: string().min(1),
+	name: string().min(1),
+	tokenId: string().optional(),
+	tokenSecret: union([string(), object({ $secretClear: literal(true) })]).optional(),
+	environment: string().optional(),
+	gpuType: string().optional(),
+	region: string().optional(),
+	costCapUsd: number().nonnegative().optional(),
+	maxRuntimeSec: number().int().positive().optional(),
+	failedDatasetGraceHours: number().nonnegative().optional()
+});
+var TrainingCredentialCheckSchema = object({
+	ok: boolean(),
+	/** Workspace / account name, when the provider says. */
+	account: string().optional(),
+	reason: _enum([
+		"missing",
+		"invalid",
+		"forbidden",
+		"network",
+		"quota"
+	]).optional(),
+	detail: string().optional()
+});
+var ProviderJobStateSchema = _enum([
+	"pending",
+	"starting",
+	"running",
+	"succeeded",
+	"failed",
+	"cancelled",
+	"lost"
+]);
+var ProviderJobStatusSchema = object({
+	jobKey: string(),
+	providerJobId: string().optional(),
+	state: ProviderJobStateSchema,
+	startedAt: number().optional(),
+	endedAt: number().optional(),
+	exitCode: number().int().optional(),
+	failureReason: string().optional(),
+	gpuType: string(),
+	region: string().optional(),
+	billedSeconds: number().nonnegative(),
+	costUsd: number().nonnegative(),
+	/** True when `costUsd` is runtime × list price, not a billing answer. */
+	costIsEstimate: boolean(),
+	lastFetchedAt: number()
+});
+/**
+* The trainer the job runs, by SOURCE revision: the provider turns it into an
+* image its own way (Modal builds the published Dockerfile at that revision;
+* a registry-pull provider maps it to a tag). Recorded on the job and echoed
+* in `result.json`.
+*/
+var TrainerSourceRefSchema = object({
+	/** Hugging Face repo id, e.g. `camstack/camstack-trainer`. */
+	repo: string().min(1),
+	/** A commit sha (never a branch) — the job must be reproducible. */
+	revision: string().regex(/^[0-9a-f]{7,64}$/)
+});
+/** Cloud job identity — route with the owning addon's `addonId` selector. */
+var JobRef = {
+	entryId: string().min(1),
+	jobKey: string().uuid()
+};
+var TrainingLogLineSchema = object({
+	ts: number(),
+	text: string()
+});
+method(object({}), array(TrainingProviderDescriptorSchema).readonly(), { auth: "admin" }), method(object({}), array(TrainingProviderTypeSchema).readonly(), { auth: "admin" }), method(object({}), array(TrainingProviderEntrySchema).readonly(), { auth: "admin" }), method(object({
+	typeId: string().min(1),
+	name: string().min(1)
+}), object({ entryId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ entryId: string().min(1) }), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(TrainingProviderUpdateEntryInputSchema, object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ entryId: string().min(1) }), TrainingCredentialCheckSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 3e4
+}), method(object({
+	entryId: string().min(1),
+	gpuType: string(),
+	region: string(),
+	datasetBytes: number().int().nonnegative(),
+	gpuSecondsLow: number().nonnegative(),
+	gpuSecondsHigh: number().nonnegative()
+}), object({
+	usdLow: number().nonnegative(),
+	usdHigh: number().nonnegative(),
+	notes: array(string()).readonly()
+}), { auth: "admin" }), method(object({
+	...JobRef,
+	ticket: PeerBytesTicketSchema
+}), object({
+	bytes: number().int().nonnegative(),
+	sha256: string()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 120 * 6e4
+}), method(object({
+	...JobRef,
+	trainer: TrainerSourceRefSchema,
+	jobSpecJson: string().min(2).max(64e3),
+	gpuType: string(),
+	region: string(),
+	maxRuntimeSec: number().int().positive()
+}), ProviderJobStatusSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 30 * 6e4
+}), method(object(JobRef), ProviderJobStatusSchema, {
+	auth: "admin",
+	timeoutMs: 6e4
+}), method(object({
+	...JobRef,
+	cursor: string().optional(),
+	max: number().int().min(1).max(500)
+}), object({
+	lines: array(TrainingLogLineSchema).readonly(),
+	cursor: string()
+}), {
+	auth: "admin",
+	timeoutMs: 6e4
+}), method(object(JobRef), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 6e4
+}), method(object(JobRef), object({
+	found: boolean(),
+	text: string().optional()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 5 * 6e4
+}), method(object({
+	...JobRef,
+	path: _enum(["bundle.tar"])
+}), object({ ticket: PeerBytesTicketSchema }), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 5 * 6e4
+}), method(object(JobRef), object({ deleted: array(string()).readonly() }), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 5 * 6e4
+}), method(object({ entryId: string().min(1).optional() }), array(ProviderJobStatusSchema).readonly(), {
+	auth: "admin",
+	timeoutMs: 2 * 6e4
+});
+/**
+* `training` — the cloud-training orchestrator (D805). Hub-only singleton,
+* provided by `addon-training`.
+*
+* It owns what every provider must agree on, written once:
+*
+* - **Jobs.** A persisted state machine, a reconcile loop against the
+*   provider, a cost guard, a daily orphan sweep and the retention rules.
+* - **The return flow.** Verified artefacts → Model Studio
+*   (`custom-model-registry.importModelBundle`) → canary on cameras →
+*   rollback. Nothing is ever registered automatically.
+*
+* Plan/start takes a live {@link TrainingCorpusSelection} (collections +
+* work-state rule); frame ids are resolved via pipeline-analytics at that
+* moment and snapshotted on the job. No frozen dataset version.
+*
+* Every method is `admin`.
+*/
+/**
+* Live corpus criteria for plan/start (design §5.2). Default is complete-only.
+* Frame ids are resolved at plan/start — never a frozen version id.
+*/
+var TrainingCorpusSelectionSchema = object({
+	collectionIds: array(string()).min(1),
+	/** Default complete-only for v1 */
+	workState: _enum([
+		"complete",
+		"annotated_or_complete",
+		"any_annotated"
+	]).default("complete")
+});
+/** A base model a detector job can fine-tune, and the baseline it is judged against. */
+var TrainingBaseModelSchema = object({
+	modelId: string(),
+	label: string(),
+	weights: string(),
+	imgsz: number().int(),
+	baselineOnnxUrl: string(),
+	baselineFloors: record(string(), number()),
+	/** The base the fleet runs most — the UI's default. */
+	recommended: boolean()
+});
+var TrainingPresetSchema = _enum([
+	"quick",
+	"standard",
+	"thorough"
+]);
+var TrainingJobRequestSchema = object({
+	/** Live collection + work-state criteria; resolved at plan/start. */
+	selection: TrainingCorpusSelectionSchema,
+	/**
+	* The provider **entry** that runs it (credentials + defaults).
+	* Resolve to an owning addon via `training-provider.describe` / `listEntries`.
+	*/
+	entryId: string().min(1),
+	gpuType: string().min(1),
+	region: string(),
+	baseModelId: string().min(1),
+	preset: TrainingPresetSchema,
+	/** Freeze the backbone's first N layers; `null` = the preset's choice. */
+	freeze: number().int().nonnegative().nullable(),
+	/** Cameras held out whole for evaluation; `null` = the orchestrator's default. */
+	holdoutCameras: array(number().int()).nullable()
+});
+var TrainingSplitPlanSchema = object({
+	holdoutCameras: array(number().int()).readonly(),
+	/** Used when no camera is held out: the last N days of every camera. */
+	holdoutLastDays: number().int().nonnegative(),
+	/** Holdout subjects per class (camera holdout only; `null` = known only after the split). */
+	holdoutSupport: record(string(), number().int()).nullable(),
+	trainSubjects: number().int()
+});
+var TrainingRefusalReasonSchema = _enum([
+	"unknown-dataset",
+	"unknown-provider",
+	"provider-not-configured",
+	"unknown-base-model",
+	"unknown-gpu",
+	"dataset-too-large",
+	"no-training-subjects",
+	"job-already-running"
+]);
+var TrainingJobPlanSchema = object({
+	refusal: object({
+		reason: TrainingRefusalReasonSchema,
+		detail: string()
+	}).nullable(),
+	warnings: array(string()).readonly(),
+	split: TrainingSplitPlanSchema.nullable(),
+	estimate: object({
+		datasetBytes: number().int(),
+		uploadMinutesAt20Mbps: number(),
+		gpuSecondsLow: number(),
+		gpuSecondsHigh: number(),
+		usdLow: number(),
+		usdHigh: number(),
+		notes: array(string()).readonly()
+	}).nullable(),
+	/** Pre-filled from the provider's settings; the operator may lower or raise them. */
+	defaults: object({
+		maxCostUsd: number(),
+		maxRuntimeSec: number().int()
+	}).nullable(),
+	/** The sentence the confirm dialog repeats: where the frames go and when they are deleted. */
+	dataNotice: string()
+});
+/**
+* Orchestrator-owned states, persisted. `uploading` covers exporting the
+* archive (it is streamed, never staged). Terminal: `failed`, `cancelled`,
+* `lost`, `expired`, `discarded`. `registered` and `canary` are where a
+* result lives after the operator acted on it.
+*/
+var TrainingJobStateSchema = _enum([
+	"queued",
+	"uploading",
+	"submitted",
+	"starting",
+	"running",
+	"collecting",
+	"ready",
+	"registered",
+	"canary",
+	"failed",
+	"cancelling",
+	"cancelled",
+	"lost",
+	"expired",
+	"discarded"
+]);
+var TrainingFailureReasonSchema = _enum([
+	"cost-cap",
+	"runtime-cap",
+	"upload-failed",
+	"submit-failed",
+	"trainer-failed",
+	"result-invalid",
+	"checksum-mismatch",
+	"fetch-failed",
+	"provider-error",
+	"hub-restart-during-upload"
+]);
+var TrainingProgressPointSchema = object({
+	epoch: number().int(),
+	map50: number().nullable(),
+	map50_95: number().nullable()
+});
+var TrainingCanarySchema = object({
+	deviceIds: array(number().int()).readonly(),
+	since: number(),
+	/** Every override the canary replaced, exactly, so rollback restores it. */
+	previous: array(object({
+		deviceId: number().int(),
+		nodeId: string(),
+		deviceKey: string(),
+		patch: object({
+			modelId: string().optional(),
+			settings: record(string(), unknown()).readonly().optional()
+		}).nullable()
+	})).readonly()
+});
+var TrainingJobSchema = object({
+	id: string(),
+	idempotencyKey: string(),
+	name: string(),
+	createdAt: number(),
+	updatedAt: number(),
+	state: TrainingJobStateSchema,
+	/**
+	* Shared by every job enqueued together via `startJobBatch`.
+	* `null` for a lone `startJob`. The engine advances queued siblings by this id.
+	*/
+	batchId: string().nullable().default(null),
+	stage: TrainingStageSchema.nullable(),
+	failure: object({
+		reason: TrainingFailureReasonSchema,
+		stage: string().nullable(),
+		detail: string()
+	}).nullable(),
+	request: TrainingJobRequestSchema,
+	maxCostUsd: number().nonnegative(),
+	maxRuntimeSec: number().int().positive(),
+	trainer: TrainerSourceRefSchema,
+	datasetLayout: RetrainExportLayoutSchema,
+	/** Frame count snapshotted when the job started (audit; equals `frameIds.length`). */
+	frameCount: number().int().nonnegative(),
+	/** Resolved frame ids at start — the archive ships exactly these. */
+	frameIds: array(string()).max(2e4).readonly(),
+	/** Hash of what those frames taught at start (trainer `dataset.annotationHash`). */
+	annotationHash: string(),
+	dataset: object({
+		bytes: number().int(),
+		sha256: string(),
+		uploadedAt: number()
+	}).nullable(),
+	split: TrainingSplitPlanSchema,
+	provider: object({
+		state: ProviderJobStateSchema.nullable(),
+		providerJobId: string().nullable(),
+		startedAt: number().nullable(),
+		endedAt: number().nullable(),
+		billedSeconds: number(),
+		costUsd: number(),
+		costIsEstimate: boolean(),
+		lastPolledAt: number().nullable()
+	}),
+	progress: object({
+		epoch: number().int().nullable(),
+		epochs: number().int().nullable(),
+		etaSec: number().nullable(),
+		series: array(TrainingProgressPointSchema).readonly()
+	}),
+	/** The last lines of the job's output (≤ 200), newest last. Never frame paths. */
+	logTail: array(string()).readonly(),
+	logCursor: string().nullable(),
+	artifacts: object({
+		bundleBytes: number().int(),
+		bundleSha256: string(),
+		fetchedAt: number(),
+		/** When the staged artefacts are deleted from the hub. */
+		expiresAt: number()
+	}).nullable(),
+	/** When the provider-side copy of the frames was deleted; null while it exists. */
+	cloudDatasetDeletedAt: number().nullable(),
+	/** A failed job's dataset is kept until then (the provider's grace), then deleted. */
+	cloudCleanupDueAt: number().nullable(),
+	/** Model ids registered from this job (base, and int8 when kept). */
+	registeredModelIds: array(string()).readonly(),
+	canary: TrainingCanarySchema.nullable()
+});
+var IdInput = object({ id: string().min(1) });
+method(object({}), array(TrainingBaseModelSchema).readonly(), { auth: "admin" }), method(TrainingJobRequestSchema, TrainingJobPlanSchema, {
+	auth: "admin",
+	timeoutMs: 6e4
+}), method(TrainingJobRequestSchema.extend({
+	name: string().min(1).max(120),
+	maxCostUsd: number().positive(),
+	maxRuntimeSec: number().int().positive(),
+	idempotencyKey: string().min(8).max(80)
+}), discriminatedUnion("kind", [object({
+	kind: literal("started"),
+	job: TrainingJobSchema
+}), object({
+	kind: literal("refused"),
+	reason: TrainingRefusalReasonSchema,
+	detail: string()
+})]), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
+}), method(TrainingJobRequestSchema.omit({ baseModelId: true }).extend({
+	baseModelIds: array(string().min(1)).min(1),
+	name: string().min(1).max(120),
+	maxCostUsd: number().positive(),
+	maxRuntimeSec: number().int().positive(),
+	idempotencyKey: string().min(8).max(80)
+}), discriminatedUnion("kind", [object({
+	kind: literal("started"),
+	batchId: string(),
+	jobs: array(TrainingJobSchema).min(1).readonly()
+}), object({
+	kind: literal("refused"),
+	reason: TrainingRefusalReasonSchema,
+	detail: string()
+})]), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
+}), method(object({}), array(TrainingJobSchema).readonly(), { auth: "admin" }), method(IdInput, TrainingJobSchema.nullable(), { auth: "admin" }), method(IdInput, TrainingJobSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
+}), method(IdInput, TrainingResultSchema.nullable(), { auth: "admin" }), method(IdInput.extend({ canaryDeviceIds: array(number().int()).readonly() }), TrainingJobSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 30 * 6e4
+}), method(IdInput.extend({ deviceIds: array(number().int()).min(1).readonly() }), TrainingJobSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
+}), method(IdInput, TrainingJobSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
+}), method(IdInput, TrainingJobSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
 Object.freeze({
 	person: .5,
@@ -37348,6 +40652,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"backup.checkBackupKey": {
+		capName: "backup",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"backup.delete": {
 		capName: "backup",
 		capScope: "system",
@@ -37360,6 +40670,18 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"backup.disableEncryption": {
+		capName: "backup",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"backup.getEncryption": {
+		capName: "backup",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"backup.getEntries": {
 		capName: "backup",
 		capScope: "system",
@@ -37414,6 +40736,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"backup.setupEncryption": {
+		capName: "backup",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"backup.trigger": {
 		capName: "backup",
 		capScope: "system",
@@ -37966,6 +41294,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"customModelRegistry.importModelBundle": {
+		capName: "custom-model-registry",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"customModelRegistry.listModels": {
 		capName: "custom-model-registry",
 		capScope: "system",
@@ -39376,6 +42710,108 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"keychain.delete": {
+		capName: "keychain",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"keychain.getState": {
+		capName: "keychain",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"keychain.listMeta": {
+		capName: "keychain",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"keychain.put": {
+		capName: "keychain",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"keychain.resolve": {
+		capName: "keychain",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"keychainAdmin.acknowledgeReset": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"keychainAdmin.deleteOrphans": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"keychainAdmin.downloadRecoveryKey": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"keychainAdmin.listAudit": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"keychainAdmin.listSecrets": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"keychainAdmin.purgeRetiredKeys": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"keychainAdmin.resetKeychain": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"keychainAdmin.resetReport": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"keychainAdmin.reveal": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"keychainAdmin.rotateMasterKey": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"keychainAdmin.setSystemSecret": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"keychainAdmin.status": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"lawnMowerControl.dock": {
 		capName: "lawn-mower-control",
 		capScope: "device",
@@ -40606,6 +44042,36 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"oidcConnections.connectionFormSchema": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"oidcConnections.createConnection": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"oidcConnections.deleteConnection": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"oidcConnections.listConnections": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"oidcConnections.updateConnection": {
+		capName: "oidc-connections",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"osd.getStatus": {
 		capName: "osd",
 		capScope: "device",
@@ -40678,6 +44144,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"osdManager.setSlotCameraEnabled": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"osdManager.upsertTemplate": {
 		capName: "osd-manager",
 		capScope: "system",
@@ -40750,6 +44222,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.addRetrainFrameFromRecording": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineAnalytics.addRetrainFramesToCollection": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.applyDeviceSettingsPatch": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -40798,12 +44282,24 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.createRetrainCollection": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.deleteDeviceEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineAnalytics.deleteRetrainCollection": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineAnalytics.deleteTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -40906,6 +44402,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getRetrainCorpusKpi": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getRetrainExportUrl": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41008,6 +44510,30 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listRetrainAssistProfiles": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineAnalytics.listRetrainCollectionFrames": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineAnalytics.listRetrainCollections": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineAnalytics.listRetrainCorpusPage": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listRetrainFrames": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41038,6 +44564,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.offerRetrainArchive": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.ownersWithMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41056,6 +44588,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.proposeRetrainAnnotationsWithLlm": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.pruneEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41110,6 +44648,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.removeRetrainFrameFromCollection": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
+	"pipelineAnalytics.renameRetrainCollection": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineAnalytics.resolveRetrainTrainingCorpus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.restageRetrainTrack": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41140,6 +44696,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.setRetrainFrameComplete": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.setTrackFlags": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41176,6 +44738,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineAnalytics.writeRetrainArchive": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineExecutor.cacheFrameInPool": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -41386,6 +44954,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.abortNodeBenchmark": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.applyAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -41410,6 +44984,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.deleteNodeBenchmarkResult": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineOrchestrator.getAgentLoad": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -41518,6 +45098,24 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getNodeBenchmarkCandidates": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineOrchestrator.getNodeBenchmarkPreflight": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineOrchestrator.getNodeBenchmarkStatus": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getNodeInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -41560,6 +45158,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.listNodeBenchmarkResults": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.pauseForStorageMigration": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -41704,6 +45308,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.startNodeBenchmark": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.suggestShares": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -41722,6 +45332,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineRunner.abortNodeBench": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineRunner.attachCamera": {
 		capName: "pipeline-runner",
 		capScope: "system",
@@ -41770,6 +45386,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineRunner.getNodeBenchStatus": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineRunner.getParkedTrackFrame": {
 		capName: "pipeline-runner",
 		capScope: "system",
@@ -41812,6 +45434,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineRunner.startNodeBench": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"plateGallery.assignPlate": {
 		capName: "plate-gallery",
 		capScope: "system",
@@ -43474,6 +47102,180 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"training.canaryResult": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"training.cancelJob": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"training.discardResult": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"training.getJob": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"training.getJobResult": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"training.listBaseModels": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"training.listJobs": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"training.planJob": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"training.registerResult": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"training.rollbackCanary": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"training.startJob": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"training.startJobBatch": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.cancelJob": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.cleanupJob": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.createEntry": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.deleteEntry": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"trainingProvider.describe": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"trainingProvider.describeTypes": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"trainingProvider.estimateJob": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"trainingProvider.getJob": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"trainingProvider.listEntries": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"trainingProvider.listJobEvents": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"trainingProvider.listJobs": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"trainingProvider.offerArtifact": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.readResult": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.submitJob": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.updateEntry": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.uploadDataset": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"trainingProvider.validateCredentials": {
+		capName: "training-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"turnProvider.getTurnServers": {
 		capName: "turn-provider",
 		capScope: "system",
@@ -43498,12 +47300,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"userManagement.createApiKey": {
-		capName: "user-management",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"userManagement.createScopedToken": {
 		capName: "user-management",
 		capScope: "system",
@@ -43528,6 +47324,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"userManagement.findUserByExternalIdentity": {
+		capName: "user-management",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"userManagement.getTotpStatus": {
 		capName: "user-management",
 		capScope: "system",
@@ -43540,6 +47342,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"userManagement.listExternalIdentities": {
+		capName: "user-management",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"userManagement.listOauthSessions": {
 		capName: "user-management",
 		capScope: "system",
@@ -43618,17 +47426,17 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"userManagement.updateUser": {
+	"userManagement.unlinkExternalIdentity": {
 		capName: "user-management",
 		capScope: "system",
 		addonId: null,
-		access: "create"
+		access: "delete"
 	},
-	"userManagement.validateApiKey": {
+	"userManagement.updateUser": {
 		capName: "user-management",
 		capScope: "system",
 		addonId: null,
-		access: "view"
+		access: "create"
 	},
 	"userManagement.validateCredentials": {
 		capName: "user-management",
@@ -46662,6 +50470,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"osdManager.setSlotCameraEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"petFeeder.callPet": [{
 		name: "deviceId",
 		form: "single",
@@ -46717,6 +50530,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.addRetrainFrameFromRecording": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.applyDeviceSettingsPatch": [{
 		name: "deviceId",
 		form: "single",
@@ -46877,6 +50695,11 @@ Object.freeze({
 		form: "array",
 		optional: false
 	}],
+	"pipelineAnalytics.listRetrainCorpusPage": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineAnalytics.listRetrainStaging": [{
 		name: "deviceIds",
 		form: "array",
@@ -46907,6 +50730,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.proposeRetrainAnnotationsWithLlm": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.pruneEventsBefore": [{
 		name: "deviceId",
 		form: "single",
@@ -46957,6 +50785,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.setRetrainFrameComplete": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.setTrackFlags": [{
 		name: "deviceId",
 		form: "single",
@@ -47728,6 +51561,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"training.canaryResult": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"update.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -47971,6 +51809,7 @@ Object.freeze({
 });
 Object.freeze({
 	"broker": "broker",
+	"calendar-source": "calendar",
 	"device-export": "device-export",
 	"llm": "ai",
 	"mesh-network": "mesh",
@@ -48456,6 +52295,8 @@ var STATE_SUMMARY_VARS = [
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
 	([...RULE_TEXT], [...UPDATES]),
 	([...RULE_TEXT], [...PACKAGE_UPDATES]),
 	([...RULE_TEXT], [...PACKAGE_UPDATES]),