@morlay/dsh-client-ui-primitives 0.0.6 → 0.0.7

package/dist/client.mjs

@@ -0,0 +1,4576 @@
+import { n as __exportAll, t as __commonJSMin } from "./rolldown-runtime-EAsCxrDo.mjs";
+import { a as parseReference, i as isLocalReference, n as formatReference, o as parseReferenceToken, r as formatReferenceMention, t as findReferences } from "./reference-Cjcn21uW.mjs";
+import { createSnapshotStore } from "@deepseek-ai/dsh-client-store";
+import { Service } from "@deepseek-ai/cordis";
+import { cloneElement, createElement, forwardRef, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { IconCheckOutlineRegular, IconChevronDownOutlineRegular, IconChevronRightOutlineRegular, IconCloseOutlineRegular, IconCopyOutlineRegular, IconRefreshOutlineRegular, IconTrashOutlineRegular, Input, MarkdownText, Menu, SettingsForm as SettingsForm$1, Tooltip } from "@deepseek-ai/dsh-client-ui-primitives";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+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
+	};
+}
+function badgesOf(meta) {
+	return (meta.badges ?? []).map((badge) => badge.text);
+}
+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
+	};
+}
+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] ?? "";
+}
+function stringLeaf(path, meta) {
+	return {
+		key: keyOf(path),
+		path,
+		label: void 0,
+		meta,
+		readOnly: null,
+		type: "string"
+	};
+}
+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";
+	}
+}
+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
+		};
+	}
+}
+function unwrapLazy(node) {
+	let current = node;
+	while (current?.type === "lazy") current = current.inner;
+	return current;
+}
+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 [];
+	}
+}
+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);
+}
+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;
+	}
+}
+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;
+}
+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;
+}
+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);
+}
+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)];
+}
+function unionOf(node) {
+	const current = unwrapLazy(node);
+	return current?.type === "union" ? current : void 0;
+}
+function variantOf(node, value) {
+	const union = unionOf(node);
+	if (union === void 0) return unwrapLazy(node) ?? node;
+	return pickVariant(union, value) ?? union;
+}
+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";
+	}
+}
+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);
+}
+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;
+}
+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;
+	}
+}
+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
+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;
+	constructor(options) {
+		this.#scope = options.scope;
+		this.#root = options.root;
+		this.#validate = options.validate;
+		this.#unsubscribe = this.#scope.subscribe(() => {
+			this.#publish();
+		});
+	}
+	setRoot(root) {
+		this.#root = root;
+	}
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+	bind(project) {
+		const store = createSnapshotStore(project());
+		this.subscribe(() => {
+			store.set(project());
+		});
+		return store;
+	}
+	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
+		};
+	}
+	violation() {
+		return this.#violation;
+	}
+	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
+			};
+		}
+	}
+	set(path, value) {
+		this.#stage(path, {
+			kind: "value",
+			value
+		});
+	}
+	setText(path, text, parse) {
+		this.#stage(path, {
+			kind: "text",
+			text,
+			parse
+		});
+	}
+	clear(path) {
+		this.#stage(path, { kind: "clear" });
+	}
+	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));
+	}
+	removeItem(path, index) {
+		this.#stage([...path, String(index)], { kind: "drop" });
+	}
+	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));
+	}
+	removeKey(path, key) {
+		this.#stage([...path, key], { kind: "drop" });
+	}
+	revert(path) {
+		if (!this.#staged.delete(pathKey(path))) return;
+		this.#failed = false;
+		this.#violation = void 0;
+		this.#publish();
+	}
+	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();
+	}
+	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();
+	}
+	#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);
+}
+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;
+}
+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
+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;
+}
+function fieldKey(path) {
+	return JSON.stringify(path);
+}
+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;
+	}
+}
+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 [];
+}
+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
+	}] : []);
+}
+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;
+	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 = 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();
+			}
+		};
+	}
+	namespace() {
+		return this.#ns;
+	}
+	refresh() {
+		this.#store.set(this.#project());
+	}
+	dispose() {
+		for (const dispose of this.#disposers.splice(0)) dispose();
+		this.#model.dispose();
+	}
+	#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());
+	}
+	#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
+var SchemaFormHints = class extends Service {
+	#readers = /* @__PURE__ */ new Map();
+	#texts = /* @__PURE__ */ new Map();
+	#selects = /* @__PURE__ */ new Map();
+	#sources = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Set();
+	constructor(ctx) {
+		super(ctx, "schemaFormHints");
+	}
+	keysFor(ns, path) {
+		return lookup(this.#readers, ns, path)?.() ?? [];
+	}
+	textFor(ns, path) {
+		return lookup(this.#texts, ns, path)?.() ?? {};
+	}
+	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();
+		};
+	}
+	selectFor(ns, path) {
+		return lookup(this.#selects, ns, path);
+	}
+	source(name, spec) {
+		this.#sources.set(name, spec);
+		this.#publish();
+		return () => {
+			if (this.#sources.get(name) !== spec) return;
+			this.#sources.delete(name);
+			this.#publish();
+		};
+	}
+	sourceFor(name) {
+		return this.#sources.get(name);
+	}
+	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();
+		};
+	}
+	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();
+		};
+	}
+	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")}`;
+}
+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
+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
+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;
+}
+const FALLBACK_PRIORITY = 100;
+var RowRegistration = class {
+	#deps;
+	#live = /* @__PURE__ */ new Map();
+	#pending;
+	#disposed = false;
+	constructor(deps) {
+		this.#deps = deps;
+	}
+	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
+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
+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
+	};
+}
+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))
+	};
+}
+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);
+}
+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;
+}
+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
+	};
+}
+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;
+}
+function isNull(value) {
+	return value === null;
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toMerged(target, source) {
+	if (!isPlainObject(target) || !isPlainObject(source)) return source;
+	const result = { ...target };
+	for (const [key, value] of Object.entries(source)) result[key] = key in result ? toMerged(result[key], value) : value;
+	return result;
+}
+function mapKeys(source, map) {
+	const result = {};
+	for (const [key, value] of Object.entries(source)) result[map(key, value)] = value;
+	return result;
+}
+//#endregion
+//#region src/client/styling/token.ts
+const cssVarSymbol = Symbol("cssVar");
+const tokensSymbol = Symbol("tokens");
+const tokenInstSymbol = Symbol("tokenInst");
+const SELF = "$";
+function tokenVars(token, tokens, path) {
+	const reserved = /* @__PURE__ */ new Set([
+		"constructor",
+		"toJSON",
+		"__proto__"
+	]);
+	return new Proxy(() => {}, {
+		apply() {
+			return Token.fallbackVar(token.cssVar(path));
+		},
+		get(_target, property) {
+			if (property === Symbol.toPrimitive || property === Symbol.toStringTag || property === "toString") return () => `var(${token.cssVar(path)})`;
+			if (property === "valueOf") return () => Token.fallbackVar(token.cssVar(path));
+			if (property === tokenInstSymbol) return token;
+			if (property === tokensSymbol) return tokens;
+			if (property === cssVarSymbol) return token.cssVar(path);
+			if (!isString(property) || reserved.has(property)) return void 0;
+			const next = tokens[property];
+			if (isUndefined(next)) return void 0;
+			return tokenVars(token, next, [...path, property]);
+		}
+	});
+}
+var Token = class Token {
+	prefix;
+	static vars(tokens, options = {}) {
+		return tokenVars(new Token(options.prefix ?? ""), tokens, []);
+	}
+	static extendsVars(vars, extra) {
+		const tokens = vars[tokensSymbol] ?? {};
+		return Token.vars(toMerged(tokens, extra));
+	}
+	static assignVars(vars, overwrites) {
+		const tokens = overwrites ?? vars[tokensSymbol] ?? {};
+		const token = vars[tokenInstSymbol] ?? new Token("");
+		const result = {};
+		for (const [name, value] of flattenTokens(token, tokens, [])) result[name] = token.normalize(value);
+		return result;
+	}
+	static variants(variants) {
+		return mapKeys(variants, (key) => `&[data-variant="${key}"]`);
+	}
+	static val(strings, ...values) {
+		return function* () {
+			for (let index = 0; index < strings.length; index += 1) {
+				const literal = strings[index];
+				if (literal) yield literal;
+				if (index >= values.length) continue;
+				const value = values[index];
+				yield* isFunction(value) ? value() : [value];
+			}
+		};
+	}
+	static calc(strings, ...values) {
+		return combinator("calc(", ")", strings, values);
+	}
+	static min(strings, ...values) {
+		return combinator("min(", ")", strings, values);
+	}
+	static max(strings, ...values) {
+		return combinator("max(", ")", strings, values);
+	}
+	static url(strings, ...values) {
+		return combinator("url(", ")", strings, values);
+	}
+	static colorMix(strings, ...values) {
+		return combinator("color-mix(", ")", strings, values);
+	}
+	static colorScale(color, options = {}) {
+		const channel = (name, amount, max) => Token.calc`${name} + (${String(max)} - ${name}) * max(${amount}, 0) + ${name} * min(${amount}, 0)`;
+		const mix = (from, to, amount) => Token.colorMix`in srgb, ${from}, ${to} ${Token.calc`${amount} * 100%`}`;
+		let result = color;
+		if (!isUndefined(options.alpha) || !isUndefined(options.lightness) || !isUndefined(options.saturation)) result = Token.val`hsl(from ${result} h ${isUndefined(options.saturation) ? "s" : channel("s", options.saturation, 100)} ${isUndefined(options.lightness) ? "l" : channel("l", options.lightness, 100)} / ${isUndefined(options.alpha) ? "alpha" : channel("alpha", options.alpha, 1)})`;
+		if (!isUndefined(options.whiteness)) result = mix(result, "white", options.whiteness);
+		if (!isUndefined(options.blackness)) result = mix(result, "black", options.blackness);
+		return result;
+	}
+	static fallbackVar(value, ...fallbacks) {
+		return Object.assign(function* () {
+			yield "var(";
+			for (const [index, item] of [value, ...fallbacks].entries()) {
+				if (index > 0) yield ", ";
+				yield* asIterable(item);
+			}
+			yield ")";
+		}, { [cssVarSymbol]: value });
+	}
+	static collect(value) {
+		const iterable = isFunction(value) ? value() : value;
+		let result = "";
+		for (const item of iterable) result += `${item}`;
+		return result;
+	}
+	constructor(prefix = "") {
+		this.prefix = prefix;
+	}
+	prop = (key) => key.startsWith("--") ? key : kebabCase(key);
+	normalize = (input) => {
+		const value = isFunction(input) ? input() : input;
+		if (typeof value === "number") return `${value}`;
+		if (typeof value === "string") return value;
+		if (isUndefined(value) || isNull(value)) return "";
+		if (isFunction(value)) return Token.collect(value);
+		if (isPlainObject(value) && Symbol.iterator in value) return Token.collect(value);
+		return "";
+	};
+	cssVar = (paths) => `--${[this.prefix, ...paths].filter(Boolean).join("-")}`;
+};
+function combinator(open, close, strings, values) {
+	return function* () {
+		yield open;
+		yield* Token.val(strings, ...values)();
+		yield close;
+	};
+}
+function* asIterable(value) {
+	const resolved = isFunction(value) ? value() : value;
+	const variable = resolved?.[cssVarSymbol];
+	if (!isUndefined(variable)) {
+		yield variable;
+		return;
+	}
+	if (typeof resolved === "object" && resolved !== null && Symbol.iterator in resolved) {
+		yield* resolved;
+		return;
+	}
+	yield resolved;
+}
+function* flattenTokens(token, value, parents) {
+	for (const [property, child] of Object.entries(value)) {
+		if (property === SELF) continue;
+		if (isPlainObject(child)) {
+			yield* flattenTokens(token, child, [...parents, property]);
+			continue;
+		}
+		yield [token.cssVar([...parents, property]), child];
+	}
+}
+function kebabCase(value) {
+	return value.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+//#endregion
+//#region src/client/styling/styling.ts
+var Styling = class Styling {
+	static create() {
+		return new Styling();
+	}
+	static toRule(sheet) {
+		return sheet.selector === void 0 ? sheet.contents.join("") : `${sheet.selector} {${sheet.contents.join("")} }`;
+	}
+	#token = new Token();
+	#sheets = /* @__PURE__ */ new Map();
+	#injected = /* @__PURE__ */ new Set();
+	props = (...styles) => {
+		const merged = mergeStyles(styles);
+		if (Object.keys(merged).length === 0) return {};
+		const sheet = this.#sheet(2, this.#rules(merged));
+		return sheet === void 0 ? {} : { [`data-css-${sheet.id}`]: "" };
+	};
+	keyframes = (frames = {}) => {
+		return this.#sheet(1, this.#rules(frames))?.id ?? "anim-none";
+	};
+	injectGlobals = (styles = {}) => {
+		for (const [name, style] of Object.entries(styles)) this.#sheet(0, this.#rules(style), name);
+	};
+	className = (...styles) => {
+		const merged = mergeStyles(styles);
+		if (Object.keys(merged).length === 0) return "";
+		const sheet = this.#sheet(3, this.#rules(merged));
+		return sheet === void 0 ? "" : `cls-${sheet.id}`;
+	};
+	sheets = () => [...this.#sheets.values()].map((sheet) => Styling.toRule(sheet));
+	#sheet(type, rules, selector) {
+		let hash = 0;
+		const contents = [];
+		for (const rule of rules) {
+			contents.push(rule);
+			hash = incrementalHash(rule, hash);
+		}
+		if (selector !== void 0) hash = incrementalHash(selector, hash);
+		if (hash === 0) return void 0;
+		let id = selector ?? "";
+		if (type === 2) id = `s${hash.toString(36)}`;
+		if (type === 3) id = `c${hash.toString(36)}`;
+		if (type === 0) id = `g${hash.toString(36)}`;
+		if (type === 1) id = `a${hash.toString(36)}`;
+		let resolvedSelector = selector;
+		if (resolvedSelector === void 0) {
+			if (type === 1) resolvedSelector = `@keyframes ${id}`;
+			if (type === 2) resolvedSelector = `[data-css-${id}]`;
+			if (type === 3) resolvedSelector = `.cls-${id}`;
+		}
+		const sheet = {
+			id,
+			contents,
+			selector: resolvedSelector
+		};
+		const existing = this.#sheets.get(id);
+		if (existing !== void 0 && existing.contents.join("") === contents.join("")) return existing;
+		this.#sheets.set(id, sheet);
+		this.#inject(sheet);
+		return sheet;
+	}
+	#inject(sheet) {
+		if (this.#injected.has(sheet.id)) return;
+		this.#injected.add(sheet.id);
+		if (typeof document === "undefined") return;
+		const element = document.createElement("style");
+		element.setAttribute("data-css", sheet.id);
+		element.textContent = Styling.toRule(sheet);
+		document.head.appendChild(element);
+	}
+	*#rules(styles) {
+		const nested = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(styles)) {
+			if (isNull(value) || isUndefined(value)) continue;
+			if (isPlainObject(value)) {
+				nested.set(key, value);
+				continue;
+			}
+			yield ` ${this.#token.prop(key)}: ${this.#token.normalize(value)};`;
+		}
+		for (const [key, value] of nested.entries()) {
+			yield ` ${key} {`;
+			yield* this.#rules(value);
+			yield " }";
+		}
+	}
+};
+function mergeStyles(styles) {
+	return styles.reduce((accumulated, style) => style ? toMerged(accumulated, style) : accumulated, {});
+}
+function incrementalHash(value, previous = 0) {
+	let hash = previous;
+	for (let index = 0; index < value.length; index += 1) {
+		hash = (hash << 5) - hash + value.charCodeAt(index);
+		hash &= 2147483647;
+	}
+	return hash;
+}
+const STYLING_SINGLETON = Symbol.for("@morlay/dsh-client-ui-primitives/styling");
+const globalScope = globalThis;
+const styling = globalScope[STYLING_SINGLETON] ??= Styling.create();
+//#endregion
+//#region src/client/styling/styled.tsx
+const sxSymbol = Symbol("styled.sx");
+function styled(Component, defaultProps = {}) {
+	return (...styles) => {
+		const sx = styles.reduce((merged, style) => toMerged(merged, style), {});
+		const Styled = forwardRef((props, ref) => {
+			const styleProps = useMemo(() => styling.props(sx), []);
+			return createElement(Component, {
+				...defaultProps,
+				...props,
+				...styleProps,
+				ref
+			});
+		});
+		Styled.displayName = `styled(${typeof Component === "string" ? Component : Component.displayName ?? Component.name ?? "Component"})`;
+		return Object.assign(Styled, { [sxSymbol]: sx });
+	};
+}
+function styleOf(component) {
+	return component[sxSymbol];
+}
+//#endregion
+//#region src/client/theme.generated.ts
+const designTokens = {
+	alias: {
+		bg: {
+			base: "var(--dsw-static-neutral-bluish-00)",
+			document: {
+				preview: "var(--dsw-static-neutral-bluish-100)",
+				selection: "color-mix(in srgb, var(--dsw-static-blue-500) 40%, transparent)"
+			},
+			layer: {
+				"1": "var(--dsw-static-neutral-bluish-00)",
+				"2": "var(--dsw-static-neutral-bluish-00)",
+				"3": "var(--dsw-static-neutral-bluish-00)"
+			},
+			mask: {
+				"1": "rgba(0, 0, 0, 0.24)",
+				"2": "rgba(0, 0, 0, 0.12)",
+				"3": "rgba(0, 0, 0, 0.48)",
+				drop: "rgba(255, 255, 255, 0.7)",
+				photo: "rgba(0, 0, 0, 0.88)"
+			},
+			module: { platform: "var(--dsw-static-neutral-bluish-60)" },
+			multi: { select: "var(--dsw-static-neutral-bluish-60)" },
+			overlay: "var(--dsw-static-neutral-bluish-150)",
+			skeleton: "rgba(0, 0, 0, 0.04)"
+		},
+		border: {
+			inverted: "rgba(0, 0, 0, 0)",
+			inverted2: "rgba(0, 0, 0, 0)",
+			l1: "rgba(0, 0, 0, 0.04)",
+			l2: {
+				$: "rgba(0, 0, 0, 0.1)",
+				darkmode: { thin: "rgba(0, 0, 0, 0.1)" }
+			},
+			l3: "rgba(0, 0, 0, 0.12)",
+			l4: "rgba(0, 0, 0, 0.16)"
+		},
+		brand: {
+			primary: {
+				$: "var(--dsw-static-neutral-bluish-1000)",
+				invert: "var(--dsw-static-neutral-bluish-1000)",
+				new: { colorprimary: { new: { color: "rgb(65, 118, 230)" } } }
+			},
+			text: "var(--dsw-static-neutral-bluish-1000)"
+		},
+		button: {
+			contrast: { fill: "var(--dsw-static-neutral-bluish-700)" },
+			elevated: { fill: "var(--dsw-static-neutral-bluish-00)" },
+			floating: {
+				fill: "var(--dsw-static-neutral-bluish-00)",
+				hover: "var(--dsw-static-neutral-bluish-75)"
+			},
+			ghost: { active: {
+				border: "var(--dsw-static-neutral-bluish-500)",
+				fill: "var(--dsw-static-neutral-bluish-100)",
+				hover: "var(--dsw-static-neutral-bluish-150)"
+			} },
+			info: {
+				fill: "var(--dsw-static-deepseek-500)",
+				hover: "var(--dsw-static-deepseek-400)"
+			},
+			primary: {
+				dimmed: "var(--dsw-static-neutral-bluish-100)",
+				fill: "var(--dsw-alias-brand-primary)",
+				hover: "var(--dsw-static-neutral-bluish-750)"
+			},
+			tool: { bar: {
+				fill: {
+					$: "rgba(84, 85, 87, 0.5)",
+					invisible: "rgba(31, 31, 31, 0.36)"
+				},
+				hover: "rgba(84, 85, 87, 0.6)"
+			} }
+		},
+		code: { diff: {
+			added: "var(--dsw-static-green-500-a08)",
+			deleted: "var(--dsw-static-red-600-a08)"
+		} },
+		file: { diff: {
+			added: {
+				bg: "rgb(230, 244, 231)",
+				gutter: "rgb(237, 247, 237)",
+				marker: "rgb(1, 162, 65)"
+			},
+			deleted: {
+				bg: "rgb(252, 230, 226)",
+				gutter: "rgb(253, 236, 233)",
+				marker: "rgb(186, 39, 35)"
+			}
+		} },
+		interactive: { bg: {
+			active: "rgba(38, 49, 72, 0.1)",
+			hover: {
+				$: "rgba(38, 49, 72, 0.06)",
+				accent: "rgba(38, 49, 72, 0.14)",
+				danger: "rgba(236, 19, 19, 0.05)",
+				solid: "var(--dsw-static-neutral-bluish-75)"
+			}
+		} },
+		label: {
+			caption: "var(--dsw-static-neutral-bluish-400)",
+			deep: { diving: {
+				$: "color-mix(in srgb, var(--dsw-static-deepseek-500) 70%, var(--dsw-static-blue-950))",
+				shimmer: "color-mix(in srgb, var(--dsw-static-deepseek-500) 30%, var(--dsw-static-blue-950))"
+			} },
+			dimmed: "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)",
+				dimmed: "var(--dsw-static-neutral-bluish-950)",
+				foreground: "var(--dsw-static-neutral-bluish-00)",
+				inverted: "var(--dsw-static-neutral-bluish-00)"
+			},
+			secondary: "var(--dsw-static-neutral-bluish-700)",
+			shimmer: "color-mix(in srgb, var(--dsw-static-neutral-1000) 30%, transparent)",
+			tertiary: "var(--dsw-static-neutral-bluish-600)"
+		},
+		link: "var(--dsw-static-deepseek-500)",
+		markdown: {
+			citation: "var(--dsw-static-neutral-bluish-100)",
+			code: {
+				block: {
+					$: "var(--dsw-static-neutral-bluish-50)",
+					banner: "var(--dsw-static-neutral-bluish-50)"
+				},
+				segment: {
+					selected: "var(--dsw-static-neutral-bluish-00)",
+					unselected: "var(--dsw-static-neutral-bluish-75)"
+				}
+			},
+			inline: { code: "var(--dsw-static-neutral-50)" },
+			placeholder: "var(--dsw-static-neutral-bluish-60)",
+			tag: "var(--dsw-static-neutral-bluish-75)"
+		},
+		menu: {
+			group: { header: { fill: "rgba(248, 249, 250, 0.94)" } },
+			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)",
+				l2: "var(--dsw-static-neutral-200)"
+			},
+			hover: {
+				l1: "var(--dsw-static-neutral-300)",
+				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)",
+				tertiary: "var(--dsw-static-deepseek-100)"
+			},
+			error: {
+				primary: "var(--dsw-static-red-600)",
+				secondary: "var(--dsw-static-red-400)"
+			},
+			idle: { primary: "var(--dsw-static-neutral-300)" },
+			success: {
+				primary: "var(--dsw-static-green-500)",
+				secondary: "var(--dsw-static-green-400)",
+				tertiary: "var(--dsw-static-green-100)"
+			},
+			warn: {
+				label: "var(--dsw-static-amber-600)",
+				primary: "var(--dsw-static-amber-500)",
+				secondary: "var(--dsw-static-amber-400)",
+				tertiary: "var(--dsw-static-amber-100)"
+			}
+		},
+		switch: { thumb: "var(--dsw-static-neutral-bluish-00)" },
+		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%)" }
+		},
+		turn: { trigger: { bg: {
+			$: "var(--dsw-alias-markdown-code-block)",
+			hover: "var(--dsw-alias-interactive-bg-hover)"
+		} } }
+	},
+	corner: { shape: "superellipse(1.5)" },
+	elevation: {
+		panel: "var(--dsw-elevation-stroke), 0 3px 8px 0 rgba(0, 0, 0, 0.03), 0 0 16px 0 rgba(0, 0, 0, 0.02)",
+		prominent: "var(--dsw-elevation-stroke), 0 3px 8px 0 rgba(0, 0, 0, 0.04), 0 0 20px 0 rgba(0, 0, 0, 0.05)",
+		soft: "var(--dsw-elevation-stroke), 0 4px 16px 0 rgba(0, 0, 0, 0.03), 0 0 24px 0 rgba(0, 0, 0, 0.03)",
+		stroke: {
+			$: "0 0 0 0.5px var(--dsw-elevation-stroke-color)",
+			color: "var(--dsw-alias-border-l4)"
+		}
+	},
+	focus: { ring: {
+		color: "transparent",
+		width: "2px"
+	} },
+	font: {
+		base: {
+			"16": {
+				$: "16px/24px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "16px",
+					style: "normal",
+					weight: "400"
+				},
+				line: { height: "24px" }
+			},
+			strong: { "16": {
+				$: "500 16px/24px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "16px",
+					style: "normal",
+					weight: "500"
+				},
+				line: { height: "24px" }
+			} }
+		},
+		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: {
+				family: "var(--dsw-font-family)",
+				size: "20px",
+				style: "normal",
+				weight: "500"
+			},
+			line: { height: "28px" }
+		} },
+		m: { "18": {
+			$: "500 16px/28px var(--dsw-font-family)",
+			font: {
+				family: "var(--dsw-font-family)",
+				size: "16px",
+				style: "normal",
+				weight: "500"
+			},
+			line: { height: "28px" }
+		} },
+		markdown: {
+			base: {
+				$: "var(--dsh-content-font-size, 14px) / calc(24px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "var(--dsh-content-font-size, 14px)",
+					style: "normal",
+					weight: "400"
+				},
+				italic: {
+					$: "italic var(--dsh-content-font-size, 14px) / calc(24px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+					font: {
+						family: "var(--dsw-font-family)",
+						size: "var(--dsh-content-font-size, 14px)",
+						style: "italic",
+						weight: "400"
+					},
+					line: { height: "calc(24px + var(--dsh-content-font-delta))" }
+				},
+				line: { height: "calc(24px + var(--dsh-content-font-delta))" },
+				strong: {
+					$: "600 var(--dsh-content-font-size, 14px) / calc(24px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+					font: {
+						family: "var(--dsw-font-family)",
+						size: "var(--dsh-content-font-size, 14px)",
+						style: "normal",
+						weight: "600"
+					},
+					italic: {
+						$: "italic 600 var(--dsh-content-font-size, 14px) / calc(24px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+						font: {
+							family: "var(--dsw-font-family)",
+							size: "var(--dsh-content-font-size, 14px)",
+							style: "italic",
+							weight: "600"
+						},
+						line: { height: "calc(24px + var(--dsh-content-font-delta))" }
+					},
+					line: { height: "calc(24px + var(--dsh-content-font-delta))" }
+				}
+			},
+			code: {
+				$: "12px/19px var(--ds-font-family-code)",
+				block: {
+					$: "11px/19px var(--ds-font-family-code)",
+					font: {
+						family: "var(--ds-font-family-code)",
+						size: "11px",
+						style: "normal",
+						weight: "400"
+					},
+					line: { height: "19px" },
+					small: {
+						$: "11px/16px var(--ds-font-family-code)",
+						font: {
+							family: "var(--ds-font-family-code)",
+							size: "11px",
+							style: "normal",
+							weight: "400"
+						},
+						line: { height: "16px" }
+					}
+				},
+				font: {
+					family: "var(--ds-font-family-code)",
+					size: "12px",
+					style: "normal",
+					weight: "400"
+				},
+				line: { height: "19px" }
+			},
+			h1: {
+				$: "700 calc(21px + var(--dsh-content-font-delta)) / calc(30px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "calc(21px + var(--dsh-content-font-delta))",
+					style: "normal",
+					weight: "700"
+				},
+				line: { height: "calc(30px + var(--dsh-content-font-delta))" }
+			},
+			h2: {
+				$: "700 calc(19px + var(--dsh-content-font-delta)) / calc(28px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "calc(19px + var(--dsh-content-font-delta))",
+					style: "normal",
+					weight: "700"
+				},
+				line: { height: "calc(28px + var(--dsh-content-font-delta))" }
+			},
+			h3: {
+				$: "700 calc(18px + var(--dsh-content-font-delta)) / calc(26px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "calc(18px + var(--dsh-content-font-delta))",
+					style: "normal",
+					weight: "700"
+				},
+				line: { height: "calc(26px + var(--dsh-content-font-delta))" }
+			},
+			h4: {
+				$: "600 var(--dsh-content-font-size, 14px) / calc(24px + var(--dsh-content-font-delta)) var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "var(--dsh-content-font-size, 14px)",
+					style: "normal",
+					weight: "600"
+				},
+				line: { height: "calc(24px + var(--dsh-content-font-delta))" }
+			},
+			small: {
+				$: "12px/20px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "12px",
+					style: "normal",
+					weight: "400"
+				},
+				italic: {
+					$: "italic 12px/20px var(--dsw-font-family)",
+					font: {
+						family: "var(--dsw-font-family)",
+						size: "12px",
+						style: "italic",
+						weight: "400"
+					},
+					line: { height: "20px" }
+				},
+				line: { height: "20px" },
+				strong: {
+					$: "600 12px/20px var(--dsw-font-family)",
+					font: {
+						family: "var(--dsw-font-family)",
+						size: "12px",
+						style: "normal",
+						weight: "600"
+					},
+					italic: {
+						$: "italic 600 12px/20px var(--dsw-font-family)",
+						font: {
+							family: "var(--dsw-font-family)",
+							size: "12px",
+							style: "italic",
+							weight: "600"
+						},
+						line: { height: "20px" }
+					},
+					line: { height: "20px" }
+				}
+			},
+			table: {
+				$: "var(--dsh-content-font-size-secondary, 13px)/calc(22px + var(--dsh-content-font-delta-secondary, 0px)) var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "var(--dsh-content-font-size-secondary, 13px)",
+					style: "normal",
+					weight: "400"
+				},
+				head: {
+					$: "500 var(--dsh-content-font-size-secondary, 13px)/calc(22px + var(--dsh-content-font-delta-secondary, 0px)) var(--dsw-font-family)",
+					font: {
+						family: "var(--dsw-font-family)",
+						size: "var(--dsh-content-font-size-secondary, 13px)",
+						style: "normal",
+						weight: "500"
+					},
+					line: { height: "calc(22px + var(--dsh-content-font-delta-secondary, 0px))" }
+				},
+				line: { height: "calc(22px + var(--dsh-content-font-delta-secondary, 0px))" }
+			}
+		},
+		s: {
+			"14": {
+				$: "14px/22px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "14px",
+					style: "normal",
+					weight: "400"
+				},
+				line: { height: "22px" }
+			},
+			strong: { "14": {
+				$: "500 14px/22px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "14px",
+					style: "normal",
+					weight: "500"
+				},
+				line: { height: "22px" }
+			} }
+		},
+		xl: { "24": {
+			$: "600 24px/32px var(--dsw-font-family)",
+			font: {
+				family: "var(--dsw-font-family)",
+				size: "24px",
+				style: "normal",
+				weight: "600"
+			},
+			line: { height: "32px" }
+		} },
+		xs: {
+			"13": {
+				$: "13px/20px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "13px",
+					style: "normal",
+					weight: "400"
+				},
+				line: { height: "20px" }
+			},
+			strong: { "13": {
+				$: "500 13px/20px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "13px",
+					style: "normal",
+					weight: "500"
+				},
+				line: { height: "20px" }
+			} }
+		},
+		xxs: {
+			"12": {
+				$: "12px/18px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "12px",
+					style: "normal",
+					weight: "400"
+				},
+				line: { height: "18px" }
+			},
+			strong: { "12": {
+				$: "500 12px/18px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "12px",
+					style: "normal",
+					weight: "500"
+				},
+				line: { height: "18px" }
+			} }
+		},
+		xxxs: {
+			"11": {
+				$: "11px/14px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "11px",
+					style: "normal",
+					weight: "400"
+				},
+				line: { height: "14px" }
+			},
+			strong: { "11": {
+				$: "500 11px/14px var(--dsw-font-family)",
+				font: {
+					family: "var(--dsw-font-family)",
+					size: "11px",
+					style: "normal",
+					weight: "500"
+				},
+				line: { height: "14px" }
+			} }
+		}
+	},
+	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: "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)",
+			blur: "0 4px 12px 0 rgba(0, 0, 0, 0.02)"
+		},
+		lv2: "0 4px 12px 0 rgba(0, 0, 0, 0.02), 0 2px 8px 0 rgba(0, 0, 0, 0.04)",
+		lv3: "0 0 1px 0 rgba(0, 0, 0, 0.2), 0 0 4px 0 rgba(0, 0, 0, 0.02), 0 12px 32px 0 rgba(0, 0, 0, 0.08)"
+	},
+	specific: {
+		bubble: {
+			$: "var(--dsw-static-deepseek-50)",
+			highlight: "var(--dsw-static-deepseek-200)"
+		},
+		input: { major: "var(--dsw-static-neutral-bluish-00)" },
+		login: { input: "var(--dsw-static-neutral-bluish-50)" },
+		menu: "var(--dsw-menu-surface-fill)",
+		selector: "var(--dsw-static-neutral-bluish-60)",
+		sidebar: {
+			fill: "var(--dsw-static-neutral-bluish-50)",
+			nav: { item: {
+				active: {
+					$: "var(--dsw-static-neutral-bluish-100)",
+					accent: "var(--dsw-static-deepseek-100)"
+				},
+				hover: "var(--dsw-static-neutral-bluish-75)"
+			} }
+		},
+		tip: "var(--dsw-static-neutral-bluish-60)"
+	},
+	static: {
+		amber: {
+			"100": "rgb(254, 245, 231)",
+			"400": "rgb(247, 173, 49)",
+			"500": "rgb(245, 158, 11)",
+			"600": "rgb(221, 134, 41)",
+			"900": "rgb(39, 36, 31)"
+		},
+		blue: {
+			"50": "rgb(239, 246, 255)",
+			"75": "rgb(229, 240, 255)",
+			"100": "rgb(219, 234, 254)",
+			"300": "rgb(147, 197, 253)",
+			"400": "rgb(96, 165, 250)",
+			"450": "rgb(77, 147, 248)",
+			"500": "rgb(59, 130, 246)",
+			"600": "rgb(37, 99, 235)",
+			"800": "rgb(30, 64, 175)",
+			"900": "rgb(14, 48, 116)",
+			"950": "rgb(23, 37, 84)",
+			"50p": "rgb(234, 243, 255)"
+		},
+		deepseek: {
+			"50": "rgb(237, 243, 254)",
+			"100": "rgb(228, 237, 253)",
+			"200": "rgb(211, 226, 255)",
+			"300": "rgb(183, 200, 254)",
+			"400": "rgb(122, 170, 255)",
+			"450": "rgb(86, 134, 254)",
+			"500": "rgb(65, 118, 230)",
+			"600": "rgb(72, 104, 178)",
+			"700": { delete: "rgb(47, 76, 143)" },
+			"800": "rgb(52, 65, 91)",
+			"900": "rgb(40, 49, 66)"
+		},
+		green: {
+			"100": "rgb(230, 250, 237)",
+			"400": "rgb(78, 209, 126)",
+			"500": {
+				$: "rgb(34, 197, 94)",
+				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)"
+			}
+		},
+		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
+const MONO = "ui-monospace, SFMono-Regular, \"SF Mono\", Menlo, Consolas, monospace";
+const ROW = "22px";
+const GAP = "6px";
+const ACTION = "20px";
+const ACTION_GAP = "4px";
+const FOLD = "14px";
+const NUMBER = "32px";
+const PAD = "8px";
+const HAIRLINE = dsw.elevation.stroke;
+const LINE = dsw.elevation.stroke.color;
+const EDGE = "2px";
+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"
+});
+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
+});
+const LineValue = styled("span")({
+	display: "block",
+	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 ValueSlot = styled("span")({
+	display: "block",
+	flex: "0 1 auto",
+	minWidth: 0,
+	overflow: "hidden"
+});
+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" }
+});
+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
+	}
+});
+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: "0 1 auto",
+	minWidth: 0,
+	overflow: "hidden",
+	textOverflow: "ellipsis",
+	color: dsw.alias.state.error.primary,
+	fontFamily: "inherit",
+	fontSize: "12px"
+});
+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
+		}
+	}
+}))({ "&[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/TruncatedTooltip.tsx
+function TruncatedTooltip({ label, children }) {
+	const node = useRef(null);
+	const watch = useRef(null);
+	const [truncated, setTruncated] = useState(false);
+	const measure = useCallback(() => {
+		const el = node.current;
+		if (el === null) return;
+		setTruncated(el.scrollWidth > el.clientWidth);
+	}, []);
+	const anchor = useCallback((el) => {
+		watch.current?.disconnect();
+		watch.current = null;
+		node.current = el;
+		if (el === null) return;
+		const observer = new ResizeObserver(measure);
+		observer.observe(el);
+		watch.current = observer;
+	}, [measure]);
+	useLayoutEffect(measure);
+	return /* @__PURE__ */ jsx(Tooltip, {
+		label,
+		side: "bottom",
+		portal: true,
+		disabled: !truncated,
+		children: cloneElement(children, { ref: anchor })
+	});
+}
+//#endregion
+//#region src/client/schema-form/value.tsx
+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);
+}
+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";
+}
+function InlineValue({ owner }) {
+	if (owner.options !== void 0) return /* @__PURE__ */ jsx(OptionSelect, {
+		owner,
+		options: owner.options
+	});
+	if (owner.node.meta.secret) return /* @__PURE__ */ jsx(LineValue, {
+		"data-tone": "empty",
+		title: owner.hint,
+		children: owner.secretConfigured ? "••••••" : ""
+	});
+	const text = tokenText(owner.value);
+	return /* @__PURE__ */ jsx(TruncatedTooltip, {
+		label: text,
+		children: /* @__PURE__ */ jsx(LineValue, {
+			"data-tone": owner.node.readOnly === null ? tokenTone(owner.value) : "empty",
+			children: text
+		})
+	});
+}
+function OptionSelect({ owner, options }) {
+	const [open, setOpen] = 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__ */ jsx(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__ */ jsxs(ValueTrigger, {
+			type: "button",
+			disabled: owner.disabled,
+			"aria-label": owner.label,
+			onClick: () => {
+				setOpen(true);
+			},
+			children: [/* @__PURE__ */ jsx(LineValue, {
+				"data-tone": current === void 0 ? tokenTone(owner.value) : tokenTone(current.value),
+				children: label
+			}), /* @__PURE__ */ jsx(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);
+}
+function SchemaFieldDefault({ owner }) {
+	return /* @__PURE__ */ jsx(InlineValue, { owner });
+}
+//#endregion
+//#region src/client/schema-form/fields.tsx
+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
+function Editor(props) {
+	const { ns, state, face, t, resolveText, renderField } = props;
+	const [toggled, setToggled] = useState(() => /* @__PURE__ */ new Set());
+	const [editing, setEditing] = useState(void 0);
+	const [selected, setSelected] = useState(void 0);
+	const [dismissed, setDismissed] = useState(() => /* @__PURE__ */ new Set());
+	const fold = useFold(state, toggled, setToggled);
+	const lines = useMemo(() => editorLines(state, fold, resolveText, t), [
+		state,
+		fold,
+		resolveText,
+		t
+	]);
+	const disabled = !state.writable || !state.available;
+	return /* @__PURE__ */ jsx(EditorRoot, {
+		"data-editor": "schema-form",
+		children: lines.map((line, index) => /* @__PURE__ */ 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)}`))
+	});
+}
+function useFold(state, toggled, setToggled) {
+	const defaults = 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 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__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(LineFoldSpacer, { "data-role": "fold" }), /* @__PURE__ */ jsx(TruncatedTooltip, {
+		label: line.text,
+		children: line.invalid ? /* @__PURE__ */ jsx(LineInvalid, {
+			"data-role": "comment",
+			children: `// ${line.text}`
+		}) : /* @__PURE__ */ jsx(LineComment, {
+			"data-role": "comment",
+			children: `// ${line.text}`
+		})
+	})] }) : line.kind === "open" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(LineFold, {
+			"data-role": "fold",
+			type: "button",
+			"aria-expanded": !line.collapsed,
+			"aria-label": t("toggleGroup"),
+			onClick: () => {
+				fold.toggle(line.path);
+			},
+			children: line.collapsed ? /* @__PURE__ */ jsx(IconChevronRightOutlineRegular, { size: 14 }) : /* @__PURE__ */ jsx(IconChevronDownOutlineRegular, { size: 14 })
+		}),
+		/* @__PURE__ */ jsx(LinePrefix, {
+			line,
+			face,
+			t,
+			disabled
+		}),
+		/* @__PURE__ */ jsx(LineToken, { children: line.shape === "object" ? line.collapsed ? "{…}" : "{" : line.collapsed ? "[…]" : "[" }),
+		/* @__PURE__ */ jsx(VariantSelect, {
+			control: line.variants,
+			path: line.path,
+			face,
+			disabled,
+			t
+		})
+	] }) : line.kind === "close" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(LineFoldSpacer, { "data-role": "fold" }),
+		/* @__PURE__ */ jsx(LineToken, { children: line.shape === "object" ? "}" : "]" }),
+		/* @__PURE__ */ jsx(AddLine, {
+			line,
+			state,
+			face,
+			t,
+			resolveText,
+			disabled,
+			onAdded
+		})
+	] }) : /* @__PURE__ */ jsx(FieldLine, {
+		line,
+		ns,
+		state,
+		face,
+		t,
+		disabled,
+		editing,
+		dismissed,
+		onEdit,
+		onDismiss,
+		renderField
+	});
+	return /* @__PURE__ */ 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__ */ jsx(LineNumber, {
+			"data-role": "number",
+			onClick: () => {
+				onSelect(line.path);
+			},
+			children: n
+		}), /* @__PURE__ */ jsx(LineBody, {
+			"data-role": "body",
+			style: indent,
+			children: body
+		})]
+	});
+}
+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__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(LineFoldSpacer, { "data-role": "fold" }),
+		/* @__PURE__ */ 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__ */ jsx(LineToken, { children: member?.index === void 0 ? ": " : "  " }),
+		isEditing ? multiline ? /* @__PURE__ */ jsx(CompactTextField, { children: /* @__PURE__ */ 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__ */ jsx(CompactInput, { children: /* @__PURE__ */ jsx(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);
+				}
+			}
+		}) }) : null,
+		isEditing || line.variantsStandIn ? null : /* @__PURE__ */ jsx(ValueSlot, {
+			"data-role": "value",
+			onClick: () => {
+				if (editable) onEdit(key);
+			},
+			children: renderField(owner)
+		}),
+		/* @__PURE__ */ jsx(VariantSelect, {
+			control: line.variants,
+			path: line.path,
+			face,
+			disabled,
+			t
+		}),
+		isEditing ? /* @__PURE__ */ jsxs(HoverActions, {
+			"data-role": "actions",
+			"data-editing": "true",
+			children: [/* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": t("confirmEdit"),
+				title: t("confirmEdit"),
+				onClick: () => {
+					onEdit(void 0);
+				},
+				children: /* @__PURE__ */ jsx(IconCheckOutlineRegular, { size: 14 })
+			}), /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": t("cancelEdit"),
+				title: t("cancelEdit"),
+				onClick: () => {
+					face.revert(line.path);
+					onEdit(void 0);
+					onDismiss(key);
+				},
+				children: /* @__PURE__ */ jsx(IconCloseOutlineRegular, { size: 14 })
+			})]
+		}) : null,
+		/* @__PURE__ */ jsxs(HoverActions, {
+			"data-role": "actions",
+			children: [
+				line.field.staged && !disabled ? /* @__PURE__ */ jsx("button", {
+					type: "button",
+					"aria-label": t("revert"),
+					title: t("revert"),
+					onClick: () => {
+						face.revert(line.path);
+					},
+					children: /* @__PURE__ */ jsx(IconRefreshOutlineRegular, { size: 14 })
+				}) : null,
+				line.field.overridden && !line.field.staged && !disabled ? /* @__PURE__ */ jsx("button", {
+					type: "button",
+					"aria-label": t("reset"),
+					title: t("reset"),
+					onClick: () => {
+						face.clear(line.path);
+					},
+					children: /* @__PURE__ */ jsx(IconRefreshOutlineRegular, { size: 14 })
+				}) : null,
+				/* @__PURE__ */ 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__ */ jsx(IconCopyOutlineRegular, { size: 14 })
+				}),
+				member === void 0 ? null : /* @__PURE__ */ jsx(RemoveLineButton, {
+					member,
+					face,
+					t,
+					disabled
+				})
+			]
+		})
+	] });
+}
+function tokenFor(value) {
+	return typeof value === "string" ? JSON.stringify(value) : JSON.stringify(value ?? null);
+}
+function VariantSelect({ control, path, face, disabled, t }) {
+	const [open, setOpen] = useState(false);
+	if (control === void 0) return null;
+	const current = control.choices[control.selected];
+	return /* @__PURE__ */ jsx(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__ */ jsxs(ValueTrigger, {
+			type: "button",
+			"data-role": "variant",
+			disabled,
+			"aria-label": t("switchVariant"),
+			onClick: () => {
+				setOpen(true);
+			},
+			children: [/* @__PURE__ */ jsx(LineValue, {
+				"data-tone": "empty",
+				children: current?.label ?? ""
+			}), /* @__PURE__ */ jsx(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__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(LineKey, {
+			"data-role": "key",
+			"data-index": indexed ? "true" : void 0,
+			title: key,
+			children: key
+		}),
+		/* @__PURE__ */ jsx(LineToken, { children: indexed ? "  " : ": " }),
+		member === void 0 ? null : /* @__PURE__ */ jsx(HoverActions, {
+			"data-role": "actions",
+			children: /* @__PURE__ */ jsx(RemoveLineButton, {
+				member,
+				face,
+				t,
+				disabled
+			})
+		})
+	] });
+}
+function RemoveLineButton({ member, face, t, disabled }) {
+	return /* @__PURE__ */ 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__ */ jsx(IconTrashOutlineRegular, { size: 14 })
+	});
+}
+function AddLine({ line, state, face, t, resolveText, disabled, onAdded }) {
+	const spec = line.add;
+	const [text, setText] = useState("");
+	const [open, setOpen] = useState(false);
+	const [invalid, setInvalid] = 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__ */ jsxs(AddWrap, {
+		"data-add": spec.kind,
+		"data-invalid": invalid ? "true" : void 0,
+		children: [
+			/* @__PURE__ */ jsx(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__ */ jsx(CompactInput, { children: /* @__PURE__ */ jsx(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__ */ jsx(LineInvalid, { children: t("unknownProperty") }) : null,
+			!invalid && matched.length === 1 && matched[0]?.description !== void 0 ? /* @__PURE__ */ jsx(TruncatedTooltip, {
+				label: resolveText(matched[0].description),
+				children: /* @__PURE__ */ jsx(LineComment, { children: resolveText(matched[0].description) })
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/client/schema-form/SchemaForm.tsx
+function SchemaForm(props) {
+	const { ns, face, t, resolveText, renderSlotChain } = props;
+	const store = face.hooks.schemaForm;
+	const state = 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__ */ jsx(Hint$1, {
+		role: "status",
+		children: t("noSchema")
+	});
+	return /* @__PURE__ */ jsxs(SettingsForm$1, {
+		labels,
+		state,
+		onSave: () => {
+			face.save();
+		},
+		onDiscard: () => {
+			face.discard();
+		},
+		children: [/* @__PURE__ */ jsx(Editor, {
+			ns,
+			state,
+			face,
+			t,
+			resolveText,
+			renderField: (owner) => renderSlotChain("settings.schema-form.field", owner, { fallback: /* @__PURE__ */ jsx(SchemaFieldDefault, { owner: {
+				...owner,
+				onEditText: withParse(owner, t)
+			} }) })
+		}), state.violation === void 0 ? null : /* @__PURE__ */ 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";
+const inject$1 = [
+	"slots",
+	"locale",
+	"configForms",
+	"settingsSchema",
+	"remote",
+	"remote.pluginManager"
+];
+function apply$1(ctx) {
+	ctx.inject([...inject$1], (scope) => {
+		if (scope.get("schemaFormHints") !== void 0) return;
+		install(scope);
+	});
+}
+function install(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) {
+	return {
+		code: {
+			copyLabel: t("copy"),
+			copiedLabel: t("copied")
+		},
+		footnotes: t("markdown.footnotes")
+	};
+}
+//#endregion
+//#region src/client/settings-form/form-model.ts
+function settingsNumberField(field) {
+	return {
+		field,
+		format: (value) => typeof value === "number" ? String(value) : "",
+		parse: (text) => {
+			const trimmed = text.trim();
+			if (trimmed === "") return { kind: "clear" };
+			const parsed = Number(trimmed);
+			return Number.isFinite(parsed) ? {
+				kind: "set",
+				value: parsed
+			} : void 0;
+		}
+	};
+}
+function settingsTextField(field) {
+	return {
+		field,
+		format: (value) => typeof value === "string" ? value : "",
+		parse: (text) => {
+			const trimmed = text.trim();
+			return trimmed === "" ? { kind: "clear" } : {
+				kind: "set",
+				value: trimmed
+			};
+		}
+	};
+}
+var SettingsFormModel = class {
+	scope;
+	specs;
+	secretSpecs;
+	staged = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	baseline;
+	unsubscribe;
+	saving = false;
+	failed = false;
+	constructor(scope, specs, secrets = []) {
+		this.scope = scope;
+		this.specs = new Map(specs.map((spec) => [spec.field, spec]));
+		this.secretSpecs = new Map(secrets.map((spec) => [spec.field, spec]));
+		this.unsubscribe = scope.subscribe(() => {
+			this.publish();
+		});
+	}
+	bind(project) {
+		const store = createSnapshotStore(project());
+		this.listeners.add(() => {
+			store.set(project());
+		});
+		return store;
+	}
+	shell() {
+		const snapshot = this.scope.getSnapshot();
+		const plan = this.plan();
+		return {
+			available: snapshot.status === "ready",
+			writable: snapshot.writable,
+			dirty: plan.length > 0,
+			invalid: plan.some((item) => item.run === void 0 && item.op === void 0),
+			saving: this.saving,
+			failed: this.failed
+		};
+	}
+	field(field) {
+		const staged = this.staged.get(field);
+		if (this.secretSpecs.has(field)) return {
+			text: staged?.text ?? "",
+			overridden: false,
+			invalid: false
+		};
+		const spec = this.spec(field);
+		if (staged === void 0) return {
+			text: spec.format(this.sectionValue(field)),
+			overridden: this.stored(field),
+			invalid: false
+		};
+		const write = staged.clear ? { kind: "clear" } : spec.parse(staged.text);
+		return {
+			text: staged.text,
+			overridden: write?.kind === "set",
+			invalid: write === void 0
+		};
+	}
+	actions() {
+		return {
+			edit: (field, text) => {
+				this.stage(field, {
+					text,
+					clear: false
+				});
+			},
+			resetField: (field) => {
+				this.stage(field, {
+					text: this.spec(field).format(this.baseValue(field)),
+					clear: true
+				});
+			},
+			save: () => {
+				this.save();
+			},
+			discard: () => {
+				if (this.staged.size === 0 && !this.failed) return;
+				this.staged.clear();
+				this.baseline = void 0;
+				this.failed = false;
+				this.publish();
+			}
+		};
+	}
+	async save() {
+		const plan = this.plan();
+		if (!plan.length || this.saving || !this.scope.getSnapshot().writable || plan.some((item) => item.run === void 0 && item.op === void 0)) return;
+		this.saving = true;
+		this.failed = false;
+		this.publish();
+		try {
+			const ops = plan.flatMap((item) => item.op === void 0 ? [] : [item.op]);
+			let landed = !ops.length || await this.scope.mutate(ops, this.baseline?.revision);
+			if (!landed) {
+				this.failed = true;
+				return;
+			}
+			for (const item of plan) if (item.run) landed = await item.run() && landed;
+			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();
+	}
+	plan() {
+		const plan = [];
+		for (const [field, staged] of this.staged) {
+			const secret = this.secretSpecs.get(field);
+			if (secret !== void 0) {
+				const value = staged.text.trim();
+				if (value !== "") plan.push({
+					field,
+					run: () => secret.write(value)
+				});
+				continue;
+			}
+			const spec = this.spec(field);
+			if (staged.clear) {
+				if (this.stored(field)) plan.push({
+					field,
+					op: {
+						op: "unset",
+						path: [field]
+					}
+				});
+				continue;
+			}
+			if (staged.text === spec.format(this.sectionValue(field))) continue;
+			const write = spec.parse(staged.text);
+			if (write === void 0) plan.push({ field });
+			else if (write.kind === "clear") plan.push({
+				field,
+				op: {
+					op: "unset",
+					path: [field]
+				}
+			});
+			else plan.push({
+				field,
+				op: {
+					op: "set",
+					path: [field],
+					value: write.value
+				}
+			});
+		}
+		return plan;
+	}
+	stage(field, edit) {
+		this.baseline ??= this.scope.getSnapshot();
+		this.staged.set(field, edit);
+		this.failed = false;
+		this.publish();
+	}
+	spec(field) {
+		const spec = this.specs.get(field);
+		if (spec === void 0) throw new Error(`plugin card has no field ${field}`);
+		return spec;
+	}
+	snapshotOf() {
+		return this.scope.getSnapshot();
+	}
+	sectionValue(field) {
+		return this.snapshotOf().value?.[field];
+	}
+	baseValue(field) {
+		return this.snapshotOf().base?.[field];
+	}
+	userLayer() {
+		return this.snapshotOf().user;
+	}
+	stored(field) {
+		const user = this.userLayer();
+		return user !== void 0 && Object.hasOwn(user, field);
+	}
+	publish() {
+		for (const listener of this.listeners) listener();
+	}
+};
+//#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 = {
+	field: {
+		display: "flex",
+		flexDirection: "column",
+		gap: "6px",
+		padding: "12px 0",
+		"& + &": { borderTop: `0.5px solid ${String(dsw.alias.border.l2)}` }
+	},
+	head: {
+		display: "flex",
+		alignItems: "center",
+		gap: "8px"
+	},
+	label: {
+		flex: 1,
+		minWidth: 0,
+		fontSize: "13px",
+		fontWeight: 500,
+		lineHeight: 1.5,
+		color: dsw.alias.label.primary
+	},
+	groupLabel: { flex: "0 1 auto" },
+	labelGroup: {
+		display: "flex",
+		alignItems: "center",
+		gap: "4px",
+		flex: 1,
+		minWidth: 0
+	},
+	helpButton: {
+		display: "inline-flex",
+		alignItems: "center",
+		justifyContent: "center",
+		flex: "none",
+		width: "24px",
+		height: "24px",
+		padding: 0,
+		border: 0,
+		borderRadius: "6px",
+		background: "none",
+		color: dsw.alias.label.tertiary,
+		cursor: "pointer",
+		"&:hover": {
+			background: helpButtonHoverBackground,
+			color: dsw.alias.label.secondary
+		},
+		"&[aria-expanded='true']": {
+			background: helpButtonHoverBackground,
+			color: dsw.alias.label.secondary
+		},
+		"&:focus-visible": {
+			outline: focusRing,
+			outlineOffset: "1px"
+		}
+	},
+	help: {
+		padding: "10px 0 0",
+		fontSize: "12px",
+		lineHeight: 1.6,
+		color: dsw.alias.label.secondary,
+		"& > p": { margin: 0 },
+		"& > p + p": { marginTop: "8px" }
+	},
+	badges: {
+		display: "inline-flex",
+		alignItems: "center",
+		gap: "8px"
+	},
+	badge: {
+		display: "inline-flex",
+		alignItems: "center",
+		borderRadius: "999px",
+		cornerShape: "round",
+		padding: "1px 8px",
+		fontSize: "11px",
+		lineHeight: "17px",
+		fontWeight: 500,
+		whiteSpace: "nowrap"
+	},
+	badgeNeutral: {
+		background: dsw.alias.bg.module.platform,
+		color: dsw.alias.label.secondary
+	},
+	badgeQuiet: { color: dsw.alias.label.tertiary },
+	reset: {
+		border: "none",
+		background: "none",
+		padding: 0,
+		font: "inherit",
+		fontSize: "12px",
+		lineHeight: 1.5,
+		color: dsw.alias.label.secondary,
+		cursor: "pointer",
+		"&:hover:not(:disabled)": { color: dsw.alias.label.primary },
+		"&:disabled": { cursor: "default" }
+	},
+	input: {
+		height: "34px",
+		padding: "0 12px",
+		border: `0.5px solid ${String(dsw.alias.border.l4)}`,
+		borderRadius: "8px",
+		background: dsw.alias.bg.layer["3"],
+		font: "inherit",
+		fontSize: "13px",
+		lineHeight: 1.5,
+		color: dsw.alias.label.primary,
+		"&:focus-visible": {
+			outline: "none",
+			borderColor: dsw.alias.state.business.primary
+		},
+		"&:disabled": {
+			color: dsw.alias.label.tertiary,
+			cursor: "default"
+		},
+		"&[aria-invalid='true']": { borderColor: dsw.alias.state.error.primary }
+	},
+	invalid: {
+		margin: 0,
+		fontSize: "12px",
+		lineHeight: 1.5,
+		color: dsw.alias.state.error.primary
+	},
+	hint: {
+		margin: 0,
+		fontSize: "12px",
+		lineHeight: 1.5,
+		color: dsw.alias.label.tertiary
+	}
+};
+//#endregion
+//#region src/client/settings-form/fields.tsx
+const Field = styled("div")(styles$1.field);
+const Head = styled("div")(styles$1.head);
+const LabelGroup = styled("div")(styles$1.labelGroup);
+const GroupLabel = styled("label")(styles$1.label, styles$1.groupLabel);
+const HeadLabel = styled("label")(styles$1.label);
+const HelpButton = styled("button")(styles$1.helpButton);
+const Help = styled("div")(styles$1.help);
+const Badges = styled("span")(styles$1.badges);
+const NeutralBadge = styled("span")(styles$1.badge, styles$1.badgeNeutral);
+const QuietBadge = styled("span")(styles$1.badge, styles$1.badgeQuiet);
+const Reset = styled("button")(styles$1.reset);
+const Input$1 = styled("input")(styles$1.input);
+const Invalid = styled("p")(styles$1.invalid);
+const Hint = styled("p")(styles$1.hint);
+function InfoGlyph({ size }) {
+	return /* @__PURE__ */ jsxs("svg", {
+		width: size,
+		height: size,
+		viewBox: "0 0 14 14",
+		fill: "none",
+		xmlns: "http://www.w3.org/2000/svg",
+		"aria-hidden": "true",
+		children: [
+			/* @__PURE__ */ jsx("path", {
+				d: "M12.5757 7.00012C12.5757 3.92085 10.0794 1.42463 7.00012 1.42456C3.9208 1.42456 1.42456 3.9208 1.42456 7.00012C1.42463 10.0794 3.92085 12.5757 7.00012 12.5757C10.0793 12.5756 12.5756 10.0793 12.5757 7.00012ZM13.8002 7.00012C13.8001 10.7559 10.7559 13.8001 7.00012 13.8002C3.2443 13.8002 0.199291 10.7559 0.199219 7.00012C0.199219 3.24426 3.24426 0.199219 7.00012 0.199219C10.7559 0.199291 13.8002 3.2443 13.8002 7.00012Z",
+				fill: "currentColor"
+			}),
+			/* @__PURE__ */ jsx("path", {
+				d: "M7.6127 3.18921V4.55986H6.38735V3.18921H7.6127Z",
+				fill: "currentColor"
+			}),
+			/* @__PURE__ */ jsx("path", {
+				d: "M7.6127 5.68921V10.8109H6.38735V5.68921H7.6127Z",
+				fill: "currentColor"
+			})
+		]
+	});
+}
+function SettingsValueField(props) {
+	const [helpOpen, setHelpOpen] = useState(false);
+	const helpId = `${props.id}-help`;
+	const messageId = `${props.id}-message`;
+	const hasMessage = props.invalid || Boolean(props.hint);
+	const description = [hasMessage ? messageId : "", helpOpen ? helpId : ""].filter(Boolean).join(" ");
+	return /* @__PURE__ */ jsxs(Field, { children: [
+		/* @__PURE__ */ jsxs(Head, { children: [/* @__PURE__ */ jsxs(LabelGroup, { children: [/* @__PURE__ */ jsx(GroupLabel, {
+			htmlFor: props.id,
+			children: props.label
+		}), props.help !== void 0 ? /* @__PURE__ */ jsx(HelpButton, {
+			type: "button",
+			"aria-label": props.help.label,
+			"aria-expanded": helpOpen,
+			"aria-controls": helpId,
+			onClick: () => {
+				setHelpOpen(!helpOpen);
+			},
+			children: /* @__PURE__ */ jsx(InfoGlyph, { size: 12 })
+		}) : null] }), props.overridden ? /* @__PURE__ */ jsxs(Badges, { children: [/* @__PURE__ */ jsx(NeutralBadge, { children: props.overriddenLabel }), /* @__PURE__ */ jsx(Reset, {
+			type: "button",
+			disabled: props.disabled,
+			onClick: props.onReset,
+			children: props.resetLabel
+		})] }) : null] }),
+		/* @__PURE__ */ jsx(Input$1, {
+			id: props.id,
+			type: "text",
+			...props.numeric === true ? { inputMode: "numeric" } : {},
+			...props.invalid ? { "aria-invalid": true } : {},
+			"aria-describedby": description || void 0,
+			value: props.text,
+			placeholder: props.placeholder ?? "",
+			disabled: props.disabled,
+			onChange: (event) => {
+				props.onEdit(event.target.value);
+			}
+		}),
+		hasMessage ? props.invalid ? /* @__PURE__ */ jsx(Invalid, {
+			id: messageId,
+			children: props.invalidLabel
+		}) : /* @__PURE__ */ jsx(Hint, {
+			id: messageId,
+			children: props.hint
+		}) : null,
+		props.help !== void 0 && helpOpen ? /* @__PURE__ */ jsx(Help, {
+			id: helpId,
+			role: "region",
+			"aria-label": props.help.label,
+			children: props.help.content
+		}) : null
+	] });
+}
+function SettingsSecretField(props) {
+	const Badge = props.configured ? NeutralBadge : QuietBadge;
+	return /* @__PURE__ */ jsxs(Field, { children: [
+		/* @__PURE__ */ jsxs(Head, { children: [/* @__PURE__ */ jsx(HeadLabel, {
+			htmlFor: props.id,
+			children: props.label
+		}), /* @__PURE__ */ jsx(Badges, { children: /* @__PURE__ */ jsx(Badge, { children: props.stateLabel }) })] }),
+		/* @__PURE__ */ jsx(Input$1, {
+			id: props.id,
+			type: "password",
+			autoComplete: "new-password",
+			value: props.text,
+			disabled: props.disabled,
+			onChange: (event) => {
+				props.onEdit(event.target.value);
+			}
+		}),
+		/* @__PURE__ */ jsx(Hint, { children: props.hint })
+	] });
+}
+const styles = {
+	form: {
+		display: "flex",
+		flexDirection: "column"
+	},
+	notice: {
+		margin: "0 0 12px",
+		fontSize: "12px",
+		lineHeight: 1.5,
+		color: dsw.alias.label.tertiary
+	},
+	footer: {
+		display: "flex",
+		alignItems: "center",
+		gap: "8px",
+		paddingTop: "16px"
+	},
+	failed: {
+		flex: 1,
+		minWidth: 0,
+		margin: 0,
+		fontSize: "12px",
+		lineHeight: 1.5,
+		color: "var(--dsw-alias-label-error)"
+	},
+	save: {
+		appearance: "none",
+		border: "1px solid transparent",
+		borderRadius: "8px",
+		padding: "5px 14px",
+		font: "inherit",
+		fontSize: "13px",
+		lineHeight: 1.5,
+		cursor: "pointer",
+		background: dsw.alias.label.primary,
+		color: dsw.alias.bg.layer["3"],
+		"&:disabled": {
+			opacity: .4,
+			cursor: "default"
+		},
+		"&:focus-visible": {
+			outline: focusRing,
+			outlineOffset: "1px"
+		}
+	}
+};
+//#endregion
+//#region src/client/settings-form/SettingsForm.tsx
+const Form = styled("div")(styles.form);
+const Notice = styled("p")(styles.notice);
+const Footer = styled("div")(styles.footer);
+const Failed = styled("p")(styles.failed);
+const Save = styled("button")(styles.save);
+function SettingsForm(props) {
+	const { state, labels } = props;
+	const discard = useRef(props.onDiscard);
+	discard.current = props.onDiscard;
+	useEffect(() => () => {
+		discard.current();
+	}, []);
+	if (!state.available) return /* @__PURE__ */ jsx(Notice, {
+		role: "status",
+		children: labels.unavailable
+	});
+	const blocked = !state.dirty || state.invalid || state.saving;
+	return /* @__PURE__ */ jsxs(Form, { children: [
+		!state.writable ? /* @__PURE__ */ jsx(Notice, {
+			role: "status",
+			children: labels.readOnly
+		}) : null,
+		props.children,
+		/* @__PURE__ */ jsxs(Footer, { children: [state.failed ? /* @__PURE__ */ jsx(Failed, {
+			role: "status",
+			children: labels.saveFailed
+		}) : null, /* @__PURE__ */ jsx(Save, {
+			type: "button",
+			disabled: blocked,
+			onClick: props.onSave,
+			children: state.saving ? labels.saving : labels.save
+		})] })
+	] });
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
+/**
+* @license React
+* react.production.min.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var l = Symbol.for("react.element");
+	var n = Symbol.for("react.portal");
+	var p = Symbol.for("react.fragment");
+	var q = Symbol.for("react.strict_mode");
+	var r = Symbol.for("react.profiler");
+	var t = Symbol.for("react.provider");
+	var u = Symbol.for("react.context");
+	var v = Symbol.for("react.forward_ref");
+	var w = Symbol.for("react.suspense");
+	var x = Symbol.for("react.memo");
+	var y = Symbol.for("react.lazy");
+	var z = Symbol.iterator;
+	function A(a) {
+		if (null === a || "object" !== typeof a) return null;
+		a = z && a[z] || a["@@iterator"];
+		return "function" === typeof a ? a : null;
+	}
+	var B = {
+		isMounted: function() {
+			return !1;
+		},
+		enqueueForceUpdate: function() {},
+		enqueueReplaceState: function() {},
+		enqueueSetState: function() {}
+	};
+	var C = Object.assign;
+	var D = {};
+	function E(a, b, e) {
+		this.props = a;
+		this.context = b;
+		this.refs = D;
+		this.updater = e || B;
+	}
+	E.prototype.isReactComponent = {};
+	E.prototype.setState = function(a, b) {
+		if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+		this.updater.enqueueSetState(this, a, b, "setState");
+	};
+	E.prototype.forceUpdate = function(a) {
+		this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+	};
+	function F() {}
+	F.prototype = E.prototype;
+	function G(a, b, e) {
+		this.props = a;
+		this.context = b;
+		this.refs = D;
+		this.updater = e || B;
+	}
+	var H = G.prototype = new F();
+	H.constructor = G;
+	C(H, E.prototype);
+	H.isPureReactComponent = !0;
+	var I = Array.isArray;
+	var J = Object.prototype.hasOwnProperty;
+	var K = { current: null };
+	var L = {
+		key: !0,
+		ref: !0,
+		__self: !0,
+		__source: !0
+	};
+	function M(a, b, e) {
+		var d, c = {}, k = null, h = null;
+		if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+		var g = arguments.length - 2;
+		if (1 === g) c.children = e;
+		else if (1 < g) {
+			for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
+			c.children = f;
+		}
+		if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
+		return {
+			$$typeof: l,
+			type: a,
+			key: k,
+			ref: h,
+			props: c,
+			_owner: K.current
+		};
+	}
+	function N(a, b) {
+		return {
+			$$typeof: l,
+			type: a.type,
+			key: b,
+			ref: a.ref,
+			props: a.props,
+			_owner: a._owner
+		};
+	}
+	function O(a) {
+		return "object" === typeof a && null !== a && a.$$typeof === l;
+	}
+	function escape(a) {
+		var b = {
+			"=": "=0",
+			":": "=2"
+		};
+		return "$" + a.replace(/[=:]/g, function(a) {
+			return b[a];
+		});
+	}
+	var P = /\/+/g;
+	function Q(a, b) {
+		return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+	}
+	function R(a, b, e, d, c) {
+		var k = typeof a;
+		if ("undefined" === k || "boolean" === k) a = null;
+		var h = !1;
+		if (null === a) h = !0;
+		else switch (k) {
+			case "string":
+			case "number":
+				h = !0;
+				break;
+			case "object": switch (a.$$typeof) {
+				case l:
+				case n: h = !0;
+			}
+		}
+		if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function(a) {
+			return a;
+		})) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
+		h = 0;
+		d = "" === d ? "." : d + ":";
+		if (I(a)) for (var g = 0; g < a.length; g++) {
+			k = a[g];
+			var f = d + Q(k, g);
+			h += R(k, b, e, f, c);
+		}
+		else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done;) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);
+		else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+		return h;
+	}
+	function S(a, b, e) {
+		if (null == a) return a;
+		var d = [], c = 0;
+		R(a, d, "", "", function(a) {
+			return b.call(e, a, c++);
+		});
+		return d;
+	}
+	function T(a) {
+		if (-1 === a._status) {
+			var b = a._result;
+			b = b();
+			b.then(function(b) {
+				if (0 === a._status || -1 === a._status) a._status = 1, a._result = b;
+			}, function(b) {
+				if (0 === a._status || -1 === a._status) a._status = 2, a._result = b;
+			});
+			-1 === a._status && (a._status = 0, a._result = b);
+		}
+		if (1 === a._status) return a._result.default;
+		throw a._result;
+	}
+	var U = { current: null };
+	var V = { transition: null };
+	var W = {
+		ReactCurrentDispatcher: U,
+		ReactCurrentBatchConfig: V,
+		ReactCurrentOwner: K
+	};
+	function X() {
+		throw Error("act(...) is not supported in production builds of React.");
+	}
+	exports.Children = {
+		map: S,
+		forEach: function(a, b, e) {
+			S(a, function() {
+				b.apply(this, arguments);
+			}, e);
+		},
+		count: function(a) {
+			var b = 0;
+			S(a, function() {
+				b++;
+			});
+			return b;
+		},
+		toArray: function(a) {
+			return S(a, function(a) {
+				return a;
+			}) || [];
+		},
+		only: function(a) {
+			if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
+			return a;
+		}
+	};
+	exports.Component = E;
+	exports.Fragment = p;
+	exports.Profiler = r;
+	exports.PureComponent = G;
+	exports.StrictMode = q;
+	exports.Suspense = w;
+	exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+	exports.act = X;
+	exports.cloneElement = function(a, b, e) {
+		if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+		var d = C({}, a.props), c = a.key, k = a.ref, h = a._owner;
+		if (null != b) {
+			void 0 !== b.ref && (k = b.ref, h = K.current);
+			void 0 !== b.key && (c = "" + b.key);
+			if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
+			for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+		}
+		var f = arguments.length - 2;
+		if (1 === f) d.children = e;
+		else if (1 < f) {
+			g = Array(f);
+			for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
+			d.children = g;
+		}
+		return {
+			$$typeof: l,
+			type: a.type,
+			key: c,
+			ref: k,
+			props: d,
+			_owner: h
+		};
+	};
+	exports.createContext = function(a) {
+		a = {
+			$$typeof: u,
+			_currentValue: a,
+			_currentValue2: a,
+			_threadCount: 0,
+			Provider: null,
+			Consumer: null,
+			_defaultValue: null,
+			_globalName: null
+		};
+		a.Provider = {
+			$$typeof: t,
+			_context: a
+		};
+		return a.Consumer = a;
+	};
+	exports.createElement = M;
+	exports.createFactory = function(a) {
+		var b = M.bind(null, a);
+		b.type = a;
+		return b;
+	};
+	exports.createRef = function() {
+		return { current: null };
+	};
+	exports.forwardRef = function(a) {
+		return {
+			$$typeof: v,
+			render: a
+		};
+	};
+	exports.isValidElement = O;
+	exports.lazy = function(a) {
+		return {
+			$$typeof: y,
+			_payload: {
+				_status: -1,
+				_result: a
+			},
+			_init: T
+		};
+	};
+	exports.memo = function(a, b) {
+		return {
+			$$typeof: x,
+			type: a,
+			compare: void 0 === b ? null : b
+		};
+	};
+	exports.startTransition = function(a) {
+		var b = V.transition;
+		V.transition = {};
+		try {
+			a();
+		} finally {
+			V.transition = b;
+		}
+	};
+	exports.unstable_act = X;
+	exports.useCallback = function(a, b) {
+		return U.current.useCallback(a, b);
+	};
+	exports.useContext = function(a) {
+		return U.current.useContext(a);
+	};
+	exports.useDebugValue = function() {};
+	exports.useDeferredValue = function(a) {
+		return U.current.useDeferredValue(a);
+	};
+	exports.useEffect = function(a, b) {
+		return U.current.useEffect(a, b);
+	};
+	exports.useId = function() {
+		return U.current.useId();
+	};
+	exports.useImperativeHandle = function(a, b, e) {
+		return U.current.useImperativeHandle(a, b, e);
+	};
+	exports.useInsertionEffect = function(a, b) {
+		return U.current.useInsertionEffect(a, b);
+	};
+	exports.useLayoutEffect = function(a, b) {
+		return U.current.useLayoutEffect(a, b);
+	};
+	exports.useMemo = function(a, b) {
+		return U.current.useMemo(a, b);
+	};
+	exports.useReducer = function(a, b, e) {
+		return U.current.useReducer(a, b, e);
+	};
+	exports.useRef = function(a) {
+		return U.current.useRef(a);
+	};
+	exports.useState = function(a) {
+		return U.current.useState(a);
+	};
+	exports.useSyncExternalStore = function(a, b, e) {
+		return U.current.useSyncExternalStore(a, b, e);
+	};
+	exports.useTransition = function() {
+		return U.current.useTransition();
+	};
+	exports.version = "18.3.1";
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js
+var require_react = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_react_production_min();
+}));
+//#endregion
+//#region src/client/markdown-text.ts
+var import_react = require_react();
+//#endregion
+//#region ../../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react-jsx-runtime.production.min.js
+/**
+* @license React
+* react-jsx-runtime.production.min.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_jsx_runtime_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var f = require_react();
+	var k = Symbol.for("react.element");
+	var m = Object.prototype.hasOwnProperty;
+	var n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner;
+	var p = {
+		key: !0,
+		ref: !0,
+		__self: !0,
+		__source: !0
+	};
+	function q(c, a, g) {
+		var b, d = {}, e = null, h = null;
+		void 0 !== g && (e = "" + g);
+		void 0 !== a.key && (e = "" + a.key);
+		void 0 !== a.ref && (h = a.ref);
+		for (b in a) m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
+		if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]);
+		return {
+			$$typeof: k,
+			type: c,
+			key: e,
+			ref: h,
+			props: d,
+			_owner: n.current
+		};
+	}
+	exports.jsx = q;
+}));
+//#endregion
+//#region src/reference-markdown.tsx
+var import_jsx_runtime = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_react_jsx_runtime_production_min();
+})))();
+function referenceMentions(actions, tokens) {
+	return { resolve: (value) => {
+		const reference = tokens?.get(value) ?? parseReferenceToken(value);
+		if (reference === void 0) return void 0;
+		return {
+			label: value,
+			title: formatReference(reference),
+			open: () => {
+				openReference(reference, actions);
+			}
+		};
+	} };
+}
+const ReferenceMarkdown = (0, import_react.memo)(function ReferenceMarkdown({ text, labels, actions, streaming = false, pathImages }) {
+	const { source, tokens } = (0, import_react.useMemo)(() => tokenizeReferences(text), [text]);
+	const mentions = (0, import_react.useMemo)(() => referenceMentions(actions, tokens), [actions, tokens]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MarkdownText, {
+		text: source,
+		streaming,
+		labels,
+		fileMentions: mentions,
+		pathImages
+	});
+});
+function displayTextOf(reference) {
+	return (reference.title ?? `${reference.path ?? ""}${rangeOf(reference)}`).replaceAll("`", "'");
+}
+function rangeOf(reference) {
+	if (reference.lineStart === void 0) return "";
+	const column = reference.column === void 0 ? "" : `C${String(reference.column)}`;
+	return reference.lineEnd === void 0 ? `#L${String(reference.lineStart)}${column}` : `#L${String(reference.lineStart)}${column}-L${String(reference.lineEnd)}`;
+}
+function tokenizeReferences(text) {
+	const tokens = /* @__PURE__ */ new Map();
+	let out = "";
+	let cursor = 0;
+	for (const span of findReferences(text)) {
+		if (!isLocalReference(span.reference) || span.start < cursor) continue;
+		const display = displayTextOf(span.reference);
+		tokens.set(display, span.reference);
+		out += `${text.slice(cursor, span.start)}\`${display}\``;
+		cursor = span.end;
+	}
+	return {
+		source: cursor === 0 ? text : out + text.slice(cursor),
+		tokens
+	};
+}
+function openReference(reference, actions) {
+	const path = reference.path;
+	if (actions === void 0 || path === void 0) return;
+	if (reference.protocol === "skill") {
+		actions.openSkill(path);
+		return;
+	}
+	if (reference.protocol === "file") actions.openFile(path);
+}
+//#endregion
+//#region src/client/index.ts
+const inject = [...inject$1];
+function apply(ctx) {
+	apply$1(ctx);
+}
+//#endregion
+export { ReferenceMarkdown, NS as SCHEMA_FORM_NS, SchemaFormController, SchemaFormHints, SettingsForm, SettingsFormModel, SettingsSecretField, SettingsValueField, Styling, Token, apply, designTokens, dsw, failureOf, findReferences, formatReference, formatReferenceMention, inject, isLocalReference, markdownLabels, parseReference, parseReferenceToken, projectRoot, referenceMentions, rowRegistrations, schema_form_exports as schemaForm, settingsNumberField, settingsTextField, styleOf, styled, styling, walkFields };