@whatsaaaa/form-builder-schema 0.5.0 → 0.6.0

package/dist/index.js

@@ -85,22 +85,39 @@ function buildFieldSchema(checked, messages, ctx) {
 	return required ? schema : v.optional(schema);
 }
 const pipe = (schema, items) => items.reduce((acc, item) => v.pipe(acc, item), schema);
-// src/rules/rule-params.ts
-const cache = /* @__PURE__ */ new WeakMap();
-function paramsFor(def, kind) {
-	if (typeof def.params !== "function") return def.params;
-	let byKind = cache.get(def);
-	if (!byKind) {
-		byKind = /* @__PURE__ */ new Map();
-		cache.set(def, byKind);
-	}
-	let params = byKind.get(kind);
-	if (!params) {
-		params = def.params(kind);
-		byKind.set(kind, params);
-	}
-	return params;
-}
+// src/shared/reserved-keys.ts
+/**
+* Field keys this package owns. A field type's props can't use them.
+*/
+const RESERVED_FIELD_KEYS = [
+	"name",
+	"type",
+	"label",
+	"description",
+	"placeholder",
+	"default",
+	"required",
+	"rules",
+	"ui"
+];
+/**
+* Rule keys this package owns. A rule's params can't use them.
+*/
+const RESERVED_RULE_KEYS = ["rule", "message"];
+/**
+* Form rule keys this package owns. A form rule's params can't use them.
+*/
+const RESERVED_FORM_RULE_KEYS = [
+	"rule",
+	"field",
+	"message"
+];
+const fieldKeys = new Set(RESERVED_FIELD_KEYS);
+const ruleKeys = new Set(RESERVED_RULE_KEYS);
+const formRuleKeys = new Set(RESERVED_FORM_RULE_KEYS);
+const isReservedFieldKey = (key) => fieldKeys.has(key);
+const isReservedRuleKey = (key) => ruleKeys.has(key);
+const isReservedFormRuleKey = (key) => formRuleKeys.has(key);
 // src/field-types/basic-types.ts
 /** Types with one plain value and no props. Each maps to a native input. */
 const basicTypes = {
@@ -331,7 +348,7 @@ const any = [
 	"string",
 	"boolean"
 ];
-const meta$6 = (label) => ({
+const meta$7 = (label) => ({
 	label,
 	category: "comparison"
 });
@@ -342,54 +359,54 @@ const comparisonRules = {
 	minValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Minimum"),
+		meta: meta$7("Minimum"),
 		create: (p, m) => v.minValue(p.value, m)
 	}),
 	maxValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Maximum"),
+		meta: meta$7("Maximum"),
 		create: (p, m) => v.maxValue(p.value, m)
 	}),
 	gtValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Greater than"),
+		meta: meta$7("Greater than"),
 		create: (p, m) => v.gtValue(p.value, m)
 	}),
 	ltValue: defineRule({
 		kinds: ordered,
 		params: valueParams,
-		meta: meta$6("Less than"),
+		meta: meta$7("Less than"),
 		create: (p, m) => v.ltValue(p.value, m)
 	}),
 	value: defineRule({
 		kinds: any,
 		params: valueParams,
-		meta: meta$6("Equals"),
+		meta: meta$7("Equals"),
 		create: (p, m) => v.value(p.value, m)
 	}),
 	notValue: defineRule({
 		kinds: any,
 		params: valueParams,
-		meta: meta$6("Does not equal"),
+		meta: meta$7("Does not equal"),
 		create: (p, m) => v.notValue(p.value, m)
 	}),
 	values: defineRule({
 		kinds: ordered,
 		params: valuesParams,
-		meta: meta$6("One of"),
+		meta: meta$7("One of"),
 		create: (p, m) => v.values(p.values, m)
 	}),
 	notValues: defineRule({
 		kinds: ordered,
 		params: valuesParams,
-		meta: meta$6("None of"),
+		meta: meta$7("None of"),
 		create: (p, m) => v.notValues(p.values, m)
 	})
 };
 // src/rules/content-rules.ts
