@formadapter/core 0.0.0

package/dist/index.js

@@ -0,0 +1,1172 @@
+//#region src/path-segment.ts
+/** Names that collide with JavaScript object lookup or form-runtime state. */
+const RESERVED_FORM_PATH_SEGMENTS = new Set([
+	...Object.getOwnPropertyNames(Object.prototype),
+	"prototype",
+	"root"
+]);
+function formPathSegmentError(segment) {
+	if (segment.length === 0) return "Empty property names cannot be represented in a form path";
+	if (RESERVED_FORM_PATH_SEGMENTS.has(segment)) return `Property name “${segment}” is reserved and cannot be represented safely in a form path`;
+	if (segment.startsWith("__formadapter_")) return `Property name “${segment}” uses FormAdapter's reserved internal namespace`;
+	if (segment.startsWith("$ACTION_")) return `Property name “${segment}” uses a reserved server-action prefix and cannot be represented safely`;
+	if (segment.includes(".") || segment.includes("[") || segment.includes("]") || segment.includes("'") || segment.includes("\"")) return `Property name “${segment}” contains form-path syntax and cannot be represented safely`;
+	if (!Number.isNaN(Number(segment))) return `Numeric-like property name “${segment}” cannot be distinguished safely from an array index`;
+}
+/** True when a schema property cannot be represented losslessly as one path segment. */
+function isReservedFormPathSegment(segment) {
+	return formPathSegmentError(segment) !== void 0;
+}
+//#endregion
+//#region src/record.ts
+/** Own-property checks that are safe for null-prototype and hostile-key records. */
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+/**
+* Creates a dictionary without inherited names such as `constructor` or
+* `toString`. Use this for path-indexed internal/public maps.
+*/
+function createNullRecord() {
+	return Object.create(null);
+}
+/** Defines a normal enumerable data property without invoking `__proto__`. */
+function defineOwn(target, key, value) {
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
+function ownValue(value, key) {
+	return hasOwn(value, key) ? value[key] : void 0;
+}
+//#endregion
+//#region src/compile.ts
+var SchemaConversionError = class extends Error {
+	name = "SchemaConversionError";
+	constructor(message, options) {
+		super(message, options);
+	}
+};
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSchemaObject(schema) {
+	return typeof schema === "object" && schema !== null && !Array.isArray(schema);
+}
+function humanize(value) {
+	const words = value.replaceAll("[]", "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+	return words ? words.charAt(0).toLocaleUpperCase() + words.slice(1) : "Field";
+}
+function pointerValue(root, reference) {
+	if (!reference.startsWith("#/")) return void 0;
+	let current = root;
+	for (const encoded of reference.slice(2).split("/")) {
+		const segment = encoded.replaceAll("~1", "/").replaceAll("~0", "~");
+		if (!isRecord$2(current) || !hasOwn(current, segment)) return void 0;
+		current = current[segment];
+	}
+	return typeof current === "boolean" || isRecord$2(current) ? current : void 0;
+}
+function sameValue(left, right) {
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameValue(value, right[index]));
+	if (!isRecord$2(left) || !isRecord$2(right)) return false;
+	const leftKeys = Object.keys(left).sort();
+	const rightKeys = Object.keys(right).sort();
+	return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && sameValue(left[key], right[key]));
+}
+const COMPOSED_KEYWORDS = new Set([
+	"$defs",
+	"additionalProperties",
+	"allOf",
+	"const",
+	"default",
+	"definitions",
+	"deprecated",
+	"description",
+	"enum",
+	"examples",
+	"exclusiveMaximum",
+	"exclusiveMinimum",
+	"format",
+	"items",
+	"maxItems",
+	"maxLength",
+	"maximum",
+	"minItems",
+	"minLength",
+	"minimum",
+	"multipleOf",
+	"pattern",
+	"patternProperties",
+	"properties",
+	"propertyNames",
+	"readOnly",
+	"required",
+	"title",
+	"type",
+	"uniqueItems",
+	"writeOnly"
+]);
+function intersectSchemaValue(left, right) {
+	if (left === false || right === false) return false;
+	if (left === true) return right;
+	if (right === true) return left;
+	return { allOf: [left, right] };
+}
+function mergeSchemaMap(left, right) {
+	if (!left && !right) return void 0;
+	const merged = createNullRecord();
+	for (const [key, value] of Object.entries(left ?? {})) defineOwn(merged, key, value);
+	for (const [key, value] of Object.entries(right ?? {})) defineOwn(merged, key, hasOwn(merged, key) ? intersectSchemaValue(merged[key], value) : value);
+	return merged;
+}
+function mergeDefinitions(left, right, keyword) {
+	if (!left && !right) return {};
+	const merged = createNullRecord();
+	for (const [key, value] of Object.entries(left ?? {})) defineOwn(merged, key, value);
+	for (const [key, value] of Object.entries(right ?? {})) {
+		if (hasOwn(merged, key) && !sameValue(merged[key], value)) return { error: `Cannot safely combine conflicting ${keyword} definition “${key}”` };
+		defineOwn(merged, key, value);
+	}
+	return { definitions: merged };
+}
+function explicitTypes(schema) {
+	if (typeof schema.type === "string") return [schema.type];
+	return Array.isArray(schema.type) ? schema.type : void 0;
+}
+function intersectTypes(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	const result = [];
+	for (const leftType of left) for (const rightType of right) {
+		const intersection = leftType === rightType ? leftType : leftType === "number" && rightType === "integer" || leftType === "integer" && rightType === "number" ? "integer" : void 0;
+		if (intersection && !result.includes(intersection)) result.push(intersection);
+	}
+	return result;
+}
+function constrainedValues(schema) {
+	const hasConst = hasOwn(schema, "const");
+	const enumValues = schema.enum;
+	if (!hasConst) return enumValues;
+	if (!enumValues) return [schema.const];
+	return enumValues.some((value) => sameValue(value, schema.const)) ? [schema.const] : [];
+}
+function intersectValues(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return left.filter((leftValue) => right.some((rightValue) => sameValue(leftValue, rightValue)));
+}
+function valueMatchesType(value, type) {
+	switch (type) {
+		case "array": return Array.isArray(value);
+		case "boolean": return typeof value === "boolean";
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "null": return value === null;
+		case "number": return typeof value === "number" && Number.isFinite(value);
+		case "object": return isRecord$2(value);
+		case "string": return typeof value === "string";
+		default: return false;
+	}
+}
+function lowerBoundary(schema) {
+	const candidates = [];
+	if (schema.minimum !== void 0) candidates.push({
+		exclusive: false,
+		value: schema.minimum
+	});
+	if (schema.exclusiveMinimum !== void 0) candidates.push({
+		exclusive: true,
+		value: schema.exclusiveMinimum
+	});
+	return candidates.sort((left, right) => right.value - left.value || Number(right.exclusive) - Number(left.exclusive))[0];
+}
+function upperBoundary(schema) {
+	const candidates = [];
+	if (schema.maximum !== void 0) candidates.push({
+		exclusive: false,
+		value: schema.maximum
+	});
+	if (schema.exclusiveMaximum !== void 0) candidates.push({
+		exclusive: true,
+		value: schema.exclusiveMaximum
+	});
+	return candidates.sort((left, right) => left.value - right.value || Number(right.exclusive) - Number(left.exclusive))[0];
+}
+function stricterLower(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	if (left.value !== right.value) return left.value > right.value ? left : right;
+	return left.exclusive ? left : right;
+}
+function stricterUpper(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	if (left.value !== right.value) return left.value < right.value ? left : right;
+	return left.exclusive ? left : right;
+}
+function stricterMultipleOf(left, right) {
+	if (left === void 0) return right;
+	if (right === void 0 || Object.is(left, right)) return left;
+	if (left > 0 && right > 0) {
+		const leftRatio = left / right;
+		if (Number.isInteger(leftRatio)) return left;
+		const rightRatio = right / left;
+		if (Number.isInteger(rightRatio)) return right;
+	}
+}
+function mergeSchema(left, right) {
+	for (const key of Object.keys(left)) if (hasOwn(right, key) && !COMPOSED_KEYWORDS.has(key) && !key.startsWith("x-formadapter") && !sameValue(left[key], right[key])) return { error: `Cannot safely combine conflicting allOf keyword “${key}”` };
+	const types = intersectTypes(explicitTypes(left), explicitTypes(right));
+	if (types?.length === 0) return { error: "The allOf branches require incompatible JSON Schema types" };
+	let values = intersectValues(constrainedValues(left), constrainedValues(right));
+	if (values && types) values = values.filter((value) => types.some((type) => valueMatchesType(value, type)));
+	if (values?.length === 0) return { error: "The allOf branches have no allowed values in common" };
+	if (left.pattern !== void 0 && right.pattern !== void 0 && left.pattern !== right.pattern) return { error: "Multiple different patterns in allOf cannot be represented by one form control" };
+	if (left.format !== void 0 && right.format !== void 0 && left.format !== right.format) return { error: "Conflicting formats in allOf cannot be represented by one form control" };
+	const multipleOf = stricterMultipleOf(left.multipleOf, right.multipleOf);
+	if (left.multipleOf !== void 0 && right.multipleOf !== void 0 && multipleOf === void 0) return { error: "Different multipleOf constraints in allOf cannot be represented safely" };
+	const minimum = stricterLower(lowerBoundary(left), lowerBoundary(right));
+	const maximum = stricterUpper(upperBoundary(left), upperBoundary(right));
+	if (minimum && maximum && (minimum.value > maximum.value || minimum.value === maximum.value && (minimum.exclusive || maximum.exclusive))) return { error: "The allOf numeric constraints cannot be satisfied" };
+	const minLength = Math.max(left.minLength ?? 0, right.minLength ?? 0);
+	const maxLength = Math.min(left.maxLength ?? Number.POSITIVE_INFINITY, right.maxLength ?? Number.POSITIVE_INFINITY);
+	if (minLength > maxLength) return { error: "The allOf string-length constraints cannot be satisfied" };
+	const minItems = Math.max(left.minItems ?? 0, right.minItems ?? 0);
+	const maxItems = Math.min(left.maxItems ?? Number.POSITIVE_INFINITY, right.maxItems ?? Number.POSITIVE_INFINITY);
+	if (minItems > maxItems) return { error: "The allOf array-length constraints cannot be satisfied" };
+	const definitions = mergeDefinitions(left.definitions, right.definitions, "definitions");
+	if (definitions.error) return { error: definitions.error };
+	const defs = mergeDefinitions(left.$defs, right.$defs, "$defs");
+	if (defs.error) return { error: defs.error };
+	const leftProperties = new Set(Object.keys(left.properties ?? {}));
+	const rightProperties = new Set(Object.keys(right.properties ?? {}));
+	if (left.additionalProperties === false && [...rightProperties].some((key) => !leftProperties.has(key)) || right.additionalProperties === false && [...leftProperties].some((key) => !rightProperties.has(key))) return { error: "Closed object branches in allOf declare incompatible property sets" };
+	const merged = {
+		...left,
+		...right
+	};
+	delete merged.type;
+	if (types) merged.type = types.length === 1 ? types[0] : types;
+	delete merged.const;
+	delete merged.enum;
+	if (values) if ((hasOwn(left, "const") || hasOwn(right, "const")) && values.length === 1) merged.const = values[0];
+	else merged.enum = values;
+	const properties = mergeSchemaMap(left.properties, right.properties);
+	if (properties) merged.properties = properties;
+	const patternProperties = mergeSchemaMap(left.patternProperties, right.patternProperties);
+	if (patternProperties) merged.patternProperties = patternProperties;
+	if (left.required || right.required) merged.required = [...new Set([...left.required ?? [], ...right.required ?? []])];
+	if (hasOwn(left, "additionalProperties") && hasOwn(right, "additionalProperties")) merged.additionalProperties = intersectSchemaValue(left.additionalProperties, right.additionalProperties);
+	if (hasOwn(left, "propertyNames") && hasOwn(right, "propertyNames")) merged.propertyNames = intersectSchemaValue(left.propertyNames, right.propertyNames);
+	if (hasOwn(left, "items") && hasOwn(right, "items")) if (Array.isArray(left.items) || Array.isArray(right.items)) {
+		if (!sameValue(left.items, right.items)) return { error: "Different tuple item schemas in allOf cannot be represented safely" };
+	} else merged.items = intersectSchemaValue(left.items, right.items);
+	const allOf = [...left.allOf ?? [], ...right.allOf ?? []];
+	if (allOf.length > 0) merged.allOf = allOf;
+	else delete merged.allOf;
+	delete merged.minimum;
+	delete merged.exclusiveMinimum;
+	if (minimum) merged[minimum.exclusive ? "exclusiveMinimum" : "minimum"] = minimum.value;
+	delete merged.maximum;
+	delete merged.exclusiveMaximum;
+	if (maximum) merged[maximum.exclusive ? "exclusiveMaximum" : "maximum"] = maximum.value;
+	delete merged.minLength;
+	delete merged.maxLength;
+	if (left.minLength !== void 0 || right.minLength !== void 0) merged.minLength = minLength;
+	if (maxLength !== Number.POSITIVE_INFINITY) merged.maxLength = maxLength;
+	delete merged.minItems;
+	delete merged.maxItems;
+	if (left.minItems !== void 0 || right.minItems !== void 0) merged.minItems = minItems;
+	if (maxItems !== Number.POSITIVE_INFINITY) merged.maxItems = maxItems;
+	if (multipleOf !== void 0) merged.multipleOf = multipleOf;
+	if (left.uniqueItems !== void 0 || right.uniqueItems !== void 0) merged.uniqueItems = left.uniqueItems === true || right.uniqueItems === true;
+	if (left.readOnly !== void 0 || right.readOnly !== void 0) merged.readOnly = left.readOnly === true || right.readOnly === true;
+	if (hasOwn(left, "writeOnly") || hasOwn(right, "writeOnly")) merged.writeOnly = left.writeOnly === true || right.writeOnly === true;
+	if (definitions.definitions) merged.definitions = definitions.definitions;
+	if (defs.definitions) merged.$defs = defs.definitions;
+	return { schema: merged };
+}
+function schemaChildren(schema) {
+	const children = [];
+	children.push(...Object.values(schema.properties ?? {}));
+	children.push(...Object.values(schema.patternProperties ?? {}));
+	for (const keyword of ["additionalProperties", "propertyNames"]) {
+		const child = schema[keyword];
+		if (typeof child === "boolean" || isSchemaObject(child)) children.push(child);
+	}
+	if (Array.isArray(schema.items)) children.push(...schema.items);
+	else if (typeof schema.items === "boolean" || isSchemaObject(schema.items)) children.push(schema.items);
+	children.push(...schema.prefixItems ?? []);
+	children.push(...schema.allOf ?? [], ...schema.anyOf ?? [], ...schema.oneOf ?? []);
+	return children;
+}
+function referenceIsRecursive(root, reference) {
+	const target = pointerValue(root, reference);
+	if (target === void 0) return false;
+	const visitedObjects = /* @__PURE__ */ new Set();
+	const visitedReferences = /* @__PURE__ */ new Set();
+	const visit = (schema) => {
+		if (!isSchemaObject(schema)) return false;
+		if (schema.$ref) {
+			if (schema.$ref === reference) return true;
+			if (visitedReferences.has(schema.$ref)) return false;
+			visitedReferences.add(schema.$ref);
+			const nested = pointerValue(root, schema.$ref);
+			if (nested !== void 0 && visit(nested)) return true;
+		}
+		if (visitedObjects.has(schema)) return false;
+		visitedObjects.add(schema);
+		return schemaChildren(schema).some(visit);
+	};
+	return visit(target);
+}
+function resolveSchema(schema, context) {
+	if (!isSchemaObject(schema) || !schema.$ref) return {
+		schema,
+		context
+	};
+	const reference = schema.$ref;
+	if (context.resolvingRefs.has(reference) && referenceIsRecursive(context.rootSchema, reference)) return {
+		schema,
+		context,
+		error: `Circular JSON Schema reference “${reference}”`
+	};
+	const target = pointerValue(context.rootSchema, reference);
+	if (target === void 0) return {
+		schema,
+		context,
+		error: `Unresolved JSON Schema reference “${reference}”`
+	};
+	const nextContext = {
+		...context,
+		resolvingRefs: new Set([...context.resolvingRefs, reference])
+	};
+	const { $ref: _ignored, ...siblings } = schema;
+	if (target === false) return {
+		schema: false,
+		context: nextContext
+	};
+	if (target === true) return Object.keys(siblings).length === 0 ? {
+		schema: true,
+		context: nextContext
+	} : {
+		schema: siblings,
+		context: nextContext
+	};
+	const resolvedTarget = target.$ref ? resolveSchema(target, nextContext) : {
+		schema: target,
+		context: nextContext
+	};
+	if (resolvedTarget.error || resolvedTarget.schema === false) return resolvedTarget;
+	if (resolvedTarget.schema === true) return Object.keys(siblings).length === 0 ? resolvedTarget : {
+		schema: siblings,
+		context: resolvedTarget.context
+	};
+	if (Object.keys(siblings).length === 0) return resolvedTarget;
+	const merged = mergeSchema(resolvedTarget.schema, siblings);
+	return merged.error ? {
+		schema,
+		context,
+		error: merged.error
+	} : {
+		schema: merged.schema,
+		context: resolvedTarget.context
+	};
+}
+function collapseAllOf(schema, context) {
+	if (!schema.allOf || schema.allOf.length === 0) return {
+		schema,
+		context
+	};
+	const { allOf, ...base } = schema;
+	let merged = base;
+	const resolvingRefs = new Set(context.resolvingRefs);
+	for (const branch of allOf) {
+		const resolved = resolveSchema(branch, context);
+		if (resolved.error) return {
+			schema: merged,
+			context,
+			error: resolved.error
+		};
+		if (resolved.schema === false) return {
+			schema: merged,
+			context,
+			error: "An allOf branch can never be valid"
+		};
+		if (resolved.schema === true) continue;
+		const collapsed = collapseAllOf(resolved.schema, resolved.context);
+		if (collapsed.error) return collapsed;
+		const intersection = mergeSchema(merged, collapsed.schema);
+		if (intersection.error) return {
+			schema: merged,
+			context,
+			error: intersection.error
+		};
+		merged = intersection.schema;
+		for (const reference of collapsed.context.resolvingRefs) resolvingRefs.add(reference);
+	}
+	return {
+		schema: merged,
+		context: {
+			...context,
+			resolvingRefs
+		}
+	};
+}
+function primitive(value) {
+	return value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value);
+}
+function optionsFromSchema(schema) {
+	const raw = schema.enum ?? (schema.const !== void 0 ? [schema.const] : void 0);
+	if (!raw || !raw.every(primitive)) return void 0;
+	return raw.map((value) => ({
+		label: humanize(String(value)),
+		value
+	}));
+}
+function optionsFromUnion(branches, context, exclusive) {
+	const options = [];
+	for (const branch of branches) {
+		const resolved = resolveSchema(branch, context);
+		if (resolved.error || resolved.schema === true) return void 0;
+		if (resolved.schema === false) continue;
+		const collapsed = collapseAllOf(resolved.schema, resolved.context);
+		if (collapsed.error) return void 0;
+		const branchOptions = optionsFromSchema(collapsed.schema);
+		if (!branchOptions) return void 0;
+		for (const option of branchOptions) {
+			if (options.some((existing) => Object.is(existing.value, option.value))) {
+				if (exclusive) return void 0;
+				continue;
+			}
+			options.push({
+				label: collapsed.schema.title ?? option.label,
+				value: option.value
+			});
+		}
+	}
+	return options;
+}
+function mediaTypesFromUnion(branches, context) {
+	const mediaTypes = [];
+	for (const branch of branches) {
+		const resolved = resolveSchema(branch, context);
+		if (resolved.error || !isSchemaObject(resolved.schema)) return void 0;
+		const collapsed = collapseAllOf(resolved.schema, resolved.context);
+		if (collapsed.error || typeof collapsed.schema.contentMediaType !== "string") return;
+		if (Object.keys(collapsed.schema).find((key) => ![
+			"$comment",
+			"contentMediaType",
+			"deprecated",
+			"description",
+			"readOnly",
+			"title",
+			"writeOnly"
+		].includes(key))) return void 0;
+		if (!mediaTypes.includes(collapsed.schema.contentMediaType)) mediaTypes.push(collapsed.schema.contentMediaType);
+	}
+	return mediaTypes.length > 0 ? mediaTypes : void 0;
+}
+function sameSchema(left, right) {
+	return sameValue(left, right);
+}
+function normalizedObjectUnion(branches, context) {
+	const objects = [];
+	for (const branch of branches) {
+		const resolved = resolveSchema(branch, context);
+		if (resolved.error || !isSchemaObject(resolved.schema)) return void 0;
+		const collapsed = collapseAllOf(resolved.schema, resolved.context);
+		if (collapsed.error || !schemaTypes(collapsed.schema).includes("object")) return;
+		objects.push(collapsed.schema);
+	}
+	if (objects.length < 2) return void 0;
+	const discriminator = Object.keys(objects[0]?.properties ?? {}).filter((key) => objects.every((branch) => hasOwn(branch.properties ?? {}, key))).find((key) => {
+		const values = objects.map((branch) => {
+			const property = branch.properties?.[key];
+			if (property === void 0 || !isSchemaObject(property)) return void 0;
+			const options = optionsFromSchema(property);
+			return options?.length === 1 ? options[0]?.value : void 0;
+		});
+		return values.every((value) => value !== void 0) && new Set(values.map((value) => JSON.stringify(value))).size === values.length;
+	});
+	if (!discriminator) return void 0;
+	const discriminatorValues = objects.map((branch) => {
+		const property = branch.properties?.[discriminator];
+		return optionsFromSchema(property)?.[0]?.value;
+	});
+	const propertyNames = [...new Set(objects.flatMap((branch) => Object.keys(branch.properties ?? {})))];
+	const properties = createNullRecord();
+	const rules = createNullRecord();
+	for (const propertyName of propertyNames) {
+		const schemas = objects.flatMap((branch) => {
+			const property = branch.properties?.[propertyName];
+			return property === void 0 ? [] : [property];
+		});
+		if (propertyName === discriminator) {
+			const initial = schemas[0];
+			const { const: _const, ...withoutConst } = initial !== void 0 && isSchemaObject(initial) ? initial : {};
+			defineOwn(properties, propertyName, {
+				...withoutConst,
+				enum: discriminatorValues
+			});
+		} else {
+			const first = schemas[0];
+			defineOwn(properties, propertyName, schemas.every((candidate) => sameSchema(first, candidate)) ? first : { anyOf: schemas });
+		}
+		const visibleFor = [];
+		const requiredFor = [];
+		for (const [index, branch] of objects.entries()) {
+			if (branch.properties?.[propertyName] !== void 0) visibleFor.push(discriminatorValues[index]);
+			if (branch.required?.includes(propertyName)) requiredFor.push(discriminatorValues[index]);
+		}
+		defineOwn(rules, propertyName, {
+			requiredFor,
+			visibleFor
+		});
+	}
+	return {
+		discriminator,
+		rules,
+		schema: {
+			properties,
+			required: propertyNames.filter((propertyName) => objects.every((branch) => branch.required?.includes(propertyName))),
+			type: "object"
+		}
+	};
+}
+function runtimePathValue(values, path) {
+	return path.split(".").reduce((current, segment) => {
+		return isRecord$2(current) ? ownValue(current, segment) : void 0;
+	}, values);
+}
+function stateValue(state, values) {
+	return typeof state === "function" ? state(values) : state;
+}
+function extensionConfig(schema) {
+	const nested = isRecord$2(schema["x-formadapter"]) ? schema["x-formadapter"] : {};
+	const flat = createNullRecord();
+	const prefix = "x-formadapter-";
+	for (const [key, value] of Object.entries(schema)) if (key.startsWith(prefix)) defineOwn(flat, key.slice(14), value);
+	return {
+		...nested,
+		...flat
+	};
+}
+function fieldOverride(path, config) {
+	const fields = config.fields;
+	return fields && hasOwn(fields, path) ? fields[path] : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function booleanValue(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function resolvedConfig(schema, override) {
+	const extensions = extensionConfig(schema);
+	const control = override?.control ?? stringValue(extensions.control);
+	const placeholder = override?.placeholder ?? stringValue(extensions.placeholder);
+	const order = override?.order ?? numberValue(extensions.order);
+	const className = override?.className ?? stringValue(extensions.className ?? extensions["class-name"]);
+	return {
+		...control !== void 0 ? { control } : {},
+		...placeholder !== void 0 ? { placeholder } : {},
+		hidden: override?.hidden ?? booleanValue(extensions.hidden) ?? false,
+		disabled: override?.disabled ?? booleanValue(extensions.disabled) ?? false,
+		readOnly: override?.readOnly ?? booleanValue(extensions.readonly ?? extensions.readOnly) ?? schema.readOnly ?? false,
+		...order !== void 0 ? { order } : {},
+		...className !== void 0 ? { className } : {},
+		...override?.controlProps ? { controlProps: override.controlProps } : {},
+		multiple: override?.multiple ?? booleanValue(extensions.multiple) ?? false,
+		...override?.options ? { options: override.options } : {},
+		requiredWhenVisible: override?.requiredWhenVisible ?? booleanValue(extensions.requiredWhenVisible ?? extensions["required-when-visible"]) ?? false,
+		...override?.requiredMessage ? { requiredMessage: override.requiredMessage } : {},
+		...override?.asyncValidate !== void 0 ? { asyncValidate: override.asyncValidate } : {},
+		asyncValidationDebounceMs: Math.max(0, override?.asyncValidationDebounceMs ?? 250),
+		...override?.array ? { array: override.array } : {},
+		extensions
+	};
+}
+function schemaTypes(schema) {
+	if (typeof schema.type === "string") return [schema.type];
+	if (Array.isArray(schema.type)) {
+		const types = [...new Set(schema.type)];
+		return types.includes("number") ? types.filter((type) => type !== "integer") : types;
+	}
+	if (schema.properties) return ["object"];
+	if (schema.items) return ["array"];
+	if (schema.const !== void 0) {
+		if (schema.const === null) return ["null"];
+		return [typeof schema.const];
+	}
+	if (schema.enum?.length) return [...new Set(schema.enum.map((value) => value === null ? "null" : typeof value))];
+	return [];
+}
+function inferControl(dataType, schema, options) {
+	if (dataType === "boolean") return "checkbox";
+	if (options !== void 0) return "select";
+	if (dataType === "number" || dataType === "integer") return "number";
+	if (dataType === "file") return "file";
+	switch (schema.format) {
+		case "date": return "date";
+		case "date-time": return "text";
+		case "email": return "email";
+		case "password": return "password";
+		case "tel": return "tel";
+		case "time": return "time";
+		case "uri":
+		case "url": return "url";
+		default: return "text";
+	}
+}
+const NATIVE_INPUT_TYPES = new Set([
+	"checkbox",
+	"date",
+	"datetime-local",
+	"email",
+	"file",
+	"hidden",
+	"number",
+	"password",
+	"range",
+	"search",
+	"tel",
+	"text",
+	"time",
+	"url"
+]);
+function inputType(control) {
+	return NATIVE_INPUT_TYPES.has(control) ? control : void 0;
+}
+function constraints(schema, config, acceptedMediaTypes) {
+	return {
+		...schema.format ? { format: schema.format } : {},
+		...schema.minLength !== void 0 ? { minLength: schema.minLength } : {},
+		...schema.maxLength !== void 0 ? { maxLength: schema.maxLength } : {},
+		...schema.pattern ? { pattern: schema.pattern } : {},
+		...schema.minimum !== void 0 ? { minimum: schema.minimum } : {},
+		...schema.maximum !== void 0 ? { maximum: schema.maximum } : {},
+		...schema.exclusiveMinimum !== void 0 ? { exclusiveMinimum: schema.exclusiveMinimum } : {},
+		...schema.exclusiveMaximum !== void 0 ? { exclusiveMaximum: schema.exclusiveMaximum } : {},
+		...schema.multipleOf !== void 0 ? { multipleOf: schema.multipleOf } : {},
+		...acceptedMediaTypes?.length ? { accept: acceptedMediaTypes.join(",") } : schema.contentMediaType ? { accept: schema.contentMediaType } : {},
+		multiple: config.multiple,
+		...schema.contentEncoding ? { contentEncoding: schema.contentEncoding } : {},
+		...schema.contentMediaType ? { contentMediaType: schema.contentMediaType } : {}
+	};
+}
+function isFileSchema(schema) {
+	return schema.format === "binary" || schema.contentEncoding === "binary" || schema.contentMediaType !== void 0;
+}
+function nonNullUnionBranch(branch, context) {
+	const resolved = resolveSchema(branch, context);
+	if (resolved.error) return {
+		branch,
+		nullable: false
+	};
+	if (resolved.schema === false) return { nullable: false };
+	if (resolved.schema === true) return {
+		branch: true,
+		nullable: false
+	};
+	const collapsed = collapseAllOf(resolved.schema, resolved.context);
+	if (collapsed.error) return {
+		branch,
+		nullable: false
+	};
+	const schema = collapsed.schema;
+	const types = schemaTypes(schema);
+	if (!types.includes("null")) return {
+		branch,
+		nullable: false
+	};
+	if (types.filter((type) => type !== "null").length === 0) return { nullable: true };
+	if (Array.isArray(schema.type)) return {
+		branch: {
+			...schema,
+			type: schema.type.filter((type) => type !== "null")
+		},
+		nullable: true
+	};
+	if (schema.enum) return {
+		branch: {
+			...schema,
+			enum: schema.enum.filter((value) => value !== null)
+		},
+		nullable: true
+	};
+	return {
+		branch,
+		nullable: true
+	};
+}
+function unsupported(input, schema, reason) {
+	const objectSchema = isSchemaObject(schema) ? schema : {};
+	const override = fieldOverride(input.path, input.context.config);
+	return {
+		kind: "unsupported",
+		key: input.key,
+		path: input.path,
+		label: override?.label ?? objectSchema.title ?? input.labelFallback,
+		...override?.description ?? objectSchema.description ? { description: override?.description ?? objectSchema.description } : {},
+		required: input.required,
+		nullable: input.nullable ?? false,
+		...override?.defaultValue ?? objectSchema.default !== void 0 ? { defaultValue: override?.defaultValue ?? objectSchema.default } : {},
+		config: resolvedConfig(objectSchema, override),
+		source: schema,
+		reason
+	};
+}
+function compileNode(input) {
+	const resolved = resolveSchema(input.schema, input.context);
+	if (resolved.error) return unsupported(input, input.schema, resolved.error);
+	if (resolved.schema === false) return unsupported(input, false, "This field can never be valid");
+	if (resolved.schema === true) return unsupported(input, true, "The schema does not describe a renderable field");
+	const collapsed = collapseAllOf(resolved.schema, resolved.context);
+	if (collapsed.error) return unsupported(input, resolved.schema, collapsed.error);
+	let schema = collapsed.schema;
+	const nodeContext = collapsed.context;
+	if (schema.enum?.length === 0) return unsupported(input, schema, "An empty enum can never be valid");
+	if (Array.isArray(schema.type) && schema.type.length === 0) return unsupported(input, schema, "An empty type union can never be valid");
+	const union = schema.oneOf ?? schema.anyOf;
+	let nullable = input.nullable ?? false;
+	let unionOptions;
+	let objectUnion;
+	let acceptedMediaTypes;
+	if (union) {
+		if (union.length === 0) return unsupported(input, schema, "An empty union can never be valid");
+		const classified = union.map((branch) => nonNullUnionBranch(branch, nodeContext));
+		const nonNull = classified.flatMap((entry) => entry.branch === void 0 ? [] : [entry.branch]);
+		nullable ||= classified.some((entry) => entry.nullable);
+		acceptedMediaTypes = isFileSchema(schema) && schema.anyOf !== void 0 ? mediaTypesFromUnion(nonNull, nodeContext) : void 0;
+		objectUnion = acceptedMediaTypes ? void 0 : normalizedObjectUnion(nonNull, nodeContext);
+		if (acceptedMediaTypes) {
+			const { oneOf: _one, anyOf: _any, ...withoutUnion } = schema;
+			schema = withoutUnion;
+		} else if (objectUnion) {
+			if (input.path.includes("[]")) return unsupported(input, schema, "Discriminated object unions inside arrays are not supported yet");
+			const { oneOf: _one, anyOf: _any, ...withoutUnion } = schema;
+			const intersection = mergeSchema(withoutUnion, objectUnion.schema);
+			if (intersection.error) return unsupported(input, schema, intersection.error);
+			schema = intersection.schema;
+		} else if (nonNull.length === 1 && isSchemaObject(nonNull[0])) {
+			const { oneOf: _one, anyOf: _any, ...withoutUnion } = schema;
+			const resolvedBranch = resolveSchema(nonNull[0], nodeContext);
+			if (resolvedBranch.error) return unsupported(input, schema, resolvedBranch.error);
+			if (resolvedBranch.schema === false) return unsupported(input, schema, "This union cannot be valid");
+			if (resolvedBranch.schema === true) return unsupported(input, schema, "An unconstrained union cannot be represented as one form control");
+			const collapsedBranch = collapseAllOf(resolvedBranch.schema, resolvedBranch.context);
+			if (collapsedBranch.error) return unsupported(input, schema, collapsedBranch.error);
+			const intersection = mergeSchema(withoutUnion, collapsedBranch.schema);
+			if (intersection.error) return unsupported(input, schema, intersection.error);
+			schema = intersection.schema;
+		} else {
+			unionOptions = optionsFromUnion(nonNull, nodeContext, schema.oneOf !== void 0);
+			if (!unionOptions || unionOptions.length === 0) return unsupported(input, schema, "This union cannot be represented as one form control");
+			const { oneOf: _one, anyOf: _any, ...withoutUnion } = schema;
+			schema = {
+				...withoutUnion,
+				enum: unionOptions.map((option) => option.value)
+			};
+		}
+	}
+	const types = schemaTypes(schema).filter((type) => type !== "null");
+	nullable ||= schemaTypes(schema).includes("null");
+	const type = types.length === 1 ? types[0] : void 0;
+	const override = fieldOverride(input.path, input.context.config);
+	const extensions = extensionConfig(schema);
+	const label = override?.label ?? schema.title ?? stringValue(extensions.label) ?? input.labelFallback;
+	const description = override?.description ?? schema.description ?? stringValue(extensions.description);
+	const defaultValue = override?.defaultValue ?? schema.default;
+	const config = resolvedConfig(schema, override);
+	const common = {
+		key: input.key,
+		path: input.path,
+		label,
+		...description ? { description } : {},
+		required: input.required,
+		nullable,
+		...defaultValue !== void 0 ? { defaultValue } : {},
+		config,
+		source: schema
+	};
+	if (type === "object") {
+		const hasProperties = Object.keys(schema.properties ?? {}).length > 0;
+		if (schema.additionalProperties === true || isSchemaObject(schema.additionalProperties ?? false) || Object.keys(schema.patternProperties ?? {}).length > 0 || !hasProperties && schema.propertyNames !== void 0) return unsupported(input, schema, "Dynamic record keys are not supported yet");
+		const required = new Set(schema.required ?? []);
+		const children = Object.entries(schema.properties ?? {}).map(([key, child]) => {
+			const path = input.path ? `${input.path}.${key}` : key;
+			const childInput = {
+				context: nodeContext,
+				key,
+				labelFallback: humanize(key),
+				path,
+				required: required.has(key),
+				schema: child
+			};
+			const invalidPath = formPathSegmentError(key);
+			const compiled = invalidPath ? unsupported(childInput, child, invalidPath) : compileNode(childInput);
+			const unionInfo = objectUnion;
+			const rule = unionInfo?.rules[key];
+			if (!unionInfo || !rule || path.includes("[]")) return compiled;
+			const discriminatorPath = input.path ? `${input.path}.${unionInfo.discriminator}` : unionInfo.discriminator;
+			const existingHidden = compiled.config.hidden;
+			const existingRequired = compiled.config.requiredWhenVisible;
+			return {
+				...compiled,
+				config: {
+					...compiled.config,
+					hidden: (values) => {
+						const selected = runtimePathValue(values, discriminatorPath);
+						const branchCount = unionInfo.rules[unionInfo.discriminator]?.visibleFor.length ?? 0;
+						const branchHidden = rule.visibleFor.length < branchCount && !rule.visibleFor.some((value) => Object.is(value, selected));
+						return stateValue(existingHidden, values) || branchHidden;
+					},
+					requiredWhenVisible: (values) => {
+						const selected = runtimePathValue(values, discriminatorPath);
+						const branchRequired = rule.requiredFor.some((value) => Object.is(value, selected));
+						return stateValue(existingRequired, values) || branchRequired;
+					}
+				}
+			};
+		}).sort((left, right) => {
+			return (left.config.order ?? Number.MAX_SAFE_INTEGER) - (right.config.order ?? Number.MAX_SAFE_INTEGER);
+		});
+		return {
+			kind: "object",
+			...common,
+			children
+		};
+	}
+	if (type === "array") {
+		const itemSchema = schema.items;
+		if (Array.isArray(itemSchema) || schema.prefixItems) return unsupported(input, schema, "Tuple schemas are not supported yet");
+		if (!itemSchema) return unsupported(input, schema, "Array schema is missing its item schema");
+		const itemPath = `${input.path}[]`;
+		const item = compileNode({
+			context: nodeContext,
+			key: input.key,
+			labelFallback: `${label} item`,
+			path: itemPath,
+			required: true,
+			schema: itemSchema
+		});
+		return {
+			kind: "array",
+			...common,
+			item,
+			...schema.minItems !== void 0 ? { minItems: schema.minItems } : {},
+			...schema.maxItems !== void 0 ? { maxItems: schema.maxItems } : {},
+			uniqueItems: schema.uniqueItems ?? false
+		};
+	}
+	const configuredOptions = Array.isArray(override?.options) ? override.options : void 0;
+	const hasDynamicOptions = typeof override?.options === "function";
+	let options = configuredOptions ?? unionOptions ?? optionsFromSchema(schema);
+	const isFile = isFileSchema(schema) || acceptedMediaTypes !== void 0;
+	if (isFile && config.multiple) return unsupported(input, schema, "Multiple file selection requires an array-of-files schema");
+	const dataType = isFile ? "file" : type === "string" || type === "number" || type === "integer" || type === "boolean" ? type : "unknown";
+	if (nullable && options && !options.some((option) => option.value === null)) options = [...options, {
+		label: "None",
+		value: null
+	}];
+	if (nullable && dataType === "boolean" && !options) options = [
+		{
+			label: "Yes",
+			value: true
+		},
+		{
+			label: "No",
+			value: false
+		},
+		{
+			label: "None",
+			value: null
+		}
+	];
+	if (dataType === "unknown" && !options) return unsupported(input, schema, `Unsupported JSON Schema type “${type ?? "unknown"}”`);
+	const control = config.control ?? (hasDynamicOptions ? "select" : nullable && dataType === "boolean" ? "select" : inferControl(dataType, schema, options));
+	const nativeType = inputType(control);
+	return {
+		kind: "scalar",
+		...common,
+		dataType,
+		control,
+		...nativeType ? { inputType: nativeType } : {},
+		constraints: constraints(schema, config, acceptedMediaTypes),
+		...options ? { options } : {}
+	};
+}
+function collectFields(node, target) {
+	if (node.path) defineOwn(target, node.path, node);
+	if (node.kind === "object") for (const child of node.children) collectFields(child, target);
+	else if (node.kind === "array") collectFields(node.item, target);
+}
+function arkTypeLibraryOptions(schema, config) {
+	const configured = config.jsonSchema?.libraryOptions;
+	if (schema["~standard"].vendor !== "arktype" || config.jsonSchema?.opaqueRefinements === "error") return configured;
+	const existingFallback = isRecord$2(configured?.fallback) ? configured.fallback : {};
+	return {
+		...configured,
+		fallback: {
+			...existingFallback,
+			predicate: (context) => context.base
+		}
+	};
+}
+function toInputJsonSchema(schema, config = {}) {
+	try {
+		return schema["~standard"].jsonSchema.input({
+			target: "draft-2020-12",
+			...arkTypeLibraryOptions(schema, config) ? { libraryOptions: arkTypeLibraryOptions(schema, config) } : {}
+		});
+	} catch (error) {
+		throw new SchemaConversionError(`Unable to convert the ${schema["~standard"].vendor} schema to JSON Schema for form inference.`, { cause: error });
+	}
+}
+function compileForm(schema, config = {}) {
+	const rootSchema = toInputJsonSchema(schema, config);
+	const root = compileNode({
+		context: {
+			config,
+			rootSchema,
+			resolvingRefs: /* @__PURE__ */ new Set()
+		},
+		key: "root",
+		labelFallback: rootSchema.title ?? "Form",
+		path: "",
+		required: true,
+		schema: rootSchema
+	});
+	const fieldMap = createNullRecord();
+	collectFields(root, fieldMap);
+	return {
+		root,
+		fields: root.kind === "object" ? root.children : [root],
+		fieldMap
+	};
+}
+//#endregion
+//#region src/defaults.ts
+function cloneDefault(value) {
+	if (Array.isArray(value)) return value.map(cloneDefault);
+	if (typeof value !== "object" || value === null) return value;
+	if (value instanceof Date) return new Date(value.getTime());
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneDefault(child)]));
+}
+function defaultValueForNode(node) {
+	if (node.defaultValue !== void 0) return cloneDefault(node.defaultValue);
+	if (!node.required) return void 0;
+	switch (node.kind) {
+		case "array": {
+			const count = node.minItems ?? 0;
+			return Array.from({ length: count }, () => cloneDefault(defaultValueForNode(node.item)));
+		}
+		case "object": {
+			const value = {};
+			for (const child of node.children) {
+				const childDefault = defaultValueForNode(child);
+				if (childDefault !== void 0) defineOwn(value, child.key, childDefault);
+			}
+			return value;
+		}
+		case "scalar":
+			if (node.dataType === "boolean") return false;
+			if (node.dataType === "string" && node.required && !node.options) return "";
+			return;
+		case "unsupported": return;
+	}
+}
+function getDefaultValues(model) {
+	return defaultValueForNode(model.root) ?? {};
+}
+//#endregion
+//#region src/path.ts
+function pathToName(path) {
+	return path.map(String).join(".");
+}
+function pathToConfigPath(path) {
+	let result = "";
+	for (const segment of path) if (typeof segment === "number") result += "[]";
+	else result += result === "" ? segment : `.${segment}`;
+	return result;
+}
+//#endregion
+//#region src/rules.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveFieldState(state, values, fallback = false) {
+	if (typeof state === "function") return Boolean(state(values));
+	return typeof state === "boolean" ? state : fallback;
+}
+function isEmptyFieldValue(value) {
+	if (value === void 0 || value === null || value === "") return true;
+	if (Array.isArray(value)) return value.length === 0;
+	if (isRecord$1(value)) return Object.values(value).every(isEmptyFieldValue);
+	return false;
+}
+function visitRequiredRules(node, value, values, path, inheritedHidden, issues) {
+	const hidden = inheritedHidden || resolveFieldState(node.config.hidden, values, false);
+	const required = resolveFieldState(node.config.requiredWhenVisible, values, false);
+	if (!hidden && required && isEmptyFieldValue(value)) issues.push({
+		message: node.config.requiredMessage ?? `${node.label} is required`,
+		path
+	});
+	if (node.kind === "object") {
+		const record = isRecord$1(value) ? value : {};
+		for (const child of node.children) visitRequiredRules(child, ownValue(record, child.key), values, [...path, child.key], hidden, issues);
+	} else if (node.kind === "array" && Array.isArray(value)) for (const [index, item] of value.entries()) visitRequiredRules(node.item, item, values, [...path, index], hidden, issues);
+}
+/** Validates portable presentation rules that are intentionally outside the schema. */
+function validatePresentationRules(model, values) {
+	const issues = [];
+	const record = isRecord$1(values) ? values : {};
+	visitRequiredRules(model.root, values, record, [], false, issues);
+	return issues;
+}
+//#endregion
+//#region src/prepare.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function prepareNodeValue(field, value, rootValues) {
+	if (field.path !== "" && resolveFieldState(field.config.hidden, rootValues, false)) return void 0;
+	if (field.kind === "scalar") {
+		if (value !== "") return value;
+		if (field.nullable) return null;
+		if (!field.required) return void 0;
+		if (field.dataType === "number" || field.dataType === "integer") return;
+		return "";
+	}
+	if (field.kind === "array") return Array.isArray(value) ? value.map((item) => prepareNodeValue(field.item, item, rootValues)) : value;
+	if (field.kind === "object") {
+		const source = isRecord(value) ? value : {};
+		const prepared = {};
+		for (const child of field.children) {
+			const next = prepareNodeValue(child, ownValue(source, child.key), rootValues);
+			if (next !== void 0) defineOwn(prepared, child.key, next);
+		}
+		if (!field.required && Object.keys(prepared).length === 0) return void 0;
+		return prepared;
+	}
+	return value;
+}
+/**
+* Converts browser form values to schema input: optional blanks become absent,
+* nullable blanks become null, and presentation-hidden branches are pruned.
+*/
+function prepareFormValues(model, values) {
+	const rootValues = isRecord(values) ? values : {};
+	return prepareNodeValue(model.root, values, rootValues);
+}
+//#endregion
+//#region src/options.ts
+/** Stable DOM serialization for non-string option values. */
+function serializeOptionValue(value) {
+	if (value === null) return "null:";
+	return `${typeof value}:${String(value)}`;
+}
+function optionForSerializedValue(options, serialized) {
+	return options.find((option) => serializeOptionValue(option.value) === serialized);
+}
+//#endregion
+//#region src/submission.ts
+const initialSubmissionState = { status: "idle" };
+const SUCCESS_KEYS = new Set([
+	"data",
+	"message",
+	"status"
+]);
+const ERROR_KEYS = new Set([
+	"errorKind",
+	"fieldErrors",
+	"formErrors",
+	"status"
+]);
+function submissionFailure(options = {}) {
+	const fieldErrors = createNullRecord();
+	for (const [path, messages] of Object.entries(options.fieldErrors ?? {})) defineOwn(fieldErrors, path, messages);
+	return {
+		errorKind: options.errorKind ?? "business",
+		fieldErrors,
+		formErrors: options.formErrors ?? [],
+		status: "error"
+	};
+}
+function submissionSuccess(data, message) {
+	return {
+		...data !== void 0 ? { data } : {},
+		...message ? { message } : {},
+		status: "success"
+	};
+}
+function isSubmissionState(value) {
+	try {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+		const state = value;
+		if (!hasOwn(state, "status") || Object.getOwnPropertySymbols(state).length > 0) return false;
+		const keys = Object.keys(state);
+		const hasOnly = (allowed) => keys.every((key) => allowed.has(key));
+		if (state.status === "idle") return keys.length === 1 && keys[0] === "status";
+		if (state.status === "success") return hasOnly(SUCCESS_KEYS) && (!hasOwn(state, "message") || typeof state.message === "string");
+		if (state.status !== "error") return false;
+		if (!hasOnly(ERROR_KEYS)) return false;
+		if (!hasOwn(state, "errorKind") || !hasOwn(state, "fieldErrors") || !hasOwn(state, "formErrors")) return false;
+		if (state.errorKind !== "business" && state.errorKind !== "transport" && state.errorKind !== "validation") return false;
+		if (!Array.isArray(state.formErrors) || !state.formErrors.every((message) => typeof message === "string")) return false;
+		if (typeof state.fieldErrors !== "object" || state.fieldErrors === null || Array.isArray(state.fieldErrors)) return false;
+		return Object.values(state.fieldErrors).every((messages) => Array.isArray(messages) && messages.every((message) => typeof message === "string"));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/validation.ts
+function issuePath(issue) {
+	return (issue.path ?? []).map((segment) => {
+		if (typeof segment !== "object" || segment === null) return segment;
+		return hasOwn(segment, "key") ? segment.key : String(segment);
+	});
+}
+function issuesToFieldErrors(issues) {
+	const errors = createNullRecord();
+	for (const issue of issues) {
+		const path = pathToName(issuePath(issue).map((segment) => typeof segment === "number" || typeof segment === "string" ? segment : String(segment)));
+		let messages = errors[path];
+		if (!messages) {
+			messages = [];
+			defineOwn(errors, path, messages);
+		}
+		messages.push(issue.message);
+	}
+	return errors;
+}
+async function validate(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues === void 0) return {
+		success: true,
+		data: result.value
+	};
+	return {
+		success: false,
+		issues: result.issues.length > 0 ? result.issues : [{ message: "Schema validation failed" }]
+	};
+}
+//#endregion
+export { RESERVED_FORM_PATH_SEGMENTS, SchemaConversionError, compileForm, defaultValueForNode, getDefaultValues, initialSubmissionState, isEmptyFieldValue, isReservedFormPathSegment, isSubmissionState, issuePath, issuesToFieldErrors, optionForSerializedValue, pathToConfigPath, pathToName, prepareFormValues, resolveFieldState, serializeOptionValue, submissionFailure, submissionSuccess, toInputJsonSchema, validate, validatePresentationRules };
+
+//# sourceMappingURL=index.js.map