@qw-ui/core 0.3.0-next.40 → 0.3.0-next.42

package/dist/form-BAGkIEMY.js

@@ -0,0 +1,1354 @@
+import { C as setFormValue, S as normalizeFormNamePath, _ as formValuesEqual, b as hasFormValue, d as resolveFieldState, f as cloneFormValue, g as formValueFingerprint, h as formFieldNativeName, m as formFieldKey, p as cloneFormValues, v as freezeFormValues, x as mergeFormValues, y as getFormValue } from "./field-DMHGIMZF.js";
+import { o as normalizeSegmentedItems } from "./segmented-BaU38_L4.js";
+import { createMachine } from "@zag-js/core";
+import { addDomEvent, isDocument, isElement, isHTMLElement, isInputElement, isNode, observeChildren, setProperty } from "@zag-js/dom-query";
+import { ref } from "@zag-js/store";
+//#region src/form/ids.ts
+/** HTML form id owned by one Core instance. */
+function formDomId(scopeId) {
+	return `form:${scopeId}`;
+}
+/** Accessible name target for the form landmark. */
+function formLabelId(scopeId) {
+	return `form:${scopeId}:label`;
+}
+/**
+* Stable field stem. `formFieldKey` is the injective NamePath encoding.
+* Field root id is `field:` plus this stem.
+*/
+function formFieldStem(scopeId, name) {
+	return `form:${scopeId}:field:${formFieldKey(name)}`;
+}
+/** Actual control id shared by Input, selection and raw native inputs. */
+function formControlStem(scopeId, name) {
+	return `${formFieldStem(scopeId, name)}:control`;
+}
+/** Field root id produced by `resolveFieldState`. */
+function formFieldRootId(scopeId, name) {
+	return `field:${formFieldStem(scopeId, name)}`;
+}
+//#endregion
+//#region src/form/native.ts
+const typedHosts = "qw-checkbox, qw-radio-group, qw-segmented";
+const isHtmlElement = (node) => isHTMLElement(node) && node.namespaceURI === "http://www.w3.org/1999/xhtml";
+function textValue$1(value) {
+	return typeof value === "string" ? value : typeof value === "number" ? String(value) : "";
+}
+function fieldByControl(port, id) {
+	const scopeId = port.scope.id;
+	if (!scopeId) return void 0;
+	return port.fields().find((field) => formControlStem(scopeId, field.name) === id);
+}
+/**
+* One client lifecycle for raw inputs, supported native selection elements,
+* composite blur, and a single deferred reset transaction.
+* This listener is the only raw input/change transport. Getter props must not
+* subscribe to the same event (Vue normalizes onChange into onInput).
+* Selection controls keep their own reset listeners; user echoes are suppressed
+* until this transaction finishes so they cannot overwrite the Form reset.
+*/
+function trackFormNative(port) {
+	const root = port.scope.getRootNode?.();
+	if (!root || typeof document === "undefined") return () => {
+		port.bindSync(void 0);
+	};
+	let stopped = false;
+	let refreshQueued = false;
+	const cleanups = [];
+	const pending = /* @__PURE__ */ new Set();
+	const release = () => {
+		cleanups.splice(0).forEach((cleanup) => cleanup());
+	};
+	const sync = () => {
+		if (stopped || !port.scope.id) return;
+		for (const field of port.fields()) {
+			const rootNode = port.scope.getRootNode();
+			if (!("querySelectorAll" in rootNode)) continue;
+			const inputs = rootNode.querySelectorAll("input[data-scope=\"form\"]");
+			for (const input of inputs) {
+				if (!isHtmlElement(input)) continue;
+				if ((input.getAttribute("data-form-control") || input.id) !== formControlStem(port.scope.id, field.name)) continue;
+				const value = port.value(field.name);
+				if (input.type === "checkbox") setProperty(input, "checked", value === true);
+				else if (input.type === "radio") setProperty(input, "checked", value === input.value);
+				else setProperty(input, "value", textValue$1(value));
+			}
+		}
+	};
+	port.bindSync(sync);
+	const refreshSoon = () => {
+		if (stopped || refreshQueued) return;
+		refreshQueued = true;
+		queueMicrotask(() => {
+			refreshQueued = false;
+			refresh();
+		});
+	};
+	function onRaw(event) {
+		const input = event.target;
+		if (!isInputElement(input) || !isHtmlElement(input) || input.getAttribute("data-scope") !== "form") return;
+		if (isHtmlElement(input.closest(typedHosts))) return;
+		const field = fieldByControl(port, input.getAttribute("data-form-control") || input.id);
+		if (!field) return;
+		if (input.type === "checkbox" || input.type === "radio" ? event.type !== "change" : event.type !== "input") return;
+		if (input.type === "checkbox") port.change(field.name, input.checked);
+		else if (input.type === "radio") port.change(field.name, input.value);
+		else if (field.inputType === "number") {
+			if (!input.value.trim()) port.change(field.name, null);
+			else if (Number.isFinite(input.valueAsNumber)) port.change(field.name, input.valueAsNumber);
+		} else port.change(field.name, input.value);
+		sync();
+	}
+	function onTyped(event) {
+		const target = event.target;
+		if (!isElement(target)) return;
+		const host = target.closest(typedHosts);
+		if (!isHtmlElement(host) || !host.id) return;
+		const field = fieldByControl(port, host.id);
+		if (!field) return;
+		const detail = event.detail ?? {};
+		if (field.control === "checkbox") port.change(field.name, detail.checked === true);
+		else if (field.control === "segmented") port.change(field.name, Array.isArray(detail.value) ? [...detail.value] : []);
+		else port.change(field.name, detail.value ?? null);
+	}
+	function refresh() {
+		if (stopped) return;
+		release();
+		const form = port.scope.id ? port.scope.getById(formDomId(port.scope.id)) : null;
+		if (!isHtmlElement(form) || form.localName !== "form") return;
+		cleanups.push(addDomEvent(form, "reset", (event) => {
+			const timer = setTimeout(() => {
+				pending.delete(timer);
+				if (stopped || event.defaultPrevented) return;
+				port.suppressUser(true);
+				port.reset();
+				sync();
+				const done = setTimeout(() => {
+					pending.delete(done);
+					if (!stopped) port.suppressUser(false);
+				}, 0);
+				pending.add(done);
+			}, 0);
+			pending.add(timer);
+		}));
+		cleanups.push(addDomEvent(form, "focusout", (event) => {
+			const target = event.target;
+			if (!isElement(target)) return;
+			const fieldRoot = target.closest("[data-scope=\"field\"]");
+			if (!isHtmlElement(fieldRoot) || !form.contains(fieldRoot)) return;
+			const next = event.relatedTarget;
+			if (isNode(next) && fieldRoot.contains(next)) return;
+			const key = fieldRoot.getAttribute("data-field-key");
+			const field = port.fields().find((entry) => formFieldKey(entry.name) === key);
+			if (field) port.blur(field.name);
+		}));
+		cleanups.push(addDomEvent(form, "input", onRaw));
+		cleanups.push(addDomEvent(form, "change", onRaw));
+		cleanups.push(addDomEvent(form, "checked-change", onTyped));
+		cleanups.push(addDomEvent(form, "value-change", onTyped));
+		sync();
+	}
+	const observed = isDocument(root) ? root.body : isHtmlElement(root) ? root : null;
+	let stopObserve = observed ? observeChildren(observed, { callback: refreshSoon }) : void 0;
+	if (root.nodeType === 11 && "host" in root) {
+		const Observer = root.ownerDocument.defaultView?.MutationObserver;
+		if (Observer) {
+			const observer = new Observer(refreshSoon);
+			observer.observe(root, {
+				childList: true,
+				subtree: true
+			});
+			stopObserve = () => observer.disconnect();
+		}
+	}
+	refresh();
+	return () => {
+		stopped = true;
+		port.bindSync(void 0);
+		port.suppressUser(false);
+		release();
+		stopObserve?.();
+		pending.forEach((timer) => clearTimeout(timer));
+		pending.clear();
+	};
+}
+//#endregion
+//#region src/form/rules.ts
+const FORM_DEFAULT_MESSAGES = {
+	required: "{label}不能为空",
+	type: "{label}格式不正确",
+	min: "{label}至少为{min}",
+	max: "{label}最多为{max}",
+	length: "{label}长度应为{length}",
+	pattern: "{label}格式不正确",
+	enum: "{label}不在可选范围内",
+	validator: "{label}校验未通过"
+};
+const FORM_MESSAGES_EN = {
+	required: "{label} is required",
+	type: "{label} has an invalid format",
+	min: "{label} must be at least {min}",
+	max: "{label} must be at most {max}",
+	length: "{label} must have length {length}",
+	pattern: "{label} has an invalid format",
+	enum: "{label} is not an allowed value",
+	validator: "{label} failed validation"
+};
+const ruleTypes = [
+	"string",
+	"number",
+	"boolean",
+	"array",
+	"email",
+	"url"
+];
+const triggers = [
+	"change",
+	"blur",
+	"submit",
+	"manual"
+];
+function normalizeFormRule(rule) {
+	if (!rule || typeof rule !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(rule)) || rule.type !== void 0 && !ruleTypes.includes(rule.type)) throw new TypeError("Invalid Form rule type");
+	if (rule.message !== void 0 && typeof rule.message !== "string" || rule.flags !== void 0 && typeof rule.flags !== "string" || rule.enum !== void 0 && !Array.isArray(rule.enum)) throw new TypeError("Invalid Form rule message, flags or enumeration");
+	for (const name of [
+		"min",
+		"max",
+		"length"
+	]) if (rule[name] !== void 0 && (typeof rule[name] !== "number" || !Number.isFinite(rule[name]) || name === "length" && (!Number.isInteger(rule[name]) || rule[name] < 0))) throw new TypeError("Form rule bounds must be finite and lengths nonnegative integers");
+	if (rule.validator !== void 0 && typeof rule.validator !== "function") throw new TypeError("Form validators must be runtime functions");
+	if (rule.pattern !== void 0) {
+		if (typeof rule.pattern !== "string") throw new TypeError("Form SSR patterns must be strings");
+		try {
+			new RegExp(rule.pattern, rule.flags);
+		} catch {
+			throw new TypeError("Invalid Form rule pattern or flags");
+		}
+	}
+	const trigger = rule.trigger === void 0 ? void 0 : Array.isArray(rule.trigger) ? [...rule.trigger] : [rule.trigger];
+	if (trigger?.some((value) => !triggers.includes(value))) throw new TypeError("Invalid Form validation trigger");
+	return {
+		...rule,
+		trigger,
+		enum: rule.enum?.map((value) => cloneFormValue(value))
+	};
+}
+function isFormEmpty(value) {
+	return value === void 0 || value === null || value === false || typeof value === "string" && !value.trim() || Array.isArray(value) && !value.length;
+}
+function formErrorMessage(error, fallback = "校验失败") {
+	return error instanceof Error && error.message ? error.message : typeof error === "string" && error ? error : fallback;
+}
+function message(rule, key, context) {
+	const text = rule.message ?? context.messages?.[key] ?? FORM_DEFAULT_MESSAGES[key];
+	const values = {
+		label: context.label,
+		name: normalizeFormNamePath(context.name).join("."),
+		min: String(rule.min ?? ""),
+		max: String(rule.max ?? ""),
+		length: String(rule.length ?? "")
+	};
+	return text.replace(/\{(label|name|min|max|length)\}/g, (_, key) => values[key]);
+}
+function typeMatches(type, value) {
+	if (type === "array") return Array.isArray(value);
+	if (type === "email") return typeof value === "string" && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+	if (type === "url") {
+		if (typeof value !== "string") return false;
+		try {
+			new URL(value);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	return typeof value === type;
+}
+/** One rule returns explicit errors; request ownership is checked by the Form engine. */
+async function validateFormRule(input, value, context) {
+	const rule = normalizeFormRule(input);
+	if (context.signal.aborted) return [];
+	if (isFormEmpty(value)) {
+		if (rule.required) return [message(rule, "required", context)];
+		if (!rule.validator) return [];
+	}
+	const errors = [];
+	if (value != null && rule.type && !typeMatches(rule.type, value)) errors.push(message(rule, "type", context));
+	const size = typeof value === "number" ? value : typeof value === "string" || Array.isArray(value) ? value.length : void 0;
+	if (size !== void 0) {
+		if (rule.min !== void 0 && size < rule.min) errors.push(message(rule, "min", context));
+		if (rule.max !== void 0 && size > rule.max) errors.push(message(rule, "max", context));
+		if (rule.length !== void 0 && size !== rule.length) errors.push(message(rule, "length", context));
+	}
+	if (rule.pattern !== void 0 && value != null && !new RegExp(rule.pattern, rule.flags).test(String(value))) errors.push(message(rule, "pattern", context));
+	if (rule.enum && !rule.enum.some((entry) => formValueFingerprint(entry) === formValueFingerprint(value))) errors.push(message(rule, "enum", context));
+	if (rule.validator) try {
+		const result = await rule.validator(value === void 0 ? void 0 : cloneFormValue(value), context);
+		if (result === false) errors.push(message(rule, "validator", context));
+		else if (typeof result === "string" && result) errors.push(result);
+		else if (result !== void 0 && result !== true && typeof result !== "string") errors.push(message(rule, "validator", context));
+	} catch (error) {
+		if (!context.signal.aborted) errors.push(formErrorMessage(error, message(rule, "validator", context)));
+	}
+	return context.signal.aborted ? [] : [...new Set(errors)];
+}
+//#endregion
+//#region src/form/form.ts
+const copyErrors = (errors) => errors.map((entry) => ({
+	name: normalizeFormNamePath(entry.name),
+	errors: [...entry.errors]
+}));
+/** Feedback is synchronous Core state; bindables publish independent rendering snapshots. */
+function feedbackSnapshot(key, value) {
+	const snapshot = key === "errors" ? copyErrors(value) : [...value];
+	if (key === "errors") for (const entry of snapshot) {
+		Object.freeze(entry.name);
+		Object.freeze(entry.errors);
+		Object.freeze(entry);
+	}
+	Object.freeze(snapshot);
+	return ref(snapshot);
+}
+function feedback(service) {
+	const runtime = service.refs.get("runtime");
+	const projections = {
+		errors: service.context.get("errors"),
+		touched: service.context.get("touched"),
+		validated: service.context.get("validated"),
+		validating: service.context.get("validating")
+	};
+	return runtime.feedback ??= {
+		errors: feedbackSnapshot("errors", projections.errors),
+		touched: feedbackSnapshot("touched", projections.touched),
+		validated: feedbackSnapshot("validated", projections.validated),
+		validating: feedbackSnapshot("validating", projections.validating)
+	};
+}
+function setFeedback(service, key, value) {
+	const runtime = service.refs.get("runtime"), current = feedback(service);
+	current[key] = feedbackSnapshot(key, value);
+	const projection = feedbackSnapshot(key, current[key]);
+	const previousPublishing = runtime.publishingFeedback;
+	runtime.publishingFeedback = true;
+	try {
+		service.context.set(key, projection);
+	} finally {
+		runtime.publishingFeedback = previousPublishing;
+	}
+}
+/** Preserve explicit low-level writes without reading later render snapshots back into Core. */
+function acceptFeedback(service, key, value) {
+	if (!service.refs.get("runtime").publishingFeedback) setFeedback(service, key, value);
+}
+/** Drop in-flight submit busy. Reconnect cannot resume the old promise. */
+function normalizeFormInteraction(snapshot) {
+	if (!snapshot) return void 0;
+	const submitStatus = snapshot.submitStatus === "validating" || snapshot.submitStatus === "submitting" ? "canceled" : snapshot.submitStatus;
+	return Object.freeze({
+		errors: Object.freeze(copyErrors(snapshot.errors).map((entry) => Object.freeze(entry))),
+		touched: Object.freeze([...snapshot.touched]),
+		validated: Object.freeze([...snapshot.validated]),
+		submitStatus
+	});
+}
+function normalizeFormFields(fields) {
+	const names = /* @__PURE__ */ new Set(), nativeNames = /* @__PURE__ */ new Set();
+	return fields.map((field) => {
+		const name = normalizeFormNamePath(field.name), key = formFieldKey(name), nativeName = field.nativeName ?? formFieldNativeName(name);
+		if (names.has(key) || !nativeName.trim() || nativeNames.has(nativeName)) throw new TypeError("Form field paths and native names must be unique");
+		if (typeof field.label !== "string" || !field.label.trim()) throw new TypeError("Form fields require nonempty labels");
+		if ((field.control === "radio-group" || field.control === "segmented") && !field.items) throw new TypeError("Form selection fields require actual items");
+		names.add(key);
+		nativeNames.add(nativeName);
+		return {
+			...field,
+			name,
+			nativeName,
+			control: field.control ?? "native",
+			rules: field.rules?.map(normalizeFormRule),
+			dependencies: field.dependencies?.map(normalizeFormNamePath),
+			items: field.items ? normalizeSegmentedItems(field.items) : void 0,
+			initialValue: field.initialValue === void 0 ? void 0 : cloneFormValue(field.initialValue)
+		};
+	});
+}
+function createFormProps(props) {
+	if (!props.label?.trim() || props.id !== void 0 && !props.id.trim()) throw new TypeError("Form requires a nonempty label and supplied identity");
+	const fields = normalizeFormFields(props.fields), initialValues = cloneFormValues(props.initialValues);
+	for (const field of fields) if (!hasFormValue(initialValues, field.name) && field.initialValue !== void 0) Object.assign(initialValues, setFormValue(initialValues, field.name, field.initialValue));
+	const { initialInteraction: rawInteraction, ...rest } = props;
+	const initialInteraction = normalizeFormInteraction(rawInteraction);
+	return {
+		...rest,
+		fields,
+		values: props.values === void 0 ? void 0 : cloneFormValues(props.values),
+		initialValues,
+		initialErrors: copyErrors(props.initialErrors ?? []),
+		validateTrigger: props.validateTrigger ?? "blur",
+		...initialInteraction ? { initialInteraction } : {}
+	};
+}
+const formMachine = createMachine({
+	props: ({ props }) => createFormProps({
+		...props,
+		label: props.label ?? "",
+		fields: props.fields ?? []
+	}),
+	initialState: () => "ready",
+	refs: () => ({ runtime: {
+		epoch: 0,
+		next: 0,
+		alive: true,
+		validations: /* @__PURE__ */ new Map(),
+		reason: "cancel",
+		valueHash: "",
+		functions: /* @__PURE__ */ new WeakMap(),
+		functionCount: 0,
+		known: /* @__PURE__ */ new Map(),
+		blurSeen: /* @__PURE__ */ new Set(),
+		suppressUser: false
+	} }),
+	context({ prop, bindable, getRefs, getContext }) {
+		const interaction = normalizeFormInteraction(prop("initialInteraction"));
+		return {
+			values: bindable(() => ({
+				defaultValue: prop("initialValues"),
+				value: prop("values"),
+				isEqual: formValuesEqual,
+				onChange: (values) => prop("onValuesChange")?.({ values: cloneFormValues(values) })
+			})),
+			errors: bindable(() => ({
+				defaultValue: feedbackSnapshot("errors", interaction ? [...interaction.errors] : copyErrors(prop("initialErrors"))),
+				onChange: (value) => acceptFeedback({
+					refs: getRefs(),
+					context: getContext()
+				}, "errors", value)
+			})),
+			touched: bindable(() => ({
+				defaultValue: feedbackSnapshot("touched", [...interaction?.touched ?? []]),
+				onChange: (value) => acceptFeedback({
+					refs: getRefs(),
+					context: getContext()
+				}, "touched", value)
+			})),
+			validated: bindable(() => ({
+				defaultValue: feedbackSnapshot("validated", [...interaction?.validated ?? []]),
+				onChange: (value) => acceptFeedback({
+					refs: getRefs(),
+					context: getContext()
+				}, "validated", value)
+			})),
+			validating: bindable(() => ({
+				defaultValue: feedbackSnapshot("validating", []),
+				onChange: (value) => acceptFeedback({
+					refs: getRefs(),
+					context: getContext()
+				}, "validating", value)
+			})),
+			submitStatus: bindable(() => ({ defaultValue: interaction?.submitStatus ?? "idle" }))
+		};
+	},
+	on: { "VALUES.SET": { actions: ["setValues"] } },
+	states: { ready: {} },
+	effects: ["lifecycle", "trackNative"],
+	watch({ track, context, prop, refs }) {
+		const runtime = refs.get("runtime");
+		track([() => context.hash("values")], () => {
+			const hash = formValueFingerprint(context.get("values"));
+			if (runtime.valueHash && runtime.valueHash !== hash) cancelRequests({
+				context,
+				refs,
+				prop
+			}, "values-change");
+			runtime.valueHash = hash;
+			runtime.syncNative?.();
+		});
+		track([() => JSON.stringify(prop("fields"), (_, value) => {
+			if (typeof value !== "function") return value;
+			let id = runtime.functions.get(value);
+			if (!id) {
+				id = ++runtime.functionCount;
+				runtime.functions.set(value, id);
+			}
+			return `validator:${id}`;
+		})], () => {
+			const service = {
+				context,
+				refs,
+				prop
+			};
+			cancelRequests(service, "fields-change");
+			reconcileFormFields(service);
+		});
+	},
+	implementations: {
+		effects: {
+			lifecycle({ context, refs, prop }) {
+				const runtime = refs.get("runtime");
+				runtime.alive = true;
+				runtime.valueHash = formValueFingerprint(context.get("values"));
+				runtime.known = captureKnown(prop("fields"));
+				return () => {
+					cancelRequests({
+						context,
+						refs,
+						prop
+					}, "unmount");
+					runtime.alive = false;
+				};
+			},
+			trackNative(params) {
+				const service = params;
+				const behavior = connectFormBehavior(service);
+				return trackFormNative({
+					scope: service.scope,
+					fields: () => service.prop("fields"),
+					value: (name) => behavior.getFieldValue(name),
+					change: (name, value) => behavior.changeFieldFromUser(name, value),
+					blur: (name) => behavior.blurField(name),
+					reset: () => behavior.resetFields(),
+					suppressUser: (active) => {
+						service.refs.get("runtime").suppressUser = active;
+					},
+					bindSync: (sync) => {
+						service.refs.get("runtime").syncNative = sync;
+					}
+				});
+			}
+		},
+		actions: { setValues({ event, context }) {
+			if (event.type === "VALUES.SET") context.set("values", cloneFormValues(event.values));
+		} }
+	}
+});
+function cancelRequests(service, reason) {
+	const runtime = service.refs.get("runtime");
+	runtime.epoch++;
+	runtime.reason = reason;
+	runtime.validations.forEach((request) => request.controller.abort());
+	runtime.validations.clear();
+	setFeedback(service, "validating", []);
+	if (runtime.submission) {
+		runtime.submission.controller.abort();
+		runtime.submission = void 0;
+		service.context.set("submitStatus", "canceled");
+		if (reason !== "unmount") service.prop("onSubmitCancel")?.({ reason });
+	}
+}
+/** Await cancellation even when user code does not observe its AbortSignal. */
+function abortable(promise, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			promise.then(() => {}, () => {});
+			resolve(void 0);
+			return;
+		}
+		const abort = () => resolve(void 0);
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", abort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", abort);
+			reject(error);
+		});
+	});
+}
+function captureKnown(fields) {
+	return new Map(fields.map((field) => [formFieldKey(field.name), {
+		name: normalizeFormNamePath(field.name),
+		preserve: field.preserve
+	}]));
+}
+/** Drop preserve=false values and seed newly added field.initialValue. Keeps every other stored value. */
+function reconcileFormFields(service) {
+	const runtime = service.refs.get("runtime"), nextFields = service.prop("fields"), known = runtime.known;
+	let values = cloneFormValues(service.context.get("values"));
+	let changed = false;
+	const removed = [];
+	const nextKeys = new Set(nextFields.map((field) => formFieldKey(field.name)));
+	for (const [key, previous] of known) {
+		if (nextKeys.has(key)) continue;
+		removed.push(key);
+		if (previous.preserve === false) {
+			values = setFormValue(values, previous.name, void 0);
+			changed = true;
+		}
+	}
+	for (const field of nextFields) {
+		if (known.has(formFieldKey(field.name)) || field.initialValue === void 0 || hasFormValue(values, field.name)) continue;
+		values = setFormValue(values, field.name, field.initialValue);
+		changed = true;
+	}
+	if (changed) {
+		runtime.valueHash = formValueFingerprint(values);
+		service.context.set("values", values);
+	}
+	if (removed.length) {
+		setFeedback(service, "errors", feedback(service).errors.filter((entry) => !removed.includes(formFieldKey(entry.name))));
+		setFeedback(service, "touched", feedback(service).touched.filter((key) => !removed.includes(key)));
+		setFeedback(service, "validated", feedback(service).validated.filter((key) => !removed.includes(key)));
+		setFeedback(service, "validating", feedback(service).validating.filter((key) => !removed.includes(key)));
+	}
+	runtime.known = captureKnown(nextFields);
+}
+function enabledChoice(field, value) {
+	return !!field.items?.some((item) => item.value === value && !item.disabled);
+}
+/** Unknown and disabled choices stay stored but are not fabricated into the submit snapshot. */
+function submittedFieldValue(field, value) {
+	if (field.control === "checkbox" || field.inputType === "checkbox") return typeof value === "boolean" ? {
+		include: true,
+		value
+	} : { include: false };
+	if (field.control === "radio-group") {
+		if (value === null) return {
+			include: true,
+			value: null
+		};
+		if (typeof value === "string" && enabledChoice(field, value)) return {
+			include: true,
+			value
+		};
+		return { include: false };
+	}
+	if (field.control === "segmented") return {
+		include: true,
+		value: Array.isArray(value) ? value.filter((item) => typeof item === "string" && enabledChoice(field, item)) : []
+	};
+	return value === void 0 ? { include: false } : {
+		include: true,
+		value
+	};
+}
+function focusableControl(node) {
+	if (!isHTMLElement(node) || node.namespaceURI !== "http://www.w3.org/1999/xhtml") return null;
+	const nodes = [node, ...node.querySelectorAll("input, select, textarea, button, a[href], [tabindex]")];
+	for (const candidate of nodes) {
+		if (!isHTMLElement(candidate) || candidate.namespaceURI !== "http://www.w3.org/1999/xhtml") continue;
+		if (candidate.hasAttribute("disabled") || candidate.getAttribute("aria-disabled") === "true") continue;
+		if (candidate.getAttribute("role") === "group" && !candidate.hasAttribute("tabindex")) continue;
+		const tab = candidate.getAttribute("tabindex");
+		if (tab === "-1") continue;
+		if ([
+			"input",
+			"select",
+			"textarea",
+			"button"
+		].includes(candidate.localName) || candidate.localName === "a" && candidate.hasAttribute("href") || tab !== null) return candidate;
+	}
+	return null;
+}
+/** Headless behavior API; DOM/getter transport is composed separately. */
+function connectFormBehavior(service) {
+	const runtime = service.refs.get("runtime");
+	const fields = () => service.prop("fields");
+	const resolve = (name) => {
+		const key = formFieldKey(name), field = fields().find((entry) => formFieldKey(entry.name) === key);
+		if (!field) throw new RangeError("Form field is not registered");
+		return field;
+	};
+	const getValues = () => cloneFormValues(service.context.get("values"));
+	const getFieldState = (name) => {
+		const field = resolve(name), key = formFieldKey(name), errors = feedback(service).errors.find((entry) => formFieldKey(entry.name) === key)?.errors ?? [];
+		return {
+			name: normalizeFormNamePath(name),
+			value: getFormValue(getValues(), name),
+			errors: [...errors],
+			touched: feedback(service).touched.includes(key),
+			dirty: formValueFingerprint(getFormValue(getValues(), name)) !== formValueFingerprint(getFormValue(service.prop("initialValues"), name)),
+			validationStatus: feedback(service).validating.includes(key) ? "validating" : errors.length ? "invalid" : feedback(service).validated.includes(key) ? "valid" : "unvalidated",
+			disabled: !!service.prop("disabled") || !!field.disabled,
+			readOnly: !!service.prop("readOnly") || !!field.readOnly,
+			required: !!field.required || !!field.rules?.some((rule) => rule.required)
+		};
+	};
+	const getState = () => ({
+		values: getValues(),
+		fieldStates: fields().map((field) => getFieldState(field.name)),
+		submitting: ["validating", "submitting"].includes(service.context.get("submitStatus")),
+		submitStatus: service.context.get("submitStatus")
+	});
+	const getInteractionSnapshot = () => Object.freeze({
+		errors: Object.freeze(copyErrors(feedback(service).errors).map((entry) => Object.freeze(entry))),
+		touched: Object.freeze([...feedback(service).touched]),
+		validated: Object.freeze([...feedback(service).validated]),
+		submitStatus: service.context.get("submitStatus")
+	});
+	const notify = () => service.prop("onValidationChange")?.({ state: getState() });
+	const clearErrors = (keys) => {
+		setFeedback(service, "errors", feedback(service).errors.filter((entry) => !keys.includes(formFieldKey(entry.name))));
+		setFeedback(service, "validated", feedback(service).validated.filter((key) => !keys.includes(key)));
+	};
+	const alive = () => {
+		if (!runtime.alive) throw new TypeError("Form instance is stopped");
+	};
+	const fieldTriggers = (field) => {
+		const source = field.validateTrigger ?? service.prop("validateTrigger");
+		return Array.isArray(source) ? source : [source];
+	};
+	const markTouched = (name) => {
+		const key = formFieldKey(name);
+		if (!feedback(service).touched.includes(key)) setFeedback(service, "touched", [...feedback(service).touched, key]);
+	};
+	const initialFieldValue = (name) => {
+		const field = resolve(name);
+		return hasFormValue(service.prop("initialValues"), field.name) ? getFormValue(service.prop("initialValues"), field.name) : field.initialValue;
+	};
+	const mutate = (values, names = []) => {
+		alive();
+		const next = cloneFormValues(values);
+		cancelRequests(service, "values-change");
+		clearErrors(names.map(formFieldKey));
+		service.context.set("values", next);
+		runtime.valueHash = formValueFingerprint(service.context.get("values"));
+		notify();
+	};
+	const dependentNames = (name) => {
+		const key = formFieldKey(name);
+		return fields().filter((field) => field.dependencies?.some((dependency) => formFieldKey(dependency) === key) && (getFieldState(field.name).touched || !!getFieldState(field.name).errors.length)).map((field) => field.name);
+	};
+	const setFieldValue = (name, value) => {
+		const next = setFormValue(getValues(), name, value);
+		if (formValueFingerprint(getValues()) === formValueFingerprint(next)) return;
+		mutate(next, [name]);
+		const names = dependentNames(name);
+		if (names.length) validateFields(names, { trigger: "change" });
+	};
+	const changeFieldFromUser = (name, value) => {
+		alive();
+		const field = resolve(name), state = getFieldState(name);
+		if (state.disabled || state.readOnly || runtime.suppressUser) return;
+		const echoKey = formFieldKey(name), echoValue = formValueFingerprint(value);
+		if (runtime.userEcho?.key === echoKey && runtime.userEcho.value === echoValue) return;
+		runtime.userEcho = {
+			key: echoKey,
+			value: echoValue
+		};
+		queueMicrotask(() => {
+			if (runtime.userEcho?.key === echoKey && runtime.userEcho.value === echoValue) runtime.userEcho = void 0;
+		});
+		const hadErrors = state.errors.length > 0, next = setFormValue(getValues(), name, value), same = formValueFingerprint(getValues()) === formValueFingerprint(next);
+		if (!same) mutate(next, [name]);
+		markTouched(name);
+		const names = [];
+		if (!same && (fieldTriggers(field).includes("change") || hadErrors)) names.push(field.name);
+		names.push(...dependentNames(name).filter((dependency) => !names.some((entry) => formFieldKey(entry) === formFieldKey(dependency))));
+		if (names.length) validateFields(names, { trigger: "change" });
+	};
+	const blurField = (name) => {
+		alive();
+		const field = resolve(name), key = formFieldKey(name);
+		if (getFieldState(name).disabled || runtime.suppressUser) return;
+		if (runtime.blurSeen.has(key)) return;
+		runtime.blurSeen.add(key);
+		queueMicrotask(() => runtime.blurSeen.delete(key));
+		markTouched(name);
+		notify();
+		if (fieldTriggers(field).includes("blur")) validateFields([name], { trigger: "blur" });
+	};
+	const focusField = (name) => {
+		resolve(name);
+		const scopeId = service.scope.id;
+		if (typeof document === "undefined" || !scopeId) return false;
+		const node = service.scope.getById(formControlStem(scopeId, name));
+		const target = node ? focusableControl(node) : null;
+		if (!target) return false;
+		target.focus();
+		return true;
+	};
+	const setFieldErrors = (name, errors) => {
+		alive();
+		resolve(name);
+		const key = formFieldKey(name);
+		runtime.validations.get(key)?.controller.abort();
+		runtime.validations.delete(key);
+		setFeedback(service, "validating", feedback(service).validating.filter((entry) => entry !== key));
+		setFeedback(service, "errors", [...feedback(service).errors.filter((entry) => formFieldKey(entry.name) !== key), {
+			name: normalizeFormNamePath(name),
+			errors: [...errors]
+		}]);
+		notify();
+	};
+	const validateFields = async (names, options = {}) => {
+		alive();
+		const epoch = runtime.epoch, values = getValues(), snapshot = freezeFormValues(values), chosen = names ? names.map(resolve) : fields();
+		const results = await Promise.all(chosen.filter((field) => !getFieldState(field.name).disabled).map(async (field) => {
+			const key = formFieldKey(field.name);
+			runtime.validations.get(key)?.controller.abort();
+			const request = {
+				ticket: ++runtime.next,
+				controller: new AbortController()
+			};
+			runtime.validations.set(key, request);
+			if (!options.validateOnly) setFeedback(service, "validating", [.../* @__PURE__ */ new Set([...feedback(service).validating, key])]);
+			const value = getFormValue(values, field.name), errors = [], rules = [...field.required ? [{ required: true }] : [], ...field.rules ?? []];
+			for (const rule of rules) {
+				const trigger = options.trigger ?? "manual", triggers = rule.trigger === void 0 ? void 0 : Array.isArray(rule.trigger) ? rule.trigger : [rule.trigger];
+				if (trigger !== "submit" && trigger !== "manual" && triggers && !triggers.includes(trigger)) continue;
+				let tested = value;
+				if (rule.required && field.control === "checkbox" && tested !== true) tested = void 0;
+				if (rule.required && (field.control === "radio-group" || field.control === "segmented")) {
+					const enabled = field.items?.filter((item) => !item.disabled) ?? [];
+					if (!enabled.length) continue;
+					if (!enabled.some((item) => Array.isArray(tested) ? tested.includes(item.value) : tested === item.value)) tested = void 0;
+				}
+				const result = await abortable(validateFormRule(rule, tested, {
+					name: normalizeFormNamePath(field.name),
+					label: field.label,
+					values: snapshot,
+					signal: request.controller.signal,
+					messages: service.prop("messages")
+				}), request.controller.signal);
+				if (result) errors.push(...result);
+				if (request.controller.signal.aborted || service.prop("validateFirst") && errors.length) break;
+			}
+			const current = runtime.alive && runtime.epoch === epoch && runtime.validations.get(key)?.ticket === request.ticket && !request.controller.signal.aborted;
+			if (current) {
+				runtime.validations.delete(key);
+				setFeedback(service, "validating", feedback(service).validating.filter((entry) => entry !== key));
+				if (!options.validateOnly) {
+					setFeedback(service, "errors", [...feedback(service).errors.filter((entry) => formFieldKey(entry.name) !== key), {
+						name: normalizeFormNamePath(field.name),
+						errors: [...new Set(errors)]
+					}]);
+					setFeedback(service, "validated", [.../* @__PURE__ */ new Set([...feedback(service).validated, key])]);
+				}
+				notify();
+			}
+			return {
+				current,
+				name: normalizeFormNamePath(field.name),
+				errors: [...new Set(errors)]
+			};
+		}));
+		const outOfDate = !runtime.alive || runtime.epoch !== epoch || results.some((result) => !result.current);
+		return {
+			values,
+			errorFields: results.filter((result) => result.errors.length).map(({ name, errors }) => ({
+				name,
+				errors
+			})),
+			outOfDate,
+			canceled: outOfDate
+		};
+	};
+	const resetFields = (names) => {
+		alive();
+		cancelRequests(service, "reset");
+		const targets = names ? names.map(resolve) : fields();
+		let values = names ? getValues() : cloneFormValues(service.prop("initialValues"));
+		for (const field of targets) if (names || !hasFormValue(values, field.name)) values = setFormValue(values, field.name, initialFieldValue(field.name));
+		const keys = targets.map((field) => formFieldKey(field.name));
+		clearErrors(keys);
+		setFeedback(service, "touched", feedback(service).touched.filter((key) => !keys.includes(key)));
+		service.context.set("values", values);
+		runtime.valueHash = formValueFingerprint(service.context.get("values"));
+		service.context.set("submitStatus", "idle");
+		notify();
+	};
+	const submit = async () => {
+		alive();
+		cancelRequests(service, "superseded");
+		const request = {
+			ticket: ++runtime.next,
+			controller: new AbortController()
+		};
+		runtime.submission = request;
+		service.context.set("submitStatus", "validating");
+		notify();
+		const validation = await validateFields(void 0, { trigger: "submit" });
+		const current = () => runtime.alive && runtime.submission?.ticket === request.ticket && !request.controller.signal.aborted;
+		/** Drop only the submission this call still owns. A newer submit must keep its busy state. */
+		const canceled = () => {
+			if (runtime.submission?.ticket === request.ticket) {
+				const owned = runtime.submission;
+				runtime.submission = void 0;
+				owned.controller.abort();
+				if (!runtime.submission) {
+					service.context.set("submitStatus", "canceled");
+					service.prop("onSubmitCancel")?.({ reason: runtime.reason });
+					if (!runtime.submission) notify();
+				}
+			}
+			return {
+				status: "canceled",
+				values: validation.values,
+				errorFields: [],
+				reason: runtime.reason
+			};
+		};
+		if (!current() || validation.outOfDate) return canceled();
+		if (validation.errorFields.length) {
+			runtime.submission = void 0;
+			service.context.set("submitStatus", "invalid");
+			service.prop("onValidationFailed")?.({
+				values: cloneFormValues(validation.values),
+				errorFields: copyErrors(validation.errorFields)
+			});
+			notify();
+			if (service.prop("focusFirstError")) {
+				for (const field of fields()) if (validation.errorFields.some((entry) => formFieldKey(entry.name) === formFieldKey(field.name)) && focusField(field.name)) break;
+			}
+			return {
+				status: "invalid",
+				values: validation.values,
+				errorFields: validation.errorFields
+			};
+		}
+		let values = {};
+		for (const field of fields()) {
+			if (getFieldState(field.name).disabled) continue;
+			const submitted = submittedFieldValue(field, getFormValue(validation.values, field.name));
+			if (submitted.include) values = setFormValue(values, field.name, submitted.value);
+		}
+		service.context.set("submitStatus", "submitting");
+		notify();
+		try {
+			await abortable(Promise.resolve(service.prop("onSubmit")?.(cloneFormValues(values), { signal: request.controller.signal })), request.controller.signal);
+			if (!current()) return canceled();
+			runtime.submission = void 0;
+			service.context.set("submitStatus", "success");
+			service.prop("onSubmitSuccess")?.({ values: cloneFormValues(values) });
+			notify();
+			return {
+				status: "success",
+				values,
+				errorFields: []
+			};
+		} catch (error) {
+			if (!current()) return canceled();
+			runtime.submission = void 0;
+			service.context.set("submitStatus", "error");
+			const text = formErrorMessage(error, "提交失败");
+			service.prop("onSubmitError")?.({
+				values: cloneFormValues(values),
+				error: text
+			});
+			notify();
+			return {
+				status: "error",
+				values,
+				errorFields: [],
+				error: text
+			};
+		}
+	};
+	const setFieldsValue = (patch) => {
+		const before = getValues(), next = mergeFormValues(before, patch);
+		if (formValueFingerprint(before) === formValueFingerprint(next)) return;
+		const changed = fields().filter((field) => formValueFingerprint(getFormValue(before, field.name)) !== formValueFingerprint(getFormValue(next, field.name))).map((field) => field.name);
+		mutate(next, changed);
+		const names = changed.flatMap((name) => dependentNames(name));
+		if (names.length) validateFields(names, { trigger: "change" });
+	};
+	return {
+		get values() {
+			return getValues();
+		},
+		get state() {
+			return getState();
+		},
+		getValues,
+		getState,
+		getFieldState,
+		getInteractionSnapshot,
+		getFieldValue: (name) => getFormValue(getValues(), name),
+		setFieldValue,
+		setFieldsValue,
+		setFieldErrors,
+		validateFields,
+		resetFields,
+		submit,
+		cancelSubmit: () => {
+			alive();
+			cancelRequests(service, "cancel");
+			notify();
+		},
+		changeFieldFromUser,
+		blurField,
+		focusField,
+		initialFieldValue
+	};
+}
+//#endregion
+//#region src/form/connect.ts
+const FORM_PARTS = [
+	"root",
+	"label",
+	"content",
+	"error-summary",
+	"error-list",
+	"error-item",
+	"error-link",
+	"footer"
+];
+const part = (name) => ({
+	"data-scope": "form",
+	"data-part": name
+});
+function defined(props) {
+	return Object.fromEntries(Object.entries(props).filter(([, value]) => value !== void 0));
+}
+function labelModeFor(field, readOnly) {
+	if (field.control === "checkbox" || field.control === "radio-group" || field.control === "segmented") return "control";
+	if (field.control === "custom" || field.control === "input" && readOnly) return "custom";
+	return "label";
+}
+function textValue(value) {
+	return typeof value === "string" ? value : typeof value === "number" ? String(value) : "";
+}
+function choiceItems(field) {
+	return (field.items ?? []).map((item) => ({ ...item }));
+}
+/** Public connect. Named connectForm so package barrels do not hide other connects. */
+function connectForm(service, normalize) {
+	const behavior = connectFormBehavior(service);
+	const active = () => service.refs.get("runtime").alive;
+	const scopeId = service.scope.id;
+	if (!scopeId) throw new TypeError("Form requires a stable scope id");
+	const formId = formDomId(scopeId);
+	const link = (name) => {
+		const state = behavior.getFieldState(name);
+		const definition = service.prop("fields").find((entry) => formFieldKey(entry.name) === formFieldKey(name));
+		if (!definition) throw new RangeError("Form field is not registered");
+		const controlId = formControlStem(scopeId, name);
+		const fieldProps = {
+			id: formFieldStem(scopeId, name),
+			name: state.name,
+			label: definition.label,
+			description: definition.description,
+			errors: state.errors,
+			controlId,
+			labelMode: labelModeFor(definition, state.readOnly),
+			required: state.required,
+			disabled: state.disabled,
+			invalid: state.errors.length > 0,
+			validating: state.validationStatus === "validating"
+		};
+		return {
+			definition,
+			state,
+			controlId,
+			fieldProps,
+			resolved: resolveFieldState(fieldProps)
+		};
+	};
+	const hasErrors = () => behavior.state.fieldStates.some((field) => field.errors.length > 0);
+	return {
+		get values() {
+			return behavior.values;
+		},
+		get state() {
+			return behavior.state;
+		},
+		getValues: () => behavior.getValues(),
+		getFieldValue: (name) => behavior.getFieldValue(name),
+		getFieldState: (name) => behavior.getFieldState(name),
+		getInteractionSnapshot: () => behavior.getInteractionSnapshot(),
+		setFieldValue: (name, value) => behavior.setFieldValue(name, value),
+		setFieldsValue: (values) => behavior.setFieldsValue(values),
+		setFieldErrors: (name, errors) => behavior.setFieldErrors(name, errors),
+		validateFields: (names, options) => behavior.validateFields(names, options),
+		submit: () => behavior.submit(),
+		cancelSubmit: () => behavior.cancelSubmit(),
+		resetFields: (names) => behavior.resetFields(names),
+		focusField: (name) => behavior.focusField(name),
+		getRootProps: () => normalize.element(defined({
+			...part("root"),
+			id: formId,
+			noValidate: true,
+			"aria-labelledby": formLabelId(scopeId),
+			"aria-busy": behavior.state.submitting || void 0,
+			"data-disabled": service.prop("disabled") ? "" : void 0,
+			"data-readonly": service.prop("readOnly") ? "" : void 0,
+			"data-invalid": hasErrors() ? "" : void 0,
+			onSubmit(event) {
+				if (!active()) return;
+				event.preventDefault();
+				behavior.submit();
+			}
+		})),
+		getLabelProps: () => normalize.element({
+			...part("label"),
+			id: formLabelId(scopeId)
+		}),
+		getContentProps: () => normalize.element(part("content")),
+		getErrorSummaryProps: () => normalize.element(defined({
+			...part("error-summary"),
+			id: `${formId}:error-summary`,
+			role: "alert",
+			hidden: hasErrors() ? void 0 : true
+		})),
+		getErrorListProps: () => normalize.element(part("error-list")),
+		getErrorItemProps: (name) => {
+			const state = behavior.getFieldState(name);
+			return normalize.element({
+				...part("error-item"),
+				"data-field-key": formFieldKey(state.name)
+			});
+		},
+		getErrorLinkProps: (name) => normalize.element({
+			...part("error-link"),
+			href: `#${formControlStem(scopeId, name)}`,
+			onClick(event) {
+				if (!active()) return;
+				event.preventDefault();
+				behavior.focusField(name);
+			}
+		}),
+		getFooterProps: () => normalize.element(part("footer")),
+		getFieldProps: (name) => link(name).fieldProps,
+		getInputProps: (name) => {
+			const current = link(name);
+			return {
+				id: current.controlId,
+				readOnly: current.state.readOnly,
+				value: textValue(current.state.value),
+				onChange(next) {
+					if (!active()) return;
+					if (current.definition.inputType === "number") {
+						if (!next.trim()) {
+							behavior.changeFieldFromUser(name, null);
+							return;
+						}
+						const numeric = Number(next);
+						if (Number.isFinite(numeric)) behavior.changeFieldFromUser(name, numeric);
+						return;
+					}
+					behavior.changeFieldFromUser(name, next);
+				},
+				onBlur() {
+					if (active()) behavior.blurField(name);
+				},
+				control: defined({
+					id: current.controlId,
+					name: current.definition.nativeName,
+					form: formId,
+					disabled: current.state.disabled || void 0,
+					required: current.state.required || void 0,
+					labelledBy: current.resolved.labelId,
+					describedBy: current.resolved.describedBy,
+					invalid: current.state.errors.length > 0 || void 0
+				})
+			};
+		},
+		getCheckboxProps: (name) => {
+			const current = link(name), initial = behavior.initialFieldValue(name);
+			return defined({
+				id: current.controlId,
+				label: current.definition.label,
+				description: current.definition.controlDescription,
+				describedBy: current.resolved.describedBy,
+				checked: current.state.value === true,
+				defaultChecked: initial === true,
+				disabled: current.state.disabled,
+				readOnly: current.state.readOnly,
+				required: current.state.required,
+				invalid: current.state.errors.length > 0,
+				name: current.definition.nativeName,
+				form: formId,
+				onCheckedChange: (details) => {
+					if (active()) behavior.changeFieldFromUser(name, details.checked === true);
+				}
+			});
+		},
+		getRadioGroupProps: (name) => {
+			const current = link(name), initial = behavior.initialFieldValue(name);
+			if (!current.definition.items) throw new TypeError("Form radio fields require actual items");
+			return defined({
+				id: current.controlId,
+				label: current.definition.label,
+				description: current.definition.controlDescription,
+				describedBy: current.resolved.describedBy,
+				items: choiceItems(current.definition),
+				value: typeof current.state.value === "string" ? current.state.value : null,
+				defaultValue: typeof initial === "string" ? initial : null,
+				disabled: current.state.disabled,
+				readOnly: current.state.readOnly,
+				required: current.state.required,
+				invalid: current.state.errors.length > 0,
+				name: current.definition.nativeName,
+				form: formId,
+				onValueChange: (details) => {
+					if (active()) behavior.changeFieldFromUser(name, details.value);
+				}
+			});
+		},
+		getSegmentedProps: (name) => {
+			const current = link(name), initial = behavior.initialFieldValue(name);
+			if (!current.definition.items) throw new TypeError("Form segmented fields require actual items");
+			const value = Array.isArray(current.state.value) ? current.state.value.filter((item) => typeof item === "string") : [];
+			const fallback = Array.isArray(initial) ? initial.filter((item) => typeof item === "string") : [];
+			return defined({
+				id: current.controlId,
+				label: current.definition.label,
+				description: current.definition.controlDescription,
+				describedBy: current.resolved.describedBy,
+				items: choiceItems(current.definition),
+				selectionMode: current.definition.selectionMode ?? "single",
+				value,
+				defaultValue: fallback,
+				disabled: current.state.disabled,
+				readOnly: current.state.readOnly,
+				required: current.state.required,
+				invalid: current.state.errors.length > 0,
+				name: current.definition.nativeName,
+				form: formId,
+				onValueChange: (details) => {
+					if (active()) behavior.changeFieldFromUser(name, [...details.value]);
+				}
+			});
+		},
+		getNativeControlProps: (name) => {
+			const current = link(name), checkbox = current.definition.inputType === "checkbox" || current.definition.control === "checkbox";
+			return normalize.input(defined({
+				"data-scope": "form",
+				"data-part": "control",
+				id: current.controlId,
+				name: current.definition.nativeName,
+				form: formId,
+				type: checkbox ? "checkbox" : current.definition.inputType ?? "text",
+				value: checkbox ? void 0 : textValue(current.state.value),
+				checked: checkbox ? current.state.value === true : void 0,
+				disabled: current.state.disabled || void 0,
+				readOnly: current.state.readOnly || void 0,
+				required: current.state.required || void 0,
+				"aria-labelledby": current.resolved.labelId,
+				"aria-describedby": current.resolved.describedBy,
+				"aria-invalid": current.state.errors.length > 0 || void 0,
+				"aria-required": current.state.required || void 0,
+				"data-field-root": formFieldRootId(scopeId, name),
+				onBlur() {
+					if (active()) behavior.blurField(name);
+				},
+				onChange() {}
+			}));
+		},
+		getReadonlyProps: (name) => {
+			const current = link(name);
+			return normalize.element(defined({
+				"data-scope": "form",
+				"data-part": "control",
+				id: current.controlId,
+				role: "group",
+				"aria-labelledby": current.resolved.labelId,
+				"aria-describedby": current.resolved.describedBy,
+				"aria-invalid": current.state.errors.length > 0 || void 0
+			}));
+		},
+		getNativeElementProps: (name) => {
+			const current = link(name), initial = behavior.initialFieldValue(name);
+			const common = defined({
+				id: current.controlId,
+				label: current.definition.label,
+				description: current.definition.controlDescription,
+				describedBy: current.resolved.describedBy,
+				name: current.definition.nativeName,
+				form: formId,
+				disabled: current.state.disabled,
+				readOnly: current.state.readOnly,
+				required: current.state.required,
+				invalid: current.state.errors.length > 0
+			});
+			if (current.definition.control === "checkbox") return {
+				...common,
+				checked: current.state.value === true,
+				defaultChecked: initial === true
+			};
+			if (current.definition.control === "radio-group") return {
+				...common,
+				items: choiceItems(current.definition),
+				value: typeof current.state.value === "string" ? current.state.value : null,
+				defaultValue: typeof initial === "string" ? initial : null
+			};
+			if (current.definition.control === "segmented") {
+				const value = Array.isArray(current.state.value) ? current.state.value.filter((item) => typeof item === "string") : [];
+				const fallback = Array.isArray(initial) ? initial.filter((item) => typeof item === "string") : [];
+				return {
+					...common,
+					items: choiceItems(current.definition),
+					selectionMode: current.definition.selectionMode ?? "single",
+					value,
+					defaultValue: fallback
+				};
+			}
+			return {
+				...common,
+				type: current.definition.inputType ?? "text",
+				value: textValue(current.state.value)
+			};
+		}
+	};
+}
+//#endregion
+//#region src/form/methods.ts
+/** Live Core dispatch for a connected native method. Unknown names throw. */
+function invokeFormApi(api, method, args = []) {
+	switch (method) {
+		case "getValues": return api.getValues();
+		case "getFieldValue": return api.getFieldValue(args[0]);
+		case "getFieldState": return api.getFieldState(args[0]);
+		case "setFieldValue":
+			api.setFieldValue(args[0], args[1]);
+			return;
+		case "setFieldsValue":
+			api.setFieldsValue(args[0]);
+			return;
+		case "setFieldErrors":
+			api.setFieldErrors(args[0], [...args[1]]);
+			return;
+		case "validateFields": return api.validateFields(args[0], args[1]);
+		case "submit": return api.submit();
+		case "cancelSubmit":
+			api.cancelSubmit();
+			return;
+		case "resetFields":
+			api.resetFields(args[0]);
+			return;
+		case "focusField": return api.focusField(args[0]);
+		case "getFieldProps": return api.getFieldProps(args[0]);
+		case "getInputProps": return api.getInputProps(args[0]);
+		case "getCheckboxProps": return api.getCheckboxProps(args[0]);
+		case "getRadioGroupProps": return api.getRadioGroupProps(args[0]);
+		case "getSegmentedProps": return api.getSegmentedProps(args[0]);
+		case "getNativeControlProps": return api.getNativeControlProps(args[0]);
+		case "getNativeElementProps": return api.getNativeElementProps(args[0]);
+		case "getReadonlyProps": return api.getReadonlyProps(args[0]);
+		default: throw new TypeError(`Unknown Form method: ${method}`);
+	}
+}
+/** Hosts call this before invoke. Disconnected or not-yet-ready calls throw. */
+function assertFormMethodReady(ready) {
+	if (!ready) throw new TypeError("Form method is unavailable until the element is connected and updateComplete has resolved");
+}
+//#endregion
+//#region src/form/ssr.ts
+/**
+* SSR accepts builtin JSON rules only.
+* Custom validators and business handlers are runtime values: encountering one throws.
+* Nothing is eval'd or silently dropped.
+*/
+function assertFormSsrProps(props) {
+	const visit = (value, path) => {
+		if (typeof value === "function") throw new TypeError(`Form SSR cannot accept a runtime function at ${path}`);
+		if (value === null || typeof value === "string" || typeof value === "boolean") return;
+		if (typeof value === "number") {
+			if (!Number.isFinite(value)) throw new TypeError(`Form SSR requires finite numbers at ${path}`);
+			return;
+		}
+		if (typeof value !== "object") throw new TypeError(`Form SSR cannot serialize ${typeof value} at ${path}`);
+		const prototype = Object.getPrototypeOf(value);
+		if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) throw new TypeError(`Form SSR requires plain JSON at ${path}`);
+		if (Array.isArray(value)) {
+			value.forEach((item, index) => visit(item, `${path}[${index}]`));
+			return;
+		}
+		for (const [key, child] of Object.entries(value)) visit(child, `${path}.${key}`);
+	};
+	visit(props, "form");
+}
+//#endregion
+export { formLabelId as C, formFieldStem as S, validateFormRule as _, connectForm as a, formDomId as b, formMachine as c, submittedFieldValue as d, FORM_DEFAULT_MESSAGES as f, normalizeFormRule as g, isFormEmpty as h, FORM_PARTS as i, normalizeFormFields as l, formErrorMessage as m, assertFormMethodReady as n, connectFormBehavior as o, FORM_MESSAGES_EN as p, invokeFormApi as r, createFormProps as s, assertFormSsrProps as t, normalizeFormInteraction as u, trackFormNative as v, formFieldRootId as x, formControlStem as y };
+
+//# sourceMappingURL=form-BAGkIEMY.js.map