-const meta$5 = (label, description) => ({
+const meta$6 = (label, description) => ({
 	label,
 	description,
 	category: "content"
@@ -418,31 +435,31 @@ const contentRules = {
 	regex: defineRule({
 		kinds: ["string"],
 		params: regexParams,
-		meta: meta$5("Matches pattern", "A JavaScript regular expression, without the slashes."),
+		meta: meta$6("Matches pattern", "A JavaScript regular expression, without the slashes."),
 		create: (p, m) => v.regex(new RegExp(p.pattern, p.flags?.replace(/[gy]/g, "")), m)
 	}),
 	startsWith: defineRule({
 		kinds: ["string"],
 		params: stringParams,
-		meta: meta$5("Starts with"),
+		meta: meta$6("Starts with"),
 		create: (p, m) => v.startsWith(p.value, m)
 	}),
 	endsWith: defineRule({
 		kinds: ["string"],
 		params: stringParams,
-		meta: meta$5("Ends with"),
+		meta: meta$6("Ends with"),
 		create: (p, m) => v.endsWith(p.value, m)
 	}),
 	includes: defineRule({
 		kinds: ["string", "array"],
 		params: contentParams,
-		meta: meta$5("Contains"),
+		meta: meta$6("Contains"),
 		create: (p, m) => v.includes(p.value, m)
 	}),
 	excludes: defineRule({
 		kinds: ["string", "array"],
 		params: contentParams,
-		meta: meta$5("Does not contain"),
+		meta: meta$6("Does not contain"),
 		create: (p, m) => v.excludes(p.value, m)
 	})
 };
@@ -466,7 +483,7 @@ const dateRules = {
 };
 // src/rules/file-rules.ts
 const kinds$3 = ["file"];
-const meta$4 = (label, description) => ({
+const meta$5 = (label, description) => ({
 	label,
 	description,
 	category: "file"
@@ -478,31 +495,31 @@ const fileRules = {
 	minSize: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Minimum size", bytes),
+		meta: meta$5("Minimum size", bytes),
 		create: (p, m) => v.minSize(p.value, m)
 	}),
 	maxSize: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Maximum size", bytes),
+		meta: meta$5("Maximum size", bytes),
 		create: (p, m) => v.maxSize(p.value, m)
 	}),
 	size: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Exact size", bytes),
+		meta: meta$5("Exact size", bytes),
 		create: (p, m) => v.size(p.value, m)
 	}),
 	notSize: defineRule({
 		kinds: kinds$3,
 		params: countParams,
-		meta: meta$4("Not this size", bytes),
+		meta: meta$5("Not this size", bytes),
 		create: (p, m) => v.notSize(p.value, m)
 	}),
 	mimeType: defineRule({
 		kinds: kinds$3,
 		params: mimeTypeParams,
-		meta: meta$4("File type"),
+		meta: meta$5("File type"),
 		create: (p, m) => v.mimeType(p.types, m)
 	})
 };
@@ -573,7 +590,7 @@ const formatRules = {
 };
 // src/rules/length-rules.ts
 const kinds$2 = ["string", "array"];
-const meta$3 = (label) => ({
+const meta$4 = (label) => ({
 	label,
 	category: "length"
 });
@@ -582,31 +599,31 @@ const lengthRules = {
 	length: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Exact length"),
+		meta: meta$4("Exact length"),
 		create: (p, m) => v.length(p.value, m)
 	}),
 	minLength: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Minimum length"),
+		meta: meta$4("Minimum length"),
 		create: (p, m) => v.minLength(p.value, m)
 	}),
 	maxLength: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Maximum length"),
+		meta: meta$4("Maximum length"),
 		create: (p, m) => v.maxLength(p.value, m)
 	}),
 	notLength: defineRule({
 		kinds: kinds$2,
 		params: countParams,
-		meta: meta$3("Not this length"),
+		meta: meta$4("Not this length"),
 		create: (p, m) => v.notLength(p.value, m)
 	})
 };
 // src/rules/normalize-rules.ts
 const stage = "normalize";
-const meta$2 = (label, description) => ({
+const meta$3 = (label, description) => ({
 	label,
 	description,
 	category: "normalize"
@@ -620,31 +637,31 @@ const normalizeRules = {
 	trim: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Trim"),
+		meta: meta$3("Trim"),
 		create: () => v.trim()
 	}),
 	trimStart: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Trim start"),
+		meta: meta$3("Trim start"),
 		create: () => v.trimStart()
 	}),
 	trimEnd: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Trim end"),
+		meta: meta$3("Trim end"),
 		create: () => v.trimEnd()
 	}),
 	toLowerCase: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Lowercase"),
