@deepseek-ai/dsh-client-ui-settings 0.1.6-alpha.2 → 0.1.7-alpha.2

package/lib/client.js

@@ -6,7 +6,7 @@ window.__ModuleLoader__.load({
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 		let _deepseek_ai_cordis = require("@deepseek-ai/cordis");
 		let _deepseek_ai_dsh_client_store = require("@deepseek-ai/dsh-client-store");
-		//#region ../../../vendor/cosmokit/src/misc.ts
+		//#region ../../../vendor/cosmokit/lib/index.js
 		/** Return true when a value is `null` or `undefined`. */
 		function isNullable(value) {
 			return value === null || value === void 0;
@@ -30,8 +30,43 @@ window.__ModuleLoader__.load({
 			for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
 			return result;
 		}
-		//#endregion
-		//#region ../../../vendor/cosmokit/src/types.ts
+		/** Shared config references used by schema validators and plugin runtimes. */
+		const write = Symbol.for("cosmokit.volatile.write");
+		function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+			if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+			if (value === null || typeof value !== "object") return value;
+			if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+			ancestors.add(value);
+			try {
+				if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+				if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("volatile config objects must be plain objects or arrays");
+				return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+			} finally {
+				ancestors.delete(value);
+			}
+		}
+		/**
+		* Create a detached reference containing an immutable copy of the supplied data.
+		* @param value - validated config data; class instances and functions are unsupported.
+		* @returns a reference whose value is updated only by its owning runtime.
+		*/
+		function createVolatile(value) {
+			let current = snapshot(value);
+			return Object.freeze({
+				get: () => current,
+				[write]: (value) => {
+					current = value;
+				}
+			});
+		}
+		/**
+		* Identify references across ESM/CJS copies of the shared library.
+		* @param value - a parsed config value.
+		* @returns whether the value implements the shared reference protocol.
+		*/
+		function isVolatile(value) {
+			return typeof value === "object" && value !== null && write in value;
+		}
 		/** Test values using `instanceof` with a `toStringTag` fallback. */
 		function is(type, value) {
 			if (arguments.length === 1) return (value) => is(type, value);
@@ -43,15 +78,16 @@ window.__ModuleLoader__.load({
 		function isArrayBufferSource(value) {
 			return isArrayBufferLike(value) || ArrayBuffer.isView(value);
 		}
-		let Binary;
-		(function(_Binary) {
-			_Binary.is = isArrayBufferLike;
-			_Binary.isSource = isArrayBufferSource;
+		/** Binary source detection and base64/hex conversion helpers. */
+		var Binary;
+		(function(Binary) {
+			Binary.is = isArrayBufferLike;
+			Binary.isSource = isArrayBufferSource;
 			function fromSource(source) {
 				if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
 				else return source;
 			}
-			_Binary.fromSource = fromSource;
+			Binary.fromSource = fromSource;
 			function toBase64(source) {
 				source = fromSource(source);
 				if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
@@ -60,18 +96,18 @@ window.__ModuleLoader__.load({
 				for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
 				return btoa(binary);
 			}
-			_Binary.toBase64 = toBase64;
+			Binary.toBase64 = toBase64;
 			function fromBase64(source) {
 				if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
 				return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
 			}
-			_Binary.fromBase64 = fromBase64;
+			Binary.fromBase64 = fromBase64;
 			function toHex(source) {
 				source = fromSource(source);
 				if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
 				return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
 			}
-			_Binary.toHex = toHex;
+			Binary.toHex = toHex;
 			function fromHex(source) {
 				if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
 				const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
@@ -79,7 +115,7 @@ window.__ModuleLoader__.load({
 				for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
 				return Uint8Array.from(buffer).buffer;
 			}
-			_Binary.fromHex = fromHex;
+			Binary.fromHex = fromHex;
 		})(Binary || (Binary = {}));
 		Binary.fromBase64;
 		Binary.toBase64;
@@ -111,58 +147,78 @@ window.__ModuleLoader__.load({
 			}
 			return result;
 		}
-		/** Deeply compare arrays, dates, regexps, buffers, and plain object fields. */
+		/**
+		* Compare values recursively, treating two volatile references as equal regardless of value.
+		* Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+		* compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+		* @param a - first value.
+		* @param b - second value.
+		* @param strict - whether to require strict data equality outside volatile references.
+		* @returns whether the values compare equal.
+		*/
 		function deepEqual(a, b, strict) {
-			if (a === b) return true;
-			if (!strict && isNullable(a) && isNullable(b)) return true;
-			if (typeof a !== typeof b) return false;
-			if (typeof a !== "object") return false;
-			if (!a || !b) return false;
-			function check(test, then) {
-				return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
-			}
-			return check(Array.isArray, (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
-				if (a.byteLength !== b.byteLength) return false;
-				const viewA = new Uint8Array(a);
-				const viewB = new Uint8Array(b);
-				for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
-				return true;
-			}) ?? Object.keys({
-				...a,
-				...b
-			}).every((key) => deepEqual(a[key], b[key], strict));
+			const ancestors = /* @__PURE__ */ new Set();
+			function compare(a, b) {
+				if (a === b) return true;
+				if (isVolatile(a) || isVolatile(b)) return isVolatile(a) && isVolatile(b);
+				if (!strict && isNullable(a) && isNullable(b)) return true;
+				if (typeof a !== typeof b || typeof a !== "object" || !a || !b) return false;
+				if (ancestors.has(a)) return false;
+				function check(test, then) {
+					return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+				}
+				ancestors.add(a);
+				try {
+					return check(Array.isArray, (a, b) => {
+						if (a.length !== b.length) return false;
+						for (let index = 0; index < a.length; index++) if (!compare(a[index], b[index])) return false;
+						return true;
+					}) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("URL"), (a, b) => a.href === b.href) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+						if (a.byteLength !== b.byteLength) return false;
+						const viewA = new Uint8Array(a);
+						const viewB = new Uint8Array(b);
+						for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+						return true;
+					}) ?? ((!strict || [a, b].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({
+						...a,
+						...b
+					}).every((key) => compare(a[key], b[key])));
+				} finally {
+					ancestors.delete(a);
+				}
+			}
+			return compare(a, b);
 		}
-		//#endregion
-		//#region ../../../vendor/cosmokit/src/time.ts
-		let Time;
-		(function(_Time) {
-			_Time.millisecond = 1;
-			const second = _Time.second = 1e3;
-			const minute = _Time.minute = second * 60;
-			const hour = _Time.hour = minute * 60;
-			const day = _Time.day = hour * 24;
-			const week = _Time.week = day * 7;
+		/** Time constants plus parsing and formatting helpers. */
+		var Time;
+		(function(Time) {
+			Time.millisecond = 1;
+			Time.second = 1e3;
+			Time.minute = Time.second * 60;
+			Time.hour = Time.minute * 60;
+			Time.day = Time.hour * 24;
+			Time.week = Time.day * 7;
 			let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
 			function setTimezoneOffset(offset) {
 				timezoneOffset = offset;
 			}
-			_Time.setTimezoneOffset = setTimezoneOffset;
+			Time.setTimezoneOffset = setTimezoneOffset;
 			function getTimezoneOffset() {
 				return timezoneOffset;
 			}
-			_Time.getTimezoneOffset = getTimezoneOffset;
+			Time.getTimezoneOffset = getTimezoneOffset;
 			function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
 				if (typeof date === "number") date = new Date(date);
 				if (offset === void 0) offset = timezoneOffset;
-				return Math.floor((date.valueOf() / minute - offset) / 1440);
+				return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
 			}
-			_Time.getDateNumber = getDateNumber;
+			Time.getDateNumber = getDateNumber;
 			function fromDateNumber(value, offset) {
-				const date = new Date(value * day);
+				const date = new Date(value * Time.day);
 				if (offset === void 0) offset = timezoneOffset;
-				return new Date(+date + offset * minute);
+				return new Date(+date + offset * Time.minute);
 			}
-			_Time.fromDateNumber = fromDateNumber;
+			Time.fromDateNumber = fromDateNumber;
 			const numeric = /\d+(?:\.\d+)?/.source;
 			const timeRegExp = new RegExp(`^${[
 				"w(?:eek(?:s)?)?",
@@ -174,9 +230,9 @@ window.__ModuleLoader__.load({
 			function parseTime(source) {
 				const capture = timeRegExp.exec(source);
 				if (!capture) return 0;
-				return (parseFloat(capture[1]) * week || 0) + (parseFloat(capture[2]) * day || 0) + (parseFloat(capture[3]) * hour || 0) + (parseFloat(capture[4]) * minute || 0) + (parseFloat(capture[5]) * second || 0);
+				return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
 			}
-			_Time.parseTime = parseTime;
+			Time.parseTime = parseTime;
 			function parseDate(date) {
 				const parsed = parseTime(date);
 				if (parsed) date = Date.now() + parsed;
@@ -184,27 +240,27 @@ window.__ModuleLoader__.load({
 				else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
 				return date ? new Date(date) : /* @__PURE__ */ new Date();
 			}
-			_Time.parseDate = parseDate;
+			Time.parseDate = parseDate;
 			function format(ms) {
 				const abs = Math.abs(ms);
-				if (abs >= day - hour / 2) return Math.round(ms / day) + "d";
-				else if (abs >= hour - minute / 2) return Math.round(ms / hour) + "h";
-				else if (abs >= minute - second / 2) return Math.round(ms / minute) + "m";
-				else if (abs >= second) return Math.round(ms / second) + "s";
+				if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+				else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+				else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+				else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
 				return ms + "ms";
 			}
-			_Time.format = format;
+			Time.format = format;
 			function toDigits(source, length = 2) {
 				return source.toString().padStart(length, "0");
 			}
-			_Time.toDigits = toDigits;
+			Time.toDigits = toDigits;
 			function template(template, time = /* @__PURE__ */ new Date()) {
 				return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
 			}
-			_Time.template = template;
+			Time.template = template;
 		})(Time || (Time = {}));
 		//#endregion
-		//#region ../../../vendor/schemastery/src/index.ts
+		//#region ../../../vendor/schemastery/lib/index.mjs
 		const kSchema = Symbol.for("schemastery");
 		const kValidationError = Symbol.for("ValidationError");
 		globalThis.__schemastery_index__ ??= 0;
@@ -380,6 +436,7 @@ window.__ModuleLoader__.load({
 			return schema;
 		};
 		Schema.prototype.simplify = function simplify(value) {
+			if (isVolatile(value)) value = value.get();
 			if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
 			if (isNullable(value)) return value;
 			if (this.type === "object" || this.type === "dict") {
@@ -436,12 +493,49 @@ window.__ModuleLoader__.load({
 			};
 			return schema;
 		} });
+		Schema.prototype.volatile = function volatile() {
+			if (this.meta.volatile) throw new TypeError("volatile schema is already wrapped");
+			return this.extra("volatile", true);
+		};
 		const resolvers = {};
+		const checkedVolatile = Symbol("checked-volatile-schema");
+		function validateVolatileSchema(schema, path = [], blocked = false, seen = /* @__PURE__ */ new Map()) {
+			const states = seen.get(schema) ?? /* @__PURE__ */ new Set();
+			if (states.has(blocked)) return;
+			states.add(blocked);
+			seen.set(schema, states);
+			if (schema.meta?.volatile && blocked) throw new ValidationError("volatile fields require a fixed object path without an enclosing volatile field", { path });
+			const nested = blocked || !!schema.meta?.volatile;
+			if (schema.dict) for (const [key, child] of Object.entries(schema.dict)) validateVolatileSchema(child, [...path, key], nested, seen);
+			if (schema.sKey) validateVolatileSchema(schema.sKey, [...path, "<key>"], true, seen);
+			if (schema.inner && (schema.type !== "lazy" || schema.inner[kSchema])) validateVolatileSchema(schema.inner, [...path, "*"], true, seen);
+			if (schema.list) for (let index = 0; index < schema.list.length; index++) validateVolatileSchema(schema.list[index], [...path, String(index)], true, seen);
+		}
 		Schema.extend = function extend(type, resolve) {
 			resolvers[type] = resolve;
 		};
 		Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
 			if (!schema) return [data];
+			if (!options[checkedVolatile]) {
+				validateVolatileSchema(schema, options.path);
+				options = {
+					...options,
+					[checkedVolatile]: true
+				};
+			}
+			if (schema.meta?.volatile) {
+				const inner = Schema(schema);
+				inner.meta = {
+					...schema.meta,
+					volatile: false
+				};
+				const [value, adapted] = Schema.resolve(data, inner, options, strict);
+				try {
+					return [createVolatile(value), adapted];
+				} catch (error) {
+					throw new ValidationError(error instanceof Error ? error.message : String(error), options);
+				}
+			}
 			if (options.ignore?.(data, schema)) return [data];
 			if (isNullable(data) && schema.type !== "lazy") {
 				if (schema.meta.required) throw new ValidationError(`missing required value`, options);
@@ -544,6 +638,7 @@ window.__ModuleLoader__.load({
 					...schema.meta,
 					...schema.inner.meta
 				};
+				validateVolatileSchema(schema.inner, options.path, true);
 			}
 			return Schema.resolve(data, schema.inner, options, strict);
 		});
@@ -643,7 +738,7 @@ window.__ModuleLoader__.load({
 			} catch (e) {
 				if (!options?.autofix) throw e;
 				delete data[key];
-				return schema.meta.default;
+				return schema.meta.volatile ? createVolatile(schema.meta.default) : schema.meta.default;
 			}
 		}
 		Schema.extend("array", (data, { inner, meta }, options) => {
@@ -932,21 +1027,63 @@ window.__ModuleLoader__.load({
 			}
 		};
 		//#endregion
-		//#region lib/types/client/settings-scope.js
-		/**
-		* Host transport for the settings-namespace scope contract. This file owns the
-		* per-namespace derivation over the shared {@link SettingsDescribeMirror} and
-		* the serialized write path. Reads never touch the wire here: the
-		* mirror is the one `settings.describe` reader, and every scope is a selector
-		* over its snapshot.
-		*/
+		//#region lib/types/client/developer-tools.js
+		/** One accepted preference drives every developer-tool consumer. */
+		/** Shared preference; Host-backed features stay disabled until an accepted value arrives. */
+		var DeveloperToolsPreference = class {
+			scope;
+			/** Accepted enablement, observable through renderer-bound hooks. */
+			enabled;
+			local = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(true);
+			/**
+			* @param scope - settings-owned namespace controller.
+			*/
+			constructor(scope) {
+				this.scope = scope;
+				this.enabled = scope.getSnapshot().mode === "memory" ? this.local : {
+					getSnapshot: () => scope.getSnapshot().value?.enabled ?? false,
+					subscribe: (listener) => {
+						let previous = this.enabled.getSnapshot();
+						return scope.subscribe(() => {
+							const next = this.enabled.getSnapshot();
+							if (next === previous) return;
+							previous = next;
+							listener();
+						});
+					}
+				};
+			}
+			/**
+			* Persist a Host choice with ordered writes, or update the shared browser-local choice.
+			* @param enabled - requested developer-tool mode.
+			* @returns settlement after local publication or Host acceptance; rejects after a refused write recovers.
+			*/
+			async setEnabled(enabled) {
+				if (this.scope.getSnapshot().mode === "memory") {
+					this.local.set(enabled);
+					return;
+				}
+				if (!await this.scope.set("enabled", enabled)) throw new Error("Developer tools preference was not saved");
+			}
+		};
+		//#endregion
+		//#region lib/types/developer-tools-settings.js
+		/** Shared Web and desktop developer-tool preference stored by the Host. */
+		/** Namespace for developer UI and HTML preview capabilities. */
+		const DEVELOPER_TOOLS_NAMESPACE = "ui-settings";
+		/** New installations and missing values enable the full interface. */
+		const DeveloperToolsSettingsFields = { enabled: Schema.boolean().default(true) };
+		Schema.object(DeveloperToolsSettingsFields);
+		//#endregion
+		//#region lib/types/client/config-form.js
+		/** Shared entry values and ordered writes over the Host configuration mirror. */
 		/**
 		* One namespace's derived view over the shared describe mirror, plus that
 		* namespace's serialized Host writes. Writes carry the latest known namespace
 		* revision, fold their answers back into the mirror, and teardown waits for
 		* the operation already crossing the wire.
 		*/
-		var SettingsScopeController = class {
+		var ConfigFormController = class {
 			ctx;
 			spec;
 			mirror;
@@ -965,9 +1102,9 @@ window.__ModuleLoader__.load({
 			pendingRevision;
 			/**
 			* @param ctx - the providing plugin's context, whose `remote.settings`
-			* namespace carries this scope's writes (reads ride the mirror).
+			* namespace carries this form's writes (reads ride the mirror).
 			* @param spec - namespace identity and optional narrowing decoder.
-			* @param mirror - the shared describe mirror this scope derives from.
+			* @param mirror - the shared describe mirror this form derives from.
 			* @param persistence - client-selected Host persistence; non-loopback pages may remain process-local.
 			* @param schema - settings-owned schema operations.
 			*/
@@ -1006,11 +1143,11 @@ window.__ModuleLoader__.load({
 				return this.store.subscribe(listener);
 			}
 			/**
-			* Queue one field write; see {@link SettingsScope.set} for the ordering,
+			* Queue one field write; see {@link ConfigForm.set} for the ordering,
 			* revision, and recovery contract.
 			* @param field - scalar field inside the namespace section.
 			* @param value - JSON-shaped value selected by the user.
-			* @returns settlement after the write and any latest-write recovery read.
+			* @returns whether the Host accepted the write, after any recovery read.
 			*/
 			set(field, value) {
 				return this.mutate([{
@@ -1020,10 +1157,10 @@ window.__ModuleLoader__.load({
 				}]);
 			}
 			/**
-			* Queue one field clear; see {@link SettingsScope.unset} for the ordering,
+			* Queue one field clear; see {@link ConfigForm.unset} for the ordering,
 			* revision, and recovery contract.
 			* @param field - scalar field inside the namespace section.
-			* @returns settlement after the clear and any latest-write recovery read.
+			* @returns whether the Host accepted the clear, after any recovery read.
 			*/
 			unset(field) {
 				return this.mutate([{
@@ -1032,10 +1169,10 @@ window.__ModuleLoader__.load({
 				}]);
 			}
 			/**
-			* Queue one atomic namespace mutation; see {@link SettingsScope.mutate}.
+			* Queue one atomic namespace mutation; see {@link ConfigForm.mutate}.
 			* @param ops - ordered field operations copied when queued.
 			* @param expectedRevision - optional fixed revision read by the domain editor.
-			* @returns settlement after the mutation and any latest-write recovery read.
+			* @returns whether the Host accepted the mutation, after any recovery read.
 			*/
 			mutate(ops, expectedRevision) {
 				const ownedOps = structuredClone(ops);
@@ -1045,13 +1182,14 @@ window.__ModuleLoader__.load({
 					const response = await this.ctx.remote.settings.mutate(this.spec.namespace, ownedOps, revision);
 					if (!response.ok) {
 						await this.recover(generation);
-						return;
+						return false;
 					}
-					if (this.disposed) return;
+					if (this.disposed) return true;
 					if (generation === this.writeGeneration) {
 						this.pendingRevision = void 0;
 						this.mirror.acceptView(response.value);
 					} else this.pendingRevision = response.value.revision;
+					return true;
 				});
 			}
 			/** Reload Host state for the latest failed write; superseded failures leave recovery to it. */
@@ -1072,12 +1210,12 @@ window.__ModuleLoader__.load({
 				await this.tail;
 			}
 			enqueue(operation) {
-				if (this.persistence === "memory" || this.disposed) return Promise.resolve();
+				if (this.persistence === "memory" || this.disposed) return Promise.resolve(false);
 				const task = this.tail.then(async () => {
-					if (this.disposed) return;
-					await operation();
+					if (this.disposed) return false;
+					return await operation();
 				});
-				this.tail = task.catch(() => {});
+				this.tail = task.then(() => {}, () => {});
 				return task;
 			}
 			derive() {
@@ -1123,59 +1261,91 @@ window.__ModuleLoader__.load({
 		* cross-plugin collaboration through cordis services
 		* (`packages/client/tsdown.client.ts`).
 		*/
-		var SettingsScopeBinder = class extends _deepseek_ai_cordis.Service {
+		var ConfigForms = class extends _deepseek_ai_cordis.Service {
+			forms = /* @__PURE__ */ new Map();
+			/** Shared developer-tool preference owned by this settings provider. */
+			developerTools;
 			mirror;
 			schema;
 			persistence;
 			/**
 			* The PROVIDING fiber, kept because a Service reads `ctx` as its *consumer's*
-			* fiber: letting a bound scope write through the caller's context would make
+			* fiber: letting a shared form write through the caller's context would make
 			* every caller declare `remote.settings` in its own `inject`.
 			*/
 			owner;
 			/**
 			* @param ctx - the providing plugin's context.
-			* @param config - the shared describe mirror every bound scope derives from,
+			* @param config - the shared describe mirror every shared form derives from,
 			* the settings-owned schema operations, and the Host persistence the provider
 			* resolved from `remote.$host`.
 			*/
 			constructor(ctx, config) {
-				super(ctx, "settingsScope");
+				super(ctx, "configForms");
 				this.mirror = config.mirror;
 				this.schema = config.schema;
 				this.persistence = config.persistence;
 				this.owner = ctx;
+				this.developerTools = new DeveloperToolsPreference(this.get(DEVELOPER_TOOLS_NAMESPACE));
+				ctx.effect(() => async () => {
+					await Promise.all([...this.forms.values()].map((form) => form.dispose()));
+					this.forms.clear();
+				}, "ui-settings: configuration forms");
 			}
 			/**
 			* The shared mirror's read/fold face for cross-namespace surfaces (schema
 			* introspection, the served-namespace directory). Per-namespace consumers
-			* use {@link bind}; both derive from the same snapshot, so they can never
+			* use {@link get}; both derive from the same snapshot, so they can never
 			* disagree about the document.
 			* @returns the describe face over the shared mirror.
 			*/
 			describe() {
 				return this.mirror;
 			}
+			/** Get the shared form values and write queue for one Host plugin entry.
+			* @param entryId Unique Host plugin entry id.
+			* @returns The entry's form, owned by this provider.
+			*/
+			get(entryId) {
+				const existing = this.forms.get(entryId);
+				if (existing !== void 0) return existing;
+				const form = new ConfigFormController(this.owner, { namespace: entryId }, this.mirror, this.persistence, this.schema);
+				this.forms.set(entryId, form);
+				this.mirror.ensure();
+				return form;
+			}
 			/**
-			* Bind one namespace scope on the CALLER's plugin lifecycle — the service
-			* proxy binds `this.ctx` to the caller at call time, so the scope's disposer
-			* belongs to the calling fiber. The scope derives from the shared mirror
-			* (whose invalidation subscriptions live with the providing plugin), so
-			* binding adds no wire read of its own and activation never blocks on the
-			* settings transport.
-			* @param spec - domain-owned namespace contract.
-			* @returns the bound scope consumed by the domain's services and rows.
+			* Keep a registration alive while the Host serves any of some namespaces:
+			* `register` runs once one of them is in the describe mirror, and its
+			* disposer runs when none is or when the returned disposer runs. A plugin
+			* whose page edits a namespace another plugin owns registers the page
+			* through this, so a deployment that never composed the owner shows no
+			* trace of the page. The caller owns the returned disposer and wraps it in
+			* `ctx.effect`; unlike {@link bind}, nothing is registered on the caller's
+			* context here.
+			* @param namespaces - the settings namespaces the registration follows.
+			* @param register - registers the contribution, given every namespace the Host serves; returns its disposer.
+			* @returns the disposer ending the watch and any live registration.
 			*/
-			bind(spec) {
-				const ctx = this.ctx;
-				const controller = new SettingsScopeController(this.owner, spec, this.mirror, this.persistence, this.schema);
-				ctx.effect(() => {
-					this.mirror.ensure();
-					return async () => {
-						await controller.dispose();
-					};
-				}, `ui-settings: ${spec.namespace} settings scope`);
-				return controller;
+			whileServed(namespaces, register) {
+				let off;
+				const sync = () => {
+					const served = new Set(this.mirror.getSnapshot().view?.namespaces.map((view) => view.ns) ?? []);
+					const watched = namespaces.some((namespace) => served.has(namespace));
+					if (watched && off === void 0) off = register(served);
+					else if (!watched && off !== void 0) {
+						off();
+						off = void 0;
+					}
+				};
+				const unsubscribe = this.mirror.subscribe(sync);
+				this.mirror.ensure();
+				sync();
+				return () => {
+					unsubscribe();
+					off?.();
+					off = void 0;
+				};
 			}
 		};
 		//#endregion
@@ -1183,8 +1353,8 @@ window.__ModuleLoader__.load({
 		/**
 		* Client mirror of the Host settings document: the one `settings.describe`
 		* reader in the browser. Every settings consumer derives from this store —
-		* per-namespace scopes through `SettingsScopeBinder.bind`, cross-namespace
-		* surfaces through the binder's shared describe face — so startup cost and
+		* shared entry forms through `ConfigForms.get`, cross-namespace
+		* surfaces through the provider's shared describe face — so startup cost and
 		* freshness are properties of this class, not of how many features own a
 		* preference. The Host stays the fact source: the mirror re-reads on the
 		* invalidations its owning plugin subscribes to and folds write answers in
@@ -1331,14 +1501,8 @@ window.__ModuleLoader__.load({
 		* forwarded settings invalidation it refreshes on.
 		*/
 		const inject = ["remote", "remote.settings"];
-		/**
-		* Provide the settings-namespace scope service over one shared describe
-		* mirror, and keep that mirror fresh on the two signals that can move the
-		* settings document: a document commit and a (re)connect.
-		*
-		* Constructing the service in this plugin's fiber keeps its traced methods
-		* bound to each consuming plugin's context.
-		* @param ctx - client root context.
+		/** Provide shared forms and refresh them on document changes and reconnects.
+		* @param ctx Client provider context.
 		*/
 		function apply(ctx) {
 			const schema = new SettingsSchemaService(ctx);
@@ -1355,7 +1519,7 @@ window.__ModuleLoader__.load({
 					for (const dispose of disposers) dispose();
 				};
 			}, "ui-settings: describe mirror invalidations");
-			new SettingsScopeBinder(ctx, {
+			new ConfigForms(ctx, {
 				mirror,
 				schema,
 				persistence