@morlay/dsh-client-ui-primitives 0.0.2-alpha.8 → 0.0.2-alpha.9

package/dist/client.cjs

@@ -16,10 +16,1813 @@ window.__ModuleLoader__.load({
 			return target;
 		};
 		//#endregion
-		let react = require("react");
 		let _deepseek_ai_dsh_client_store = require("@deepseek-ai/dsh-client-store");
-		let react_jsx_runtime = require("react/jsx-runtime");
+		let _deepseek_ai_cordis = require("@deepseek-ai/cordis");
+		let react = require("react");
 		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		/** 空的元数据：动态子节点（无声明 schema 的 dict 键）与空字段树用它。 */
+		function emptyMeta() {
+			return {
+				description: void 0,
+				comment: void 0,
+				link: void 0,
+				role: void 0,
+				secret: false,
+				required: false,
+				disabled: false,
+				collapse: false,
+				badges: [],
+				pattern: void 0,
+				min: void 0,
+				max: void 0,
+				step: void 0,
+				hasDefault: false,
+				defaultValue: void 0,
+				extra: void 0
+			};
+		}
+		/** `badges` 只留文本：配色与文案由字典决定。 */
+		function badgesOf(meta) {
+			return (meta.badges ?? []).map((badge) => badge.text);
+		}
+		/** 归一化一个节点的 meta。 */
+		function metaOf(schema) {
+			const meta = schema.meta ?? {};
+			return {
+				description: meta.description,
+				comment: meta.comment,
+				link: meta.link,
+				role: meta.role,
+				secret: meta.role === "secret",
+				required: meta.required === true,
+				disabled: meta.disabled === true,
+				collapse: meta.collapse === true,
+				badges: badgesOf(meta),
+				pattern: typeof meta.pattern === "string" ? meta.pattern : meta.pattern?.source ?? void 0,
+				min: meta.min,
+				max: meta.max,
+				step: meta.step,
+				hasDefault: meta.default !== void 0,
+				defaultValue: meta.default,
+				extra: meta.extra
+			};
+		}
+		/** 外层 meta 与内层 meta 合并：外层的 undefined 不覆盖内层（transform 的 inner 带着自己的角色）。 */
+		function mergeMeta(inner, outer) {
+			const merged = { ...inner };
+			for (const [key, value] of Object.entries(outer)) if (value !== void 0) merged[key] = value;
+			return merged;
+		}
+		/** 节点自己的路径末段：动态段保持占位，根节点为空串。 */
+		function keyOf(path) {
+			return path[path.length - 1] ?? "";
+		}
+		/** 一个纯字符串叶子（dict 没有声明键 schema 时用它）。 */
+		function stringLeaf(path, meta) {
+			return {
+				key: keyOf(path),
+				path,
+				label: void 0,
+				meta,
+				readOnly: null,
+				type: "string"
+			};
+		}
+		/** 把 schema 的类型名收口成渲染层认识的那几种。 */
+		function leafTypeOf(type) {
+			switch (type) {
+				case "string": return "string";
+				case "number": return "number";
+				case "boolean": return "boolean";
+				case "function": return "function";
+				case "never": return "never";
+				default: return "any";
+			}
+		}
+		/**
+		* 投影一个 schema 节点。
+		* @param schema - rehydrate 之后的 volatile 表单 schema（或它的子节点）。
+		* @param path - 该节点相对段根的路径；动态子节点由调用方给占位段。
+		* @returns 渲染层要的字段树。
+		*/
+		function projectNode(schema, path = []) {
+			return project(schema, path, []);
+		}
+		function project(schema, path, ancestors) {
+			const base = {
+				key: keyOf(path),
+				path,
+				label: void 0,
+				meta: metaOf(schema),
+				readOnly: null
+			};
+			if (ancestors.includes(schema)) return {
+				...base,
+				type: "recursive",
+				origin: schema.type
+			};
+			const chain = [...ancestors, schema];
+			switch (schema.type) {
+				case "object": {
+					const fields = Object.entries(schema.dict ?? {}).filter(([, child]) => child.meta?.hidden !== true).map(([key, child]) => project(child, [...path, key], chain));
+					return {
+						...base,
+						type: "object",
+						fields
+					};
+				}
+				case "dict": {
+					const segment = [...path, "*"];
+					const keyNode = schema.sKey === void 0 ? stringLeaf(segment, emptyMeta()) : project(schema.sKey, segment, chain);
+					return {
+						...base,
+						type: "dict",
+						keyNode,
+						valueNode: project(schema.inner ?? schema, segment, chain)
+					};
+				}
+				case "array": {
+					const item = project(schema.inner ?? schema, [...path, "*"], chain);
+					return {
+						...base,
+						type: "array",
+						item,
+						mergeKey: mergeKeyOf(schema, item)
+					};
+				}
+				case "tuple": {
+					const items = (schema.list ?? []).map((child, index) => project(child, [...path, String(index)], chain));
+					return {
+						...base,
+						type: "tuple",
+						items
+					};
+				}
+				case "union": {
+					const members = schema.list ?? [];
+					const variants = members.map((child) => project(child, path, chain));
+					const literals = members.every((child) => child.type === "const") ? members.map((child) => child.value) : void 0;
+					return {
+						...base,
+						type: "union",
+						choices: literals,
+						variants,
+						tagKey: tagKeyOf(schema, variants)
+					};
+				}
+				case "intersect": return {
+					...base,
+					type: "intersect",
+					members: (schema.list ?? []).map((child) => project(child, path, chain))
+				};
+				case "bitset": {
+					const bits = Object.entries(schema.bits ?? {}).map(([name, bit]) => ({
+						name,
+						bit
+					}));
+					return {
+						...base,
+						type: "bitset",
+						bits
+					};
+				}
+				case "const": return {
+					...base,
+					type: "const",
+					value: schema.value
+				};
+				case "transform": {
+					const projected = project(schema.inner ?? schema, path, chain);
+					return {
+						...projected,
+						meta: mergeMeta(projected.meta, base.meta),
+						readOnly: "transform"
+					};
+				}
+				case "lazy": {
+					const inner = schema.inner;
+					return inner === void 0 ? {
+						...base,
+						type: "any"
+					} : {
+						...base,
+						type: "lazy",
+						inner: project(inner, path, chain)
+					};
+				}
+				case "is": return {
+					...base,
+					type: "any",
+					readOnly: "constructor"
+				};
+				default: return {
+					...base,
+					type: leafTypeOf(schema.type),
+					readOnly: schema.type === "function" ? "function" : null
+				};
+			}
+		}
+		/** 展开 `lazy` 包装：投影里 lazy 只是一层，值仍在同一路径上。 */
+		function unwrapLazy(node) {
+			let current = node;
+			while (current?.type === "lazy") current = current.inner;
+			return current;
+		}
+		/** 某一层可见的字段：object 直接给；union / intersect 把各变体的对象字段并起来。 */
+		function fieldsOf(node) {
+			const current = unwrapLazy(node);
+			switch (current?.type) {
+				case "object": return current.fields;
+				case "union": return current.variants.flatMap((variant) => fieldsOf(variant));
+				case "intersect": return current.members.flatMap((member) => fieldsOf(member));
+				default: return [];
+			}
+		}
+		/**
+		* 按具体路径找回投影节点（动态段匹配真实键或索引）。
+		* @param root - 段根的字段树。
+		* @param path - 具体路径。
+		* @returns 命中的节点，或 `undefined`。
+		*/
+		function seekNode(root, path) {
+			let current = root;
+			for (const segment of path) {
+				const node = unwrapLazy(current);
+				if (node === void 0) return void 0;
+				switch (node.type) {
+					case "object":
+					case "union":
+					case "intersect":
+						current = fieldsOf(node).find((field) => field.key === segment);
+						break;
+					case "dict":
+						current = node.valueNode;
+						break;
+					case "array":
+						current = node.item;
+						break;
+					case "tuple":
+						current = node.items[Number(segment)];
+						break;
+					default: return;
+				}
+			}
+			return unwrapLazy(current);
+		}
+		/**
+		* 按当前值把字段树展开成渲染顺序的扁平列表（前序）：容器在前、子项紧随其后。
+		*
+		* 出现的**只有值里有的东西，加上必填的**：对象的必填字段始终占行（值是空的也要让用户看见"必须填"），非必填的
+		* 按值出现——值里没有就不占行，它在这一层的「添加属性」候选里，选中才加。数组按索引、字典按键展开；字面量
+		* union 是叶子控件，对象 union 只展开与当前值匹配的那个变体，intersect 的各成员在同一层展开。
+		* @param root - 段根的字段树。
+		* @param value - 生效值（或草稿后的值）。
+		* @returns 渲染顺序的字段列表。
+		*/
+		function walkFields(root, value) {
+			const out = [];
+			visit(root, root.path, value, out, true, void 0, /* @__PURE__ */ new Set(), void 0);
+			return out;
+		}
+		function visit(node, path, value, out, emit, label, emitted, member) {
+			const current = unwrapLazy(node);
+			if (current === void 0) return;
+			const positioned = {
+				...current,
+				path,
+				...member === void 0 ? {} : { key: member.key },
+				...label === void 0 ? {} : { label }
+			};
+			const key = JSON.stringify(path);
+			if (emit && !emitted.has(key)) {
+				emitted.add(key);
+				out.push({
+					path,
+					node: positioned,
+					...member === void 0 ? {} : { member }
+				});
+			}
+			switch (positioned.type) {
+				case "object":
+					for (const field of positioned.fields) {
+						const child = memberOf(value, field.key);
+						if (child === void 0 && field.meta.required !== true) continue;
+						visit(field, [...path, field.key], child, out, true, void 0, emitted, void 0);
+					}
+					return;
+				case "dict":
+					for (const [key, child] of entriesOf(value)) visit(positioned.valueNode, [...path, key], child, out, true, void 0, emitted, {
+						parent: path,
+						key,
+						index: void 0
+					});
+					return;
+				case "array":
+					for (const [key, child] of entriesOf(value)) {
+						const label = positioned.mergeKey === void 0 ? void 0 : memberLabel(child, positioned.mergeKey);
+						visit(positioned.item, [...path, key], child, out, true, label, emitted, {
+							parent: path,
+							key,
+							index: Number(key)
+						});
+					}
+					return;
+				case "tuple":
+					positioned.items.forEach((item, index) => {
+						visit(item, [...path, String(index)], memberOf(value, index), out, true, void 0, emitted, void 0);
+					});
+					return;
+				case "union": {
+					if (positioned.choices !== void 0) return;
+					const variant = pickVariant(positioned, value);
+					if (variant !== void 0) visit(variant, path, value, out, false, void 0, emitted, member);
+					return;
+				}
+				case "intersect":
+					for (const part of positioned.members) visit(part, path, value, out, false, void 0, emitted, member);
+					return;
+				default: return;
+			}
+		}
+		/** 数组的项身份：显式声明优先，否则 item 上的 `id` 字段。 */
+		function mergeKeyOf(schema, item) {
+			const declared = declaredExtra(schema, "mergeKey");
+			if (declared !== void 0) return declared;
+			const current = unwrapLazy(item);
+			return current?.type === "object" && current.fields.some((field) => field.key === "id") ? "id" : void 0;
+		}
+		/** union 的判别标签：显式声明优先，否则所有对象成员共有的唯一常量字段。 */
+		function tagKeyOf(schema, variants) {
+			const declared = declaredExtra(schema, "tag");
+			if (declared !== void 0) return declared;
+			const members = variants.map((variant) => unwrapLazy(variant));
+			if (members.length === 0 || members.some((member) => member?.type !== "object")) return void 0;
+			const objects = members;
+			const candidates = (objects[0]?.fields ?? []).map((field) => unwrapLazy(field)).filter((field) => field?.type === "const").map((field) => field.key).filter((key) => objects.every((object) => unwrapLazy(object.fields.find((field) => field.key === key))?.type === "const"));
+			return candidates.length === 1 ? candidates[0] : void 0;
+		}
+		/** `role(text, { … })` 里声明的字符串约定（项身份 `mergeKey`、判别标签 `tag`）。 */
+		function declaredExtra(schema, name) {
+			const extra = schema.meta?.extra;
+			if (typeof extra !== "object" || extra === null) return void 0;
+			const value = Reflect.get(extra, name);
+			return typeof value === "string" && value.length > 0 ? value : void 0;
+		}
+		/** 一项的项身份值（渲染与冲突检查共用的读法）。 */
+		function memberLabel(value, mergeKey) {
+			if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+			const member = Reflect.get(value, mergeKey);
+			if (typeof member === "string") return member;
+			if (typeof member === "number" && Number.isFinite(member)) return String(member);
+		}
+		/**
+		* 项身份冲突：同一层里两个成员同名，或某个成员没有名字。
+		*
+		* 名字是成员的「身份」，写盘仍按索引——所以这只是保存前的本地校验：重名的数组在页面上是非法草稿，
+		* 而不是悄悄写到 host 上。
+		* @param root - 段根的字段树。
+		* @param value - 草稿后的段值。
+		* @returns 第一处冲突，或 `undefined`。
+		*/
+		function mergeKeyConflict(root, value) {
+			return scanConflict(root, root.path, value);
+		}
+		function scanConflict(node, path, value) {
+			const current = unwrapLazy(node);
+			if (current === void 0) return void 0;
+			switch (current.type) {
+				case "object":
+					for (const field of current.fields) {
+						const conflict = scanConflict(field, [...path, field.key], memberOf(value, field.key));
+						if (conflict !== void 0) return conflict;
+					}
+					return;
+				case "dict":
+					for (const [key, child] of entriesOf(value)) {
+						const conflict = scanConflict(current.valueNode, [...path, key], child);
+						if (conflict !== void 0) return conflict;
+					}
+					return;
+				case "array": {
+					const names = /* @__PURE__ */ new Set();
+					for (const [key, child] of entriesOf(value)) {
+						const itemPath = [...path, key];
+						if (current.mergeKey !== void 0) {
+							const label = memberLabel(child, current.mergeKey);
+							if (label === void 0 || label.trim() === "") return {
+								kind: "missing",
+								path: itemPath,
+								mergeKey: current.mergeKey,
+								value: ""
+							};
+							if (names.has(label)) return {
+								kind: "duplicate",
+								path: itemPath,
+								mergeKey: current.mergeKey,
+								value: label
+							};
+							names.add(label);
+						}
+						const conflict = scanConflict(current.item, itemPath, child);
+						if (conflict !== void 0) return conflict;
+					}
+					return;
+				}
+				case "tuple":
+					for (const [index, item] of current.items.entries()) {
+						const conflict = scanConflict(item, [...path, String(index)], memberOf(value, index));
+						if (conflict !== void 0) return conflict;
+					}
+					return;
+				case "union": {
+					if (current.choices !== void 0) return void 0;
+					const variant = pickVariant(current, value);
+					return variant === void 0 ? void 0 : scanConflict(variant, path, value);
+				}
+				case "intersect":
+					for (const member of current.members) {
+						const conflict = scanConflict(member, path, value);
+						if (conflict !== void 0) return conflict;
+					}
+					return;
+				default: return;
+			}
+		}
+		/** 一个容器值里的成员（对象键或数组索引）。 */
+		function entriesOf(value) {
+			if (Array.isArray(value)) return value.map((item, index) => [String(index), item]);
+			if (typeof value === "object" && value !== null) return Object.entries(value);
+			return [];
+		}
+		/** 读一个成员的值。 */
+		function memberOf(value, key) {
+			if (Array.isArray(value)) return value[Number(key)];
+			if (typeof value === "object" && value !== null) return value[String(key)];
+		}
+		/** 把节点收成 union：渲染层判形状与选支都从这里进。 */
+		function unionOf(node) {
+			const current = unwrapLazy(node);
+			return current?.type === "union" ? current : void 0;
+		}
+		/**
+		* 当前值落在哪一支：与 {@link walkFields} 的展开同一判据（标签值优先，其次值的形状，最后第一支）。
+		* @param node - 字段节点（不是 union 就原样返回）。
+		* @param value - 这一层的值。
+		* @returns 选中变体的节点。
+		*/
+		function variantOf(node, value) {
+			const union = unionOf(node);
+			if (union === void 0) return unwrapLazy(node) ?? node;
+			return pickVariant(union, value) ?? union;
+		}
+		/** 变体里那个判别标签字段的常量值（不是 `const` 就没有）。 */
+		function tagValueOf(variant, tagKey) {
+			const current = unwrapLazy(variant);
+			if (current?.type !== "object" && current?.type !== "intersect") return {
+				found: false,
+				value: void 0
+			};
+			for (const field of fieldsOf(current)) {
+				if (field.key !== tagKey) continue;
+				const candidate = unwrapLazy(field);
+				if (candidate?.type === "const") return {
+					found: true,
+					value: candidate.value
+				};
+			}
+			return {
+				found: false,
+				value: void 0
+			};
+		}
+		/** 一个变体在页面上的名字：能看出"这一支是什么"，而不是内部类型名。 */
+		function variantLabel(variant, tag) {
+			if (tag.found) return JSON.stringify(tag.value);
+			switch (unwrapLazy(variant)?.type) {
+				case "string": return "\"\"";
+				case "number": return "0";
+				case "boolean": return "true";
+				case "array":
+				case "tuple": return "[ ]";
+				case "object":
+				case "dict":
+				case "intersect": return "{ }";
+				default: return unwrapLazy(variant)?.type ?? "any";
+			}
+		}
+		/**
+		* 变体切换的选项。
+		*
+		* 带判别标签的 union 写**标签值**（`session-rdb` 的 `type: sqlite` ↔ `type: postgres`）；没有标签的写目标变体的
+		* 空值（`access` 在「一段文本」与「一组文本」之间切）。
+		* @param union - 投影出来的 union 节点。
+		* @returns 每个变体一项，顺序即声明顺序。
+		*/
+		function variantChoices(union) {
+			return union.variants.map((variant) => {
+				const tag = union.tagKey === void 0 ? {
+					found: false,
+					value: void 0
+				} : tagValueOf(variant, union.tagKey);
+				return {
+					label: variantLabel(variant, tag),
+					value: tag.found ? tag.value : emptyValueOf(variant)
+				};
+			});
+		}
+		/** 按路径读一个值：对象键与数组下标都认（值的读法只有这一处）。 */
+		function readPath(root, path) {
+			return path.reduce((node, segment) => {
+				if (Array.isArray(node)) return node[Number(segment)];
+				if (typeof node !== "object" || node === null) return void 0;
+				return node[segment];
+			}, root);
+		}
+		/**
+		* 这个"默认值"其实不是值——它不该用来当新加进来的那一项的初值。
+		*
+		* 两种：`null`（"没有值"的判断位，例如 `defaultModel` 用 `.default(null)` 表达"没配就没有这个键"），以及
+		* schemastery 给容器类型自动塞的空壳（`{}`）。两种都该让容器把字段摆出来。
+		* @param node - 字段节点。
+		* @returns 是不是空壳。
+		*/
+		function isBlankDefault(node) {
+			const value = node.meta.defaultValue;
+			if (value === null) return true;
+			if (node.type !== "object" && node.type !== "intersect") return false;
+			return typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+		}
+		/**
+		* 一个新子节点的初值：声明的默认值优先；对象把字段摆出来（见下）；字典/数组给空的容器；其余标量给 **`null`**。
+		*
+		* `null` 在这里是"还没有值"的判断位（`null` / `undefined` 都算），页面据此把它画成一个等着输入的位子——
+		* 而不是 `""`、`0` 这种看着像已经填过的值。host 侧也认这个语义：非必填字段拿到 `null` 回退到默认值，
+		* 必填字段拿到 `null` 就是"必须填"。
+		* @param node - 子节点的字段树。
+		* @returns 初值。
+		*/
+		function emptyValueOf(node) {
+			if (node.meta.hasDefault && !isBlankDefault(node)) return structuredClone(node.meta.defaultValue);
+			switch (node.type) {
+				case "array": return [];
+				case "tuple": return node.items.map((item) => emptyValueOf(item));
+				case "dict": return {};
+				case "object":
+				case "intersect": return Object.fromEntries(fieldsOf(node).map((field) => [field.key, emptyValueOf(field)]));
+				case "const": return node.value;
+				case "bitset": return 0;
+				case "lazy": return emptyValueOf(node.inner);
+				default: return null;
+			}
+		}
+		/** 选中与当前值匹配的 union 变体：对象按判别标签的值判，叶子按值类型判。 */
+		function pickVariant(node, value) {
+			if (node.tagKey !== void 0 && typeof value === "object" && value !== null && !Array.isArray(value)) {
+				const tagValue = Reflect.get(value, node.tagKey);
+				for (const variant of node.variants) {
+					const current = unwrapLazy(variant);
+					if (current?.type !== "object") continue;
+					const field = unwrapLazy(current.fields.find((candidate) => candidate.key === node.tagKey));
+					if (field?.type === "const" && field.value === tagValue) return variant;
+				}
+			}
+			for (const variant of node.variants) {
+				const current = unwrapLazy(variant);
+				if (current?.type === "string" && typeof value === "string") return variant;
+				if (current?.type === "number" && typeof value === "number") return variant;
+				if (current?.type === "boolean" && typeof value === "boolean") return variant;
+				if (current?.type === "array" && Array.isArray(value)) return variant;
+			}
+			return node.variants[0];
+		}
+		//#endregion
+		//#region src/client/schema-form/draft.ts
+		/**
+		* 把校验器抛出的错误收成一条失败。
+		*
+		* schemastery 的 `ValidationError` 把路径留在 `options.path` 上（消息里的 `$…` 前缀是给命令行看的），所以这里
+		* 取路径、去前缀——行内报错据此知道挂在哪一行。
+		* @param error - 校验器抛出的错误。
+		* @returns 消息与路径。
+		*/
+		function failureOf(error) {
+			const raw = error instanceof Error ? error.message : String(error);
+			const path = (error.options?.path ?? []).filter((segment) => typeof segment === "string" || typeof segment === "number").map(String);
+			const message = raw.replace(/^\$\S*\s/, "").trim();
+			return {
+				message: message === "" ? raw : message,
+				path
+			};
+		}
+		/**
+		* 一页配置的草稿。一个命名空间一个实例：它订阅共享配置表单，投影给渲染层读。
+		*/
+		var SchemaDraftModel = class {
+			#scope;
+			#root;
+			#validate;
+			#staged = /* @__PURE__ */ new Map();
+			#listeners = /* @__PURE__ */ new Set();
+			#unsubscribe;
+			#baseline;
+			#saving = false;
+			#failed = false;
+			#violation;
+			/**
+			* @param options - 本页的共享配置表单、字段树与整段校验。
+			*/
+			constructor(options) {
+				this.#scope = options.scope;
+				this.#root = options.root;
+				this.#validate = options.validate;
+				this.#unsubscribe = this.#scope.subscribe(() => {
+					this.#publish();
+				});
+			}
+			/**
+			* 换一份字段树。
+			*
+			* 增删项要按它取节点默认值，而 schema 可能随 describe 变（行的 Config 改了）——所以控制器每次投影都同步一次，
+			* 否则加进来的项会取不到默认值。
+			* @param root - 段根的字段树。
+			*/
+			setRoot(root) {
+				this.#root = root;
+			}
+			/**
+			* 观察草稿与读数的变化。
+			* @param listener - 每次投影都调一次的回调。
+			* @returns 取消订阅。
+			*/
+			subscribe(listener) {
+				this.#listeners.add(listener);
+				return () => {
+					this.#listeners.delete(listener);
+				};
+			}
+			/**
+			* 投影一份读数给渲染层。
+			* @param project - 用模型的当前读数造渲染要的状态。
+			* @returns 渲染层按选择器读的 store。
+			*/
+			bind(project) {
+				const store = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(project());
+				this.subscribe(() => {
+					store.set(project());
+				});
+				return store;
+			}
+			/**
+			* 表单级状态（与上游 `SettingsForm` 的壳同形）。
+			* @returns 可用性、可写性、脏、非法、保存中、上次保存失败。
+			*/
+			shell() {
+				const { writes, blocked } = this.#plan();
+				return {
+					available: this.#scope.getSnapshot().status === "ready",
+					writable: this.#scope.getSnapshot().writable,
+					dirty: writes.some((item) => item.op !== void 0) || blocked,
+					invalid: blocked || this.#violation !== void 0,
+					saving: this.#saving,
+					failed: this.#failed
+				};
+			}
+			/**
+			* 保存前的整段校验（保存被 schema 挡下时非空）。
+			* @returns 失败消息与它的位置，或 `undefined`。
+			*/
+			violation() {
+				return this.#violation;
+			}
+			/**
+			* 读一个字段的草稿状态。
+			* @param path - 具体路径（动态段已按真实键或索引替换）。
+			* @param preview - 本轮已经算好的读数（`preview()` 的结果）。
+			*
+			* **容器的值要跟着别处的草稿走**：判别式 union 的选支就是容器的值，若这里读生效层，`type` 的切换控件会显示旧
+			* 的那一支（字段树却已经换了）。所以有 `preview` 就用它——控制器一次投影里只算一份。
+			* @returns 显示值、文本草稿、非法消息、是否覆盖。
+			*/
+			field(path, preview) {
+				const snapshot = this.#scope.getSnapshot();
+				const staged = this.#staged.get(pathKey(path));
+				const stored = hasPath(snapshot.user, path);
+				if (staged === void 0) return {
+					value: readPath(preview ?? snapshot.value, path),
+					text: void 0,
+					invalid: void 0,
+					overridden: stored,
+					staged: false
+				};
+				switch (staged.edit.kind) {
+					case "value": return {
+						value: staged.edit.value,
+						text: void 0,
+						invalid: void 0,
+						overridden: true,
+						staged: true
+					};
+					case "text": {
+						const parsed = staged.edit.parse(staged.edit.text);
+						return {
+							value: parsed.kind === "value" ? parsed.value : readPath(snapshot.value, path),
+							text: staged.edit.text,
+							invalid: parsed.kind === "invalid" ? parsed.message : void 0,
+							overridden: true,
+							staged: true
+						};
+					}
+					case "clear": return {
+						value: readPath(snapshot.base, path),
+						text: void 0,
+						invalid: void 0,
+						overridden: false,
+						staged: true
+					};
+					case "drop": return {
+						value: void 0,
+						text: void 0,
+						invalid: void 0,
+						overridden: false,
+						staged: true
+					};
+				}
+			}
+			/**
+			* 暂存一个合法值。
+			* @param path - 具体路径。
+			* @param value - 控件给出的值。
+			*/
+			set(path, value) {
+				this.#stage(path, {
+					kind: "value",
+					value
+				});
+			}
+			/**
+			* 暂存一段文本，保存时才解析。
+			* @param path - 具体路径。
+			* @param text - 用户输入的原文。
+			* @param parse - 解析规则；失败时给出消息并挡住保存。
+			*/
+			setText(path, text, parse) {
+				this.#stage(path, {
+					kind: "text",
+					text,
+					parse
+				});
+			}
+			/**
+			* 暂存「恢复默认」。
+			* @param path - 具体路径。
+			*/
+			clear(path) {
+				this.#stage(path, { kind: "clear" });
+			}
+			/**
+			* 追加一个数组项，值取该项节点的默认值。
+			* @param path - 数组字段的具体路径。
+			*/
+			appendItem(path) {
+				const node = seekNode(this.#root, path);
+				if (node?.type !== "array") return;
+				const current = readPath(this.preview(), path);
+				const index = Array.isArray(current) ? current.length : 0;
+				this.set([...path, String(index)], emptyValueOf(node.item));
+			}
+			/**
+			* 移除一个数组项。
+			* @param path - 数组字段的具体路径。
+			* @param index - 项在数组里的位置。
+			*/
+			removeItem(path, index) {
+				this.#stage([...path, String(index)], { kind: "drop" });
+			}
+			/**
+			* 给一层加一项，值取它的默认值。
+			*
+			* 字典认任意键；对象只认 schema 声明过的字段（写一个没声明的键会被 host 挡下，所以这里直接不写）。
+			* @param path - 容器的具体路径。
+			* @param key - 要加的键。
+			*/
+			addKey(path, key) {
+				const node = seekNode(this.#root, path);
+				if (node === void 0) return;
+				if (node.type === "dict") {
+					this.set([...path, key], emptyValueOf(node.valueNode));
+					return;
+				}
+				const field = fieldsOf(node).find((candidate) => candidate.key === key);
+				if (field === void 0) return;
+				this.set([...path, key], emptyValueOf(field));
+			}
+			/**
+			* 删一个字典键。
+			* @param path - 字典字段的具体路径。
+			* @param key - 要删的键。
+			*/
+			removeKey(path, key) {
+				this.#stage([...path, key], { kind: "drop" });
+			}
+			/**
+			* 撤销一个字段的草稿（回到它当前的生效值）——行内编辑取消时用。
+			* @param path - 具体路径。
+			*/
+			revert(path) {
+				if (!this.#staged.delete(pathKey(path))) return;
+				this.#failed = false;
+				this.#violation = void 0;
+				this.#publish();
+			}
+			/** 丢弃全部草稿，回到 host 的读数。 */
+			discard() {
+				if (this.#staged.size === 0 && !this.#failed && this.#violation === void 0) return;
+				this.#staged.clear();
+				this.#baseline = void 0;
+				this.#failed = false;
+				this.#violation = void 0;
+				this.#publish();
+			}
+			/**
+			* 把全部草稿写成一次带 revision 栅栏的提交。
+			*
+			* host 是「值是否被接受」的唯一权威（有些约束 schema 表达不出来），所以落盘与否读回来决定，而不是在这里
+			* 预测；没落盘的保存保留草稿，让用户改而不是重打。
+			* @returns 写完与读回之后的收束。
+			*/
+			async save() {
+				const snapshot = this.#scope.getSnapshot();
+				if (this.#saving || !snapshot.writable) return;
+				const { writes, blocked } = this.#plan();
+				if (blocked) return;
+				const ops = writes.flatMap((item) => item.op === void 0 ? [] : [item.op]);
+				if (ops.length === 0) {
+					this.#violation = void 0;
+					this.#publish();
+					return;
+				}
+				const failure = this.#validate(applyOps(snapshot.value ?? {}, ops));
+				if (failure !== void 0) {
+					this.#violation = failure;
+					this.#publish();
+					return;
+				}
+				this.#violation = void 0;
+				this.#saving = true;
+				this.#failed = false;
+				this.#publish();
+				try {
+					const landed = await this.#scope.mutate(ops, this.#baseline?.revision);
+					if (landed) {
+						this.#staged.clear();
+						this.#baseline = void 0;
+					}
+					this.#failed = !landed;
+				} catch {
+					this.#failed = true;
+				} finally {
+					this.#saving = false;
+					this.#publish();
+				}
+			}
+			/** 释放对共享配置表单的订阅。 */
+			dispose() {
+				this.#unsubscribe();
+				this.#listeners.clear();
+			}
+			/** 每条草稿这一轮会写什么；被 schema 挡下的草稿没有 op，但仍然是脏的。 */
+			#plan() {
+				const snapshot = this.#scope.getSnapshot();
+				const writes = [];
+				let blocked = false;
+				for (const { path, edit } of this.#staged.values()) {
+					if (edit.kind === "drop") {
+						writes.push({ op: {
+							op: "unset",
+							path: [...path]
+						} });
+						continue;
+					}
+					if (edit.kind === "clear") {
+						if (hasPath(snapshot.user, path)) writes.push({ op: {
+							op: "unset",
+							path: [...path]
+						} });
+						continue;
+					}
+					const parsed = edit.kind === "value" ? {
+						kind: "value",
+						value: edit.value
+					} : edit.parse(edit.text);
+					if (parsed.kind === "invalid") {
+						blocked = true;
+						continue;
+					}
+					if (parsed.kind === "skip") continue;
+					if (sameValue$1(readPath(snapshot.value, path), parsed.value)) continue;
+					writes.push({ op: {
+						op: "set",
+						path: [...path],
+						value: parsed.value
+					} });
+				}
+				return {
+					writes,
+					blocked
+				};
+			}
+			/** 生效值套上本轮草稿后的段值：字段树按它展开（追加的数组项立刻出现），整段校验也看它。 */
+			preview() {
+				const ops = this.#plan().writes.flatMap((item) => item.op === void 0 ? [] : [item.op]);
+				return applyOps(this.#scope.getSnapshot().value ?? {}, ops);
+			}
+			#stage(path, edit) {
+				this.#baseline ??= this.#scope.getSnapshot();
+				this.#staged.set(pathKey(path), {
+					path: [...path],
+					edit
+				});
+				this.#failed = false;
+				this.#violation = void 0;
+				this.#publish();
+			}
+			#publish() {
+				for (const listener of this.#listeners) listener();
+			}
+		};
+		/** 深比较：值相等就不写（避免把「改回原值」也当成一次写）。 */
+		function sameValue$1(left, right) {
+			if (Object.is(left, right)) return true;
+			if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+			return JSON.stringify(left) === JSON.stringify(right);
+		}
+		/** 路径的 map 键。 */
+		function pathKey(path) {
+			return JSON.stringify(path);
+		}
+		/** 路径末段是否在用户层里存在（覆盖判据）。 */
+		function hasPath(root, path) {
+			if (path.length === 0) return root !== void 0;
+			const parent = readPath(root, path.slice(0, -1));
+			const leaf = path[path.length - 1] ?? "";
+			if (Array.isArray(parent)) return Number(leaf) < parent.length;
+			if (typeof parent !== "object" || parent === null) return false;
+			return leaf in parent;
+		}
+		/** 把一组 op 套到一个段值上（本地读数用，不写 host）。 */
+		function applyOps(section, ops) {
+			const next = structuredClone(section);
+			for (const op of ops) {
+				const parent = readPath(next, op.path.slice(0, -1));
+				const leaf = op.path[op.path.length - 1] ?? "";
+				if (Array.isArray(parent)) {
+					if (op.op === "set") parent[Number(leaf)] = op.value;
+					else parent.splice(Number(leaf), 1);
+					continue;
+				}
+				if (typeof parent !== "object" || parent === null) continue;
+				if (op.op === "set") parent[leaf] = op.value;
+				else Reflect.deleteProperty(parent, leaf);
+			}
+			return next;
+		}
+		//#endregion
+		//#region src/client/schema-form/controller.ts
+		/** `role('select', { source })` 里声明的候选源名字。 */
+		function declaredSource(node) {
+			const extra = node?.meta.extra;
+			if (typeof extra !== "object" || extra === null) return void 0;
+			const name = Reflect.get(extra, "source");
+			return typeof name === "string" && name.length > 0 ? name : void 0;
+		}
+		/** 字段在状态表里的键（具体路径的 JSON）。 */
+		function fieldKey(path) {
+			return JSON.stringify(path);
+		}
+		/**
+		* rehydrate 一段配置 schema，并判它能不能当页面的根。
+		*
+		* 能当根的形状有三种：对象段、**相交段**（共享判别字段 + 各分支的 `const` 标记，段值仍是对象）、以及带判别
+		* 标签的 `union`（成员都是对象）。字面量 `union`（整段就是一个标量）不行：那一行的写盘会变成整段替换。
+		* @param serialized - host 发来的 `schema.toJSON()`。
+		* @param rehydrate - host schema 的 rehydrate。
+		* @returns schema 与它的字段树，或 `undefined`（不能当页面根）。
+		*/
+		function projectRoot(serialized, rehydrate) {
+			try {
+				const schema = rehydrate(serialized);
+				const root = projectNode(schema);
+				if (root.type === "object" || root.type === "intersect") return {
+					schema,
+					root
+				};
+				if (root.type === "union" && root.tagKey !== void 0 && root.choices === void 0) return {
+					schema,
+					root
+				};
+				return;
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 一行能否自动生成配置页：它的 schema 能 rehydrate 且根是 {@link projectRoot} 认的形状。
+		* @param view - host 发来的命名空间视图。
+		* @param rehydrate - host schema 的 rehydrate。
+		* @returns 是否可以渲染。
+		*/
+		function canRender(view, rehydrate) {
+			return view !== void 0 && projectRoot(view.schema, rehydrate) !== void 0;
+		}
+		/** 段根不是可渲染对象时的空字段树。 */
+		const NO_FIELDS = {
+			key: "",
+			path: [],
+			label: void 0,
+			meta: emptyMeta(),
+			readOnly: null,
+			type: "object",
+			fields: []
+		};
+		/** 值里已有的键（数组给索引）。 */
+		function keysOf(value) {
+			if (Array.isArray(value)) return value.map((_item, index) => String(index));
+			if (typeof value === "object" && value !== null) return Object.keys(value);
+			return [];
+		}
+		/**
+		* 一个容器当前能加什么。
+		*
+		* 对象层（含相交与 union 的选中变体）是**非必填**、值里又没有的字段——必填的已经占着行了；字典层是业务注册的
+		* 候选键（模式清单这类运行期数据）。数组层不在这里：它的「添加一项」是追加一个空项，没有键名可选。
+		* @param node - 容器节点。
+		* @param path - 该容器的具体路径。
+		* @param value - 该容器自己的值（草稿后的）。
+		* @param hints - 提示面（只用到候选键）。
+		* @returns 可添加项，顺序即 schema / 读数的顺序；列表为空时页面不给输入框。
+		*/
+		function addableAt(node, path, value, hints) {
+			const current = variantOf(node, value);
+			if (current.type === "dict") {
+				const present = new Set(keysOf(value));
+				return (hints?.keysFor(path) ?? []).flatMap((key) => present.has(key) ? [] : [{
+					key,
+					description: void 0
+				}]);
+			}
+			if (current.type !== "object" && current.type !== "intersect") return [];
+			return fieldsOf(current).flatMap((field) => field.meta.required !== true && readPath(value, [field.key]) === void 0 ? [{
+				key: field.key,
+				description: field.meta.description ?? field.meta.comment
+			}] : []);
+		}
+		/**
+		* 一个字段的可选项。
+		*
+		* 字面量集合的 union（`z.union(["wal", "delete"])`）自己就带着候选；其余看提示面注册的读数——读的时候把依赖的
+		* 兄弟字段值喂进去，所以「选完服务商才列它有哪些模型」是投影的一部分，不是额外的一次订阅。
+		* @param node - 字段节点。
+		* @param path - 该字段的具体路径。
+		* @param value - 段值（草稿后的）。
+		* @param hints - 提示面。
+		* @returns 可选项；没有候选就是 `undefined`。
+		*/
+		function optionsFor(node, path, value, hints) {
+			const current = unwrapLazy(node);
+			if (current?.type === "union" && current.choices !== void 0) return current.choices.map((choice) => ({ value: choice }));
+			const source = declaredSource(current);
+			const spec = source === void 0 ? hints?.selectFor?.(path) : hints?.sourceFor?.(source);
+			if (spec === void 0) return void 0;
+			const parent = path.slice(0, -1);
+			const options = spec.options((relative) => readPath(value, [...parent, ...relative]));
+			return options.length === 0 ? void 0 : options;
+		}
+		/**
+		* 一行配置页的控制器。
+		*/
+		var SchemaFormController = class {
+			#ns;
+			#deps;
+			#model;
+			#store;
+			#disposers = [];
+			#view;
+			#schema;
+			#root;
+			/**
+			* @param ns - settings 命名空间（行 id）。
+			* @param deps - 该行的共享表单与 schema 面。
+			*/
+			constructor(ns, deps) {
+				this.#ns = ns;
+				this.#deps = deps;
+				this.#model = new SchemaDraftModel({
+					scope: deps.form,
+					root: NO_FIELDS,
+					validate: (value) => this.#validate(deps, value)
+				});
+				this.#store = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(this.#project());
+				this.#disposers.push(this.#model.subscribe(() => {
+					this.#store.set(this.#project());
+				}));
+				this.#disposers.push(deps.describe.subscribe(() => {
+					this.#sync();
+				}));
+				deps.describe.ensure();
+				this.#sync();
+			}
+			/** 槽位渲染器要的动作与状态。 */
+			face() {
+				return {
+					hooks: { schemaForm: this.#store },
+					set: (path, value) => {
+						this.#model.set(path, value);
+					},
+					setText: (path, text, parse) => {
+						this.#model.setText(path, text, parse);
+					},
+					clear: (path) => {
+						this.#model.clear(path);
+					},
+					appendItem: (path) => {
+						this.#model.appendItem(path);
+					},
+					removeItem: (path, index) => {
+						this.#model.removeItem(path, index);
+					},
+					addKey: (path, key) => {
+						this.#model.addKey(path, key);
+					},
+					removeKey: (path, key) => {
+						this.#model.removeKey(path, key);
+					},
+					save: () => {
+						this.#model.save();
+					},
+					revert: (path) => {
+						this.#model.revert(path);
+					},
+					discard: () => {
+						this.#model.discard();
+					}
+				};
+			}
+			/** 本行的 settings 命名空间。 */
+			namespace() {
+				return this.#ns;
+			}
+			/** 外部提示（候选键这类）变了：重新投影一次，字段树与草稿都不动。 */
+			refresh() {
+				this.#store.set(this.#project());
+			}
+			/** 释放订阅。 */
+			dispose() {
+				for (const dispose of this.#disposers.splice(0)) dispose();
+				this.#model.dispose();
+			}
+			/** 重新读 schema（describe 变了）：只换字段树，草稿与 store 不动。 */
+			#sync() {
+				const view = this.#deps.describe.getSnapshot().view?.namespaces.find((row) => row.ns === this.#ns);
+				this.#view = view;
+				const projected = view === void 0 ? void 0 : projectRoot(view.schema, this.#deps.rehydrate);
+				this.#schema = projected?.schema;
+				this.#root = projected?.root;
+				this.#model.setRoot(projected?.root ?? NO_FIELDS);
+				this.#store.set(this.#project());
+			}
+			/** 整段校验：schema 先说话，再看数组的项身份有没有冲突。 */
+			#validate(deps, value) {
+				if (this.#schema !== void 0) {
+					const failure = deps.validate(this.#schema, value);
+					if (failure !== void 0) return failure;
+				}
+				if (this.#root === void 0) return void 0;
+				const conflict = mergeKeyConflict(this.#root, value);
+				if (conflict === void 0) return void 0;
+				return {
+					message: conflict.kind === "duplicate" ? deps.t("duplicateItem", {
+						key: conflict.mergeKey,
+						value: conflict.value
+					}) : deps.t("missingItem", { key: conflict.mergeKey }),
+					path: conflict.path
+				};
+			}
+			/** 渲染层读的一份完整投影。 */
+			#project() {
+				const fields = /* @__PURE__ */ new Map();
+				const root = this.#root;
+				const preview = this.#model.preview();
+				const walked = root === void 0 ? [] : walkFields(root, preview);
+				for (const item of walked) fields.set(fieldKey(item.path), this.#model.field(item.path, preview));
+				const secrets = /* @__PURE__ */ new Map();
+				for (const secret of this.#view?.secrets ?? []) secrets.set(fieldKey(secret.path), secret.set);
+				const texts = /* @__PURE__ */ new Map();
+				const options = /* @__PURE__ */ new Map();
+				const addable = /* @__PURE__ */ new Map();
+				for (const item of walked) {
+					const text = this.#deps.hints?.textFor(item.path);
+					if (text !== void 0) texts.set(fieldKey(item.path), text);
+					const candidates = optionsFor(item.node, item.path, preview, this.#deps.hints);
+					if (candidates !== void 0) options.set(fieldKey(item.path), candidates);
+					const addableHere = addableAt(item.node, item.path, readPath(preview, item.path), this.#deps.hints);
+					if (addableHere.length > 0) addable.set(fieldKey(item.path), addableHere);
+				}
+				const violation = this.#model.violation();
+				const invalidAt = /* @__PURE__ */ new Map();
+				if (violation !== void 0 && violation.path.length > 0) invalidAt.set(fieldKey(violation.path), violation.message);
+				return {
+					...this.#model.shell(),
+					configured: root !== void 0,
+					root: root ?? NO_FIELDS,
+					walked,
+					fields,
+					secrets,
+					texts,
+					options,
+					addable,
+					violation,
+					invalidAt
+				};
+			}
+		};
+		//#endregion
+		//#region src/client/schema-form/hints.ts
+		/**
+		* 通用表单的提示面：业务知道、而 schema 表达不了的结构信息。
+		*
+		* 两件事：**dict 字段的候选键**（例如「会话模式」那一行，键是运行期清单里的模式 id，schema 里写不出来），以及
+		* **字段的候选值**（选服务商、选模型这类——候选来自部署里的另一份配置，还经常互相依赖）。业务在客户端注册一个
+		* 同步读数，表单一侧在投影时用它补出「未配置」行或把字段画成选择器。
+		*
+		* 读数必须是**同步**的：投影发生在渲染帧里。异步来源（HTTP / remote）由业务自己取好再注册；注册本身就当作一次
+		* 变更通知（所以"取到清单后再注册"是推荐用法）。
+		*/
+		/** 提示面的完整服务（业务用注册侧，表单一侧用读侧）。 */
+		var SchemaFormHints = class extends _deepseek_ai_cordis.Service {
+			#readers = /* @__PURE__ */ new Map();
+			#texts = /* @__PURE__ */ new Map();
+			#selects = /* @__PURE__ */ new Map();
+			#sources = /* @__PURE__ */ new Map();
+			#listeners = /* @__PURE__ */ new Set();
+			/** @param ctx - 提供本服务的插件上下文。 */
+			constructor(ctx) {
+				super(ctx, "schemaFormHints");
+			}
+			/** @param ns - settings 命名空间。 @param path - 字段路径。 @returns 该处的键。 */
+			keysFor(ns, path) {
+				return lookup(this.#readers, ns, path)?.() ?? [];
+			}
+			/** @param ns - settings 命名空间。 @param path - 字段路径。 @returns 该处注册的文案。 */
+			textFor(ns, path) {
+				return lookup(this.#texts, ns, path)?.() ?? {};
+			}
+			/**
+			* @param ns - settings 命名空间。
+			* @param path - 字段路径。
+			* @param spec - 候选取法与依赖。
+			* @returns 注销函数。
+			*/
+			select(ns, path, spec) {
+				const key = locationKey(ns, path);
+				this.#selects.set(key, spec);
+				this.#publish();
+				return () => {
+					if (this.#selects.get(key) !== spec) return;
+					this.#selects.delete(key);
+					this.#publish();
+				};
+			}
+			/** @param ns - settings 命名空间。 @param path - 字段路径。 @returns 该处注册的候选读数。 */
+			selectFor(ns, path) {
+				return lookup(this.#selects, ns, path);
+			}
+			/**
+			* @param name - 源的名字。
+			* @param spec - 候选取法与依赖。
+			* @returns 注销函数。
+			*/
+			source(name, spec) {
+				this.#sources.set(name, spec);
+				this.#publish();
+				return () => {
+					if (this.#sources.get(name) !== spec) return;
+					this.#sources.delete(name);
+					this.#publish();
+				};
+			}
+			/** @param name - 源的名字。 @returns 该源注册的候选读数。 */
+			sourceFor(name) {
+				return this.#sources.get(name);
+			}
+			/**
+			* @param ns - settings 命名空间。
+			* @param path - 字段路径。
+			* @param read - 同步读数。
+			* @returns 注销函数。
+			*/
+			describe(ns, path, read) {
+				const key = locationKey(ns, path);
+				this.#texts.set(key, read);
+				this.#publish();
+				return () => {
+					if (this.#texts.get(key) !== read) return;
+					this.#texts.delete(key);
+					this.#publish();
+				};
+			}
+			/**
+			* @param ns - settings 命名空间。
+			* @param path - 字段路径。
+			* @param read - 同步读数。
+			* @returns 注销函数。
+			*/
+			suggestKeys(ns, path, read) {
+				const key = locationKey(ns, path);
+				this.#readers.set(key, read);
+				this.#publish();
+				return () => {
+					if (this.#readers.get(key) !== read) return;
+					this.#readers.delete(key);
+					this.#publish();
+				};
+			}
+			/**
+			* 观察候选键的变化（注册与注销）。
+			* @param listener - 变更回调。
+			* @returns 取消订阅。
+			*/
+			subscribe(listener) {
+				this.#listeners.add(listener);
+				return () => {
+					this.#listeners.delete(listener);
+				};
+			}
+			/**
+			* 重新通知一次：读数背后的数据变了（业务自己知道），页面据此重算候选行。
+			*/
+			refresh() {
+				this.#publish();
+			}
+			#publish() {
+				for (const listener of this.#listeners) listener();
+			}
+		};
+		/** 一处字段的定位键（命名空间 + 路径）。 */
+		function locationKey(ns, path) {
+			return `${ns}\u0000${path.join("\0")}`;
+		}
+		/**
+		* 按具体路径找一处注册：先精确匹配，再试**模板变体**（动态键 / 数组下标的段写成 `*`）。
+		*
+		* 业务因此可以注册一次 `models.*.provider` 就覆盖每个模式，不必知道运行期有哪些键。
+		* @param map - 某类注册表。
+		* @param ns - settings 命名空间。
+		* @param path - 具体路径。
+		* @returns 命中的注册，或 `undefined`。
+		*/
+		function lookup(map, ns, path) {
+			const exact = map.get(locationKey(ns, path));
+			if (exact !== void 0) return exact;
+			for (const masked of templates(path)) {
+				const hit = map.get(locationKey(ns, masked));
+				if (hit !== void 0) return hit;
+			}
+		}
+		/** 具体路径的模板变体（首段是顶层字段名，保持原样）：通配得多的先试。 */
+		function* templates(path) {
+			const wildcardable = Math.max(0, path.length - 1);
+			for (let bits = (1 << wildcardable) - 1; bits > 0; bits--) yield path.map((segment, index) => index > 0 && (bits & 1 << index - 1) !== 0 ? "*" : segment);
+		}
+		//#endregion
+		//#region src/client/schema-form/locales.ts
+		/**
+		* 本包字典（命名空间 `settings.schema-form`）：表单壳、字段控件与只读呈现的文案。
+		*
+		* 字段自身的人话标签不在这里（那是业务方经字段槽或 schema `description` 给的），这里只放**机制**文案。
+		*/
+		/** 中文文案（部署语言偏好是 zh）。 */
+		const zh = {
+			unavailable: "该插件当前未加载，暂时无法配置。",
+			readOnly: "本部署的设置为只读。",
+			save: "保存",
+			confirmEdit: "确认",
+			cancelEdit: "取消",
+			saving: "保存中…",
+			saveFailed: "本部署没有接受这些值，已保留供你修改。",
+			notSaved: "没有保存：{message}",
+			noSchema: "这一行没有可自动生成的配置项。",
+			reset: "恢复默认",
+			revert: "撤回",
+			invalid: "这个值不被接受。",
+			invalidNumber: "需要一个数字。",
+			invalidInteger: "需要一个整数。",
+			invalidJson: "需要一段合法的 JSON。",
+			invalidBoolean: "需要 true 或 false。",
+			invalidConst: "这个字段只接受固定值。",
+			invalidPattern: "要匹配 {pattern}。",
+			invalidRange: "要在 {min} 与 {max} 之间。",
+			invalidMin: "不能小于 {min}。",
+			invalidMax: "不能大于 {max}。",
+			invalidChoice: "只能是 {choices} 之一。",
+			unknownProperty: "这一层没有这个字段：从上面的候选里选，或换个键名。",
+			empty: "（空）",
+			toggleGroup: "展开 / 收起这一层",
+			switchVariant: "切换这一层的形状或分支",
+			copyValue: "复制值",
+			copied: "已复制",
+			addProperty: "添加属性",
+			addItemPaste: "添加数组项（可粘贴 JSON 字符串）",
+			addItem: "添加一项",
+			removeItem: "移除",
+			addKey: "添加键（可粘贴 JSON 字符串）",
+			keyName: "键名",
+			noKeys: "还没有键。",
+			noItems: "还没有项。",
+			deprecated: "已废弃",
+			experimental: "试验中",
+			secretSet: "已配置",
+			secretUnset: "未配置",
+			secretHint: "留空即保留已存的值。",
+			constValue: "固定值",
+			notEditable: "这一项由插件在运行时提供，不能在页面上编辑。",
+			recursive: "递归结构：展开到这一层为止。",
+			fixedLength: "固定长度",
+			bitsetHint: "可多选。",
+			unconfigured: "未配置",
+			readOnlyField: "只读",
+			noDescription: "（无说明）",
+			required: "必填",
+			duplicateItem: "重复的 {key}：{value}",
+			missingItem: "每一项都需要一个 {key}"
+		};
+		/** 英文文案。 */
+		const en = {
+			unavailable: "This plugin is not loaded, so it cannot be configured right now.",
+			readOnly: "This deployment stores settings read-only.",
+			save: "Save",
+			confirmEdit: "Confirm",
+			cancelEdit: "Cancel",
+			saving: "Saving…",
+			saveFailed: "This deployment did not accept these values; they are kept for you to fix.",
+			notSaved: "Not saved: {message}",
+			noSchema: "This row has no configuration to generate.",
+			reset: "Reset",
+			revert: "Revert",
+			invalid: "This value is not accepted.",
+			invalidNumber: "Enter a number.",
+			invalidInteger: "Enter a whole number.",
+			invalidJson: "Enter valid JSON.",
+			invalidBoolean: "Enter true or false.",
+			invalidConst: "This field only accepts its fixed value.",
+			invalidPattern: "Must match {pattern}.",
+			invalidRange: "Must be between {min} and {max}.",
+			invalidMin: "Must not be less than {min}.",
+			invalidMax: "Must not be greater than {max}.",
+			invalidChoice: "Must be one of {choices}.",
+			unknownProperty: "No such field at this level: pick one of the candidates above.",
+			empty: "(empty)",
+			toggleGroup: "Expand or collapse this level",
+			switchVariant: "Switch this level's shape or branch",
+			copyValue: "Copy value",
+			copied: "Copied",
+			addProperty: "Add property",
+			addItemPaste: "Add item (a JSON string can be pasted)",
+			addItem: "Add item",
+			removeItem: "Remove",
+			addKey: "Add key (a JSON string can be pasted)",
+			keyName: "Key",
+			noKeys: "No keys yet.",
+			noItems: "No items yet.",
+			deprecated: "deprecated",
+			experimental: "experimental",
+			secretSet: "configured",
+			secretUnset: "not set",
+			secretHint: "Leave blank to keep the stored value.",
+			constValue: "fixed",
+			notEditable: "This entry is provided by the plugin at runtime and cannot be edited here.",
+			recursive: "Recursive structure: expanded down to this level.",
+			fixedLength: "fixed length",
+			bitsetHint: "Multiple choices.",
+			unconfigured: "not configured",
+			readOnlyField: "read-only",
+			noDescription: "(no description)",
+			required: "required",
+			duplicateItem: "Duplicate {key}: {value}",
+			missingItem: "Every item needs a {key}"
+		};
+		//#endregion
+		//#region src/client/schema-form/rows.ts
+		/**
+		* 配对命名空间与 bundle 行清单。
+		* @param namespaces - host 发来的命名空间视图。
+		* @param bundles - host 的 bundle 清单（含各 bundle 声明的行 id）。
+		* @returns 该自动注册的行，按命名空间视图的顺序。
+		*/
+		function rowRegistrations(namespaces, bundles) {
+			const owners = /* @__PURE__ */ new Map();
+			for (const bundle of bundles) for (const row of bundle.rows) owners.set(row.rowId, bundle.name);
+			const plans = [];
+			for (const view of namespaces) {
+				if (view.autoGenerate !== true) continue;
+				const owner = owners.get(view.ns);
+				if (owner === void 0) continue;
+				plans.push({
+					key: `${owner}#${view.ns}`,
+					ns: view.ns
+				});
+			}
+			return plans;
+		}
+		/** 自动项的兜底优先级：手写卡片（默认 0）遮住它。 */
+		const FALLBACK_PRIORITY = 100;
+		/**
+		* 自动注册的差分器：按 describe 与 bundle 清单把「该有的行」与「已在的行」对齐。
+		*/
+		var RowRegistration = class {
+			#deps;
+			#live = /* @__PURE__ */ new Map();
+			#pending;
+			#disposed = false;
+			/**
+			* @param deps - 槽位、清单读面与每行的槽项工厂。
+			*/
+			constructor(deps) {
+				this.#deps = deps;
+			}
+			/**
+			* 对齐一次：新增该有的行，注销不该有的行。
+			*
+			* 并发调用折叠成一次（bundle 清单只读一趟），后到的调用等同一趟结束。
+			* @returns 对齐完成。
+			*/
+			sync() {
+				if (this.#disposed) return Promise.resolve();
+				this.#pending ??= this.#run().finally(() => {
+					this.#pending = void 0;
+				});
+				return this.#pending;
+			}
+			/** 收掉自己：注销还活着的全部注册并释放它们的控制器。 */
+			dispose() {
+				this.#disposed = true;
+				this.#release();
+			}
+			async #run() {
+				const bundles = await this.#deps.bundles();
+				if (this.#disposed) return;
+				const namespaces = this.#deps.describe.getSnapshot().view?.namespaces ?? [];
+				const wanted = /* @__PURE__ */ new Map();
+				for (const plan of rowRegistrations(namespaces, bundles)) {
+					if (this.#deps.entryFor(plan.ns) === void 0) continue;
+					wanted.set(plan.ns, plan);
+				}
+				for (const [ns, dispose] of this.#live) {
+					if (wanted.has(ns)) continue;
+					dispose();
+					this.#live.delete(ns);
+					this.#deps.release(ns);
+				}
+				for (const [ns, plan] of wanted) {
+					if (this.#live.has(ns)) continue;
+					const entry = this.#deps.entryFor(ns);
+					if (entry === void 0) continue;
+					const dispose = this.#deps.slots.register({
+						name: "plugins.row.config",
+						key: plan.key,
+						priority: FALLBACK_PRIORITY,
+						locale: this.#deps.locale
+					}, entry.component);
+					this.#live.set(ns, dispose);
+				}
+			}
+			/** 注销全部并释放控制器。 */
+			#release() {
+				for (const [ns, dispose] of this.#live) {
+					dispose();
+					this.#live.delete(ns);
+					this.#deps.release(ns);
+				}
+			}
+		};
+		//#endregion
+		//#region src/client/schema-form/labels.ts
+		/** 字段的说明（`description` 本地化后 + `comment`），没有就是 undefined。 */
+		function fieldHint(node, resolveText) {
+			const parts = [];
+			if (node.meta.description !== void 0) parts.push(resolveText(node.meta.description));
+			if (node.meta.comment !== void 0) parts.push(node.meta.comment);
+			return parts.length === 0 ? void 0 : parts.join(" ");
+		}
+		//#endregion
+		//#region src/client/schema-form/lines.ts
+		/**
+		* 行模型：把字段树（`walkFields` 的结果）排成**编辑器的行**——结构行（`{` / `[` / `}` / `]`）、字段行、注释行、
+		* 以及容器尾部的添加行。
+		*
+		* 渲染层因此只按行画，不必自己递归：行序 = 视觉顺序，行号连续。折叠在这里生效（折叠的容器只留开启行）。
+		*/
+		/**
+		* 容器的形状：对象类用 `{}`，序列类用 `[]`。
+		*
+		* union 没有自己的形状——它跟着**当前选中那一支**走（`access` 是数组就在页面上画 `[`），这也是
+		* `access: string | string[]` 这类字段以前被画成对象容器的原因。
+		* @param node - 字段节点。
+		* @param value - 这一层的值（选支判据）。
+		* @returns 形状；叶子节点是 `undefined`。
+		*/
+		function containerShape(node, value) {
+			switch (variantOf(node, value).type) {
+				case "object":
+				case "dict":
+				case "intersect": return "object";
+				case "array":
+				case "tuple": return "array";
+				default: return;
+			}
+		}
+		/** 渲染顺序里可见的字段：折叠的容器把整棵子树滤掉，只留它自己的开启行。 */
+		function visibleFields(state, fold) {
+			const containers = new Set(state.walked.filter((item) => containerShape(item.node, valueAt(state, item.path)) !== void 0).map((item) => fieldKey(item.path)));
+			return state.walked.filter((item) => {
+				for (let depth = 1; depth < item.path.length; depth++) {
+					const ancestor = item.path.slice(0, depth);
+					if (containers.has(fieldKey(ancestor)) && fold.collapsed(ancestor)) return false;
+				}
+				return true;
+			});
+		}
+		/** 这一层的当前值：与字段行显示的是同一份读数（草稿优先）。 */
+		function valueAt(state, path) {
+			return state.fields.get(fieldKey(path))?.value;
+		}
+		/** 这一层能加什么：数组追加空项，字典敲键名（可来自候选），对象从还没配的声明字段里选。 */
+		function addOf(node, shape, options) {
+			if (shape === "array") return { kind: "item" };
+			if (unwrapLazy(node)?.type === "dict") return {
+				kind: "key",
+				options
+			};
+			return options.length === 0 ? void 0 : {
+				kind: "prop",
+				options
+			};
+		}
+		/** 一个节点上的变体切换控件：不是 union、或只有一支、或成员全是常量（字面量集合是选择器）时没有。 */
+		function variantsOf(node, value) {
+			const union = unionOf(node);
+			if (union === void 0 || union.choices !== void 0 || union.variants.length < 2) return void 0;
+			return {
+				choices: variantChoices(union),
+				selected: union.variants.indexOf(variantOf(union, value))
+			};
+		}
+		/**
+		* 排成行序列。
+		* @param state - 页面读数。
+		* @param fold - 折叠状态。
+		* @param resolveText - `description` 的本地化。
+		* @param t - 本包字典。
+		* @returns 行序列（行号即下标）。
+		*/
+		function editorLines(state, fold, resolveText, t) {
+			const lines = [];
+			const open = [];
+			const closeOpenUntil = (path) => {
+				while (open.length > 0) {
+					const top = open[open.length - 1];
+					if (isPrefix(top.path, path)) return;
+					open.pop();
+					lines.push({
+						kind: "close",
+						path: top.path,
+						node: top.node,
+						shape: top.shape,
+						depth: top.depth,
+						add: top.add,
+						member: top.member
+					});
+				}
+			};
+			for (const item of visibleFields(state, fold)) {
+				closeOpenUntil(item.path);
+				const node = unwrapLazy(item.node) ?? item.node;
+				const value = valueAt(state, item.path);
+				const depth = item.path.length;
+				const comment = commentFor(state, item, resolveText, t);
+				if (comment !== void 0) lines.push({
+					kind: "comment",
+					path: item.path,
+					depth,
+					text: comment.text,
+					invalid: comment.invalid
+				});
+				const variants = variantsOf(node, value);
+				const shape = containerShape(node, value);
+				if (shape !== void 0) {
+					const collapsed = fold.collapsed(item.path);
+					const add = addOf(node, shape, state.addable.get(fieldKey(item.path)) ?? []);
+					lines.push({
+						kind: "open",
+						path: item.path,
+						node,
+						shape,
+						depth,
+						collapsed,
+						member: item.member,
+						variants
+					});
+					if (!collapsed) open.push({
+						path: item.path,
+						node,
+						shape,
+						depth,
+						add,
+						member: item.member
+					});
+					continue;
+				}
+				lines.push({
+					kind: "field",
+					path: item.path,
+					node,
+					depth,
+					field: state.fields.get(fieldKey(item.path)) ?? {
+						value: void 0,
+						text: void 0,
+						invalid: void 0,
+						overridden: false,
+						staged: false
+					},
+					member: item.member,
+					variants,
+					variantsStandIn: false
+				});
+			}
+			while (open.length > 0) {
+				const top = open.pop();
+				lines.push({
+					kind: "close",
+					path: top.path,
+					node: top.node,
+					shape: top.shape,
+					depth: top.depth,
+					add: top.add,
+					member: top.member
+				});
+			}
+			return moveVariantControlToTag(lines);
+		}
+		/**
+		* 判别式 union 的切换控件挪到**标签字段那一行**上：`session-rdb` 的页面上用户改的就是 `type`，把它放在容器
+		* 行上等于让人在两处看同一件事。没有标签字段（`access` 这种按值形状选的）就留在 union 自己那一行。
+		*/
+		function moveVariantControlToTag(lines) {
+			for (const line of lines) {
+				if (line.kind === "comment" || line.kind === "close") continue;
+				if (line.variants === void 0) continue;
+				const tagKey = unionOf(line.node)?.tagKey;
+				if (tagKey === void 0) continue;
+				const tagPath = [...line.path, tagKey];
+				const tagLine = lines.find((candidate) => candidate.kind === "field" && candidate.path.length === tagPath.length && candidate.path.every((segment, index) => segment === tagPath[index]));
+				if (tagLine === void 0 || tagLine.kind !== "field") continue;
+				tagLine.variants = line.variants;
+				tagLine.variantsStandIn = true;
+				line.variants = void 0;
+			}
+			return lines;
+		}
+		/**
+		* 一行的注释：业务给的文案（字段槽的 label/hint）优先，其次 schema 的说明。
+		*
+		* 这一行有问题时**注释位让给那条消息**（参考实现也是把错误画在行尾那一段的位置上）——说明换成"哪里不对"，
+		* 错误因此不必挤在值后面。
+		*/
+		function commentFor(state, item, resolveText, t) {
+			const key = fieldKey(item.path);
+			const failure = state.fields.get(key)?.invalid ?? state.invalidAt.get(key);
+			if (failure !== void 0) return {
+				text: failure,
+				invalid: true
+			};
+			const node = unwrapLazy(item.node) ?? item.node;
+			const parts = [];
+			const text = state.texts.get(fieldKey(item.path));
+			const hint = [text?.label, text?.hint].filter((part) => part !== void 0 && part !== "").join("：") || fieldHint(node, resolveText);
+			if (hint !== void 0 && hint !== "") parts.push(hint);
+			if (node.meta.disabled) parts.push(t("readOnlyField"));
+			if (node.meta.badges.length > 0) parts.push(node.meta.badges.join(" / "));
+			return parts.length === 0 ? void 0 : {
+				text: parts.join(" · "),
+				invalid: false
+			};
+		}
+		/** `path` 是不是 `prefix` 的后代（含自身）。 */
+		function isPrefix(prefix, path) {
+			if (prefix.length > path.length) return false;
+			return prefix.every((segment, index) => path[index] === segment);
+		}
+		//#endregion
 		//#region src/client/styling/toolkit.ts
 		function isUndefined(value) {
 			return value === void 0;
@@ -324,7 +2127,7 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/theme.generated.ts
 		/**
-		* 官方主题的 `--dsw-*` token 全集（373 个），由 packages/client/ui-primitives/scripts/gen-design-tokens.mts 生成，勿手改。
+		* 官方主题的 `--dsw-*` token 全集（395 个），由 packages/client/ui-primitives/scripts/gen-design-tokens.mts 生成，勿手改。
 		*
 		* 叶子是该变量的**默认值**（官方 light 主题里首次出现的定义）：既是类型推导的来源，也可作 fallback。
 		* `"$"` 键出现在「自身也是 token 的分支」上（命名体系里有 40 个短名同时是长名前缀的 token）。
@@ -334,7 +2137,7 @@ window.__ModuleLoader__.load({
 			alias: {
 				bg: {
 					base: "var(--dsw-static-neutral-bluish-00)",
-					document: { preview: "var(--dsw-static-neutral-bluish-750)" },
+					document: { preview: "var(--dsw-static-neutral-bluish-100)" },
 					layer: {
 						"1": "var(--dsw-static-neutral-bluish-00)",
 						"2": "var(--dsw-static-neutral-bluish-00)",
@@ -428,7 +2231,7 @@ window.__ModuleLoader__.load({
 				label: {
 					caption: "var(--dsw-static-neutral-bluish-400)",
 					dimmed: "var(--dsw-static-neutral-bluish-200)",
-					document: { preview: "var(--dsw-static-neutral-bluish-200)" },
+					document: { preview: "var(--dsw-static-neutral-bluish-700)" },
 					primary: {
 						$: "var(--dsw-static-neutral-bluish-1000)",
 						bluish: "var(--dsw-static-blue-900)",
@@ -456,6 +2259,13 @@ window.__ModuleLoader__.load({
 					placeholder: "var(--dsw-static-neutral-bluish-60)",
 					tag: "var(--dsw-static-neutral-bluish-75)"
 				},
+				menu: { icon: "var(--dsw-static-neutral-bluish-800)" },
+				onboarding: {
+					accent: "rgb(57, 100, 254)",
+					card: { fill: "color-mix(in srgb, var(--dsw-static-neutral-bluish-00) 80%, transparent)" },
+					checkbox: { border: "color-mix(in srgb, var(--dsw-static-neutral-bluish-1000) 20%, transparent)" },
+					secondary: { fill: "var(--dsw-static-neutral-bluish-00)" }
+				},
 				scrollbar: {
 					bg: {
 						l1: "var(--dsw-static-neutral-200)",
@@ -466,6 +2276,10 @@ window.__ModuleLoader__.load({
 						l2: "var(--dsw-static-neutral-300)"
 					}
 				},
+				settings: { card: {
+					fill: "var(--dsw-alias-bg-layer-2)",
+					stroke: "var(--dsw-alias-border-l4)"
+				} },
 				state: {
 					business: {
 						primary: "var(--dsw-static-deepseek-500)",
@@ -488,8 +2302,14 @@ window.__ModuleLoader__.load({
 						tertiary: "var(--dsw-static-amber-100)"
 					}
 				},
-				toast: { bg: "var(--dsw-static-neutral-bluish-800)" },
-				tooltip: { bg: "var(--dsw-static-neutral-bluish-850)" }
+				toast: {
+					bg: "var(--dsw-static-neutral-bluish-800)",
+					label: "var(--dsw-static-neutral-bluish-00)"
+				},
+				tooltip: {
+					bg: "var(--dsw-static-neutral-bluish-850)",
+					key: { bg: "color-mix(in srgb, var(--dsw-alias-tooltip-bg), white 18%)" }
+				}
 			},
 			corner: { shape: "superellipse(1.5)" },
 			elevation: {
@@ -501,6 +2321,10 @@ window.__ModuleLoader__.load({
 					color: "var(--dsw-alias-border-l4)"
 				}
 			},
+			focus: { ring: {
+				color: "transparent",
+				width: "2px"
+			} },
 			font: {
 				base: {
 					"16": {
@@ -524,7 +2348,10 @@ window.__ModuleLoader__.load({
 						line: { height: "24px" }
 					} }
 				},
-				family: "-apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC',\n    'Hiragino Sans GB', 'Microsoft YaHei', 'Helvetica Neue', Helvetica, Arial, sans-serif",
+				family: {
+					$: "-apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC',\n    'Hiragino Sans GB', 'Microsoft YaHei', 'Helvetica Neue', Helvetica, Arial, sans-serif",
+					brand: "'Montserrat', var(--dsw-font-family)"
+				},
 				l: { "20": {
 					$: "500 20px/28px var(--dsw-font-family)",
 					font: {
@@ -816,12 +2643,28 @@ window.__ModuleLoader__.load({
 					} }
 				}
 			},
+			gradient: { onboarding: {
+				blue: { stops: "#3964fe 18.75%, #398efe 51.78%, #6dccff 86.252%, #3964fe" },
+				cyan: { stops: "#0293b4 21.154%, #2dc8eb 50.954%, #aff0ff 85.326%, #0293b4" },
+				violet: { stops: "#2a2fb6 33.102%, #8b76f6 50.954%, #c5c0ff 85.326%, #2a2fb6" }
+			} },
 			linear: {
 				gradient: { think: "linear-gradient(180deg, #fff 20.19%, rgba(255, 255, 255, 0) 100%)" },
 				think: { select: "linear-gradient(180deg, #f5f6f7 20.19%, rgba(245, 246, 247, 0) 100%)" }
 			},
-			mask: { blur: "blur(2px)" },
-			menu: { backdrop: { filter: "blur(40px) saturate(150%)" } },
+			mask: { blur: "none" },
+			menu: {
+				backdrop: { filter: "blur(40px) saturate(150%)" },
+				surface: { fill: "rgba(248, 249, 250, 0.58)" }
+			},
+			radius: {
+				lg: "16px",
+				md: "12px",
+				panel: "28px",
+				sm: "8px",
+				xl: "20px",
+				xs: "4px"
+			},
 			shadow: {
 				lv1: {
 					$: "0 2px 4px 0 rgba(0, 0, 0, 0.05)",
@@ -837,7 +2680,7 @@ window.__ModuleLoader__.load({
 				},
 				input: { major: "var(--dsw-static-neutral-bluish-00)" },
 				login: { input: "var(--dsw-static-neutral-bluish-50)" },
-				menu: "rgba(248, 249, 250, 0.58)",
+				menu: "var(--dsw-menu-surface-fill)",
 				selector: "var(--dsw-static-neutral-bluish-60)",
 				sidebar: {
 					fill: "var(--dsw-static-neutral-bluish-50)",
@@ -894,66 +2737,1277 @@ window.__ModuleLoader__.load({
 						a08: "rgb(34 197 94 / 8%)",
 						a12: "rgb(34 197 94 / 12%)"
 					},
-					"900": "rgb(35, 60, 44)"
-				},
-				neutral: {
-					"50": "rgb(250, 250, 250)",
-					"100": "rgb(245, 245, 245)",
-					"150": "rgb(237, 237, 237)",
-					"200": "rgb(229, 229, 229)",
-					"250": "rgb(220, 220, 220)",
-					"300": "rgb(212, 212, 212)",
-					"400": "rgb(162, 164, 166)",
-					"500": "rgb(127, 130, 135)",
-					"550": "rgb(101, 103, 107)",
-					"600": "rgb(84, 85, 87)",
-					"700": "rgb(60, 60, 61)",
-					"800": "rgb(41, 41, 41)",
-					"850": "rgb(33, 33, 35)",
-					"900": "rgb(15, 15, 15)",
-					"1000": "rgb(0, 0, 0)",
-					"00": "rgb(255, 255, 255)",
-					bluish: {
-						"50": "rgb(249, 250, 251)",
-						"60": "rgb(245, 246, 247)",
-						"75": "rgb(241, 243, 245)",
-						"100": "rgb(235, 238, 242)",
-						"150": "rgb(233, 236, 242)",
-						"200": "rgb(225, 229, 238)",
-						"300": "rgb(207, 211, 214)",
-						"400": "rgb(173, 178, 184)",
-						"500": "rgb(151, 157, 166)",
-						"600": "rgb(129, 133, 140)",
-						"700": "rgb(97, 102, 107)",
-						"750": "rgb(67, 69, 74)",
-						"800": "rgb(53, 54, 56)",
-						"850": "rgb(44, 44, 46)",
-						"875": "rgb(35, 35, 36)",
-						"900": "rgb(27, 27, 28)",
-						"950": "rgb(21, 21, 23)",
-						"1000": "rgb(15, 17, 21)",
-						"00": "rgb(255, 255, 255)"
+					"900": "rgb(35, 60, 44)"
+				},
+				neutral: {
+					"50": "rgb(250, 250, 250)",
+					"100": "rgb(245, 245, 245)",
+					"150": "rgb(237, 237, 237)",
+					"200": "rgb(229, 229, 229)",
+					"250": "rgb(220, 220, 220)",
+					"300": "rgb(212, 212, 212)",
+					"400": "rgb(162, 164, 166)",
+					"500": "rgb(127, 130, 135)",
+					"550": "rgb(101, 103, 107)",
+					"600": "rgb(84, 85, 87)",
+					"700": "rgb(60, 60, 61)",
+					"800": "rgb(41, 41, 41)",
+					"850": "rgb(33, 33, 35)",
+					"900": "rgb(15, 15, 15)",
+					"1000": "rgb(0, 0, 0)",
+					"00": "rgb(255, 255, 255)",
+					bluish: {
+						"50": "rgb(249, 250, 251)",
+						"60": "rgb(245, 246, 247)",
+						"75": "rgb(241, 243, 245)",
+						"100": "rgb(235, 238, 242)",
+						"150": "rgb(233, 236, 242)",
+						"200": "rgb(225, 229, 238)",
+						"300": "rgb(207, 211, 214)",
+						"400": "rgb(173, 178, 184)",
+						"500": "rgb(151, 157, 166)",
+						"600": "rgb(129, 133, 140)",
+						"700": "rgb(97, 102, 107)",
+						"750": "rgb(67, 69, 74)",
+						"800": "rgb(53, 54, 56)",
+						"850": "rgb(44, 44, 46)",
+						"875": "rgb(35, 35, 36)",
+						"900": "rgb(27, 27, 28)",
+						"950": "rgb(21, 21, 23)",
+						"1000": "rgb(15, 17, 21)",
+						"00": "rgb(255, 255, 255)"
+					}
+				},
+				red: {
+					"50": "rgb(254, 242, 242)",
+					"100": "rgb(254, 226, 226)",
+					"400": {
+						$: "rgb(242, 90, 90)",
+						a12: "rgb(242 90 90 / 12%)"
+					},
+					"500": "rgb(239, 68, 68)",
+					"600": {
+						$: "rgb(236, 19, 19)",
+						a08: "rgb(236 19 19 / 8%)"
+					},
+					"900": "rgb(87, 12, 12)"
+				}
+			}
+		};
+		//#endregion
+		//#region src/client/theme.ts
+		const dsw = Token.vars(designTokens, { prefix: "dsw" });
+		//#endregion
+		//#region src/client/schema-form/styles.ts
+		/**
+		* 行式编辑器的样式：等宽、行号、语法色、悬停行为——全部消费官方 `--dsw-*` token。
+		*
+		* 几何只有一套：行高、行内间距、动作按钮尺寸都由下面几个常量给，行与行之间不各自决定。
+		*/
+		/** 等宽字体栈：配置值的观感与代码一致。 */
+		const MONO = "ui-monospace, SFMono-Regular, \"SF Mono\", Menlo, Consolas, monospace";
+		/** 行高：行内容、行内输入、折叠箭头、按钮排都在这一档上对齐。 */
+		const ROW = "22px";
+		/** 行内元素之间的间距。 */
+		const GAP = "6px";
+		/** 动作按钮：方形图标键，尺寸与行高同一档的紧凑版。 */
+		const ACTION = "20px";
+		/** 动作按钮之间的间距（比行内间距紧一档）。 */
+		const ACTION_GAP = "4px";
+		/** 折叠列（chevron 与它的占位）宽度。 */
+		const FOLD = "14px";
+		/** 行号列宽度。 */
+		const NUMBER = "32px";
+		/** 行尾留白。 */
+		const PAD = "8px";
+		/** 细线：theme 给的 0.5px 描边（`0 0 0 0.5px var(--dsw-elevation-stroke-color)`）。 */
+		const HAIRLINE = dsw.elevation.stroke;
+		/** 描边色：theme 里给描边用的那一档（与官方 `Menu` 面板同源）。 */
+		const LINE = dsw.elevation.stroke.color;
+		/** 行左侧那道「改过」的标记宽度。 */
+		const EDGE = "2px";
+		/** 出错那一行的底色：theme 的红掺进透明里（半透明红），比整行实红轻、又比只有一道条明显。 */
+		const ERROR_WASH = `color-mix(in srgb, ${String(dsw.alias.state.error.secondary)} 12%, transparent)`;
+		/** 编辑器的根：纵向排列的行。 */
+		const EditorRoot = styled("div")({
+			display: "flex",
+			flexDirection: "column",
+			width: "100%",
+			fontFamily: MONO,
+			fontSize: "14px",
+			lineHeight: ROW,
+			color: dsw.alias.label.primary
+		});
+		/** 一行：行号 + 折进 + 行内容。悬停给一层浅底。 */
+		const LineRow = styled("div")({
+			display: "flex",
+			alignItems: "flex-start",
+			gap: GAP,
+			minHeight: ROW,
+			paddingRight: PAD,
+			whiteSpace: "nowrap",
+			"&:hover": { background: dsw.alias.bg.layer["2"] },
+			"&[data-selected='true']": { background: dsw.alias.bg.layer["3"] },
+			"&[data-dirty='true']": { boxShadow: `inset ${EDGE} 0 0 ${String(dsw.alias.brand.primary)}` },
+			"&[data-overridden='true']": { boxShadow: `inset ${EDGE} 0 0 ${String(LINE)}` },
+			"&[data-dirty='true'] [data-role='key']": { color: dsw.alias.brand.primary },
+			"&[data-overridden='true'] [data-role='key']": { color: dsw.alias.brand.primary },
+			"&[data-invalid='true']": {
+				background: ERROR_WASH,
+				boxShadow: `inset ${EDGE} 0 0 ${String(dsw.alias.state.error.primary)}`
+			},
+			"&[data-invalid='true'] [data-role='key']": { color: dsw.alias.state.error.primary },
+			"&:hover [data-role='actions']": { opacity: 1 }
+		});
+		/** 一行的内容区：**缩进只作用在这里**——行号列固定在左边，缩进不推它。 */
+		const LineBody = styled("div")({
+			display: "flex",
+			alignItems: "center",
+			gap: GAP,
+			flex: 1,
+			minWidth: 0,
+			minHeight: ROW
+		});
+		/** 行号列：右对齐、不可选、淡色。 */
+		const LineNumber = styled("span")({
+			flex: "none",
+			width: NUMBER,
+			lineHeight: ROW,
+			textAlign: "right",
+			color: dsw.alias.label.caption,
+			userSelect: "none",
+			cursor: "pointer"
+		});
+		/** 折叠 chevron（官方箭头图标，尺寸与别的行内图标同源）。 */
+		const LineFold = styled("button")({
+			display: "inline-flex",
+			alignItems: "center",
+			justifyContent: "center",
+			flex: "none",
+			width: FOLD,
+			height: ROW,
+			padding: 0,
+			border: 0,
+			background: "none",
+			color: dsw.alias.label.caption,
+			cursor: "pointer",
+			"&:hover": { color: dsw.alias.label.secondary }
+		});
+		/** 叶子行的折叠占位（保持列对齐）。 */
+		const LineFoldSpacer = styled("span")({
+			flex: "none",
+			width: FOLD
+		});
+		/** 键名（配置键原样；数组下标淡一些）。 */
+		const LineKey = styled("span")({
+			flex: "none",
+			color: dsw.alias.label.primary,
+			"&[data-index='true']": { color: dsw.alias.label.caption }
+		});
+		/** 结构符与标点（`{` `}` `[` `]` `:`）。 */
+		const LineToken = styled("span")({
+			flex: "none",
+			color: dsw.alias.label.caption
+		});
+		/** 值（token）：字符串 / 数字 / 布尔各有语法色。 */
+		const LineValue = styled("span")({
+			minWidth: 0,
+			overflow: "hidden",
+			textOverflow: "ellipsis",
+			cursor: "text",
+			color: dsw.alias.state.business.primary,
+			"&[data-tone='number']": { color: dsw.alias.state.warn.primary },
+			"&[data-tone='boolean']": { color: dsw.alias.state.success.primary },
+			"&[data-tone='empty']": { color: dsw.alias.label.caption }
+		});
+		/**
+		* 值上的下拉触发：**它自己就是值的呈现**（不再是「值 + 一个下拉」两遍），点开才出菜单。
+		*/
+		const ValueTrigger = styled("button")({
+			display: "inline-flex",
+			alignItems: "center",
+			gap: "2px",
+			minWidth: 0,
+			padding: 0,
+			border: 0,
+			background: "none",
+			font: "inherit",
+			textAlign: "left",
+			cursor: "pointer",
+			color: dsw.alias.label.caption,
+			"&:disabled": { cursor: "default" },
+			"&:focus-visible": { outline: "none" }
+		});
+		/**
+		* 行内输入的外壳：官方 `Input` 压到与值同一行高，并**吃掉剩下的宽度**。
+		*
+		* 行内编辑与容器闭合行的添加输入共用它——两处的输入框因此长得一模一样。
+		*/
+		const CompactInput = styled("span")({
+			display: "inline-flex",
+			flex: "1 1 auto",
+			minWidth: 0,
+			"& > span": {
+				width: "100%",
+				height: ROW,
+				padding: "0 6px",
+				borderRadius: "4px"
+			},
+			"& input": {
+				fontSize: "14px",
+				lineHeight: ROW
+			}
+		});
+		/**
+		* 多行值的行内输入：官方没有多行原子，所以这里用同一套观感的字段壳（同边框、同圆角、同焦点色），
+		* 高度跟着内容长、宽度同样撑满剩下的位置。
+		*/
+		const CompactTextField = styled("span")({
+			display: "inline-flex",
+			flex: "1 1 auto",
+			minWidth: 0,
+			padding: "0 6px",
+			borderRadius: "4px",
+			background: dsw.alias.bg.layer["1"],
+			border: 0,
+			boxShadow: HAIRLINE,
+			"&:focus-within": { "--dsw-elevation-stroke-color": dsw.alias.brand.primary },
+			"& > textarea": {
+				flex: 1,
+				width: "100%",
+				minHeight: ACTION,
+				maxHeight: "240px",
+				padding: 0,
+				border: 0,
+				outline: "none",
+				background: "transparent",
+				resize: "none",
+				fieldSizing: "content",
+				fontFamily: "inherit",
+				fontSize: "14px",
+				lineHeight: ROW,
+				color: dsw.alias.label.primary
+			}
+		});
+		/** 行内注释（schema 说明与业务文案）：比配置值小一档，占满这一行剩下的宽度，长了就截断（hover 看全文）。 */
+		const LineComment = styled("span")({
+			flex: "1 1 auto",
+			minWidth: 0,
+			overflow: "hidden",
+			textOverflow: "ellipsis",
+			color: dsw.alias.label.tertiary,
+			fontFamily: "inherit",
+			fontSize: "12px"
+		});
+		/** 行内的校验消息（与注释放同一档字号）。 */
+		const LineInvalid = styled("span")({
+			flex: "none",
+			color: dsw.alias.state.error.primary,
+			fontFamily: "inherit",
+			fontSize: "12px"
+		});
+		/**
+		* 悬停行时才显示这一行的动作按钮：显形规则写在行上（`[data-role='actions']`），组件只需要带这个属性。
+		*/
+		const HoverActions = styled(styled("span")({
+			display: "inline-flex",
+			alignItems: "center",
+			gap: ACTION_GAP,
+			flex: "none",
+			opacity: 0,
+			"& > button": {
+				display: "inline-flex",
+				alignItems: "center",
+				justifyContent: "center",
+				width: ACTION,
+				height: ACTION,
+				padding: 0,
+				border: 0,
+				borderRadius: "4px",
+				background: "none",
+				color: dsw.alias.label.secondary,
+				cursor: "pointer",
+				"&:hover": {
+					background: dsw.alias.bg.layer["3"],
+					color: dsw.alias.label.primary
+				},
+				"&:disabled": {
+					cursor: "not-allowed",
+					color: dsw.alias.label.dimmed
+				}
+			}
+		}))({ 
+		/**
+		* 编辑态的两个按钮常显，而且**要有底色与描边**：行底色上只有淡色图标是看不见的，
+		* 所以这里给实体按钮（theme 的描边 + 一层底），确认用成功档、取消用中性档。
+		*/
+"&[data-editing='true']": {
+			opacity: 1,
+			gap: GAP,
+			"& > button": {
+				boxShadow: HAIRLINE,
+				background: dsw.alias.bg.layer["1"],
+				color: dsw.alias.label.primary,
+				"&:first-of-type": { color: dsw.alias.state.success.primary }
+			}
+		} });
+		/** 添加输入：**跟在容器的闭合括号同一行**（菜单锚在它上面），宽度吃掉剩下的位置。 */
+		const AddWrap = styled("span")({
+			position: "relative",
+			display: "inline-flex",
+			alignItems: "center",
+			gap: GAP,
+			flex: "1 1 auto",
+			minWidth: 0,
+			marginLeft: GAP,
+			"&[data-invalid='true'] input": { borderColor: dsw.alias.state.error.primary }
+		});
+		/** 一行说明（不可用 / 没有可生成项时用）。 */
+		const Hint$1 = styled("p")({
+			margin: 0,
+			fontSize: "12px",
+			lineHeight: 1.5,
+			color: dsw.alias.label.tertiary
+		});
+		//#endregion
+		//#region src/client/schema-form/value.tsx
+		/**
+		* 行内值的呈现与编辑文本规则，以及字段槽注册方复用的默认值组件。
+		*
+		* 值本身仍走草稿：这个文件只决定"怎么显示"（语法色 token、下拉触发的呈现）与"怎么编辑"（一行输入框里的文本
+		* 形状——字符串把换行写成 `\n`，与一行的输入框相配）。
+		*/
+		/** 编辑态文本：字符串就是原文（换行照旧），其余按 JSON 写。 */
+		function valueText(value) {
+			if (value === void 0 || value === null) return "";
+			if (typeof value === "string") return value;
+			if (typeof value === "number" || typeof value === "boolean") return String(value);
+			return JSON.stringify(value);
+		}
+		/** 这个值要在多行输入里编辑吗（字符串带换行）。 */
+		function isMultiline(value) {
+			return typeof value === "string" && /[\r\n]/.test(value);
+		}
+		/** 显示态文本：字符串带引号；多行与特殊字符都按 JSON 的写法收在一行里。 */
+		function tokenText(value) {
+			if (value === void 0 || value === null) return "null";
+			if (typeof value === "string") return JSON.stringify(value);
+			if (typeof value === "number" || typeof value === "boolean") return String(value);
+			return JSON.stringify(value);
+		}
+		/** 值的语法色分组。 */
+		function tokenTone(value) {
+			if (value === void 0 || value === null) return "empty";
+			if (typeof value === "number") return "number";
+			if (typeof value === "boolean") return "boolean";
+			return "string";
+		}
+		/**
+		* 行内值的默认呈现（显示态 token）。
+		* @param props.owner - 字段上下文（值、是否 secret、只读原因）。
+		* @returns 一行里的值节点。
+		*/
+		function InlineValue({ owner }) {
+			if (owner.options !== void 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OptionSelect, {
+				owner,
+				options: owner.options
+			});
+			if (owner.node.meta.secret) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineValue, {
+				"data-tone": "empty",
+				title: owner.hint,
+				children: owner.secretConfigured ? "••••••" : ""
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineValue, {
+				"data-tone": owner.node.readOnly === null ? tokenTone(owner.value) : "empty",
+				title: tokenText(owner.value),
+				children: tokenText(owner.value)
+			});
+		}
+		/**
+		* 选择器：**值本身**就是下拉的触发（不再另画一个 `select` 与它并列），点开是官方菜单。
+		*
+		* 当前值不在候选里时（例如目录里已经没有那个服务商）照原样显示，选中才换成新值。
+		*/
+		function OptionSelect({ owner, options }) {
+			const [open, setOpen] = (0, react.useState)(false);
+			const selected = options.findIndex((option) => sameValue(option.value, owner.value));
+			const current = selected < 0 ? void 0 : options[selected];
+			const label = current?.label ?? (owner.value === void 0 ? owner.t("unconfigured") : tokenText(current?.value ?? owner.value));
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Menu, {
+				open,
+				dense: true,
+				compact: true,
+				portal: true,
+				align: "start",
+				items: options.map((option, index) => ({
+					id: String(index),
+					label: option.label ?? tokenText(option.value)
+				})),
+				selectedId: selected < 0 ? void 0 : String(selected),
+				onSelect: (id) => {
+					setOpen(false);
+					const option = options[Number(id)];
+					if (option !== void 0) owner.onChange(option.value);
+				},
+				onClose: () => {
+					setOpen(false);
+				},
+				anchor: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(ValueTrigger, {
+					type: "button",
+					disabled: owner.disabled,
+					"aria-label": owner.label,
+					onClick: () => {
+						setOpen(true);
+					},
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineValue, {
+						"data-tone": current === void 0 ? tokenTone(owner.value) : tokenTone(current.value),
+						children: label
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronDownOutlineRegular, { size: 14 })]
+				})
+			});
+		}
+		/** 值是否就是这一项（菜单的高亮判据）。 */
+		function sameValue(left, right) {
+			if (Object.is(left, right)) return true;
+			if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+			return JSON.stringify(left) === JSON.stringify(right);
+		}
+		/**
+		* 字段槽注册方复用的默认值：只改文案时拿它包一层即可（`owner` 上覆盖 `label`/`hint`）。
+		*
+		* 注意行式视图里键名来自配置键本身、注释来自 `hint`，所以 `label` 只在业务自写控件时才需要。
+		*/
+		function SchemaFieldDefault({ owner }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(InlineValue, { owner });
+		}
+		//#endregion
+		//#region src/client/schema-form/fields.tsx
+		/**
+		* 各类型的文本解析规则（消息来自本包字典）。
+		*
+		* 解析不只看类型：schema 上声明的界限（`pattern` / `min` / `max` / `step`）与字面量集合都在这里说话——
+		* 用户敲完当场就知道对不对，而不是等保存时被整段校验退回。
+		* @param node - 字段节点（`meta` 是约束的来源）。
+		* @param t - 本包字典。
+		* @returns 这段文本的解析规则。
+		*/
+		function parseFor(node, t) {
+			switch (node.type) {
+				case "number": return (text) => {
+					const trimmed = text.trim();
+					const value = Number(trimmed);
+					if (trimmed === "" || !Number.isFinite(value)) return {
+						kind: "invalid",
+						message: t("invalidNumber")
+					};
+					if (node.meta.step === 1 && !Number.isInteger(value)) return {
+						kind: "invalid",
+						message: t("invalidInteger")
+					};
+					const { min, max } = node.meta;
+					if (min !== void 0 && max !== void 0 && (value < min || value > max)) return {
+						kind: "invalid",
+						message: t("invalidRange", {
+							min,
+							max
+						})
+					};
+					if (min !== void 0 && value < min) return {
+						kind: "invalid",
+						message: t("invalidMin", { min })
+					};
+					if (max !== void 0 && value > max) return {
+						kind: "invalid",
+						message: t("invalidMax", { max })
+					};
+					return {
+						kind: "value",
+						value
+					};
+				};
+				case "string": {
+					const pattern = node.meta.pattern;
+					if (pattern === void 0) return (text) => ({
+						kind: "value",
+						value: text
+					});
+					return (text) => new RegExp(pattern).test(text) ? {
+						kind: "value",
+						value: text
+					} : {
+						kind: "invalid",
+						message: t("invalidPattern", { pattern })
+					};
+				}
+				case "boolean": return (text) => {
+					const trimmed = text.trim();
+					if (trimmed === "true") return {
+						kind: "value",
+						value: true
+					};
+					if (trimmed === "false") return {
+						kind: "value",
+						value: false
+					};
+					return {
+						kind: "invalid",
+						message: t("invalidBoolean")
+					};
+				};
+				case "const": return (text) => text === String(node.type === "const" ? node.value : "") || text.trim() === JSON.stringify(node.value) ? {
+					kind: "value",
+					value: node.value
+				} : {
+					kind: "invalid",
+					message: t("invalidConst")
+				};
+				case "bitset": return (text) => {
+					const value = Number(text.trim());
+					return Number.isFinite(value) ? {
+						kind: "value",
+						value
+					} : {
+						kind: "invalid",
+						message: t("invalidNumber")
+					};
+				};
+				case "any": return (text) => {
+					try {
+						return {
+							kind: "value",
+							value: JSON.parse(text)
+						};
+					} catch {
+						return {
+							kind: "invalid",
+							message: t("invalidJson")
+						};
+					}
+				};
+				default:
+					if (node.type === "union" && node.choices !== void 0) {
+						const choices = node.choices;
+						const options = choices.map((choice) => String(choice)).join(" / ");
+						return (text) => choices.some((choice) => String(choice) === text) ? {
+							kind: "value",
+							value: text
+						} : {
+							kind: "invalid",
+							message: t("invalidChoice", { choices: options })
+						};
+					}
+					return (text) => ({
+						kind: "value",
+						value: text
+					});
+			}
+		}
+		//#endregion
+		//#region src/client/schema-form/Editor.tsx
+		/**
+		* 行式编辑器：按 `editorLines` 排出的行画 JSON 结构视图——行号、折进、`key: value`、结构行、注释行、容器闭合行
+		* 后面的添加入口；值在行内点开编辑（Enter 提交 / Esc 撤销）。
+		*
+		* 缩进只作用在**行内容**上（行号列固定），添加输入与闭合括号同一行；行内控件用官方的 `Input` / `Menu` / `Button`，
+		* 与设置页其余部分同一套视觉与键盘行为。
+		*
+		* 字段槽仍然生效：命中时该字段**值**的位置换成注册方的组件，键名、注释、行号与行为按钮仍由这里画。
+		*/
+		/**
+		* 画一行的配置。
+		* @param props - 读数、动作、字典与字段槽入口。
+		* @returns 行式编辑器。
+		*/
+		function Editor(props) {
+			const { ns, state, face, t, resolveText, renderField } = props;
+			const [toggled, setToggled] = (0, react.useState)(() => /* @__PURE__ */ new Set());
+			const [editing, setEditing] = (0, react.useState)(void 0);
+			const [selected, setSelected] = (0, react.useState)(void 0);
+			const [dismissed, setDismissed] = (0, react.useState)(() => /* @__PURE__ */ new Set());
+			const fold = useFold(state, toggled, setToggled);
+			const lines = (0, react.useMemo)(() => editorLines(state, fold, resolveText, t), [
+				state,
+				fold,
+				resolveText,
+				t
+			]);
+			const disabled = !state.writable || !state.available;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(EditorRoot, {
+				"data-editor": "schema-form",
+				children: lines.map((line, index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+					line,
+					n: index + 1,
+					ns,
+					state,
+					face,
+					fold,
+					t,
+					resolveText,
+					disabled,
+					editing,
+					selected,
+					onEdit: (key) => {
+						setEditing(key);
+						if (key !== void 0) setDismissed((previous) => {
+							const next = new Set(previous);
+							next.delete(key);
+							return next;
+						});
+					},
+					onAdded: (path) => {
+						setEditing(fieldKey(path));
+					},
+					dismissed,
+					onDismiss: (key) => {
+						setDismissed((previous) => new Set(previous).add(key));
+					},
+					onSelect: (path) => {
+						setSelected(fieldKey(path));
+					},
+					renderField
+				}, `${line.kind}:${fieldKey(line.path)}:${String(index)}`))
+			});
+		}
+		/** 折叠状态：记「用户切换过的路径」，开合 = 切换过就反转 schema 的默认值。 */
+		function useFold(state, toggled, setToggled) {
+			const defaults = (0, react.useMemo)(() => {
+				const collapsed = /* @__PURE__ */ new Set();
+				for (const item of state.walked) {
+					const value = state.fields.get(fieldKey(item.path))?.value;
+					if (item.node.meta.collapse && containerShape(item.node, value) !== void 0) collapsed.add(fieldKey(item.path));
+				}
+				return collapsed;
+			}, [state.walked, state.fields]);
+			return (0, react.useMemo)(() => ({
+				collapsed: (path) => {
+					const key = fieldKey(path);
+					return toggled.has(key) !== defaults.has(key);
+				},
+				toggle: (path) => {
+					const key = fieldKey(path);
+					const next = new Set(toggled);
+					if (next.has(key)) next.delete(key);
+					else next.add(key);
+					setToggled(next);
+				}
+			}), [
+				defaults,
+				setToggled,
+				toggled
+			]);
+		}
+		/** 一行的渲染分派。 */
+		function Row({ line, n, ns, state, face, fold, t, resolveText, disabled, editing, selected, dismissed, onEdit, onAdded, onDismiss, onSelect, renderField }) {
+			const key = fieldKey(line.path);
+			const indent = { paddingLeft: `${String(line.depth * 14)}px` };
+			const body = line.kind === "comment" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineFoldSpacer, { "data-role": "fold" }), line.invalid ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineInvalid, {
+				title: line.text,
+				children: `// ${line.text}`
+			}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineComment, {
+				title: line.text,
+				children: `// ${line.text}`
+			})] }) : line.kind === "open" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineFold, {
+					"data-role": "fold",
+					type: "button",
+					"aria-expanded": !line.collapsed,
+					"aria-label": t("toggleGroup"),
+					onClick: () => {
+						fold.toggle(line.path);
+					},
+					children: line.collapsed ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronRightOutlineRegular, { size: 14 }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronDownOutlineRegular, { size: 14 })
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LinePrefix, {
+					line,
+					face,
+					t,
+					disabled
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineToken, { children: line.shape === "object" ? line.collapsed ? "{…}" : "{" : line.collapsed ? "[…]" : "[" }),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(VariantSelect, {
+					control: line.variants,
+					path: line.path,
+					face,
+					disabled,
+					t
+				})
+			] }) : line.kind === "close" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineFoldSpacer, { "data-role": "fold" }),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineToken, { children: line.shape === "object" ? "}" : "]" }),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AddLine, {
+					line,
+					state,
+					face,
+					t,
+					resolveText,
+					disabled,
+					onAdded
+				})
+			] }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FieldLine, {
+				line,
+				ns,
+				state,
+				face,
+				t,
+				disabled,
+				editing,
+				dismissed,
+				onEdit,
+				onDismiss,
+				renderField
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(LineRow, {
+				"data-line": line.kind,
+				"data-field-path": line.path.join("."),
+				"data-selected": selected === key ? "true" : void 0,
+				"data-dirty": line.kind === "field" && line.field.staged ? "true" : void 0,
+				"data-overridden": line.kind === "field" && line.field.overridden && !line.field.staged ? "true" : void 0,
+				"data-invalid": line.kind === "field" && (line.field.invalid !== void 0 || state.invalidAt.has(key)) ? "true" : void 0,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineNumber, {
+					"data-role": "number",
+					onClick: () => {
+						onSelect(line.path);
+					},
+					children: n
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineBody, {
+					"data-role": "body",
+					style: indent,
+					children: body
+				})]
+			});
+		}
+		/** 字段行：`key: value`（数组成员的键名是下标，淡一些）。 */
+		function FieldLine({ line, ns, state, face, t, disabled, editing, dismissed, onEdit, onDismiss, renderField }) {
+			const key = fieldKey(line.path);
+			const member = line.member;
+			const owner = {
+				ns,
+				path: line.path,
+				node: line.node,
+				label: line.node.label ?? member?.key ?? line.node.key,
+				hint: void 0,
+				value: line.field.value,
+				options: state.options.get(key),
+				text: line.field.text,
+				secretConfigured: state.secrets.get(key) === true,
+				depth: line.depth,
+				overridden: line.field.overridden,
+				invalid: line.field.invalid,
+				disabled,
+				t,
+				actions: face,
+				group: void 0,
+				member,
+				onChange: (value) => {
+					face.set(line.path, value);
+				},
+				onEditText: (text, parse) => {
+					face.setText(line.path, text, parse ?? parseFor(line.node, t));
+				},
+				onReset: () => {
+					face.clear(line.path);
+				}
+			};
+			const readOnly = line.node.meta.disabled || line.node.readOnly !== null;
+			const editable = !disabled && !readOnly && line.node.type !== "const" && owner.options === void 0 && !line.variantsStandIn;
+			const missing = line.field.value === null || line.field.value === void 0;
+			const isEditing = editable && (editing === key || missing && !dismissed.has(key));
+			const text = line.field.text ?? valueText(line.field.value);
+			const multiline = isMultiline(line.field.value) || /[\r\n]/.test(text);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineFoldSpacer, { "data-role": "fold" }),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineKey, {
+					"data-role": "key",
+					"data-index": member?.index === void 0 ? void 0 : "true",
+					title: member?.key ?? line.node.key,
+					children: member?.key ?? line.node.key
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineToken, { children: member?.index === void 0 ? ": " : "  " }),
+				isEditing ? multiline ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CompactTextField, { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+					autoFocus: !missing,
+					rows: 1,
+					"aria-label": owner.label,
+					value: text,
+					onChange: (event) => {
+						owner.onEditText(event.target.value);
+					},
+					onKeyDown: (event) => {
+						if (event.key === "Escape") {
+							face.revert(line.path);
+							onEdit(void 0);
+						}
+					}
+				}) }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CompactInput, { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Input, {
+					autoFocus: !missing,
+					type: "text",
+					"aria-label": owner.label,
+					placeholder: missing ? t("empty") : "",
+					value: text,
+					onBlur: () => {
+						if (!missing) onEdit(void 0);
+					},
+					onChange: (event) => {
+						owner.onEditText(event.target.value);
+					},
+					onKeyDown: (event) => {
+						if (event.key === "Enter" && !missing) onEdit(void 0);
+						if (event.key === "Escape") {
+							face.revert(line.path);
+							onEdit(void 0);
+						}
 					}
-				},
-				red: {
-					"50": "rgb(254, 242, 242)",
-					"100": "rgb(254, 226, 226)",
-					"400": {
-						$: "rgb(242, 90, 90)",
-						a12: "rgb(242 90 90 / 12%)"
+				}) }) : null,
+				isEditing || line.variantsStandIn ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					onClick: () => {
+						if (editable) onEdit(key);
 					},