+		meta: meta$3("Lowercase"),
 		create: () => v.toLowerCase()
 	}),
 	toUpperCase: defineRule({
 		kinds: ["string"],
 		stage,
-		meta: meta$2("Uppercase"),
+		meta: meta$3("Uppercase"),
 		create: () => v.toUpperCase()
 	}),
 	normalize: defineRule({
@@ -656,27 +673,27 @@ const normalizeRules = {
 			"NFKC",
 			"NFKD"
 		])) }),
-		meta: meta$2("Unicode normalize", "Defaults to NFC."),
+		meta: meta$3("Unicode normalize", "Defaults to NFC."),
 		create: (p) => v.normalize(p.form)
 	}),
 	toMinValue: defineRule({
 		kinds: ["number"],
 		stage,
 		params: limit,
-		meta: meta$2("Raise to minimum", "Replaces a smaller number with the minimum."),
+		meta: meta$3("Raise to minimum", "Replaces a smaller number with the minimum."),
 		create: (p) => v.toMinValue(p.value)
 	}),
 	toMaxValue: defineRule({
 		kinds: ["number"],
 		stage,
 		params: limit,
-		meta: meta$2("Lower to maximum", "Replaces a larger number with the maximum."),
+		meta: meta$3("Lower to maximum", "Replaces a larger number with the maximum."),
 		create: (p) => v.toMaxValue(p.value)
 	})
 };
 // src/rules/number-rules.ts
 const kinds$1 = ["number"];
-const meta$1 = (label) => ({
+const meta$2 = (label) => ({
 	label,
 	category: "number"
 });
@@ -685,29 +702,29 @@ const divisor = v.pipe(v.number(), v.finite(), v.notValue(0, "Can't be 0"));
 const numberRules = {
 	integer: defineRule({
 		kinds: kinds$1,
-		meta: meta$1("Whole number"),
+		meta: meta$2("Whole number"),
 		create: (_, m) => v.integer(m)
 	}),
 	safeInteger: defineRule({
 		kinds: kinds$1,
-		meta: meta$1("Safe whole number"),
+		meta: meta$2("Safe whole number"),
 		create: (_, m) => v.safeInteger(m)
 	}),
 	finite: defineRule({
 		kinds: kinds$1,
-		meta: meta$1("Finite number"),
+		meta: meta$2("Finite number"),
 		create: (_, m) => v.finite(m)
 	}),
 	multipleOf: defineRule({
 		kinds: kinds$1,
 		params: v.object({ value: divisor }),
-		meta: meta$1("Multiple of"),
+		meta: meta$2("Multiple of"),
 		create: (p, m) => v.multipleOf(p.value, m)
 	})
 };
 // src/rules/text-unit-rules.ts
 const kinds = ["string"];
-const meta = (label, description) => ({
+const meta$1 = (label, description) => ({
 	label,
 	description,
 	category: "text"
@@ -729,73 +746,73 @@ const textUnitRules = {
 	graphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Exact characters", graphemesInfo),
+		meta: meta$1("Exact characters", graphemesInfo),
 		create: (p, m) => v.graphemes(p.value, m)
 	}),
 	minGraphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Minimum characters", graphemesInfo),
+		meta: meta$1("Minimum characters", graphemesInfo),
 		create: (p, m) => v.minGraphemes(p.value, m)
 	}),
 	maxGraphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Maximum characters", graphemesInfo),
+		meta: meta$1("Maximum characters", graphemesInfo),
 		create: (p, m) => v.maxGraphemes(p.value, m)
 	}),
 	notGraphemes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Not this many characters", graphemesInfo),
+		meta: meta$1("Not this many characters", graphemesInfo),
 		create: (p, m) => v.notGraphemes(p.value, m)
 	}),
 	words: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Exact words"),
+		meta: meta$1("Exact words"),
 		create: (p, m) => v.words(p.locale, p.value, m)
 	}),
 	minWords: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Minimum words"),
+		meta: meta$1("Minimum words"),
 		create: (p, m) => v.minWords(p.locale, p.value, m)
 	}),
 	maxWords: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Maximum words"),
