@warlock.js/seal 5.9.0 → 5.11.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@warlock.js/seal` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.11.0 - 2026-09-14
+
+### Fixed
+
+- `v.boolean().accepted()` / `.declined()` (and their conditional variants) rejected every string form they advertised — `"yes"`, `"on"`, `"1"` — because the boolean type rule ran first. They now parse those form values into a real boolean.
+
+## 5.10.0 - 2026-09-14
+
+### Added
+
+- `.coerce()` on `v.boolean()` — opt-in query-string coercion (`"true"`/`"1"` → `true`, `"false"`/`"0"` → `false`).
+
 ## 5.9.0 - 2026-09-13
 
 ### Added
@@ -17,6 +29,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - Internal type-safety hardening; no behaviour change.
 
 ## 5.6.0 - 2026-09-08
+
 ### Fixed
 
 - **`warlock build` and `warlock start` died inside Seal before any application code ran**, with a `ReferenceError` from `array-validator.ts` extending `BaseValidator` before `base-validator.ts` had finished evaluating. The cause was one inline `type` import: under `verbatimModuleSyntax`, `import { type ValidateOptions } from "./validators"` is emitted as a real side-effect import, which closed an import cycle that a type-only import would never have created. Written as `import type { ... }`, the module is not pulled into evaluation at all. Nothing about the validators changed — only which modules load, and when.
@@ -92,7 +105,7 @@ changelogs.
 - `v.literal("")` could never pass. Every validator is required by default and `required` rejects anything the empty-value check calls empty — which includes `""` — so a schema demanding an exact empty string reported "is required" for a field that was present. A literal set containing an empty value now uses `present` (the key must exist) instead of `required`, leaving the literal set to judge the value. Only the empty string was affected; `v.literal(0)` and `v.literal(false)` always worked
 - `v.literal("").optional()` silently disabled the literal check rather than fixing it, accepting `""`, `null` **and** a missing key alike. The literal rule now runs on empty values (`requiresValue: false`) while treating absence as the required/present rule's question, so `.optional()` means optional again and a present value must still match
 - a **failed** validation no longer returns the input it rejected. `object` returned the raw input — including the unknown keys it had just complained about — while `discriminatedUnion` returned `undefined`; the same call shape had two contracts. Validating an outbound DTO to keep internal fields out of a response, then reading `data` without branching on `isValid`, shipped every field the schema existed to exclude. `data` is now `undefined` whenever `isValid` is `false`
-- `v.number().toFixed(n)` could never produce a valid result — the mutator returned `Number(value).toFixed(n)`, a *string*, which the validator's own `number` type rule then rejected. It now yields a number (`3.14159` → `3.14`), so the method works where it lives. No working code can have depended on the old output, since every such validation failed; for a fixed-point *string*, format at the presentation edge rather than asking a number schema to emit one
+- `v.number().toFixed(n)` could never produce a valid result — the mutator returned `Number(value).toFixed(n)`, a _string_, which the validator's own `number` type rule then rejected. It now yields a number (`3.14159` → `3.14`), so the method works where it lives. No working code can have depended on the old output, since every such validation failed; for a fixed-point _string_, format at the presentation edge rather than asking a number schema to emit one
 
 ## 4.2.11
 

package/cjs/index.cjs

@@ -1127,6 +1127,273 @@ const removeEmptyArrayElementsMutator = async (value) => {
 	return value.filter((item) => !isEmptyValue(item));
 };
 
+//#endregion
+//#region ../seal/src/rules/scalar/accepted-rule.ts
+/**
+* The full set of values treated as "accepted" by `acceptedRule` and its
+* conditional variants. Shared with `formBooleanMutator` (see
+* `../../mutators/boolean-mutators`) so `v.boolean().accepted()` recognizes
+* exactly this list — single source of truth, no duplicated literals.
+*/
+const ACCEPTED_VALUES = [
+	"1",
+	"true",
+	"yes",
+	"y",
+	"on",
+	1,
+	true,
+	"Yes",
+	"Y",
+	"On"
+];
+const isAcceptedValue = (value) => {
+	return ACCEPTED_VALUES.includes(value);
+};
+/**
+* Validate value as accepted if it equals:
+* 1 | "1" | true | "true" | "yes" | "y" | "on"
+*/
+const acceptedRule = {
+	name: "accepted",
+	defaultErrorMessage: "The :input must be accepted",
+	description: "The value must be accepted if it equals: 1 | '1' | true | 'true' | 'yes' | 'y' | 'on' | 1 | true | 'Yes' | 'Y' | 'On'",
+	async validate(value, context) {
+		if (isAcceptedValue(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Accepted value if another field's value equals to a specific value
+*/
+const acceptedIfRule = {
+	name: "acceptedIf",
+	description: "The field must be accepted if :field's value equals to :value",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue !== expectedValue) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is not equal to the given value
+*/
+const acceptedUnlessRule = {
+	name: "acceptedUnless",
+	description: "The field must be accepted if :field's value is not equal to :value",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue === expectedValue) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is required
+*/
+const acceptedIfRequiredRule = {
+	name: "acceptedIfRequired",
+	description: "The field must be accepted if :field is required",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is present
+*/
+const acceptedIfPresentRule = {
+	name: "acceptedIfPresent",
+	description: "The field must be accepted if :field is present",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue === void 0) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is missing
+*/
+const acceptedWithoutRule = {
+	name: "acceptedWithout",
+	description: "The field must be accepted if :field is missing",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue !== void 0) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+//#region ../seal/src/rules/scalar/declined-rule.ts
+/**
+* The full set of values treated as "declined" by `declinedRule` and its
+* conditional variants. Shared with `formBooleanMutator` (see
+* `../../mutators/boolean-mutators`) so `v.boolean().declined()` recognizes
+* exactly this list — single source of truth, no duplicated literals.
+*/
+const DECLINED_VALUES = [
+	"0",
+	"false",
+	"no",
+	"n",
+	"off",
+	0,
+	false,
+	"No",
+	"N",
+	"Off"
+];
+const isDeclinedValue = (value) => {
+	return DECLINED_VALUES.includes(value);
+};
+/**
+* Validate value as declined if it equals:
+* 0 | "0" | false | "false" | "no" | "n" | "off" | 0 | false | "No" | "N" | "Off"
+*/
+const declinedRule = {
+	name: "declined",
+	defaultErrorMessage: "The :input must be declined",
+	description: "The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'",
+	async validate(value, context) {
+		if (isDeclinedValue(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Declined value if another field's value equals to a specific value
+*/
+const declinedIfRule = {
+	name: "declinedIf",
+	description: "The field must be declined if :field's value equals to :value",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue !== expectedValue) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is not equal to the given value
+*/
+const declinedUnlessRule = {
+	name: "declinedUnless",
+	description: "The field must be declined if :field's value is not equal to :value",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue === expectedValue) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is required
+*/
+const declinedIfRequiredRule = {
+	name: "declinedIfRequired",
+	description: "The field must be declined if :field is required",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is present
+*/
+const declinedIfPresentRule = {
+	name: "declinedIfPresent",
+	description: "The field must be declined if :field is present",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue === void 0) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is missing
+*/
+const declinedWithoutRule = {
+	name: "declinedWithout",
+	description: "The field must be declined if :field is missing",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue !== void 0) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+//#region ../seal/src/mutators/boolean-mutators.ts
+/**
+* Coerce a query-string-shaped boolean into a real boolean.
+*
+* Converts exactly: `"true"` / `"1"` / `1` → `true`, `"false"` / `"0"` / `0` → `false`.
+* Case-sensitive, no trimming. Any other value (`"yes"`, `"on"`, `"TRUE"`, `""`,
+* `2`, `null`, etc.) passes through unchanged so the boolean type rule rejects it.
+*/
+const booleanCoerceMutator = async (value) => {
+	if (value === "true" || value === "1" || value === 1) return true;
+	if (value === "false" || value === "0" || value === 0) return false;
+	return value;
+};
+/**
+* Parse form-shaped boolean values into a real boolean, ahead of the type
+* rule.
+*
+* Opted into by calling any `accepted*`/`declined*` method on
+* `v.boolean()` (see `BooleanValidator`'s `withFormBooleanMutator`). Converts
+* every value in `ACCEPTED_VALUES` (`1`, `"1"`, `true`, `"true"`, `"yes"`,
+* `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true`, and every value in
+* `DECLINED_VALUES` (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+* `"No"`, `"N"`, `"Off"`) to `false`. Any other value passes through
+* unchanged so the boolean type rule still rejects it.
+*
+* Named (not anonymous) so callers can detect whether it has already been
+* added — see the idempotence check in `BooleanValidator`.
+*/
+const formBooleanMutator = async (value) => {
+	if (ACCEPTED_VALUES.includes(value)) return true;
+	if (DECLINED_VALUES.includes(value)) return false;
+	return value;
+};
+
 //#endregion
 //#region ../seal/src/mutators/date-mutators.ts
 /**
@@ -5484,224 +5751,6 @@ var PrimitiveValidator = class extends BaseValidator {
 	}
 };
 
-//#endregion
-//#region ../seal/src/rules/scalar/accepted-rule.ts
-const isAcceptedValue = (value) => {
-	return [
-		"1",
-		"true",
-		"yes",
-		"y",
-		"on",
-		1,
-		true,
-		"Yes",
-		"Y",
-		"On"
-	].includes(value);
-};
-/**
-* Validate value as accepted if it equals:
-* 1 | "1" | true | "true" | "yes" | "y" | "on"
-*/
-const acceptedRule = {
-	name: "accepted",
-	defaultErrorMessage: "The :input must be accepted",
-	description: "The value must be accepted if it equals: 1 | '1' | true | 'true' | 'yes' | 'y' | 'on' | 1 | true | 'Yes' | 'Y' | 'On'",
-	async validate(value, context) {
-		if (isAcceptedValue(value)) return VALID_RULE;
-		return invalidRule(this, context);
-	}
-};
-/**
-* Accepted value if another field's value equals to a specific value
-*/
-const acceptedIfRule = {
-	name: "acceptedIf",
-	description: "The field must be accepted if :field's value equals to :value",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue !== expectedValue) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is not equal to the given value
-*/
-const acceptedUnlessRule = {
-	name: "acceptedUnless",
-	description: "The field must be accepted if :field's value is not equal to :value",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue === expectedValue) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is required
-*/
-const acceptedIfRequiredRule = {
-	name: "acceptedIfRequired",
-	description: "The field must be accepted if :field is required",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is present
-*/
-const acceptedIfPresentRule = {
-	name: "acceptedIfPresent",
-	description: "The field must be accepted if :field is present",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue === void 0) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is missing
-*/
-const acceptedWithoutRule = {
-	name: "acceptedWithout",
-	description: "The field must be accepted if :field is missing",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue !== void 0) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-
-//#endregion
-//#region ../seal/src/rules/scalar/declined-rule.ts
-const isDeclinedValue = (value) => {
-	return [
-		"0",
-		"false",
-		"no",
-		"n",
-		"off",
-		0,
-		false,
-		"No",
-		"N",
-		"Off"
-	].includes(value);
-};
-/**
-* Validate value as declined if it equals:
-* 0 | "0" | false | "false" | "no" | "n" | "off" | 0 | false | "No" | "N" | "Off"
-*/
-const declinedRule = {
-	name: "declined",
-	defaultErrorMessage: "The :input must be declined",
-	description: "The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'",
-	async validate(value, context) {
-		if (isDeclinedValue(value)) return VALID_RULE;
-		return invalidRule(this, context);
-	}
-};
-/**
-* Declined value if another field's value equals to a specific value
-*/
-const declinedIfRule = {
-	name: "declinedIf",
-	description: "The field must be declined if :field's value equals to :value",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue !== expectedValue) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is not equal to the given value
-*/
-const declinedUnlessRule = {
-	name: "declinedUnless",
-	description: "The field must be declined if :field's value is not equal to :value",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue === expectedValue) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is required
-*/
-const declinedIfRequiredRule = {
-	name: "declinedIfRequired",
-	description: "The field must be declined if :field is required",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is present
-*/
-const declinedIfPresentRule = {
-	name: "declinedIfPresent",
-	description: "The field must be declined if :field is present",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue === void 0) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is missing
-*/
-const declinedWithoutRule = {
-	name: "declinedWithout",
-	description: "The field must be declined if :field is missing",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue !== void 0) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-
 //#endregion
 //#region ../seal/src/validators/boolean-validator.ts
 /**
@@ -5722,65 +5771,112 @@ var BooleanValidator = class extends PrimitiveValidator {
 	matchesType(value) {
 		return typeof value === "boolean";
 	}
-	/** Value must be accepted (true, "yes", 1, "on", etc.) */
+	/**
+	* Add a rule from the accepted/declined family, opting the validator into
+	* form-boolean parsing.
+	*
+	* Calling ANY `accepted*`/`declined*` method on `v.boolean()` adds (once,
+	* idempotently — checked by mutator identity so chaining several of these
+	* methods never stacks duplicates) `formBooleanMutator`, which runs before
+	* the type rule and converts the accepted set (`1`, `"1"`, `true`,
+	* `"true"`, `"yes"`, `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true` and
+	* the declined set (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+	* `"No"`, `"N"`, `"Off"`) to `false`; any other value passes through
+	* unchanged and is rejected by the strict type rule as before.
+	*
+	* The mutator and the rule are added to the SAME resolved instance in one
+	* pass — resolving `this.instance` twice (once per `addRule`/`addMutator`
+	* call) would clone twice on an immutable validator and silently drop one
+	* of the two additions.
+	*/
+	addFormBooleanRule(rule, errorMessage, options = {}) {
+		const instance = this.instance;
+		if (!instance.mutators.some((mutator) => mutator.mutate === formBooleanMutator)) instance.addMutableMutator(formBooleanMutator);
+		instance.addMutableRule(rule, errorMessage, options);
+		return instance;
+	}
+	/** Value must be accepted (true, "yes", 1, "on", etc. — form strings are parsed into a real boolean first) */
 	accepted(errorMessage) {
-		return this.addRule(acceptedRule, errorMessage);
+		return this.addFormBooleanRule(acceptedRule, errorMessage);
 	}
 	/** Value must be accepted if another field equals a value */
 	acceptedIf(field, value, errorMessage) {
-		return this.addRule(acceptedIfRule, errorMessage, {
+		return this.addFormBooleanRule(acceptedIfRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be accepted unless another field equals a value */
 	acceptedUnless(field, value, errorMessage) {
-		return this.addRule(acceptedUnlessRule, errorMessage, {
+		return this.addFormBooleanRule(acceptedUnlessRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be accepted if another field is required */
 	acceptedIfRequired(field, errorMessage) {
-		return this.addRule(acceptedIfRequiredRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedIfRequiredRule, errorMessage, { field });
 	}
 	/** Value must be accepted if another field is present */
 	acceptedIfPresent(field, errorMessage) {
-		return this.addRule(acceptedIfPresentRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedIfPresentRule, errorMessage, { field });
 	}
 	/** Value must be accepted if another field is missing */
 	acceptedWithout(field, errorMessage) {
-		return this.addRule(acceptedWithoutRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedWithoutRule, errorMessage, { field });
 	}
-	/** Value must be declined (false, "no", 0, "off", etc.) */
+	/** Value must be declined (false, "no", 0, "off", etc. — form strings are parsed into a real boolean first) */
 	declined(errorMessage) {
-		return this.addRule(declinedRule, errorMessage);
+		return this.addFormBooleanRule(declinedRule, errorMessage);
 	}
 	/** Value must be declined if another field equals a value */
 	declinedIf(field, value, errorMessage) {
-		return this.addRule(declinedIfRule, errorMessage, {
+		return this.addFormBooleanRule(declinedIfRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be declined unless another field equals a value */
 	declinedUnless(field, value, errorMessage) {
-		return this.addRule(declinedUnlessRule, errorMessage, {
+		return this.addFormBooleanRule(declinedUnlessRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be declined if another field is required */
 	declinedIfRequired(field, errorMessage) {
-		return this.addRule(declinedIfRequiredRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedIfRequiredRule, errorMessage, { field });
 	}
 	/** Value must be declined if another field is present */
 	declinedIfPresent(field, errorMessage) {
-		return this.addRule(declinedIfPresentRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedIfPresentRule, errorMessage, { field });
 	}
 	/** Value must be declined if another field is missing */
 	declinedWithout(field, errorMessage) {
-		return this.addRule(declinedWithoutRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedWithoutRule, errorMessage, { field });
+	}
+	/**
+	* Opt in to coercion: an exact query-string-shaped boolean is converted to a
+	* real boolean **before** the type rules run; any other value passes through
+	* unchanged so bad input still fails the type rule.
+	*
+	* Converts exactly `"true"` / `"1"` / `1` → `true` and `"false"` / `"0"` / `0`
+	* → `false`. Case-sensitive, no trimming — `"TRUE"`, `"yes"`, `"on"`, `""`, and
+	* `2` all pass through unchanged and fail the type rule. `v.boolean()` does
+	* **not** coerce by default; this only takes effect when explicitly chained.
+	* For form-style truthy strings like `"yes"` / `"on"`, use `.accepted()` /
+	* `.declined()` instead — those methods opt into their own form-boolean
+	* parsing (a wider value set, case-insensitive on a few forms) and then
+	* apply the accepted/declined pass-fail rule on top of the parsed boolean.
+	*
+	* The output type is unchanged (`Infer<>` keys off the validator class), so
+	* `v.boolean().coerce()` still infers `boolean`.
+	*
+	* @example
+	* v.boolean().coerce()   // "true" → true; "1" → true; "0" → false; "yes" → invalid
+	*/
+	coerce() {
+		return this.addMutator(booleanCoerceMutator);
 	}
 	/**
 	* Value must be strictly true (not "yes", "on", 1, etc.)
@@ -8808,6 +8904,7 @@ exports.betweenNumbersRule = betweenNumbersRule;
 exports.betweenTimesRule = betweenTimesRule;
 exports.betweenYearsRule = betweenYearsRule;
 exports.birthdayRule = birthdayRule;
+exports.booleanCoerceMutator = booleanCoerceMutator;
 exports.booleanMutator = booleanMutator;
 exports.booleanRule = booleanRule;
 exports.businessDayRule = businessDayRule;
@@ -8839,6 +8936,7 @@ exports.forbiddenIfNotRule = forbiddenIfNotRule;
 exports.forbiddenIfRule = forbiddenIfRule;
 exports.forbiddenMethodsApplied = forbiddenMethodsApplied;
 exports.forbiddenRule = forbiddenRule;
+exports.formBooleanMutator = formBooleanMutator;
 exports.fromHourRule = fromHourRule;
 exports.fromMinuteRule = fromMinuteRule;
 exports.fromTodayRule = fromTodayRule;