-					"500": "rgb(239, 68, 68)",
-					"600": {
-						$: "rgb(236, 19, 19)",
-						a08: "rgb(236 19 19 / 8%)"
+					children: renderField(owner)
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(VariantSelect, {
+					control: line.variants,
+					path: line.path,
+					face,
+					disabled,
+					t
+				}),
+				isEditing ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(HoverActions, {
+					"data-role": "actions",
+					"data-editing": "true",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						"aria-label": t("confirmEdit"),
+						title: t("confirmEdit"),
+						onClick: () => {
+							onEdit(void 0);
+						},
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconCheckOutlineRegular, { size: 14 })
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						"aria-label": t("cancelEdit"),
+						title: t("cancelEdit"),
+						onClick: () => {
+							face.revert(line.path);
+							onEdit(void 0);
+							onDismiss(key);
+						},
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconCloseOutlineRegular, { size: 14 })
+					})]
+				}) : null,
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(HoverActions, {
+					"data-role": "actions",
+					children: [
+						line.field.staged && !disabled ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							"aria-label": t("revert"),
+							title: t("revert"),
+							onClick: () => {
+								face.revert(line.path);
+							},
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconRefreshOutlineRegular, { size: 14 })
+						}) : null,
+						line.field.overridden && !line.field.staged && !disabled ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							"aria-label": t("reset"),
+							title: t("reset"),
+							onClick: () => {
+								face.clear(line.path);
+							},
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconRefreshOutlineRegular, { size: 14 })
+						}) : null,
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							"aria-label": t("copyValue"),
+							title: t("copyValue"),
+							onClick: () => {
+								navigator.clipboard?.writeText(line.field.text ?? tokenFor(line.field.value)).catch(() => {});
+							},
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconCopyOutlineRegular, { size: 14 })
+						}),
+						member === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RemoveLineButton, {
+							member,
+							face,
+							t,
+							disabled
+						})
+					]
+				})
+			] });
+		}
+		/** 复制用的文本（字符串带引号，粘到哪里都是合法片段）。 */
+		function tokenFor(value) {
+			return typeof value === "string" ? JSON.stringify(value) : JSON.stringify(value ?? null);
+		}
+		/** 变体切换：判别式 union 挂在标签行上，按形状选的挂在字段行上。触发元素就是当前那一支。 */
+		function VariantSelect({ control, path, face, disabled, t }) {
+			const [open, setOpen] = (0, react.useState)(false);
+			if (control === void 0) return null;
+			const current = control.choices[control.selected];
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Menu, {
+				open,
+				dense: true,
+				compact: true,
+				portal: true,
+				align: "start",
+				items: control.choices.map((choice, index) => ({
+					id: String(index),
+					label: choice.label
+				})),
+				selectedId: String(control.selected),
+				onSelect: (id) => {
+					setOpen(false);
+					const choice = control.choices[Number(id)];
+					if (choice !== void 0) face.set(path, choice.value);
+				},
+				onClose: () => {
+					setOpen(false);
+				},
+				anchor: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(ValueTrigger, {
+					type: "button",
+					"data-role": "variant",
+					disabled,
+					"aria-label": t("switchVariant"),
+					onClick: () => {
+						setOpen(true);
 					},
-					"900": "rgb(87, 12, 12)"
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineValue, {
+						"data-tone": "empty",
+						children: current?.label ?? ""
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronDownOutlineRegular, { size: 14 })]
+				})
+			});
+		}
+		/** 开启行的前缀：字段键名（对象里的一层）或数组成员的下标；成员行另外带移除。 */
+		function LinePrefix({ line, face, t, disabled }) {
+			const member = line.member;
+			const key = member?.key ?? line.node.key;
+			if (key === "") return null;
+			const indexed = member !== void 0 && member.index !== void 0;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineKey, {
+					"data-role": "key",
+					"data-index": indexed ? "true" : void 0,
+					title: key,
+					children: key
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineToken, { children: indexed ? "  " : ": " }),
+				member === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(HoverActions, {
+					"data-role": "actions",
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RemoveLineButton, {
+						member,
+						face,
+						t,
+						disabled
+					})
+				})
+			] });
+		}
+		/** 成员行的移除（悬停时出现）：数组项按索引、字典键按键名。 */
+		function RemoveLineButton({ member, face, t, disabled }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+				type: "button",
+				"aria-label": t("removeItem"),
+				title: t("removeItem"),
+				disabled,
+				onClick: () => {
+					if (member.index === void 0) face.removeKey(member.parent, member.key);
+					else face.removeItem(member.parent, member.index);
+				},
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconTrashOutlineRegular, { size: 14 })
+			});
+		}
+		/**
+		* 容器闭合行后面的添加入口。
+		*
+		* 数组是「追加一个空项」；对象/字典给出**候选**——对象列的是 schema 声明了、值里还没有的字段（带说明），
+		* 字典列的是业务注册的候选键（还能自己敲键名）。粘一整段 `{…}` / `[…]` 则整层覆盖。
+		*/
+		function AddLine({ line, state, face, t, resolveText, disabled, onAdded }) {
+			const spec = line.add;
+			const [text, setText] = (0, react.useState)("");
+			const [open, setOpen] = (0, react.useState)(false);
+			const [invalid, setInvalid] = (0, react.useState)(false);
+			if (spec === void 0 || disabled) return null;
+			const options = spec.kind === "item" ? [] : spec.options;
+			const query = text.trim().toLowerCase();
+			const matched = options.filter((option) => query === "" || option.key.toLowerCase().includes(query));
+			const label = spec.kind === "item" ? t("addItemPaste") : spec.kind === "key" ? t("addKey") : t("addProperty");
+			const commit = (picked) => {
+				const raw = (picked ?? text).trim();
+				if (raw === "") return;
+				setInvalid(false);
+				if (raw.startsWith("{") || raw.startsWith("[")) try {
+					face.set(line.path, JSON.parse(raw));
+					setText("");
+					setOpen(false);
+					return;
+				} catch {}
+				if (spec.kind === "key") {
+					face.addKey(line.path, raw);
+					onAdded([...line.path, raw]);
+				} else if (spec.kind === "item") {
+					const current = state.fields.get(fieldKey(line.path))?.value;
+					const index = Array.isArray(current) ? current.length : 0;
+					face.appendItem(line.path);
+					onAdded([...line.path, String(index)]);
+				} else {
+					if (!spec.options.some((option) => option.key === raw)) {
+						setInvalid(true);
+						return;
+					}
+					face.addKey(line.path, raw);
+					onAdded([...line.path, raw]);
 				}
-			}
-		};
+				setText("");
+				setOpen(false);
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(AddWrap, {
+				"data-add": spec.kind,
+				"data-invalid": invalid ? "true" : void 0,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Menu, {
+						open: open && spec.kind !== "item" && matched.length > 0,
+						dense: true,
+						compact: true,
+						portal: true,
+						align: "start",
+						items: matched.map((option) => ({
+							id: option.key,
+							label: option.key
+						})),
+						onSelect: (key) => {
+							commit(key);
+						},
+						onClose: () => {
+							setOpen(false);
+						},
+						anchor: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CompactInput, { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Input, {
+							value: text,
+							placeholder: label,
+							"aria-label": label,
+							disabled,
+							onFocus: () => {
+								setOpen(true);
+							},
+							onChange: (event) => {
+								setText(event.target.value);
+								setInvalid(false);
+								setOpen(true);
+							},
+							onKeyDown: (event) => {
+								if (event.key === "Enter") {
+									event.preventDefault();
+									commit(matched.length === 1 && spec.kind === "prop" ? matched[0]?.key : void 0);
+								}
+								if (event.key === "Escape") {
+									setText("");
+									setOpen(false);
+								}
+							}
+						}) })
+					}),
+					invalid ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineInvalid, { children: t("unknownProperty") }) : null,
+					!invalid && matched.length === 1 && matched[0]?.description !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LineComment, {
+						title: resolveText(matched[0].description),
+						children: resolveText(matched[0].description)
+					}) : null
+				]
+			});
+		}
 		//#endregion