+		meta: meta$1("Maximum words"),
 		create: (p, m) => v.maxWords(p.locale, p.value, m)
 	}),
 	notWords: defineRule({
 		kinds,
 		params: wordsParams,
-		meta: meta("Not this many words"),
+		meta: meta$1("Not this many words"),
 		create: (p, m) => v.notWords(p.locale, p.value, m)
 	}),
 	bytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Exact bytes", bytesInfo),
+		meta: meta$1("Exact bytes", bytesInfo),
 		create: (p, m) => v.bytes(p.value, m)
 	}),
 	minBytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Minimum bytes", bytesInfo),
+		meta: meta$1("Minimum bytes", bytesInfo),
 		create: (p, m) => v.minBytes(p.value, m)
 	}),
 	maxBytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Maximum bytes", bytesInfo),
+		meta: meta$1("Maximum bytes", bytesInfo),
 		create: (p, m) => v.maxBytes(p.value, m)
 	}),
 	notBytes: defineRule({
 		kinds,
 		params: countParams,
-		meta: meta("Not this many bytes", bytesInfo),
+		meta: meta$1("Not this many bytes", bytesInfo),
 		create: (p, m) => v.notBytes(p.value, m)
 	})
 };
@@ -812,10 +829,71 @@ const defaultRules = {
 	...fileRules,
 	...normalizeRules
 };