-		//#region src/client/theme.ts
-		const dsw = Token.vars(designTokens, { prefix: "dsw" });
+		//#region src/client/schema-form/SchemaForm.tsx
+		/**
+		* 一行的配置页：官方表单壳（保存 / 丢弃 / 只读 / 不可用）+ 行式 JSON 结构编辑器 + 字段槽。
+		*
+		* 每个可渲染的行注册项经 `renderFactorySlot('settings.schema-form.form', …)` 渲染这个 Factory，字段槽因此只需在
+		* Factory 的 `children` 里声明一次（slots 的 children 声明 per key 唯一，而本包给每个行都注册了一项）。
+		*/
+		/**
+		* 渲染一行的配置页。
+		* @param props - 行 id、控制器面、本地化解析与框架注入的槽位渲染座位。
+		* @returns 表单壳里的行式编辑器，或「没有可自动生成的配置项」一行。
+		*/
+		function SchemaForm(props) {
+			const { ns, face, t, resolveText, renderSlotChain } = props;
+			const store = face.hooks.schemaForm;
+			const state = (0, react.useSyncExternalStore)((listener) => store.subscribe(listener), () => store.getSnapshot());
+			const labels = {
+				unavailable: t("unavailable"),
+				readOnly: t("readOnly"),
+				saveFailed: t("saveFailed"),
+				save: t("save"),
+				saving: t("saving")
+			};
+			if (!state.configured) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Hint$1, {
+				role: "status",
+				children: t("noSchema")
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_deepseek_ai_dsh_client_ui_primitives.SettingsForm, {
+				labels,
+				state,
+				onSave: () => {
+					face.save();
+				},
+				onDiscard: () => {
+					face.discard();
+				},
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Editor, {
+					ns,
+					state,
+					face,
+					t,
+					resolveText,
+					renderField: (owner) => renderSlotChain("settings.schema-form.field", owner, { fallback: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SchemaFieldDefault, { owner: {
+						...owner,
+						onEditText: withParse(owner, t)
+					} }) })
+				}), state.violation === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Hint$1, {
+					role: "alert",
+					"data-violation": "true",
+					children: t("notSaved", { message: state.violation.message })
+				})]
+			});
+		}
+		/** 文本草稿的解析规则按字段类型给：行内编辑只上报原文，值在保存那一刻成形。 */
+		function withParse(owner, t) {
+			return (text, parse) => {
+				owner.onEditText(text, parse ?? parseFor(owner.node, t));
+			};
+		}
+		//#endregion
+		//#region src/client/schema-form/index.ts
+		var schema_form_exports = /* @__PURE__ */ __exportAll({
+			InlineValue: () => InlineValue,
+			NS: () => NS,
+			SchemaFieldDefault: () => SchemaFieldDefault,
+			SchemaFormController: () => SchemaFormController,
+			SchemaFormHints: () => SchemaFormHints,
+			apply: () => apply$1,
+			canRender: () => canRender,
+			containerShape: () => containerShape,
+			editorLines: () => editorLines,
+			failureOf: () => failureOf,
+			inject: () => inject$1,
+			optionsFor: () => optionsFor,
+			parseFor: () => parseFor,
+			projectNode: () => projectNode,
+			projectRoot: () => projectRoot,
+			rowRegistrations: () => rowRegistrations,
+			tokenText: () => tokenText,
+			tokenTone: () => tokenTone,
+			valueText: () => valueText,
+			visibleFields: () => visibleFields,
+			walkFields: () => walkFields
+		});
+		/** 本包字典与槽位文案的命名空间。 */
+		const NS = "settings.schema-form";
+		/** 需要的服务：槽位、字典、共享配置表单、schema 服务与插件管理（bundle 行清单）。 */
+		const inject$1 = [
+			"slots",
+			"locale",
+			"configForms",
+			"settingsSchema",
+			"remote",
+			"remote.pluginManager"
+		];
+		/**
+		* 装上本包：字典、Factory（字段槽的声明者）与按行自动注册。
+		* @param ctx - 浏览器插件上下文。
+		*/
+		function apply$1(ctx) {
+			ctx.effect(() => ctx.locale.register(NS, {
+				zh,
+				en
+			}), "ui-schema-form: dictionaries");
+			const hints = new SchemaFormHints(ctx);
+			ctx.effect(() => ctx.slots.registerFactory({
+				name: "settings.schema-form.form",
+				scope: "root",
+				children: { "settings.schema-form.field": {
+					kind: "chain",
+					scope: "root"
+				} },
+				locale: NS
+			}, SchemaForm), "ui-schema-form: form factory");
+			const rehydrate = (serialized) => ctx.settingsSchema.rehydrate(serialized);
+			const validate = (schema, value) => {
+				try {
+					schema(value);
+					return;
+				} catch (error) {
+					return failureOf(error);
+				}
+			};
+			const resolveText = (text) => typeof text === "string" ? text : ctx.locale.resolveText(text);
+			const entries = /* @__PURE__ */ new Map();
+			const entryFor = (ns) => {
+				const describe = ctx.configForms.describe();
+				const view = describe.getSnapshot().view?.namespaces.find((row) => row.ns === ns);
+				if (!canRender(view, rehydrate)) return void 0;
+				const existing = entries.get(ns);
+				if (existing !== void 0) return existing;
+				const controller = new SchemaFormController(ns, {
+					form: ctx.configForms.get(ns),
+					describe,
+					rehydrate,
+					validate,
+					t: ctx.locale.bind(NS),
+					hints: {
+						keysFor: (path) => hints.keysFor(ns, path),
+						textFor: (path) => hints.textFor(ns, path),
+						selectFor: (path) => hints.selectFor(ns, path),
+						sourceFor: (name) => hints.sourceFor(name)
+					}
+				});
+				const face = controller.face();
+				const props = {
+					ns,
+					face,
+					resolveText
+				};
+				const component = (entryProps) => entryProps.view === "page" ? entryProps.renderFactorySlot("settings.schema-form.form", props) : null;
+				const entry = {
+					controller,
+					face,
+					component
+				};
+				entries.set(ns, entry);
+				return entry;
+			};
+			const registration = new RowRegistration({
+				slots: ctx.slots,
+				describe: ctx.configForms.describe(),
+				bundles: async () => {
+					const response = await ctx.remote.pluginManager.listBundles();
+					return response.ok ? response.value : [];
+				},
+				subscribeBundles: (listener) => ctx.remote.$on("plugin-manager/changed", listener),
+				entryFor,
+				locale: NS,
+				release: (ns) => {
+					const entry = entries.get(ns);
+					entries.delete(ns);
+					entry?.controller.dispose();
+				}
+			});
+			ctx.effect(() => {
+				const offDescribe = ctx.configForms.describe().subscribe(() => {
+					registration.sync();
+				});
+				const offHints = hints.subscribe(() => {
+					for (const entry of entries.values()) entry.controller.refresh();
+				});
+				registration.sync();
+				return () => {
+					offDescribe();
+					offHints();
+					registration.dispose();
+					for (const [ns, entry] of entries) {
+						entries.delete(ns);
+						entry.controller.dispose();
+					}
+				};
+			}, "ui-schema-form: row registrations");
+		}
 		//#endregion
 		//#region src/client/markdown-labels.ts
 		function markdownLabels(t) {
@@ -1256,6 +4310,9 @@ window.__ModuleLoader__.load({
 			}
 		};
 		//#endregion
+		//#region src/client/styling/focus.ts
+		const focusRing = `${String(dsw.focus.ring.width)} solid ${Token.collect(Token.fallbackVar(dsw.focus.ring.color, String(dsw.alias.state.business.primary)))}`;
+		//#endregion
 		//#region src/client/settings-form/fields.styles.ts
 		const helpButtonHoverBackground = "var(--dsw-alias-bg-layer-4)";
 		const styles$1 = {
@@ -1309,7 +4366,7 @@ window.__ModuleLoader__.load({
 					color: dsw.alias.label.secondary
 				},
 				"&:focus-visible": {
-					outline: `2px solid ${String(dsw.alias.brand.primary)}`,
+					outline: focusRing,
 					outlineOffset: "1px"
 				}
 			},
@@ -1366,7 +4423,7 @@ window.__ModuleLoader__.load({
 				color: dsw.alias.label.primary,
 				"&:focus-visible": {
 					outline: "none",
-					borderColor: dsw.alias.brand.primary
+					borderColor: dsw.alias.state.business.primary
 				},
 				"&:disabled": {
 					color: dsw.alias.label.tertiary,
@@ -1492,6 +4549,7 @@ window.__ModuleLoader__.load({
 		* A write-only credential control. The value never rides a response, so the
 		* control reports only whether one is configured and starts blank; a blank
 		* draft writes nothing, which keeps the stored key rather than clearing it.
+		* 控件要求浏览器不要把已存的登录密码自动填进来（上游 11c0511271）。
 		* @param props - the field's copy, its staged text, and the configured state.
 		* @returns the labelled control.
 		*/
@@ -1505,7 +4563,7 @@ window.__ModuleLoader__.load({
 				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Input, {
 					id: props.id,
 					type: "password",
-					autoComplete: "off",
+					autoComplete: "new-password",
 					value: props.text,
 					disabled: props.disabled,
 					onChange: (event) => {
@@ -1556,7 +4614,7 @@ window.__ModuleLoader__.load({
 					cursor: "default"
 				},
 				"&:focus-visible": {
-					outline: `2px solid ${String(dsw.alias.brand.primary)}`,
+					outline: focusRing,
 					outlineOffset: "1px"
 				}
 			}
@@ -2113,7 +5171,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.js
+		//#region ../../../node_modules/.pnpm/micromark-factory-space@2.1.0/node_modules/micromark-factory-space/index.js
 		/**
 		* @import {Effects, State, TokenType} from 'micromark-util-types'
 		*/
@@ -2143,14 +5201,14 @@ window.__ModuleLoader__.load({
 		* @param {State} ok
 		*   State switched to when successful.
 		* @param {TokenType} type
-		*   Type (`' \t'`).
+		*   Type of the whole whitespace.
 		* @param {number | undefined} [max=Infinity]
 		*   Max (exclusive).
 		* @returns {State}
 		*   Start state.
 		*/
 		function factorySpace(effects, ok, type, max) {
-			const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+			const limit = max ? max - 1 : Infinity;
 			let size = 0;
 			return start;
 			/** @type {State} */
@@ -2171,8 +5229,56 @@ window.__ModuleLoader__.load({
 				return ok(code);
 			}
 		}
+		/**
+		* Parse spaces and tabs, with a required minimum and maximum, matching
+		* `markdown-rs`’s `space_or_tab_min_max`.
+		*
+		* Unlike `factorySpace`, this can fail: `nok` is used when fewer than
+		* `min` spaces or tabs are found.
+		*
+		* @param {Effects} effects
+		*   Context.
+		* @param {State} ok
+		*   State switched to when successful.
+		* @param {State} nok
+		*   State switched to when unsuccessful.
+		* @param {TokenType} type
+		*   Type of the whole whitespace.
+		* @param {number} min
+		*   Minimum allowed characters (inclusive).
+		* @param {number} max
+		*   Maximum allowed characters (inclusive).
+		* @returns {State}
+		*   Start state.
+		*/
+		function factorySpaceMinMax(effects, ok, nok, type, min, max) {
+			let size = 0;
+			return start;
+			/** @type {State} */
+			function start(code) {
+				if (max > 0 && markdownSpace(code)) {
+					effects.enter(type);
+					return prefix(code);
+				}
+				return after(code);
+			}
+			/** @type {State} */
+			function prefix(code) {
+				if (markdownSpace(code) && size < max) {
+					effects.consume(code);
+					size++;
+					return prefix;
+				}
+				effects.exit(type);
+				return after(code);
+			}
+			/** @type {State} */
+			function after(code) {
+				return size >= min ? ok(code) : nok(code);
+			}
+		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/initialize/content.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/initialize/content.js
 		/**
 		* @import {
 		*   InitialConstruct,
@@ -2234,12 +5340,158 @@ window.__ModuleLoader__.load({
 					effects.exit("chunkText");
 					return lineStart;
 				}
-				effects.consume(code);
-				return data;
+				effects.consume(code);
+				return data;
+			}
+		}
+		//#endregion
+		//#region ../../../node_modules/.pnpm/micromark-util-edit-map@1.0.0/node_modules/micromark-util-edit-map/index.js
+		/**
+		* @import {Event} from 'micromark-util-types'
+		*/
+		/**
+		* @typedef {[number, number, Array<Event>]} Change
+		* @typedef {[number, number, number]} Jump
+		*/
+		/**
+		* Tracks a bunch of edits.
+		*
+		* Port of `edit_map.rs` from `markdown-rs`:
+		* <https://github.com/wooorm/markdown-rs/blob/1506572f/src/util/edit_map.rs>.
+		*
+		* Deal with several changes in events, batching them together.
+		*
+		* Preferably, changes should be kept to a minimum.
+		* Sometimes, it’s needed to change the list of events, because parsing can be
+		* messy, and it helps to expose a cleaner interface of events to the compiler
+		* and other users.
+		* It can also help to merge many adjacent similar events.
+		* And, in other cases, it’s needed to parse subcontent: pass some events
+		* through another tokenizer and inject the result.
+		*/
+		var EditMap$1 = class {
+			/**
+			* Create a new edit map.
+			*
+			* @returns
+			*   New instance.
+			*/
+			constructor() {
+				/**
+				* Changes by index, so `add` does not need to scan `map` (which is
+				* quadratic for documents with many edits at different places).
+				*
+				* @type {Map<number, Change>}
+				*/
+				this.index = /* @__PURE__ */ new Map();
+				/**
+				* Record of changes.
+				*
+				* @type {Array<Change>}
+				*/
+				this.map = [];
+			}
+			/**
+			* Create an edit: a remove and/or add at a certain place.
+			*
+			* @param {number} index
+			*   Index at which to apply the edit.
+			* @param {number} remove
+			*   Count of items to remove at the index.
+			* @param {Array<Event>} add
+			*   Items to add at the index.
+			* @returns {undefined}
+			*   Nothing.
+			*/
+			add(index, remove, add) {
+				addImplementation$1(this, index, remove, add, false);
+			}
+			/**
+			* Create an edit: but insert `add` before existing additions, instead of
+			* after them.
+			*
+			* @param {number} index
+			*   Index at which to apply the edit.
+			* @param {number} remove
+			*   Count of items to remove at the index.
+			* @param {Array<Event>} add
+			*   Items to add at the index.
+			* @returns {undefined}
+			*   Nothing.
+			*/
+			addBefore(index, remove, add) {
+				addImplementation$1(this, index, remove, add, true);
+			}
+			/**
+			* Done, change the events.
+			*
+			* @param {Array<Event>} events
+			*   List of events to apply the edits to.
+			* @returns {undefined}
+			*   Nothing.
+			*/
+			consume(events) {
+				this.map.sort(function(a, b) {
+					return a[0] - b[0];
+				});
+				if (this.map.length === 0) return;
+				let index = this.map.length;
+				/** @type {Array<Array<Event>>} */
+				const vecs = [];
+				while (index > 0) {
+					index -= 1;
+					vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);
+					events.length = this.map[index][0];
+				}
+				vecs.push(events.slice());
+				events.length = 0;
+				let slice = vecs.pop();
+				while (slice) {
+					for (const element of slice) events.push(element);
+					slice = vecs.pop();
+				}
+				this.map.length = 0;
+				this.index.clear();
+			}
+		};
+		/**
+		* Create an edit.
+		*
+		* @param {EditMap} editMap
+		*   Edit map to apply to.
+		* @param {number} at
+		*   Index at which to apply the edit.
+		* @param {number} remove
+		*   Count of items to remove at the index.
+		* @param {Array<Event>} add
+		*   Items to add at the index.
+		* @param {boolean} before
+		*   Insert `add` before existing additions at `at`, instead of after them.
+		* @returns {undefined}
+		*   Nothing.
+		*/
+		function addImplementation$1(editMap, at, remove, add, before) {
+			if (remove === 0 && add.length === 0) return;
+			const existing = editMap.index.get(at);
+			if (existing) {
+				existing[1] += remove;
+				if (before) {
+					add.push(...existing[2]);
+					existing[2] = add;
+				} else existing[2].push(...add);
+				return;
 			}
+			/** @type {Change} */
+			const change = [
+				at,
+				remove,
+				add
+			];
+			editMap.map.push(change);
+			editMap.index.set(at, change);
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/initialize/document.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/initialize/document.js
 		/**
 		* @import {
 		*   Construct,
@@ -2308,8 +5560,10 @@ window.__ModuleLoader__.load({
 						self.events[index][1].end = { ...point };
 						index++;
 					}
-					splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
-					self.events.length = index;
+					const editMap = new EditMap$1();
+					editMap.add(indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
+					editMap.add(indexBeforeExits, index - indexBeforeExits, []);
+					editMap.consume(self.events);
 					return checkNewContainers(code);
 				}
 				return start(code);
@@ -2419,8 +5673,10 @@ window.__ModuleLoader__.load({
 						self.events[index][1].end = { ...point };
 						index++;
 					}
-					splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
-					self.events.length = index;
+					const editMap = new EditMap$1();
+					editMap.add(indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
+					editMap.add(indexBeforeExits, index - indexBeforeExits, []);
+					editMap.consume(self.events);
 				}
 			}
 			/**
@@ -2508,7 +5764,7 @@ window.__ModuleLoader__.load({
 			return events;
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/attention.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/attention.js
 		/**
 		* @import {
 		*   Code,
@@ -2535,47 +5791,33 @@ window.__ModuleLoader__.load({
 		*/
 		function resolveAllAttention(events, context) {
 			let index = -1;
-			/** @type {number} */
-			let open;
-			/** @type {Token} */
-			let group;
-			/** @type {Token} */
-			let text;
-			/** @type {Token} */
-			let openingSequence;
-			/** @type {Token} */
-			let closingSequence;
-			/** @type {number} */
-			let use;
 			/** @type {Array<Event>} */
 			let nextEvents;
-			/** @type {number} */
-			let offset;
 			while (++index < events.length) if (events[index][0] === "enter" && events[index][1].type === "attentionSequence" && events[index][1]._close) {
-				open = index;
+				let open = index;
 				while (open--) if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {
 					if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) continue;
-					use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
+					const use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
 					const start = { ...events[open][1].end };
 					const end = { ...events[index][1].start };
 					movePoint(start, -use);
 					movePoint(end, use);
-					openingSequence = {
+					const openingSequence = {
 						type: use > 1 ? "strongSequence" : "emphasisSequence",
 						start,
 						end: { ...events[open][1].end }
 					};
-					closingSequence = {
+					const closingSequence = {
 						type: use > 1 ? "strongSequence" : "emphasisSequence",
 						start: { ...events[index][1].start },
 						end
 					};
-					text = {
+					const text = {
 						type: use > 1 ? "strongText" : "emphasisText",
 						start: { ...events[open][1].end },
 						end: { ...events[index][1].start }
 					};
-					group = {
+					const group = {
 						type: use > 1 ? "strong" : "emphasis",
 						start: { ...openingSequence.start },
 						end: { ...closingSequence.end }
@@ -2637,6 +5879,8 @@ window.__ModuleLoader__.load({
 							context
 						]
 					]);
+					/** @type {number} */
+					let offset = 0;
 					if (events[index][1].end.offset - events[index][1].start.offset) {
 						offset = 2;
 						nextEvents = push(nextEvents, [[
@@ -2648,7 +5892,7 @@ window.__ModuleLoader__.load({
 							events[index][1],
 							context
 						]]);
-					} else offset = 0;
+					}
 					splice(events, open - 1, index - open + 3, nextEvents);
 					index = open + nextEvents.length - offset - 2;
 					break;
@@ -2702,8 +5946,8 @@ window.__ModuleLoader__.load({
 				}
 				const token = effects.exit("attentionSequence");
 				const after = classifyCharacter(code);
-				const open = !after || after === 2 && before || attentionMarkers.includes(code);
-				const close = !before || before === 2 && after || attentionMarkers.includes(previous);
+				const open = !after || after === 2 && before || attentionMarkers.includes(code) && code !== 42 && code !== 95;
+				const close = !before || before === 2 && after || attentionMarkers.includes(previous) && previous !== 42 && previous !== 95;
 				token._open = Boolean(marker === 42 ? open : open && (before || !close));
 				token._close = Boolean(marker === 42 ? close : close && (after || !open));
 				return ok(code);
@@ -2728,7 +5972,7 @@ window.__ModuleLoader__.load({
 			point._bufferIndex += offset;
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/autolink.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/autolink.js
 		/**
 		* @import {
 		*   Construct,
@@ -2939,7 +6183,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/blank-line.js
 		/**
 		* @import {
 		*   Construct,
@@ -2996,7 +6240,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/block-quote.js
 		/**
 		* @import {
 		*   Construct,
@@ -3123,7 +6367,7 @@ window.__ModuleLoader__.load({
 			effects.exit("blockQuote");
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-escape.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/character-escape.js
 		/**
 		* @import {
 		*   Construct,
@@ -3183,7 +6427,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/character-reference.js
 		/**
 		* @import {
 		*   Code,
@@ -3321,7 +6565,55 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-fenced.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/partial-non-lazy-continuation.js
+		/** @type {Construct} */
+		const nonLazyContinuation = {
+			partial: true,
+			tokenize: tokenizeNonLazyContinuation
+		};
+		/**
+		* @this {TokenizeContext}
+		*   Context.
+		* @type {Tokenizer}
+		*/
+		function tokenizeNonLazyContinuation(effects, ok, nok) {
+			const self = this;
+			return start;
+			/**
+			* At eol, before continuation.
+			*
+			* ```markdown
+			* > | * ```js
+			*            ^
+			*   | b
+			* ```
+			*
+			* @type {State}
+			*/
+			function start(code) {
+				if (code === null) return nok(code);
+				effects.enter("lineEnding");
+				effects.consume(code);
+				effects.exit("lineEnding");
+				return after;
+			}
+			/**
+			* A continuation.
+			*
+			* ```markdown
+			*   | * ```js
+			* > | b
+			*     ^
+			* ```
+			*
+			* @type {State}
+			*/
+			function after(code) {
+				return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+			}
+		}
+		//#endregion
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/code-fenced.js
 		/**
 		* @import {
 		*   Code,
@@ -3332,11 +6624,6 @@ window.__ModuleLoader__.load({
 		* } from 'micromark-util-types'
 		*/
 		/** @type {Construct} */
-		const nonLazyContinuation = {
-			partial: true,
-			tokenize: tokenizeNonLazyContinuation
-		};
-		/** @type {Construct} */
 		const codeFenced = {
 			concrete: true,
 			name: "codeFenced",
@@ -3706,37 +6993,8 @@ window.__ModuleLoader__.load({
 				}
 			}
 		}
-		/**
-		* @this {TokenizeContext}
-		*   Context.
-		* @type {Tokenizer}
-		*/
-		function tokenizeNonLazyContinuation(effects, ok, nok) {
-			const self = this;
-			return start;
-			/**
-			*
-			*
-			* @type {State}
-			*/
-			function start(code) {
-				if (code === null) return nok(code);
-				effects.enter("lineEnding");
-				effects.consume(code);
-				effects.exit("lineEnding");
-				return lineStart;
-			}
-			/**
-			*
-			*
-			* @type {State}
-			*/
-			function lineStart(code) {
-				return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
-			}
-		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-indented.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/code-indented.js
 		/**
 		* @import {
 		*   Construct,
@@ -3761,7 +7019,6 @@ window.__ModuleLoader__.load({
 		* @type {Tokenizer}
 		*/
 		function tokenizeCodeIndented(effects, ok, nok) {
-			const self = this;
 			return start;
 			/**
 			* Start of code (indented).
@@ -3779,21 +7036,7 @@ window.__ModuleLoader__.load({
 			*/
 			function start(code) {
 				effects.enter("codeIndented");
-				return factorySpace(effects, afterPrefix, "linePrefix", 5)(code);
-			}
-			/**
-			* At start, after 1 or 4 spaces.
-			*
-			* ```markdown
-			* > |     aaa
-			*         ^
-			* ```
-			*
-			* @type {State}
-			*/
-			function afterPrefix(code) {
-				const tail = self.events[self.events.length - 1];
-				return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);
+				return factorySpaceMinMax(effects, atBreak, nok, "linePrefix", 4, 4)(code);
 			}
 			/**
 			* At a break.
@@ -3862,25 +7105,28 @@ window.__ModuleLoader__.load({
 					effects.exit("lineEnding");
 					return furtherStart;
 				}
-				return factorySpace(effects, afterPrefix, "linePrefix", 5)(code);
+				return factorySpaceMinMax(effects, ok, onNotEnoughPrefix, "linePrefix", 4, 4)(code);
 			}
 			/**
-			* At start, after 1 or 4 spaces.
+			* After not enough of a prefix.
+			*
+			* A following line ending is another (potentially blank) line to try,
+			* anything else means this isn’t a continuation.
 			*
 			* ```markdown
 			* > |     aaa
-			*         ^
+			*
+			*   |     bbb
 			* ```
 			*
 			* @type {State}
 			*/
-			function afterPrefix(code) {
-				const tail = self.events[self.events.length - 1];
-				return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);
+			function onNotEnoughPrefix(code) {
+				return markdownLineEnding(code) ? furtherStart(code) : nok(code);
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/code-text.js
 		/**
 		* @import {
 		*   Construct,
@@ -4450,7 +7696,7 @@ window.__ModuleLoader__.load({
 			return gaps;
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/content.js
 		/**
 		* @import {
 		*   Construct,
@@ -5086,7 +8332,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/definition.js
 		/**
 		* @import {
 		*   Construct,
@@ -5301,7 +8547,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/hard-break-escape.js
 		/**
 		* @import {
 		*   Construct,
@@ -5358,7 +8604,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/heading-atx.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/heading-atx.js
 		/**
 		* @import {
 		*   Construct,
@@ -5379,20 +8625,16 @@ window.__ModuleLoader__.load({
 		function resolveHeadingAtx(events, context) {
 			let contentEnd = events.length - 2;
 			let contentStart = 3;
-			/** @type {Token} */
-			let content;
-			/** @type {Token} */
-			let text;
 			if (events[contentStart][1].type === "whitespace") contentStart += 2;
 			if (contentEnd - 2 > contentStart && events[contentEnd][1].type === "whitespace") contentEnd -= 2;
 			if (events[contentEnd][1].type === "atxHeadingSequence" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === "whitespace")) contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
 			if (contentEnd > contentStart) {
-				content = {
+				const content = {
 					type: "atxHeadingText",
 					start: events[contentStart][1].start,
 					end: events[contentEnd][1].end
 				};
-				text = {
+				const text = {
 					type: "chunkText",
 					start: events[contentStart][1].start,
 					end: events[contentEnd][1].end,
@@ -5642,7 +8884,7 @@ window.__ModuleLoader__.load({
 			"textarea"
 		];
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-flow.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/html-flow.js
 		/**
 		* @import {
 		*   Code,
@@ -5665,10 +8907,6 @@ window.__ModuleLoader__.load({
 			partial: true,
 			tokenize: tokenizeBlankLineBefore
 		};
-		const nonLazyContinuationStart = {
-			partial: true,
-			tokenize: tokenizeNonLazyContinuationStart
-		};
 		/** @type {Resolver} */
 		function resolveToHtmlFlow(events) {
 			let index = events.length;
@@ -6171,7 +9409,7 @@ window.__ModuleLoader__.load({
 			* @type {State}
 			*/
 			function continuationStart(code) {
-				return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);
+				return effects.check(nonLazyContinuation, continuationStartNonLazy, continuationAfter)(code);
 			}
 			/**
 			* In continuation, at eol, before non-lazy content.
@@ -6351,49 +9589,6 @@ window.__ModuleLoader__.load({
 		*   Context.
 		* @type {Tokenizer}
 		*/
-		function tokenizeNonLazyContinuationStart(effects, ok, nok) {
-			const self = this;
-			return start;
-			/**
-			* At eol, before continuation.
-			*
-			* ```markdown
-			* > | * ```js
-			*            ^
-			*   | b
-			* ```
-			*
-			* @type {State}
-			*/
-			function start(code) {
-				if (markdownLineEnding(code)) {
-					effects.enter("lineEnding");
-					effects.consume(code);
-					effects.exit("lineEnding");
-					return after;
-				}
-				return nok(code);
-			}
-			/**
-			* A continuation.
-			*
-			* ```markdown
-			*   | * ```js
-			* > | b
-			*     ^
-			* ```
-			*
-			* @type {State}
-			*/
-			function after(code) {
-				return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
-			}
-		}
-		/**
-		* @this {TokenizeContext}
-		*   Context.
-		* @type {Tokenizer}
-		*/
 		function tokenizeBlankLineBefore(effects, ok, nok) {
 			return start;
 			/**
@@ -6415,7 +9610,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-text.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/html-text.js
 		/**
 		* @import {
 		*   Code,
@@ -7029,7 +10224,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-end.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/label-end.js
 		/**
 		* @import {
 		*   Construct,
@@ -7075,8 +10270,6 @@ window.__ModuleLoader__.load({
 		function resolveToLabelEnd(events, context) {
 			let index = events.length;
 			let offset = 0;
-			/** @type {Token} */
-			let token;
 			/** @type {number | undefined} */
 			let open;
 			/** @type {number | undefined} */
@@ -7084,7 +10277,7 @@ window.__ModuleLoader__.load({
 			/** @type {Array<Event>} */
 			let media;
 			while (index--) {
-				token = events[index][1];
+				const token = events[index][1];
 				if (open) {
 					if (token.type === "link" || token.type === "labelLink" && token._inactive) break;
 					if (events[index][0] === "enter" && token.type === "labelLink") token._inactive = true;
@@ -7159,14 +10352,14 @@ window.__ModuleLoader__.load({
 		*/
 		function tokenizeLabelEnd(effects, ok, nok) {
 			const self = this;
-			let index = self.events.length;
+			const labelStarts = self._labelStarts;
 			/** @type {Token} */
 			let labelStart;
 			/** @type {boolean} */
 			let defined;
-			while (index--) if ((self.events[index][1].type === "labelImage" || self.events[index][1].type === "labelLink") && !self.events[index][1]._balanced) {
-				labelStart = self.events[index][1];
-				break;
+			if (labelStarts) {
+				while (labelStarts.length > 0 && labelStarts[labelStarts.length - 1]._balanced) labelStarts.pop();
+				labelStart = labelStarts[labelStarts.length - 1];
 			}
 			return start;
 			/**
@@ -7253,6 +10446,7 @@ window.__ModuleLoader__.load({
 			* @type {State}
 			*/
 			function labelEndOk(code) {
+				labelStarts.pop();
 				return ok(code);
 			}
 			/**
@@ -7499,11 +10693,12 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-image.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/label-start-image.js
 		/**
 		* @import {
 		*   Construct,
 		*   State,
+		*   Token,
 		*   TokenizeContext,
 		*   Tokenizer
 		* } from 'micromark-util-types'
@@ -7521,6 +10716,8 @@ window.__ModuleLoader__.load({
 		*/
 		function tokenizeLabelStartImage(effects, ok, nok) {
 			const self = this;
+			/** @type {Token} */
+			let labelImage;
 			return start;
 			/**
 			* Start of label (image) start.
@@ -7554,7 +10751,7 @@ window.__ModuleLoader__.load({
 					effects.enter("labelMarker");
 					effects.consume(code);
 					effects.exit("labelMarker");
-					effects.exit("labelImage");
+					labelImage = effects.exit("labelImage");
 					return after;
 				}
 				return nok(code);
@@ -7587,16 +10784,20 @@ window.__ModuleLoader__.load({
 			* @type {State}
 			*/
 			function after(code) {
-				/* c8 ignore next 3 */
-				return code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs ? nok(code) : ok(code);
+				/* c8 ignore next 6 */
+				if (code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs) return nok(code);
+				self._labelStarts = self._labelStarts || [];
+				self._labelStarts.push(labelImage);
+				return ok(code);
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-link.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/label-start-link.js
 		/**
 		* @import {
 		*   Construct,
 		*   State,
+		*   Token,
 		*   TokenizeContext,
 		*   Tokenizer
 		* } from 'micromark-util-types'
@@ -7614,6 +10815,8 @@ window.__ModuleLoader__.load({
 		*/
 		function tokenizeLabelStartLink(effects, ok, nok) {
 			const self = this;
+			/** @type {Token} */
+			let labelLink;
 			return start;
 			/**
 			* Start of label (link) start.
@@ -7630,17 +10833,20 @@ window.__ModuleLoader__.load({
 				effects.enter("labelMarker");
 				effects.consume(code);
 				effects.exit("labelMarker");
-				effects.exit("labelLink");
+				labelLink = effects.exit("labelLink");
 				return after;
 			}
 			/** @type {State} */
 			function after(code) {
-				/* c8 ignore next 3 */
-				return code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs ? nok(code) : ok(code);
+				/* c8 ignore next 6 */
+				if (code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs) return nok(code);
+				self._labelStarts = self._labelStarts || [];
+				self._labelStarts.push(labelLink);
+				return ok(code);
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/line-ending.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/line-ending.js
 		/**
 		* @import {
 		*   Construct,
@@ -7670,7 +10876,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/thematic-break.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/thematic-break.js
 		/**
 		* @import {
 		*   Code,
@@ -7765,7 +10971,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/list.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/list.js
 		/**
 		* @import {
 		*   Code,
@@ -7937,7 +11143,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/setext-underline.js
+		//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.4/node_modules/micromark-core-commonmark/lib/setext-underline.js
 		/**
 		* @import {
 		*   Code,
@@ -7956,6 +11162,7 @@ window.__ModuleLoader__.load({
 		};
 		/** @type {Resolver} */
 		function resolveToSetextUnderline(events, context) {
+			const editMap = new EditMap$1();
 			let index = events.length;
 			/** @type {number | undefined} */
 			let content;
@@ -7970,7 +11177,7 @@ window.__ModuleLoader__.load({
 				}
 				if (events[index][1].type === "paragraph") text = index;
 			} else {
-				if (events[index][1].type === "content") events.splice(index, 1);
+				if (events[index][1].type === "content") editMap.add(index, 1, []);
 				if (!definition && events[index][1].type === "definition") definition = index;
 			}
 			const heading = {
@@ -7980,23 +11187,24 @@ window.__ModuleLoader__.load({
 			};
 			events[text][1].type = "setextHeadingText";
 			if (definition) {
-				events.splice(text, 0, [
+				editMap.add(text, 0, [[
 					"enter",
 					heading,
 					context
-				]);
-				events.splice(definition + 1, 0, [
+				]]);
+				editMap.add(definition + 1, 0, [[
 					"exit",
 					events[content][1],
 					context
-				]);
+				]]);
 				events[content][1].end = { ...events[definition][1].end };
 			} else events[content][1] = heading;
-			events.push([
+			editMap.add(events.length, 0, [[
 				"exit",
 				heading,
 				context
-			]);
+			]]);
+			editMap.consume(events);
 			return events;
 		}
 		/**
@@ -8089,7 +11297,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/initialize/flow.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/initialize/flow.js
 		/**
 		* @import {
 		*   InitialConstruct,
@@ -8136,7 +11344,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/initialize/text.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/initialize/text.js
 		/**
 		* @import {
 		*   Code,
@@ -8253,6 +11461,7 @@ window.__ModuleLoader__.load({
 		* @type {Resolver}
 		*/
 		function resolveAllLineSuffixes(events, context) {
+			const editMap = new EditMap$1();
 			let eventIndex = 0;
 			while (++eventIndex <= events.length) if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") {
 				const data = events[eventIndex - 1][1];
@@ -8295,25 +11504,23 @@ window.__ModuleLoader__.load({
 					};
 					data.end = { ...token.start };
 					if (data.start.offset === data.end.offset) Object.assign(data, token);
-					else {
-						events.splice(eventIndex, 0, [
-							"enter",
-							token,
-							context
-						], [
-							"exit",
-							token,
-							context
-						]);
-						eventIndex += 2;
-					}
+					else editMap.add(eventIndex, 0, [[
+						"enter",
+						token,
+						context
+					], [
+						"exit",
+						token,
+						context
+					]]);
 				}
 				eventIndex++;
 			}
+			editMap.consume(events);
 			return events;
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/constructs.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/constructs.js
 		/**
 		* @import {Extension} from 'micromark-util-types'
 		*/
@@ -8391,7 +11598,7 @@ window.__ModuleLoader__.load({
 		/** @satisfies {Extension['disable']} */
 		const disable = { null: [] };
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/create-tokenizer.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/create-tokenizer.js
 		/**
 		* @import {
 		*   Chunk,
@@ -8547,12 +11754,10 @@ window.__ModuleLoader__.load({
 			*   Nothing.
 			*/
 			function main() {
-				/** @type {number} */
-				let chunkIndex;
 				while (point._index < chunks.length) {
 					const chunk = chunks[point._index];
 					if (typeof chunk === "string") {
-						chunkIndex = point._index;
+						const chunkIndex = point._index;
 						if (point._bufferIndex < 0) point._bufferIndex = 0;
 						while (point._index === chunkIndex && point._bufferIndex < chunk.length) go(chunk.charCodeAt(point._bufferIndex));
 					} else go(chunk);
@@ -8860,7 +12065,7 @@ window.__ModuleLoader__.load({
 			return result.join("");
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/parse.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/parse.js
 		/**
 		* @import {
 		*   Create,
@@ -8904,7 +12109,7 @@ window.__ModuleLoader__.load({
 			}
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/postprocess.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/postprocess.js
 		/**
 		* @import {Event} from 'micromark-util-types'
 		*/
@@ -8919,7 +12124,7 @@ window.__ModuleLoader__.load({
 			return events;
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/micromark@4.0.2_supports-color@9.4.0/node_modules/micromark/lib/preprocess.js
+		//#region ../../../node_modules/.pnpm/micromark@4.0.3_supports-color@9.4.0/node_modules/micromark/lib/preprocess.js
 		/**
 		* @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'
 		*/
@@ -8950,20 +12155,10 @@ window.__ModuleLoader__.load({
 			return preprocessor;
 			/** @type {Preprocessor} */
 			function preprocessor(value, encoding, end) {
+				value = buffer + (typeof value === "string" ? value.toString() : new TextDecoder(encoding || void 0).decode(value));
 				/** @type {Array<Chunk>} */
 				const chunks = [];
-				/** @type {RegExpMatchArray | null} */
-				let match;
-				/** @type {number} */
-				let next;
-				/** @type {number} */
-				let startPosition;
-				/** @type {number} */
-				let endPosition;
-				/** @type {Code} */
-				let code;
-				value = buffer + (typeof value === "string" ? value.toString() : new TextDecoder(encoding || void 0).decode(value));
-				startPosition = 0;
+				let startPosition = 0;
 				buffer = "";
 				if (start) {
 					if (value.charCodeAt(0) === 65279) startPosition++;
@@ -8971,9 +12166,9 @@ window.__ModuleLoader__.load({
 				}
 				while (startPosition < value.length) {
 					search.lastIndex = startPosition;
-					match = search.exec(value);
-					endPosition = match && match.index !== void 0 ? match.index : value.length;
-					code = value.charCodeAt(endPosition);
+					const match = search.exec(value);
+					const endPosition = match && match.index !== void 0 ? match.index : value.length;
+					const code = value.charCodeAt(endPosition);
 					if (!match) {
 						buffer = value.slice(startPosition);
 						break;
@@ -8995,11 +12190,12 @@ window.__ModuleLoader__.load({
 								chunks.push(65533);
 								column++;
 								break;
-							case 9:
-								next = Math.ceil(column / 4) * 4;
+							case 9: {
+								const next = Math.ceil(column / 4) * 4;
 								chunks.push(-2);
 								while (column++ < next) chunks.push(-1);
 								break;
+							}
 							case 10:
 								chunks.push(-4);
 								column = 1;
@@ -11074,7 +14270,8 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/mdast-util-gfm-strikethrough@2.0.0_supports-color@9.4.0/node_modules/mdast-util-gfm-strikethrough/lib/index.js
+		//#region ../../../node_modules/.pnpm/mdast-util-gfm-strikethrough@2.0.1_supports-color@9.4.0/node_modules/mdast-util-gfm-strikethrough/lib/index.js
+		handleDelete.attention = attentionDelete;
 		handleDelete.peek = peekDelete;
 		/**
 		* Create an extension for `mdast-util-from-markdown` to enable GFM
@@ -11091,16 +14288,21 @@ window.__ModuleLoader__.load({
 			};
 		}
 		/**
+		* Enter strikethrough.
+		*
 		* @this {CompileContext}
 		* @type {FromMarkdownHandle}
 		*/
 		function enterStrikethrough(token) {
 			this.enter({
 				type: "delete",
-				children: []
+				children: [],
+				position: void 0
 			}, token);
 		}
 		/**
+		* Exit strikethrough.
+		*
 		* @this {CompileContext}
 		* @type {FromMarkdownHandle}
 		*/
@@ -11108,23 +14310,43 @@ window.__ModuleLoader__.load({
 			this.exit(token);
 		}
 		/**
+		* Serialize a delete node.
+		*
 		* @type {ToMarkdownHandle}
 		* @param {Delete} node
+		*   Node to serialize.
 		*/
 		function handleDelete(node, _, state, info) {
 			const tracker = state.createTracker(info);
+			const sequence = state.stack.includes("strikethrough") ? "~" : "~~";
 			const exit = state.enter("strikethrough");
-			let value = tracker.move("~~");
+			let value = tracker.move(sequence);
 			value += state.containerPhrasing(node, {
 				...tracker.current(),
 				before: value,
 				after: "~"
 			});
-			value += tracker.move("~~");
+			value += tracker.move(sequence);
 			exit();
 			return value;
 		}
-		/** @type {ToMarkdownHandle} */
+		/**
+		* Serialize a delete node as attention.
+		*
+		* @type {Attention}
+		*/
+		function attentionDelete() {
+			return {
+				construct: "strikethrough",
+				markers: ["~"],
+				sizes: [2, 1]
+			};
+		}
+		/**
+		* Peek the first character of a delete node.
+		*
+		* @type {ToMarkdownHandle}
+		*/
 		function peekDelete() {
 			return "~";
 		}
@@ -14398,10 +17620,24 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/index.ts
-		const inject = [];
-		function apply(_ctx) {}
+		/**
+		* 需要的**服务名**：样式与引用那半不要服务，schema 表单那半要槽位、字典与配置表单。
+		*
+		* 与包清单里的 `dsh.client.inject` 不是一回事：那份是**装配行 id**（谁先到），交给模块系统排 arrival 顺序；
+		* 这里读的是 cordis 服务名（谁已 provide），Loader 拿它决定这一行何时才算 active。写错成包名，这一行就永远
+		* pending（`web boot: ... waiting for services`）。
+		*
+		* 值直接取自 schema 表单那一面，不另抄一份清单。
+		*/
+		const inject = [...inject$1];
+		function apply(ctx) {
+			apply$1(ctx);
+		}
 		//#endregion
 		exports.ReferenceMarkdown = ReferenceMarkdown;
+		exports.SCHEMA_FORM_NS = NS;
+		exports.SchemaFormController = SchemaFormController;
+		exports.SchemaFormHints = SchemaFormHints;
 		exports.SettingsForm = SettingsForm;
 		exports.SettingsFormModel = SettingsFormModel;
 		exports.SettingsSecretField = SettingsSecretField;
@@ -14411,6 +17647,7 @@ window.__ModuleLoader__.load({
 		exports.apply = apply;
 		exports.designTokens = designTokens;
 		exports.dsw = dsw;
+		exports.failureOf = failureOf;
 		exports.findReferences = findReferences;
 		exports.formatReference = formatReference;
 		exports.formatReferenceMention = formatReferenceMention;
@@ -14419,12 +17656,21 @@ window.__ModuleLoader__.load({
 		exports.markdownLabels = markdownLabels;
 		exports.parseReference = parseReference;
 		exports.parseReferenceToken = parseReferenceToken;
+		exports.projectRoot = projectRoot;
 		exports.referenceMentions = referenceMentions;
+		exports.rowRegistrations = rowRegistrations;
+		Object.defineProperty(exports, "schemaForm", {
+			enumerable: true,
+			get: function() {
+				return schema_form_exports;
+			}
+		});
 		exports.settingsNumberField = settingsNumberField;
 		exports.settingsTextField = settingsTextField;
 		exports.styleOf = styleOf;
 		exports.styled = styled;
 		exports.styling = styling;
+		exports.walkFields = walkFields;
 		return module.exports;
 	}
 });