+// src/rules/define-form-rule.ts
+const defineFormRule = (def) => def;
+// src/rules/form-rules.ts
+const meta = (label, description) => ({
+	label,
+	description,
+	category: "comparison"
+});
+const comparable = (value) => value instanceof Date ? value.getTime() : value;
+const otherParams = v.object({ other: v.string() });
+const operators = {
+	lt: (a, b) => a < b,
+	lte: (a, b) => a <= b,
+	gt: (a, b) => a > b,
+	gte: (a, b) => a >= b
+};
+/** Every built-in form rule. */
+const defaultFormRules = {
+	sameAs: defineFormRule({
+		params: otherParams,
+		reads: (params) => [params.other],
+		kinds: [
+			"string",
+			"number",
+			"boolean",
+			"date"
+		],
+		sameKind: true,
+		meta: meta("Same as", "Equals another field, e.g. to confirm a password"),
+		check: ([value, other]) => comparable(value) === comparable(other)
+	}),
+	differentFrom: defineFormRule({
+		params: otherParams,
+		reads: (params) => [params.other],
+		kinds: [
+			"string",
+			"number",
+			"boolean",
+			"date"
+		],
+		sameKind: true,
+		meta: meta("Different from", "Differs from another field, e.g. a new password"),
+		check: ([value, other]) => comparable(value) !== comparable(other)
+	}),
+	compare: defineFormRule({
+		params: v.object({
+			op: v.picklist([
+				"lt",
+				"lte",
+				"gt",
+				"gte"
+			]),
+			other: v.string()
+		}),
+		reads: (params) => [params.other],
+		kinds: ["number", "date"],
+		sameKind: true,
+		meta: meta("Compare", "Less or greater than another field, e.g. an end date after the start"),
+		check: ([value, other], { op }) => operators[op](comparable(value), comparable(other))
+	})
+};
 // src/builder/registry.ts
 /** Consumer entries replace defaults with the same key. */
 function mergeRegistry(custom) {
-	const rules = custom.includeDefaultRules === false ? {} : defaultRules;
+	const defaults = custom.includeDefaultRules !== false;
 	return {
 		kinds: Object.freeze({
 			...defaultKinds,
@@ -826,37 +904,34 @@ function mergeRegistry(custom) {
 			...custom.fieldTypes
 		}),
 		rules: Object.freeze({
-			...rules,
+			...defaults ? defaultRules : {},
 			...custom.rules
+		}),
+		formRules: Object.freeze({
+			...defaults ? defaultFormRules : {},
+			...custom.formRules
 		})
 	};
 }
 function lookup(record, key) {
 	return Object.hasOwn(record, key) ? record[key] : void 0;
 }
-// src/shared/reserved-keys.ts
-/**
-* Field keys this package owns. A field type's props can't use them.
-*/
-const RESERVED_FIELD_KEYS = [
-	"name",
-	"type",
-	"label",
-	"description",
-	"placeholder",
-	"default",
-	"required",
-	"rules",
-	"ui"
-];
-/**
-* Rule keys this package owns. A rule's params can't use them.
-*/
-const RESERVED_RULE_KEYS = ["rule", "message"];
-const fieldKeys = new Set(RESERVED_FIELD_KEYS);
-const ruleKeys = new Set(RESERVED_RULE_KEYS);
-const isReservedFieldKey = (key) => fieldKeys.has(key);
-const isReservedRuleKey = (key) => ruleKeys.has(key);
+// src/rules/rule-params.ts
+const cache = /* @__PURE__ */ new WeakMap();
+function paramsFor(def, kind) {
+	if (typeof def.params !== "function") return def.params;
+	let byKind = cache.get(def);
+	if (!byKind) {
+		byKind = /* @__PURE__ */ new Map();
+		cache.set(def, byKind);
+	}
+	let params = byKind.get(kind);
+	if (!params) {
+		params = def.params(kind);
+		byKind.set(kind, params);
+	}
+	return params;
+}
 // src/builder/validate-definition.ts
 const fieldShape = v.looseObject({
 	name: v.optional(v.string()),
@@ -869,7 +944,7 @@ const fieldShape = v.looseObject({
 	rules: v.optional(v.array(v.unknown())),
 	ui: v.optional(v.record(v.string(), v.unknown()))
 });
-const ruleShape = v.looseObject({
+const ruleShape$1 = v.looseObject({
 	rule: v.string(),
 	message: v.optional(v.string())
 });
@@ -985,7 +1060,7 @@ function checkProps(field, type, path, issues) {
 	issues.push(...toIssues("invalid_props", path, parsed.issues));
 }
 function checkRule(raw, { kind, itemKind }, path, registry, issues) {
-	const shape = v.safeParse(ruleShape, raw);
+	const shape = v.safeParse(ruleShape$1, raw);
 	if (!shape.success) {
 		issues.push(...toIssues("invalid_shape", path, shape.issues));
 		return;
@@ -1003,28 +1078,38 @@ function checkRule(raw, { kind, itemKind }, path, registry, issues) {
 		issues.push(issue("kind_mismatch", [...path, "rule"], message));
 		return;
 	}
+	const params = checkParams(rule, paramsFor(def, each ? itemKind : kind), isReservedRuleKey, `Rule "${rule.rule}"`, path, issues);
+	if (!params) return void 0;
+	return {
+		name: rule.rule,
+		def,
+		params,
+		message: rule.message,
+		each
+	};
+}
+/**
+* Checks the params of a rule or a form rule. Every key that isn't reserved must be one of
+* `params`, and together they must pass it. Returns the parsed params, or undefined when they
+* have issues. `at` names the rule in messages, e.g. `Rule "minLength"`.
+*/
+function checkParams(raw, params, isReserved, at, path, issues) {
 	const issueCount = issues.length;
-	const params = paramsFor(def, each ? itemKind : kind);
 	const paramKeys = Object.keys(params?.entries ?? {});
 	const input = {};
-	for (const key of Object.keys(rule)) {
-		if (isReservedRuleKey(key)) continue;
-		if (paramKeys.includes(key)) input[key] = rule[key];
-		else issues.push(issue("unknown_param", [...path, key], `Rule "${rule.rule}" has no param "${key}"`));
+	for (const key of Object.keys(raw)) {
+		if (isReserved(key)) continue;
+		if (paramKeys.includes(key)) input[key] = raw[key];
+		else issues.push(issue("unknown_param", [...path, key], `${at} has no param "${key}"`));
 	}
 	const parsed = v.safeParse(params ?? noParams, input);
 	if (!parsed.success) issues.push(...toIssues("invalid_params", path, parsed.issues));
 	if (!parsed.success || issues.length > issueCount) return void 0;
-	return {
-		name: rule.rule,
-		def,
-		params: parsed.output,
-		message: rule.message,
-		each
-	};
+	return parsed.output;
 }
 function checkRegistry(registry) {
 	for (const [name, rule] of Object.entries(registry.rules)) for (const kind of rule.kinds) for (const key of Object.keys(paramsFor(rule, kind)?.entries ?? {})) if (isReservedRuleKey(key)) throw new TypeError(`Rule "${name}": params can't use the reserved key "${key}"`);
+	for (const [name, rule] of Object.entries(registry.formRules)) for (const key of Object.keys(rule.params?.entries ?? {})) if (isReservedFormRuleKey(key)) throw new TypeError(`Form rule "${name}": params can't use the reserved key "${key}"`);
 	for (const [name, type] of Object.entries(registry.fieldTypes)) {
 		const at = `Field type "${name}"`;
 		for (const kind of [type.kind, type.itemKind]) if (typeof kind === "string" && !lookup(registry.kinds, kind)) throw new TypeError(`${at}: kind "${kind}" is not registered`);
@@ -1050,10 +1135,164 @@ function toIssues(code, path, valibotIssues) {
 		return issue(code, [...path, ...keys], valibotIssue.message);
 	});
 }
+// src/builder/check-form-rules.ts
+const ruleShape = v.looseObject({
+	rule: v.string(),
+	field: v.string(),
+	message: v.string()
+});
+/**
+* Checks the definition's form rules against the fields the compiler built, and adds their
+* issues to `issues`. Returns the rules that are ready to build.
+*/
+function checkFormRules(rules, registry, fieldsByPath, issues) {
+	return rules.flatMap((raw, i) => checkFormRule(raw, ["formRules", i], registry, fieldsByPath, issues) ?? []);
+}
+function checkFormRule(raw, path, registry, fieldsByPath, issues) {
+	const shape = v.safeParse(ruleShape, raw);
+	if (!shape.success) {
+		issues.push(...toIssues("invalid_shape", path, shape.issues));
+		return;
+	}
+	const rule = shape.output;
+	const at = `Form rule "${rule.rule}"`;
+	const def = lookup(registry.formRules, rule.rule);
+	if (!def) {
+		issues.push(issue("unknown_rule", [...path, "rule"], `Unknown form rule "${rule.rule}"`));
+		return;
+	}
+	const params = checkParams(rule, def.params, isReservedFormRuleKey, at, path, issues);
+	if (!params) return void 0;
+	const dotPaths = [rule.field, ...def.reads(params)];
+	const paths = dotPaths.map((dotPath) => dotPath.split("."));
+	const fieldKeys = paths[0];
+	const issueCount = issues.length;
+	const fields = dotPaths.map((dotPath, i) => {
+		const found = findField(dotPath, fieldsByPath);
+		const message = typeof found === "string" ? found : i > 0 && outsideItem(paths[i], fieldKeys);
+		if (!message) return found;
+		issues.push(issue("unknown_field", i === 0 ? [...path, "field"] : path, message));
+		return null;
+	});
+	if (issues.length > issueCount) return void 0;
+	if (fields.some((field) => !field)) return void 0;
+	const checked = fields;
+	const kinds = checked.map((field) => field.valueKind);
+	const wrong = kinds.find((kind) => def.kinds && !def.kinds.includes(kind));
+	if (wrong !== void 0) {
+		const message = `${at} can't be used on ${wrong} fields`;
+		issues.push(issue("kind_mismatch", [...path, "rule"], message));
+		return;
+	}
+	if (def.sameKind && new Set(kinds).size > 1) {
+		const message = `${at} needs fields of one kind, not ${[...new Set(kinds)].join(" and ")}`;
+		issues.push(issue("kind_mismatch", [...path, "rule"], message));
+		return;
+	}
+	const field = checked[0].field;
+	return {
+		name: rule.rule,
+		def,
+		params,
+		message: rule.message,
+		path,
+		field,
+		paths
+	};
+}
+/**
+* The field with a value at `dotPath`. Null when a field on the way has issues of its own, and
+* the issue's message when there is no such field.
+*/
+function findField(dotPath, fieldsByPath) {
+	const keys = dotPath.split(".");
+	let found;
+	for (let i = 1; i <= keys.length; i++) {
+		found = fieldsByPath.get(keys.slice(0, i).join("."));
+		if (found === null) return null;
+		if (found) continue;
+		if (keys[i - 1] === "*" && i < keys.length) continue;
+		if (fieldsByPath.get(keys.slice(0, i - 1).join("."))?.valueKind === "array" && keys[i - 1] !== "*") return `Unknown field "${dotPath}". A list's items are read with "*": "${[
+			...keys.slice(0, i - 1),
+			"*",
+			...keys.slice(i - 1)
+		].join(".")}"`;
+		return `Unknown field "${dotPath}"`;
+	}
+	return found ?? `Unknown field "${dotPath}"`;
+}
+/**
+* A path into the items of a list is read once per item, so `field` must be in the same items.
+* Returns the issue's message when it isn't.
+*/
+function outsideItem(keys, fieldKeys) {
+	const star = keys.lastIndexOf("*");
+	const item = (path) => path.slice(0, star + 1).join(".");
+	if (star === -1 || item(keys) === item(fieldKeys)) return void 0;
+	const list = keys.slice(0, star).join(".");
+	return `"${keys.join(".")}" is read from each item of "${list}", so "${fieldKeys.join(".")}" must be too`;
+}
+// src/builder/form-rule-action.ts
+/**
+* Runs a form rule on the form's value and puts its issue on `field`. A rule on the fields of a
+* list's items runs once per item, with the item's index in place of each `'*'`.
+*
+* The rule only runs when none of the fields it reads has an issue. `v.partialCheck` can't do
+* this: it runs whenever the form has no schema issues, even when a field it reads failed a rule.
+*/
+function formRuleAction(rule, message) {
+	const { def, params, paths } = rule;
+	const fieldKeys = paths[0];
+	return v.rawCheck(({ dataset, addIssue }) => {
+		for (const indexes of itemIndexes(dataset.value, fieldKeys)) {
+			const read = paths.map((keys) => withIndexes(keys, indexes));
+			if (read.some((path) => hasIssue(dataset.issues, path))) continue;
+			const values = read.map((path) => valueAt(dataset.value, path));
+			if (values.includes(void 0) || def.check(values, params)) continue;
+			const field = read[0];
+			addIssue({
+				message,
+				input: values[0],
+				path: issuePath(dataset.value, field)
+			});
+		}
+	});
+}
+/** Replaces each `'*'` in `keys` with the next index. */
+const withIndexes = (keys, indexes) => {
+	let next = 0;
+	return keys.map((key) => key === "*" ? indexes[next++] : key);
+};
+const valueAt = (input, path) => path.reduce((value, key) => typeof value === "object" && value !== null ? value[key] : void 0, input);
+/** True when an issue is on `path`, inside it, or on a value that holds it. */
+const hasIssue = (issues, path) => !!issues?.some((issue) => (issue.path ?? []).every((item, i) => i >= path.length || item.key === path[i]));
+/** Valibot's path to `path` in `input`, the way an object or array schema reports it. */
+const issuePath = (input, path) => path.map((key, i) => {
+	const parent = valueAt(input, path.slice(0, i));
+	return {
+		type: Array.isArray(parent) ? "array" : "object",
+		origin: "value",
+		input: parent,
+		key,
+		value: valueAt(parent, [key])
+	};
+});
+/** The indexes for each `'*'` in `keys`, for every item `value` has there. */
+function* itemIndexes(value, keys, indexes = []) {
+	const star = keys.indexOf("*");
+	if (star === -1) {
+		yield indexes;
+		return;
+	}
+	const list = valueAt(value, keys.slice(0, star));
+	if (!Array.isArray(list)) return;
+	for (const [i, item] of list.entries()) yield* itemIndexes(item, keys.slice(star + 1), [...indexes, i]);
+}
 // src/builder/compile-definition.ts
 const formShape = v.object({
 	version: v.string(),
-	fields: v.array(v.unknown())
+	fields: v.array(v.unknown()),
+	formRules: v.optional(v.array(v.unknown()))
 });
 /**
 * Checks a definition and builds its schema in the same pass, so `validate()` and `build()`
@@ -1078,9 +1317,23 @@ function compileDefinition(json, registry, messages) {
 			schema: v.object({})
 		};
 	}
+	const compiler = createCompiler(registry, messages, issues);
+	const schema = compiler.fields(form.output.fields, ["fields"]);
+	const rules = checkFormRules(form.output.formRules ?? [], registry, compiler.fieldsByPath, issues);
+	if (issues.length || !rules.length) return {
+		issues,
+		schema
+	};
 	return {
 		issues,
-		schema: createCompiler(registry, messages, issues).fields(form.output.fields, ["fields"])
+		schema: rules.reduce((acc, rule) => {
+			const ctx = {
+				field: rule.field,
+				rule: rule.name,
+				path: rule.path
+			};
+			return v.pipe(acc, formRuleAction(rule, messages.resolve(rule.message, ctx)));
+		}, schema)
 	};
 }
 /** Every field the compiler checks adds its issues to `issues`. */
@@ -1090,29 +1343,54 @@ function createCompiler(registry, messages, issues) {
 		buildFields: fields,
 		buildField: field
 	});
+	const fieldsByPath = /* @__PURE__ */ new Map();
+	const parents = [];
+	const parentPath = () => parents.at(-1) ?? [];
 	function fields(list, path) {
 		const entries = {};
 		const names = /* @__PURE__ */ new Set();
 		list.forEach((raw, i) => {
 			const checked = checkField(raw, [...path, i], registry, names, issues);
-			if (checked?.name) entries[checked.name] = build(checked);
+			const name = checked ? checked.name : nameOf(raw);
+			if (name === void 0) return;
+			const dataPath = [...parentPath(), name];
+			remember(raw, checked, dataPath);
+			if (checked) entries[name] = build(checked, dataPath);
 		});
 		return v.object(entries);
 	}
 	function field(raw, path) {
 		const checked = checkField(raw, path, registry, void 0, issues);
-		return checked ? build(checked) : v.never();
+		const dataPath = parentPath();
+		remember(raw, checked, dataPath);
+		return checked ? build(checked, dataPath) : v.never();
 	}
-	function build(checked) {
-		const schema = buildFieldSchema(checked, messages, context(checked.path));
-		checkDefault(checked, schema, issues);
-		return schema;
+	function build(checked, dataPath) {
+		parents.push(checked.valueKind === "array" ? [...dataPath, "*"] : dataPath);
+		try {
+			const schema = buildFieldSchema(checked, messages, context(checked.path));
+			checkDefault(checked, schema, issues);
+			return schema;
+		} finally {
+			parents.pop();
+		}
+	}
+	/** The first field at a path wins, as with duplicate names. Display elements are left out. */
+	function remember(raw, checked, dataPath) {
+		const key = dataPath.join(".");
+		if (fieldsByPath.has(key) || !checked && !hasValue(raw, registry)) return;
+		fieldsByPath.set(key, checked ?? null);
 	}
 	return {
 		fields,
-		field
+		field,
+		fieldsByPath
 	};
 }
+const isRecord = (value) => typeof value === "object" && value !== null;
+const nameOf = (raw) => isRecord(raw) && typeof raw.name === "string" ? raw.name : void 0;
+/** An unknown type counts as one with a value, so a form rule that reads the field is fine. */
+const hasValue = (raw, registry) => isRecord(raw) && typeof raw.type === "string" && lookup(registry.fieldTypes, raw.type)?.kind !== "none";
 /** A default must be a value the field accepts. An empty one is the same as none. */
 function checkDefault({ field, kind, path }, schema, issues) {
 	if (field.default === void 0 || kind.isEmpty(field.default)) return;
@@ -1180,7 +1458,8 @@ function createSchemaBuilder(options = {}) {
 		rulesForKind,
 		kinds: registry.kinds,
 		fieldTypes: registry.fieldTypes,
-		rules: registry.rules
+		rules: registry.rules,
+		formRules: registry.formRules
 	};
 }
 // src/definition/initial-input.ts
@@ -1239,6 +1518,6 @@ function* walkField(field, definitionPath, dataPath, depth) {
 	}
 }
 const isField = (value) => typeof value === "object" && value !== null && "type" in value;
-export { DefinitionError, RESERVED_FIELD_KEYS, RESERVED_RULE_KEYS, comparisonRules, contentRules, createBuildContext, createSchemaBuilder, dateRules, defaultFieldTypes, defaultKinds, defaultRules, defineFieldType, defineRule, fileRules, formatPath, formatRules, getInitialInput, lengthRules, normalizeRules, numberRules, textUnitRules, walkFields };
+export { DefinitionError, RESERVED_FIELD_KEYS, RESERVED_FORM_RULE_KEYS, RESERVED_RULE_KEYS, comparisonRules, contentRules, createBuildContext, createSchemaBuilder, dateRules, defaultFieldTypes, defaultFormRules, defaultKinds, defaultRules, defineFieldType, defineFormRule, defineRule, fileRules, formatPath, formatRules, getInitialInput, lengthRules, normalizeRules, numberRules, textUnitRules, walkFields };
 
 //# sourceMappingURL=index.js.map