@vielzeug/spell 26.11.9 → 26.11.10

package/dist/spell.js

@@ -1,50 +1,37 @@
 import { isPlainObject as e } from "@vielzeug/arsenal";
 // src/errors.ts
-function fail(e, t, n) {
-	return [{
-		code: e,
-		message: t,
-		params: n,
-		path: []
-	}];
-}
-function resolveMessage(e, t) {
-	return typeof e == "function" ? e(t) : e;
-}
-function prependIssuePath(e, t) {
-	return e.map((e) => ({
-		...e,
-		path: [t, ...e.path]
-	}));
-}
-function joinIssuePath(e, t = ".") {
-	return !e || e.length === 0 ? "" : e.map((e) => typeof e == "object" && e && "key" in e ? String(e.key) : String(e)).join(t);
-}
 var SpellError = class extends Error {
 	constructor(e, t) {
 		super(e, t), this.name = new.target.name, Object.setPrototypeOf(this, new.target.prototype);
 	}
-};
-function formatIssues(e) {
-	return e.map(({ code: e, message: t, path: n }) => `${n.length ? n.join(".") : "value"}: ${t} [${e}]`).join("\n");
+}, SpellDefinitionError = class extends SpellError {};
+function joinIssuePath(e, t = ".") {
+	return e ? e.map((e) => String(typeof e == "object" && e ? e.key : e)).join(t) : "";
 }
 function pathsEqual(e, t) {
 	return e.length === t.length && e.every((e, n) => e === t[n]);
 }
-var SpellDefinitionError = class extends SpellError {}, SpellValidationError = class extends SpellError {
+var SpellValidationError = class extends SpellError {
 	issues;
 	constructor(e, t) {
-		super(formatIssues(e), { cause: t }), this.issues = Object.freeze([...e]);
+		super(e.map(({ code: e, message: t, path: n }) => `${joinIssuePath(n) || "value"}: ${t} [${e}]`).join("\n"), t), this.issues = Object.freeze([...e]);
 	}
 	flatten() {
 		let e = [], t = [], n = /* @__PURE__ */ new Map();
-		for (let r of this.issues) if (r.path.length === 0) t.push(r.message);
-		else {
-			let t = JSON.stringify(r.path), i = n.get(t);
-			i === void 0 ? (n.set(t, e.length), e.push({
-				messages: [r.message],
-				path: [...r.path]
-			})) : e[i]?.messages.push(r.message);
+		for (let r of this.issues) {
+			if (r.path.length === 0) {
+				t.push(r.message);
+				continue;
+			}
+			let i = JSON.stringify(r.path), a = n.get(i);
+			if (a) a.messages.push(r.message);
+			else {
+				let t = {
+					messages: [r.message],
+					path: [...r.path]
+				};
+				n.set(i, t), e.push(t);
+			}
 		}
 		return {
 			fieldErrors: e,
@@ -54,9 +41,9 @@ var SpellDefinitionError = class extends SpellError {}, SpellValidationError = c
 	flattenFirst() {
 		let { fieldErrors: e, formErrors: t } = this.flatten();
 		return {
-			fieldErrors: e.map((e) => ({
-				message: e.messages[0],
-				path: e.path
+			fieldErrors: e.map(({ messages: e, path: t }) => ({
+				message: e[0],
+				path: t
 			})),
 			formErrors: t
 		};
@@ -85,8 +72,13 @@ function objectFromEntries(e) {
 	for (let [n, r] of e) defineOwnProperty(t, n, r);
 	return t;
 }
-function cloneRecord(e) {
-	return objectFromEntries(Object.entries(e));
+function materialize(t) {
+	return Array.isArray(t) ? t.map(materialize) : t instanceof Date ? new Date(t.getTime()) : t instanceof Map ? new Map([...t].map(([e, t]) => [materialize(e), materialize(t)])) : t instanceof Set ? new Set([...t].map(materialize)) : e(t) ? objectFromEntries(Object.entries(t).map(([e, t]) => [e, materialize(t)])) : t;
+}
+function deepFreeze(e) {
+	if (typeof e != "object" || !e || Object.isFrozen(e)) return e;
+	for (let t of Object.values(e)) deepFreeze(t);
+	return Object.freeze(e);
 }
 // src/messages.ts
 var n = {
@@ -115,6 +107,10 @@ var n = {
 		min: ({ min: e }) => `Must be after ${e.toISOString()}`,
 		type: () => "Expected valid date"
 	},
+	discriminatedUnion: {
+		invalidDiscriminator: ({ discriminator: e, expected: t }) => `Invalid discriminator value at "${e}": expected ${t.map((e) => JSON.stringify(e)).join(" | ")}`,
+		type: () => "Expected object"
+	},
 	enum: { invalid: ({ values: e }) => `Expected one of: ${e.map((e) => JSON.stringify(e)).join(", ")}` },
 	instanceof: { type: ({ className: e }) => `Expected instance of ${e}` },
 	literal: { expected: ({ expected: e }) => `Expected ${JSON.stringify(e)}` },
@@ -155,8 +151,6 @@ var n = {
 		base64url: () => "Invalid base64url",
 		cuid: () => "Invalid CUID",
 		cuid2: () => "Invalid CUID2",
-		date: () => "Invalid date",
-		dateTime: () => "Invalid datetime",
 		duration: () => "Invalid ISO 8601 duration",
 		email: () => "Invalid email address",
 		emoji: () => "Invalid emoji sequence",
@@ -165,6 +159,8 @@ var n = {
 		hexColor: () => "Invalid hex color",
 		includes: ({ substr: e }) => `Must include "${e}"`,
 		ip: () => "Invalid IP address",
+		isoDate: () => "Invalid date",
+		isoDateTime: () => "Invalid datetime",
 		jwt: () => "Invalid JWT",
 		length: ({ exact: e }) => `Must be exactly ${e} characters`,
 		max: ({ max: e }) => `Must be at most ${e} characters`,
@@ -187,230 +183,208 @@ var n = {
 		min: ({ min: e }) => `Expected tuple with at least ${e} items`,
 		type: () => "Expected array"
 	},
-	union: { invalid: () => "Does not match any of the expected types" },
-	variant: {
-		invalidDiscriminator: ({ discriminator: e, expected: t }) => `Invalid discriminator value at "${e}": expected ${t.map((e) => JSON.stringify(e)).join(" | ")}`,
-		type: () => "Expected object"
-	}
+	union: { invalid: () => "Does not match any of the expected types" }
 };
-function isRecord(e) {
-	return typeof e == "object" && !!e && !Array.isArray(e);
-}
-function mergeMessages(e, t) {
-	let n = cloneRecord(e);
-	for (let [e, r] of Object.entries(t)) {
-		if (r === void 0) continue;
-		if (isUnsafeObjectKey(e)) {
-			`${e}`;
+function mergeMessages(t, n) {
+	let r = objectFromEntries(Object.entries(t));
+	for (let [t, i] of Object.entries(n)) {
+		if (i === void 0) continue;
+		if (isUnsafeObjectKey(t)) {
+			`${t}`;
 			continue;
 		}
-		let t = n[e];
-		isRecord(t) && isRecord(r) ? defineOwnProperty(n, e, mergeMessages(t, r)) : defineOwnProperty(n, e, r);
+		let n = r[t];
+		defineOwnProperty(r, t, e(n) && e(i) ? mergeMessages(n, i) : i);
 	}
-	return n;
+	return r;
 }
 function createParseContext(e = {}) {
-	return { messages: mergeMessages(n, e) };
+	return deepFreeze({ messages: mergeMessages(n, e) });
 }
-// src/types.ts
-var r = {
+var r = createParseContext();
+// src/_parse.ts
+function chain(e, t) {
+	return e instanceof Promise ? e.then(t) : t(e);
+}
+function all(e) {
+	return e.some((e) => e instanceof Promise) ? Promise.all(e) : e;
+}
+function issue(e, t, ...[n]) {
+	return n === void 0 ? {
+		code: e,
+		message: t,
+		path: []
+	} : {
+		code: e,
+		message: t,
+		params: n,
+		path: []
+	};
+}
+function resolveMessage(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function prefixIssues(e, t) {
+	return e.map((e) => ({
+		...e,
+		path: [t, ...e.path]
+	}));
+}
+var atLeast = (e, t) => e === void 0 || t > e ? t : e, atMost = (e, t) => e === void 0 || t < e ? t : e, ok = (e) => ({
+	issues: [],
+	typeOk: !0,
+	value: e
+}), invalid = (e, ...t) => ({
+	issues: t,
+	typeOk: !1,
+	value: e
+}), i = {
 	custom: "custom",
-	invalid_base64: "invalid_base64",
 	invalid_date: "invalid_date",
-	invalid_duration: "invalid_duration",
+	invalid_discriminator: "invalid_discriminator",
 	invalid_enum: "invalid_enum",
 	invalid_finite: "invalid_finite",
+	invalid_format: "invalid_format",
 	invalid_integer: "invalid_integer",
 	invalid_keys: "invalid_keys",
 	invalid_length: "invalid_length",
 	invalid_literal: "invalid_literal",
 	invalid_multiple_of: "invalid_multiple_of",
 	invalid_safe: "invalid_safe",
-	invalid_string: "invalid_string",
 	invalid_type: "invalid_type",
 	invalid_union: "invalid_union",
 	invalid_unique: "invalid_unique",
-	invalid_url: "invalid_url",
-	invalid_variant: "invalid_variant",
 	too_big: "too_big",
 	too_small: "too_small"
-};
-// src/core.ts
-function deepFreeze(e) {
-	if (typeof e != "object" || !e || Object.isFrozen(e)) return e;
-	for (let t of Object.values(e)) deepFreeze(t);
-	return Object.freeze(e);
-}
-function materializeValue(t) {
-	if (typeof t != "object" || !t) return t;
-	if (Array.isArray(t)) return t.map((e) => materializeValue(e));
-	if (t instanceof Date) return new Date(t.getTime());
-	if (t instanceof Map) {
-		let e = /* @__PURE__ */ new Map();
-		for (let [n, r] of t.entries()) e.set(materializeValue(n), materializeValue(r));
-		return e;
-	}
-	if (t instanceof Set) return new Set([...t.values()].map((e) => materializeValue(e)));
-	if (e(t)) {
-		let e = {};
-		for (let [n, r] of Object.entries(t)) defineOwnProperty(e, n, materializeValue(r));
-		return e;
-	}
-	return t;
-}
-function defaultState() {
-	return {
-		hasAsyncChecks: !1,
-		hasRuntimeChecks: !1,
-		isNullable: !1,
-		isOptional: !1,
-		postprocessors: [],
-		preprocessors: [],
-		validators: []
-	};
-}
-function cloneState(e) {
-	return {
-		catch: e.catch,
-		defaultValue: e.defaultValue,
-		description: e.description,
-		hasAsyncChecks: e.hasAsyncChecks,
-		hasRuntimeChecks: e.hasRuntimeChecks,
-		isNullable: e.isNullable,
-		isOptional: e.isOptional,
-		postprocessors: [...e.postprocessors],
-		preprocessors: [...e.preprocessors],
-		validators: [...e.validators]
+}, a = {
+	meta: {},
+	nullable: !1,
+	optional: !1,
+	portable: !0,
+	preprocess: [],
+	steps: []
+}, asyncMisuse = () => new SpellError("Schema contains async checks; use parseAsync() or safeParseAsync().");
+function toResult({ issues: e, value: t }) {
+	return e.length === 0 ? {
+		data: t,
+		success: !0
+	} : {
+		error: new SpellValidationError(e),
+		success: !1
 	};
 }
-function _makeCtx(e) {
-	return e ? { messages: e } : createParseContext();
-}
-function normalizeValidateResult(e, t, n) {
-	let i = [...t];
-	return typeof e == "string" ? i.push({
-		code: r.custom,
-		message: e,
-		path: []
-	}) : e === !1 && i.length === 0 && i.push({
-		code: r.custom,
-		message: n.messages.check.default(),
-		path: []
-	}), i.length ? i : null;
+function checkIssues(e, t, n) {
+	return typeof e == "string" ? t.push(issue(i.custom, e)) : e === !1 && t.length === 0 && t.push(issue(i.custom, n.check.default())), t.length > 0 ? t : null;
 }
 var Schema = class {
-	state;
-	_annotations = {};
-	_typeValidator = null;
+	state = a;
+	get kind() {
+		return "unknown";
+	}
+	get description() {
+		return this.state.description;
+	}
+	get isOptional() {
+		return this.state.optional || this.state.default !== void 0 || this.state.catch !== void 0;
+	}
+	get isNullable() {
+		return this.state.nullable;
+	}
 	get "~standard"() {
 		return {
-			validate: async (e) => {
-				let t = await this.safeParseAsync(e);
-				return t.success ? { value: t.data } : { issues: t.error.issues.map(({ message: e, path: t }) => ({
-					message: e,
-					path: t
-				})) };
-			},
+			validate: (e) => chain(this._run(e, {
+				async: !0,
+				messages: r.messages
+			}), ({ issues: e, value: t }) => e.length === 0 ? { value: t } : { issues: e.map(({ message: e, path: t }) => ({
+				message: e,
+				path: t
+			})) }),
 			vendor: "vielzeug",
 			version: 1
 		};
 	}
-	constructor(e) {
-		this.state = defaultState(), this._typeValidator = e ?? null;
-	}
 	parse(e, t) {
-		if (this.state.hasAsyncChecks) throw new SpellValidationError([{
-			code: r.custom,
-			message: "parse() cannot evaluate async checks. Use parseAsync().",
-			path: []
-		}]);
-		let n = t ?? _makeCtx();
-		return this._withCatch(() => {
-			let t = this._prepareInput(e);
-			if (t.skip) return t.value;
-			let r = this._parse(t.value, n), i = r.typeOk ? this._runValidatorsSync(r.data, n) : [], a = [...r.issues, ...i];
-			if (a.length) throw new SpellValidationError(a);
-			return this._runPostprocessors(r.data);
+		let n = this.safeParse(e, t);
+		if (n.success) return n.data;
+		throw n.error;
+	}
+	safeParse(e, t = r) {
+		let n = this._run(e, {
+			async: !1,
+			messages: t.messages
 		});
-	}
-	safeParse(e, t) {
-		try {
-			return {
-				data: this.parse(e, t),
-				success: !0
-			};
-		} catch (e) {
-			if (e instanceof SpellValidationError) return {
-				error: e,
-				success: !1
-			};
-			throw e;
-		}
+		if (n instanceof Promise) throw asyncMisuse();
+		return toResult(n);
 	}
 	async parseAsync(e, t) {
-		let n = t ?? _makeCtx();
-		return this._withCatchAsync(async () => {
-			let t = this._prepareInput(e);
-			if (t.skip) return t.value;
-			let r = await this._parseAsync(t.value, n), i = r.typeOk ? await this._runValidatorsAsync(r.data, n) : [], a = [...r.issues, ...i];
-			if (a.length) throw new SpellValidationError(a);
-			return this._runPostprocessors(r.data);
-		});
+		let n = await this.safeParseAsync(e, t);
+		if (n.success) return n.data;
+		throw n.error;
+	}
+	async safeParseAsync(e, t = r) {
+		return toResult(await this._run(e, {
+			async: !0,
+			messages: t.messages
+		}));
 	}
-	async safeParseAsync(e, t) {
-		try {
-			return {
-				data: await this.parseAsync(e, t),
-				success: !0
+	is(e) {
+		return this.safeParse(e).success;
+	}
+	assert(e, t) {
+		let n = this.safeParse(e);
+		if (!n.success) throw t ? new SpellValidationError(n.error.issues.map((e) => e.path.length === 0 ? {
+			...e,
+			message: `${t}: ${e.message}`
+		} : e)) : n.error;
+	}
+	_run(e, t) {
+		let { catch: n, default: r, nullable: i, optional: a, preprocess: o } = this.state, s = e;
+		for (let e of o) s = e(s);
+		if (s === void 0) {
+			if (r) return {
+				issues: [],
+				value: r()
 			};
-		} catch (e) {
-			if (e instanceof SpellValidationError) return {
-				error: e,
-				success: !1
+			if (a) return {
+				issues: [],
+				value: s
 			};
-			throw e;
 		}
-	}
-	_parseFullSync(e, t) {
-		if (this.state.hasAsyncChecks) throw new SpellValidationError([{
-			code: r.custom,
-			message: "Sync parsing cannot evaluate async checks. Use parseAsync().",
-			path: []
-		}]);
-		let n = t ?? _makeCtx(), i = this._prepareInput(e);
-		if (i.skip) return {
-			data: i.value,
-			issues: []
+		if (s === null && i) return {
+			issues: [],
+			value: s
 		};
-		let a = this._parse(i.value, n), o = a.typeOk ? this._runValidatorsSync(a.data, n) : [], s = [...a.issues, ...o];
-		return s.length > 0 ? this.state.catch ? {
-			data: this.state.catch(),
-			issues: []
-		} : {
-			data: a.data,
-			issues: s
-		} : {
-			data: this._runPostprocessors(a.data),
-			issues: []
+		let c = chain(this._parse(s, t), (e) => e.typeOk ? this._runSteps(e.value, e.issues, t, 0) : e);
+		return n ? chain(c, (e) => e.issues.length === 0 ? e : {
+			issues: [],
+			value: n()
+		}) : c;
+	}
+	_runSteps(e, t, n, r) {
+		let { steps: i } = this.state, a = e;
+		for (let e = r; e < i.length; e++) {
+			let r = i[e];
+			if (r.kind === "transform") {
+				if (t.length > 0) break;
+				a = r.run(a);
+				continue;
+			}
+			if (r.async && !n.async) throw asyncMisuse();
+			let o = r.run(a, n);
+			if (o instanceof Promise) {
+				if (!n.async) throw o.catch(() => {}), asyncMisuse();
+				let r = a;
+				return o.then((i) => this._runSteps(r, i ? [...t, ...i] : t, n, e + 1));
+			}
+			o && (t = [...t, ...o]);
+		}
+		return {
+			issues: t,
+			value: a
 		};
 	}
-	async _parseFullAsync(e, t) {
-		let n = t ?? _makeCtx(), r = this._prepareInput(e);
-		if (r.skip) return {
-			data: r.value,
-			issues: []
-		};
-		let i = await this._parseAsync(r.value, n), a = i.typeOk ? await this._runValidatorsAsync(i.data, n) : [], o = [...i.issues, ...a];
-		return o.length > 0 ? this.state.catch ? {
-			data: this.state.catch(),
-			issues: []
-		} : {
-			data: i.data,
-			issues: o
-		} : {
-			data: this._runPostprocessors(i.data),
-			issues: []
-		};
+	_parse(e, t) {
+		return ok(e);
 	}
 	check(e) {
 		return this._addCheck(e, !1);
@@ -419,238 +393,127 @@ var Schema = class {
 		return this._addCheck(e, !0);
 	}
 	_addCheck(e, t) {
-		let validator = (t, n) => {
-			let r = [], i = e(t, { addIssue: (e) => r.push({
-				...e,
-				path: e.path ?? []
-			}) });
-			return i instanceof Promise ? i.then((e) => normalizeValidateResult(e, r, n)) : normalizeValidateResult(i, r, n);
-		}, n = this._addConstraint(validator);
-		return n.state.hasRuntimeChecks = !0, t && (n.state.hasAsyncChecks = !0), n;
+		let run = (t, n) => {
+			let r = [];
+			return chain(e(t, { addIssue: ({ path: e = [], ...t }) => r.push({
+				...t,
+				path: e
+			}) }), (e) => checkIssues(e, r, n.messages));
+		};
+		return this._with({
+			portable: !1,
+			steps: [...this.state.steps, {
+				async: t,
+				kind: "check",
+				run
+			}]
+		});
+	}
+	_refine(e, t, n) {
+		let run = (n, r) => e(n) ? null : [t(n, r.messages)];
+		return this._with({
+			meta: n ? {
+				...this.state.meta,
+				...n(this.state.meta)
+			} : this.state.meta,
+			steps: [...this.state.steps, {
+				async: !1,
+				kind: "check",
+				run
+			}]
+		});
 	}
 	optional() {
-		let e = this._clone();
-		return e.state.isOptional = !0, e;
+		return this._with({ optional: !0 });
 	}
 	nullable() {
-		let e = this._clone();
-		return e.state.isNullable = !0, e;
+		return this._with({ nullable: !0 });
 	}
 	nullish() {
-		let e = this._clone();
-		return e.state.isOptional = !0, e.state.isNullable = !0, e;
+		return this._with({
+			nullable: !0,
+			optional: !0
+		});
 	}
 	required() {
-		let e = this._clone();
-		return e.state.isOptional = !1, e;
+		return this._with({
+			default: void 0,
+			optional: !1
+		});
 	}
 	default(e) {
-		let t = this._clone();
-		return t.state.defaultValue = typeof e == "function" ? e : () => materializeValue(e), t;
+		let t = typeof e == "function" ? e : () => materialize(e);
+		return this._with({
+			default: t,
+			portable: !1
+		});
 	}
 	catch(e) {
-		let t = this._clone();
-		return t.state.catch = typeof e == "function" ? e : () => materializeValue(e), t;
+		let t = typeof e == "function" ? e : () => materialize(e);
+		return this._with({
+			catch: t,
+			portable: !1
+		});
 	}
 	transform(e) {
-		let t = this._clone();
-		return t.state.postprocessors.push(e), t;
+		let t = {
+			kind: "transform",
+			run: e
+		};
+		return this._with({
+			portable: !1,
+			steps: [...this.state.steps, t]
+		});
 	}
 	preprocess(e) {
-		let t = this._clone();
-		return t.state.preprocessors.push(e), t;
+		return this._with({
+			portable: !1,
+			preprocess: [...this.state.preprocess, e]
+		});
 	}
 	pipe(e) {
 		return new PipeSchema(this, e);
 	}
-	label(e) {
-		let t = this._clone();
-		return t.state.description = e, t;
+	describe(e) {
+		return this._with({ description: e });
 	}
 	definition() {
-		if (this.state.catch || this.state.defaultValue || this.state.postprocessors.length > 0 || this.state.preprocessors.length > 0 || this.state.hasRuntimeChecks) throw new SpellDefinitionError("Schemas with checks, transforms, defaults, catches, or preprocessors have no declarative definition.");
-		return deepFreeze(this._toDescriptorImpl());
-	}
-	get description() {
-		return this.state.description;
-	}
-	get isOptional() {
-		return this.state.isOptional;
-	}
-	get isNullable() {
-		return this.state.isNullable;
-	}
-	is(e) {
-		return this.safeParse(e).success;
-	}
-	assert(e, t) {
-		let n = this._parseFullSync(e);
-		if (n.issues.length !== 0) throw new SpellValidationError(t ? n.issues.map((e) => ({
-			...e,
-			message: e.path.length === 0 ? `${t}: ${e.message}` : e.message
-		})) : n.issues);
-	}
-	get kind() {
-		return this._kind;
-	}
-	get _kind() {
-		return "unknown";
-	}
-	_describeBase() {
-		return {
-			...this.state.description === void 0 ? {} : { description: this.state.description },
-			...this.state.isNullable ? { isNullable: !0 } : {},
-			...this.state.isOptional ? { isOptional: !0 } : {}
-		};
-	}
-	_addConstraint(e, t) {
-		let n = this._clone();
-		return n.state.validators.push(e), t && (n._annotations = t({ ...n._annotations })), n;
-	}
-	_construct(e) {
-		let t = Object.assign(Object.create(Object.getPrototypeOf(this)), this, { state: e });
-		return t._annotations = { ...this._annotations }, t;
+		if (!this.state.portable) throw new SpellDefinitionError("Schemas with custom checks, transforms, preprocessors, defaults, or catches have no declarative definition.");
+		return deepFreeze(this._describe());
 	}
-	_clone() {
-		return this._construct(cloneState(this.state));
-	}
-	_copyStateTo(e) {
-		return e.state = cloneState(this.state), e;
-	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
 			kind: "unknown"
 		};
 	}
-	_withCatch(e) {
-		if (!this.state.catch) return e();
-		try {
-			return e();
-		} catch (e) {
-			if (e instanceof SpellValidationError) return this.state.catch();
-			throw e;
-		}
-	}
-	async _withCatchAsync(e) {
-		if (!this.state.catch) return e();
-		try {
-			return await e();
-		} catch (e) {
-			if (e instanceof SpellValidationError) return this.state.catch();
-			throw e;
-		}
-	}
-	_prepareInput(e) {
-		let t = this._runPreprocessors(e), n = t === void 0 && this.state.defaultValue ? this.state.defaultValue() : t;
-		return this.state.isOptional && n === void 0 || this.state.isNullable && n === null ? {
-			skip: !0,
-			value: n
-		} : {
-			skip: !1,
-			value: n
-		};
-	}
-	_runPreprocessors(e) {
-		let t = e;
-		for (let e of this.state.preprocessors) t = e(t);
-		return t;
-	}
-	_runPostprocessors(e) {
-		let t = e;
-		for (let e of this.state.postprocessors) t = e(t);
-		return t;
-	}
-	_runValidatorsSync(e, t) {
-		if (this._typeValidator) {
-			let n = this._typeValidator(e, t);
-			if (n instanceof Promise) throw new SpellValidationError([{
-				code: r.custom,
-				message: "Type validator returned a Promise. Use parseAsync() for async validation.",
-				path: []
-			}]);
-			if (n && n.length > 0) return n;
-		}
-		let n = [];
-		for (let i of this.state.validators) {
-			let a = i(e, t);
-			if (a instanceof Promise) throw new SpellValidationError([{
-				code: r.custom,
-				message: "Sync parsing received an async check. Use checkAsync() and parseAsync().",
-				path: []
-			}]);
-			a && n.push(...a);
-		}
-		return n;
-	}
-	async _runValidatorsAsync(e, t) {
-		if (this._typeValidator) {
-			let n = await this._typeValidator(e, t);
-			if (n && n.length > 0) return n;
-		}
-		let n = [];
-		for (let r of this.state.validators) {
-			let i = await r(e, t);
-			i && n.push(...i);
-		}
-		return n;
-	}
-	_parse(e, t) {
+	_describeBase() {
+		let { description: e, nullable: t, optional: n } = this.state;
 		return {
-			data: e,
-			issues: [],
-			typeOk: !0
+			...e !== void 0 && { description: e },
+			...t && { isNullable: !0 },
+			...n && { isOptional: !0 }
 		};
 	}
-	_parseAsync(e, t) {
-		return Promise.resolve(this._parse(e, t));
+	_with(e) {
+		return Object.assign(Object.create(Object.getPrototypeOf(this)), this, { state: {
+			...this.state,
+			...e
+		} });
 	}
 }, PipeSchema = class extends Schema {
 	from;
 	to;
-	get _kind() {
-		return "pipe";
-	}
 	constructor(e, t) {
 		super(), this.from = e, this.to = t;
 	}
-	_parse(e, t) {
-		let n = this.from._parseFullSync(e, t);
-		if (n.issues.length > 0) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let r = this.to._parseFullSync(n.data, t);
-		return r.issues.length > 0 ? {
-			data: n.data,
-			issues: r.issues,
-			typeOk: !1
-		} : {
-			data: r.data,
-			issues: [],
-			typeOk: !0
-		};
+	get kind() {
+		return "pipe";
 	}
-	async _parseAsync(e, t) {
-		let n = await this.from._parseFullAsync(e, t);
-		if (n.issues.length > 0) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let r = await this.to._parseFullAsync(n.data, t);
-		return r.issues.length > 0 ? {
-			data: n.data,
-			issues: r.issues,
-			typeOk: !1
-		} : {
-			data: r.data,
-			issues: [],
-			typeOk: !0
-		};
+	_parse(e, t) {
+		return chain(this.from._run(e, t), (n) => n.issues.length > 0 ? invalid(e, ...n.issues) : chain(this.to._run(n.value, t), (e) => e.issues.length > 0 ? invalid(n.value, ...e.issues) : ok(e.value)));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
 			from: this.from.definition(),
@@ -660,943 +523,535 @@ var Schema = class {
 	}
 }, ArraySchema = class extends Schema {
 	itemSchema;
-	get _kind() {
-		return "array";
-	}
 	constructor(e) {
 		super(), this.itemSchema = e;
 	}
-	_parseItemsSync(e, t) {
-		let n = [], r = [];
-		for (let i = 0; i < e.length; i++) {
-			let a = this.itemSchema._parseFullSync(e[i], t);
-			a.issues.length === 0 ? r.push(a.data) : (n.push(...prependIssuePath(a.issues, i)), r.push(e[i]));
-		}
-		return {
-			data: r,
-			issues: n
-		};
+	get kind() {
+		return "array";
 	}
 	_parse(e, t) {
-		if (!Array.isArray(e)) return {
-			data: e,
-			issues: fail(r.invalid_type, t.messages.array.type()),
-			typeOk: !1
-		};
-		let { data: n, issues: i } = this._parseItemsSync(e, t);
-		return {
-			data: n,
-			issues: i,
-			typeOk: !0
-		};
-	}
-	async _parseAsync(e, t) {
-		if (!Array.isArray(e)) return {
-			data: e,
-			issues: fail(r.invalid_type, t.messages.array.type()),
-			typeOk: !1
-		};
-		let n = await Promise.all(e.map((e) => this.itemSchema._parseFullAsync(e, t))), i = [], a = [];
-		for (let t = 0; t < n.length; t++) {
-			let r = n[t];
-			r.issues.length === 0 ? a.push(r.data) : (i.push(...prependIssuePath(r.issues, t)), a.push(e[t]));
-		}
-		return {
-			data: a,
-			issues: i,
-			typeOk: !0
-		};
+		return Array.isArray(e) ? chain(all(e.map((e) => this.itemSchema._run(e, t))), (t) => {
+			let n = [];
+			return {
+				issues: n,
+				typeOk: !0,
+				value: t.map((t, r) => t.issues.length === 0 ? t.value : (n.push(...prefixIssues(t.issues, r)), e[r]))
+			};
+		}) : invalid(e, issue(i.invalid_type, t.messages.array.type()));
 	}
 	min(e, t) {
-		return this._addConstraint((n, i) => n.length >= e ? null : fail(r.too_small, resolveMessage(t ?? i.messages.array.min, {
+		return this._refine((t) => t.length >= e, (n, r) => issue(i.too_small, resolveMessage(t ?? r.array.min, {
 			min: e,
 			value: n
-		}), { min: e }), (t) => {
-			let n = t;
-			return {
-				...n,
-				minItems: n.minItems === void 0 ? e : Math.max(n.minItems, e)
-			};
-		});
+		}), { min: e }), (t) => ({ minItems: atLeast(t.minItems, e) }));
 	}
 	max(e, t) {
-		return this._addConstraint((n, i) => n.length <= e ? null : fail(r.too_big, resolveMessage(t ?? i.messages.array.max, {
+		return this._refine((t) => t.length <= e, (n, r) => issue(i.too_big, resolveMessage(t ?? r.array.max, {
 			max: e,
 			value: n
-		}), { max: e }), (t) => {
-			let n = t;
-			return {
-				...n,
-				maxItems: n.maxItems === void 0 ? e : Math.min(n.maxItems, e)
-			};
-		});
+		}), { max: e }), (t) => ({ maxItems: atMost(t.maxItems, e) }));
 	}
 	length(e, t) {
-		return this._addConstraint((n, i) => n.length === e ? null : fail(r.invalid_length, resolveMessage(t ?? i.messages.array.length, {
+		return this._refine((t) => t.length === e, (n, r) => issue(i.invalid_length, resolveMessage(t ?? r.array.length, {
 			exact: e,
 			value: n
 		}), { exact: e }), (t) => ({
-			...t,
-			maxItems: e,
-			minItems: e
+			maxItems: atMost(t.maxItems, e),
+			minItems: atLeast(t.minItems, e)
 		}));
 	}
 	nonEmpty(e) {
-		return this._addConstraint((t, n) => {
-			let i = t;
-			return i.length > 0 ? null : fail(r.too_small, resolveMessage(e ?? n.messages.array.nonEmpty, {
-				min: 1,
-				value: i
-			}), { min: 1 });
-		});
+		return this._refine((e) => e.length > 0, (t, n) => issue(i.too_small, resolveMessage(e ?? n.array.nonEmpty, { value: t }), { min: 1 }), (e) => ({ minItems: atLeast(e.minItems, 1) }));
 	}
-	unique(e, t) {
-		let n = typeof e == "function" && e.length === 2, i = n ? e : null, a = n ? t : typeof e == "function" ? e : void 0;
-		return this._addConstraint((e, t) => {
-			let n = e, o;
-			return o = i ? n.every((e, t) => n.slice(0, t).every((t) => !i(e, t))) : new Set(n).size === n.length, o ? null : fail(r.invalid_unique, resolveMessage(a ?? t.messages.array.unique, { value: n }), { unique: !0 });
-		});
+	unique(e = {}) {
+		let { by: t, message: n } = e, r = this._refine((e) => new Set(t ? e.map(t) : e).size === e.length, (e, t) => issue(i.invalid_unique, resolveMessage(n ?? t.array.unique, { value: e })), t ? void 0 : () => ({ uniqueItems: !0 }));
+		return t ? r._with({ portable: !1 }) : r;
 	}
-	_toDescriptorImpl() {
-		let e = this._annotations;
+	_describe() {
 		return {
 			...this._describeBase(),
-			...e.maxItems === void 0 ? {} : { maxItems: e.maxItems },
-			...e.minItems === void 0 ? {} : { minItems: e.minItems },
+			...this.state.meta,
 			items: this.itemSchema.definition(),
 			kind: "array"
 		};
 	}
-}, i = class BigIntSchema extends Schema {
-	get _kind() {
+}, BigIntSchema = class extends Schema {
+	get kind() {
 		return "bigint";
 	}
-	constructor() {
-		super((e, t) => typeof e == "bigint" ? null : fail(r.invalid_type, t.messages.bigint.type()));
+	_parse(e, t) {
+		return typeof e == "bigint" ? ok(e) : invalid(e, issue(i.invalid_type, t.messages.bigint.type()));
 	}
 	min(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a >= e ? null : fail(r.too_small, resolveMessage(t ?? i.messages.bigint.min, {
-				min: e,
-				value: a
-			}), { min: e });
-		});
+		return this._refine((t) => t >= e, (n, r) => issue(i.too_small, resolveMessage(t ?? r.bigint.min, {
+			min: e,
+			value: n
+		}), { min: e }), (t) => ({ minimum: atLeast(t.minimum, e) }));
 	}
 	max(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a <= e ? null : fail(r.too_big, resolveMessage(t ?? i.messages.bigint.max, {
-				max: e,
-				value: a
-			}), { max: e });
-		});
+		return this._refine((t) => t <= e, (n, r) => issue(i.too_big, resolveMessage(t ?? r.bigint.max, {
+			max: e,
+			value: n
+		}), { max: e }), (t) => ({ maximum: atMost(t.maximum, e) }));
 	}
 	positive(e) {
-		return this._addConstraint((t, n) => {
-			let i = t;
-			return i > 0n ? null : fail(r.too_small, resolveMessage(e ?? n.messages.bigint.positive, { value: i }), {
-				exclusive: !0,
-				min: 0n
-			});
-		});
+		return this._refine((e) => e > 0n, (t, n) => issue(i.too_small, resolveMessage(e ?? n.bigint.positive, { value: t }), {
+			exclusive: !0,
+			min: 0n
+		}), (e) => ({ exclusiveMinimum: atLeast(e.exclusiveMinimum, 0n) }));
 	}
 	negative(e) {
-		return this._addConstraint((t, n) => {
-			let i = t;
-			return i < 0n ? null : fail(r.too_big, resolveMessage(e ?? n.messages.bigint.negative, { value: i }), {
-				exclusive: !0,
-				max: 0n
-			});
-		});
+		return this._refine((e) => e < 0n, (t, n) => issue(i.too_big, resolveMessage(e ?? n.bigint.negative, { value: t }), {
+			exclusive: !0,
+			max: 0n
+		}), (e) => ({ exclusiveMaximum: atMost(e.exclusiveMaximum, 0n) }));
 	}
 	nonNegative(e) {
-		return this._addConstraint((t, n) => {
-			let i = t;
-			return i >= 0n ? null : fail(r.too_small, resolveMessage(e ?? n.messages.bigint.nonNegative, { value: i }), { min: 0n });
-		});
+		return this._refine((e) => e >= 0n, (t, n) => issue(i.too_small, resolveMessage(e ?? n.bigint.nonNegative, { value: t }), { min: 0n }), (e) => ({ minimum: atLeast(e.minimum, 0n) }));
 	}
 	nonPositive(e) {
-		return this._addConstraint((t, n) => {
-			let i = t;
-			return i <= 0n ? null : fail(r.too_big, resolveMessage(e ?? n.messages.bigint.nonPositive, { value: i }), { max: 0n });
-		});
+		return this._refine((e) => e <= 0n, (t, n) => issue(i.too_big, resolveMessage(e ?? n.bigint.nonPositive, { value: t }), { max: 0n }), (e) => ({ maximum: atMost(e.maximum, 0n) }));
 	}
 	multipleOf(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a % e === 0n ? null : fail(r.invalid_multiple_of, resolveMessage(t ?? i.messages.bigint.multipleOf, {
-				step: e,
-				value: a
-			}), { step: e });
-		});
-	}
-	_toDescriptorImpl() {
-		return this.state.validators.length, {
-			...this._describeBase(),
-			kind: "bigint"
-		};
-	}
-	static coerce() {
-		return new BigIntSchema().preprocess((e) => {
-			if (typeof e == "bigint") return e;
-			if (typeof e == "number") {
-				if (!Number.isFinite(e) || !Number.isInteger(e)) return e;
-				try {
-					return BigInt(e);
-				} catch {
-					return e;
-				}
-			}
-			if (typeof e == "string") {
-				let t = e.trim();
-				if (t.length === 0 || t.length > 1e3) return e;
-				try {
-					return BigInt(t);
-				} catch {
-					return e;
-				}
-			}
-			return e;
-		});
-	}
-}, a = class BooleanSchema extends Schema {
-	get _kind() {
-		return "boolean";
-	}
-	constructor() {
-		super((e, t) => typeof e == "boolean" ? null : [{
-			code: r.invalid_type,
-			message: t.messages.boolean.type(),
-			path: []
-		}]);
+		return this._refine((t) => e !== 0n && t % e === 0n, (n, r) => issue(i.invalid_multiple_of, resolveMessage(t ?? r.bigint.multipleOf, {
+			step: e,
+			value: n
+		}), { step: e }), () => ({ multipleOf: e }));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
-			kind: "boolean"
+			...this.state.meta,
+			kind: "bigint"
 		};
 	}
-	static coerce() {
-		return new BooleanSchema().preprocess((e) => typeof e == "boolean" ? e : e === "true" || e === "1" || e === 1 ? !0 : e === "false" || e === "0" || e === 0 ? !1 : e);
-	}
-}, o = class DateSchema extends Schema {
-	get _kind() {
+}, DateSchema = class extends Schema {
+	get kind() {
 		return "date";
 	}
-	constructor() {
-		super((e, t) => e instanceof Date && !Number.isNaN(e.getTime()) ? null : fail(r.invalid_date, t.messages.date.type()));
+	_parse(e, t) {
+		return e instanceof Date && !Number.isNaN(e.getTime()) ? ok(e) : invalid(e, issue(i.invalid_date, t.messages.date.type()));
 	}
 	min(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a >= e ? null : fail(r.too_small, resolveMessage(t ?? i.messages.date.min, {
-				min: e,
-				value: a
-			}), { min: e });
-		});
+		return this._refine((t) => t >= e, (n, r) => issue(i.too_small, resolveMessage(t ?? r.date.min, {
+			min: e,
+			value: n
+		}), { min: e }), (t) => ({ minimum: t.minimum === void 0 || e > new Date(t.minimum) ? e.toISOString() : t.minimum }));
 	}
 	max(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a <= e ? null : fail(r.too_big, resolveMessage(t ?? i.messages.date.max, {
-				max: e,
-				value: a
-			}), { max: e });
-		});
+		return this._refine((t) => t <= e, (n, r) => issue(i.too_big, resolveMessage(t ?? r.date.max, {
+			max: e,
+			value: n
+		}), { max: e }), (t) => ({ maximum: t.maximum === void 0 || e < new Date(t.maximum) ? e.toISOString() : t.maximum }));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
+			...this.state.meta,
 			kind: "date"
 		};
 	}
-	static coerce() {
-		return new DateSchema().preprocess((e) => e instanceof Date ? e : typeof e == "string" || typeof e == "number" ? new Date(e) : e);
-	}
-};
-// src/schemas/enum.ts
-function buildEnumValidator(e) {
-	let t = new Set(e);
-	return (n, i) => t.has(n) ? null : [{
-		code: r.invalid_enum,
-		message: i.messages.enum.invalid({ values: e }),
-		params: { values: e },
-		path: []
-	}];
-}
-var EnumSchema = class extends Schema {
-	values;
-	get _kind() {
-		return "enum";
+}, BooleanSchema = class extends Schema {
+	get kind() {
+		return "boolean";
 	}
-	constructor(e) {
-		super(buildEnumValidator(e)), this.values = e;
+	_parse(e, t) {
+		return typeof e == "boolean" ? ok(e) : invalid(e, issue(i.invalid_type, t.messages.boolean.type()));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
-			kind: "enum",
-			values: this.values
+			kind: "boolean"
 		};
 	}
-}, InstanceOfSchema = class extends Schema {
-	cls;
-	get _kind() {
-		return "instanceof";
-	}
+}, LiteralSchema = class extends Schema {
+	value;
 	constructor(e) {
-		super((t, n) => t instanceof e ? null : [{
-			code: r.invalid_type,
-			message: n.messages.instanceof.type({ className: e.name }),
-			path: []
-		}]), this.cls = e;
+		super(), this.value = e;
 	}
-	_toDescriptorImpl() {
-		return {
-			...this._describeBase(),
-			className: this.cls.name,
-			kind: "instanceof"
-		};
-	}
-};
-// src/schemas/intersect.ts
-function deepMerge(t, n) {
-	if (e(t) && e(n)) {
-		let e = cloneRecord(t);
-		for (let [r, i] of Object.entries(n)) defineOwnProperty(e, r, deepMerge(t[r], i));
-		return e;
-	}
-	return n;
-}
-var IntersectSchema = class extends Schema {
-	schemas;
-	get _kind() {
-		return "intersect";
-	}
-	constructor(e) {
-		super(), this.schemas = Object.freeze([...e]);
+	get kind() {
+		return "literal";
 	}
 	_parse(e, t) {
-		let n = {
-			hasOutput: !1,
-			issues: [],
-			output: e
-		};
-		for (let r = 0; r < this.schemas.length; r++) {
-			let i = this.schemas[r]._parseFullSync(e, t);
-			i.issues.length > 0 ? n.issues.push(...i.issues) : n.hasOutput ? n.output = deepMerge(n.output, i.data) : (n.hasOutput = !0, n.output = i.data);
-		}
-		return {
-			data: n.output,
-			issues: n.issues,
-			typeOk: n.issues.length === 0
-		};
-	}
-	async _parseAsync(e, t) {
-		let n = {
-			hasOutput: !1,
-			issues: [],
-			output: e
-		};
-		for (let r = 0; r < this.schemas.length; r++) {
-			let i = await this.schemas[r]._parseFullAsync(e, t);
-			i.issues.length > 0 ? n.issues.push(...i.issues) : n.hasOutput ? n.output = deepMerge(n.output, i.data) : (n.hasOutput = !0, n.output = i.data);
-		}
-		return {
-			data: n.output,
-			issues: n.issues,
-			typeOk: n.issues.length === 0
-		};
+		return e === this.value ? ok(e) : invalid(e, issue(i.invalid_literal, t.messages.literal.expected({ expected: this.value }), { expected: this.value }));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
-			branches: this.schemas.map((e) => e.definition()),
-			kind: "intersect"
+			kind: "literal",
+			value: this.value
 		};
 	}
-}, s = class LazySchema extends Schema {
-	_getter;
-	_resolved;
-	get _kind() {
-		return "lazy";
-	}
+}, EnumSchema = class extends Schema {
+	values;
+	_allowed;
 	constructor(e) {
-		super(), this._getter = e;
+		super(), this.values = Object.freeze([...e]), this._allowed = new Set(e);
 	}
-	_resolve() {
-		return this._resolved ??= this._getter();
+	get kind() {
+		return "enum";
 	}
 	_parse(e, t) {
-		let n = this._resolve()._parseFullSync(e, t);
-		return n.issues.length === 0 ? {
-			data: n.data,
-			issues: [],
-			typeOk: !0
-		} : {
-			data: e,
-			issues: n.issues,
-			typeOk: !0
-		};
+		return this._allowed.has(e) ? ok(e) : invalid(e, issue(i.invalid_enum, t.messages.enum.invalid({ values: this.values }), { values: this.values }));
 	}
-	async _parseAsync(e, t) {
-		let n = await this._resolve()._parseFullAsync(e, t);
-		return n.issues.length === 0 ? {
-			data: n.data,
-			issues: [],
-			typeOk: !0
-		} : {
-			data: e,
-			issues: n.issues,
-			typeOk: !0
-		};
-	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
-			kind: "lazy"
+			kind: "enum",
+			values: this.values
 		};
 	}
-	_construct(e) {
-		let t = new LazySchema(this._getter);
-		return t.state = e, t;
-	}
-}, LiteralSchema = class extends Schema {
-	value;
-	get _kind() {
-		return "literal";
-	}
+}, InstanceOfSchema = class extends Schema {
+	cls;
 	constructor(e) {
-		super((t, n) => t === e ? null : [{
-			code: r.invalid_literal,
-			message: n.messages.literal.expected({ expected: e }),
-			params: { expected: e },
-			path: []
-		}]), this.value = e;
-	}
-	_toDescriptorImpl() {
-		return {
-			...this._describeBase(),
-			kind: "literal",
-			value: this.value
-		};
+		super(), this.cls = e;
 	}
-}, MapSchema = class extends Schema {
-	keySchema;
-	valueSchema;
-	get _kind() {
-		return "map";
-	}
-	constructor(e, t) {
-		super(), this.keySchema = e, this.valueSchema = t;
+	get kind() {
+		return "instanceof";
 	}
 	_parse(e, t) {
-		if (!(e instanceof Map)) return {
-			data: e,
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.map.type(),
-				path: []
-			}],
-			typeOk: !1
-		};
-		let n = /* @__PURE__ */ new Map(), i = [], a = 0;
-		for (let [r, o] of e) {
-			let e = this.keySchema._parseFullSync(r, t), s = this.valueSchema._parseFullSync(o, t);
-			e.issues.length > 0 && i.push(...prependIssuePath(e.issues, a)), s.issues.length > 0 && i.push(...prependIssuePath(s.issues, a)), e.issues.length === 0 && s.issues.length === 0 && n.set(e.data, s.data), a += 1;
-		}
-		return {
-			data: n,
-			issues: i,
-			typeOk: !0
-		};
-	}
-	async _parseAsync(e, t) {
-		if (!(e instanceof Map)) return {
-			data: e,
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.map.type(),
-				path: []
-			}],
-			typeOk: !1
-		};
-		let n = [...e], i = await Promise.all(n.map(([e, n]) => Promise.all([this.keySchema._parseFullAsync(e, t), this.valueSchema._parseFullAsync(n, t)]))), a = [], o = /* @__PURE__ */ new Map();
-		for (let e = 0; e < i.length; e++) {
-			let [t, n] = i[e];
-			t.issues.length > 0 && a.push(...prependIssuePath(t.issues, e)), n.issues.length > 0 && a.push(...prependIssuePath(n.issues, e)), t.issues.length === 0 && n.issues.length === 0 && o.set(t.data, n.data);
-		}
-		return {
-			data: o,
-			issues: a,
-			typeOk: !0
-		};
-	}
-	min(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a.size >= e ? null : fail(r.too_small, resolveMessage(t ?? i.messages.map.min, {
-				min: e,
-				value: a
-			}), { min: e });
-		});
-	}
-	max(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a.size <= e ? null : fail(r.too_big, resolveMessage(t ?? i.messages.map.max, {
-				max: e,
-				value: a
-			}), { max: e });
-		});
-	}
-	size(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a.size === e ? null : fail(r.invalid_length, resolveMessage(t ?? i.messages.map.size, {
-				exact: e,
-				value: a
-			}), { exact: e });
-		});
-	}
-	nonEmpty(e) {
-		return this._addConstraint((t, n) => t.size > 0 ? null : fail(r.too_small, resolveMessage(e ?? n.messages.map.nonEmpty, { min: 1 }), { min: 1 }));
+		return e instanceof this.cls ? ok(e) : invalid(e, issue(i.invalid_type, t.messages.instanceof.type({ className: this.cls.name })));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
-			key: this.keySchema.definition(),
-			kind: "map",
-			value: this.valueSchema.definition()
+			className: this.cls.name,
+			kind: "instanceof"
 		};
 	}
 }, NeverSchema = class extends Schema {
-	get _kind() {
+	get kind() {
 		return "never";
 	}
-	constructor() {
-		super((e, t) => [{
-			code: r.invalid_type,
-			message: t.messages.never.invalid(),
-			path: []
-		}]);
+	_parse(e, t) {
+		return invalid(e, issue(i.invalid_type, t.messages.never.invalid()));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
 			kind: "never"
 		};
 	}
-}, c = class NumberSchema extends Schema {
-	get _kind() {
-		return "number";
+}, o = class ObjectSchema extends Schema {
+	shape;
+	_unknownKeys;
+	_tolerated;
+	constructor(e, t = "strict", n = []) {
+		super(), this.shape = Object.freeze(objectFromEntries(Object.entries(e))), this._unknownKeys = t, this._tolerated = Object.freeze([...new Set(n)]);
 	}
-	constructor() {
-		super((e, t) => typeof e == "number" && !Number.isNaN(e) ? null : fail(r.invalid_type, t.messages.number.type()));
+	get kind() {
+		return "object";
 	}
-	min(e, t) {
-		return this._addConstraint((n, i) => n >= e ? null : fail(r.too_small, resolveMessage(t ?? i.messages.number.min, {
-			min: e,
-			value: n
-		}), { min: e }), (t) => {
-			let n = t;
+	_parse(e, t) {
+		if (typeof e != "object" || !e || Array.isArray(e)) return invalid(e, issue(i.invalid_type, t.messages.object.type()));
+		let n = e, r = Object.keys(this.shape), a = Object.keys(n).filter((e) => !Object.hasOwn(this.shape, e) && !this._tolerated.includes(e));
+		return chain(all(r.map((e) => this.shape[e]._run(n[e], t))), (e) => {
+			let o = [], s = {};
+			if (a.length > 0 && this._unknownKeys === "strict" && o.push(issue(i.invalid_keys, t.messages.object.invalidKeys({ keys: a }), { keys: a })), e.forEach((e, t) => {
+				let i = r[t];
+				e.issues.length > 0 ? o.push(...prefixIssues(e.issues, i)) : (e.value !== void 0 || Object.hasOwn(n, i)) && defineOwnProperty(s, i, e.value);
+			}), this._unknownKeys === "relaxed") for (let e of a) isUnsafeObjectKey(e) || defineOwnProperty(s, e, n[e]);
 			return {
-				...n,
-				minimum: n.minimum === void 0 ? e : Math.max(n.minimum, e)
+				issues: o,
+				typeOk: !0,
+				value: s
 			};
 		});
 	}
-	max(e, t) {
-		return this._addConstraint((n, i) => n <= e ? null : fail(r.too_big, resolveMessage(t ?? i.messages.number.max, {
-			max: e,
-			value: n
-		}), { max: e }), (t) => {
-			let n = t;
-			return {
-				...n,
-				maximum: n.maximum === void 0 ? e : Math.min(n.maximum, e)
-			};
-		});
+	relaxed() {
+		return this._withShape(this.shape, "relaxed");
 	}
-	int(e) {
-		return this._addConstraint((t, n) => Number.isInteger(t) ? null : fail(r.invalid_integer, resolveMessage(e ?? n.messages.number.int, { value: t })), (e) => ({
-			...e,
-			typeHint: "integer"
-		}));
+	strict() {
+		return this._withShape(this.shape, "strict");
 	}
-	positive(e) {
-		return this._addConstraint((t, n) => t > 0 ? null : fail(r.too_small, resolveMessage(e ?? n.messages.number.positive, { value: t }), {
-			exclusive: !0,
-			min: 0
-		}), (e) => {
-			let t = e;
-			return {
-				...t,
-				exclusiveMinimum: t.exclusiveMinimum === void 0 ? 0 : Math.max(t.exclusiveMinimum, 0)
-			};
-		});
+	tolerate(...e) {
+		return this._withShape(this.shape, this._unknownKeys, [...this._tolerated, ...e]);
 	}
-	negative(e) {
-		return this._addConstraint((t, n) => t < 0 ? null : fail(r.too_big, resolveMessage(e ?? n.messages.number.negative, { value: t }), {
-			exclusive: !0,
-			max: 0
-		}), (e) => {
-			let t = e;
-			return {
-				...t,
-				exclusiveMaximum: t.exclusiveMaximum === void 0 ? 0 : Math.min(t.exclusiveMaximum, 0)
-			};
+	extend(e) {
+		return this._derive({
+			...this.shape,
+			...e
 		});
 	}
-	nonNegative(e) {
-		return this._addConstraint((t, n) => t >= 0 ? null : fail(r.too_small, resolveMessage(e ?? n.messages.number.nonNegative, { value: t }), { min: 0 }), (e) => {
-			let t = e;
-			return {
-				...t,
-				minimum: t.minimum === void 0 ? 0 : Math.max(t.minimum, 0)
-			};
-		});
+	pick(...e) {
+		let t = objectFromEntries(Object.entries(this.shape).filter(([t]) => e.includes(t)));
+		return this._derive(t);
 	}
-	nonPositive(e) {
-		return this._addConstraint((t, n) => t <= 0 ? null : fail(r.too_big, resolveMessage(e ?? n.messages.number.nonPositive, { value: t }), { max: 0 }), (e) => {
-			let t = e;
-			return {
-				...t,
-				maximum: t.maximum === void 0 ? 0 : Math.min(t.maximum, 0)
-			};
-		});
+	omit(...e) {
+		let t = objectFromEntries(Object.entries(this.shape).filter(([t]) => !e.includes(t)));
+		return this._derive(t);
 	}
-	multipleOf(e, t) {
-		return this._addConstraint((n, i) => Math.abs(Math.round(n / e) - n / e) < 1e-9 ? null : fail(r.invalid_multiple_of, resolveMessage(t ?? i.messages.number.multipleOf, {
-			step: e,
-			value: n
-		}), { step: e }), (t) => ({
-			...t,
-			multipleOf: e
-		}));
+	partial(...e) {
+		return this._derive(objectFromEntries(Object.entries(this.shape).map(([t, n]) => [t, e.length === 0 || e.includes(t) ? n.optional() : n])));
 	}
-	safe(e) {
-		return this._addConstraint((t, n) => Number.isSafeInteger(t) ? null : fail(r.invalid_safe, resolveMessage(e ?? n.messages.number.safe, { value: t })));
+	keyof() {
+		return new EnumSchema(Object.keys(this.shape));
 	}
-	finite(e) {
-		return this._addConstraint((t, n) => Number.isFinite(t) ? null : fail(r.invalid_finite, resolveMessage(e ?? n.messages.number.finite, { value: t })));
+	_withShape(e, t = this._unknownKeys, n = this._tolerated) {
+		let r = new ObjectSchema(e, t, n);
+		return r.state = this.state, r;
+	}
+	_derive(e) {
+		let { catch: t, default: n, preprocess: r, steps: i } = this.state;
+		if (i.length > 0 || r.length > 0 || t || n) throw new SpellDefinitionError("Cannot derive a new shape from an object schema with checks, transforms, preprocessors, defaults, or catches. Derive the shape first, then add them.");
+		return this._withShape(e);
 	}
-	_toDescriptorImpl() {
-		let e = this._annotations;
+	_describe() {
+		let e = {};
+		for (let [t, n] of Object.entries(this.shape)) defineOwnProperty(e, t, n.definition());
 		return {
 			...this._describeBase(),
-			...e.exclusiveMaximum === void 0 ? {} : { exclusiveMaximum: e.exclusiveMaximum },
-			...e.exclusiveMinimum === void 0 ? {} : { exclusiveMinimum: e.exclusiveMinimum },
-			...e.maximum === void 0 ? {} : { maximum: e.maximum },
-			...e.minimum === void 0 ? {} : { minimum: e.minimum },
-			...e.multipleOf === void 0 ? {} : { multipleOf: e.multipleOf },
-			...e.typeHint === void 0 ? {} : { typeHint: e.typeHint },
-			kind: "number"
+			fields: e,
+			kind: "object",
+			strict: this._unknownKeys === "strict",
+			...this._tolerated.length > 0 && { tolerated: this._tolerated }
 		};
 	}
-	static coerce() {
-		return new NumberSchema().preprocess((e) => {
-			if (typeof e == "number") return e;
-			if (typeof e == "string" || typeof e == "boolean") {
-				let t = Number(e);
-				return Number.isNaN(t) ? e : t;
-			}
-			return e;
-		});
-	}
-}, UnionSchema = class extends Schema {
-	schemas;
-	get _kind() {
-		return "union";
+}, DiscriminatedUnionSchema = class extends Schema {
+	discriminator;
+	branches;
+	constructor(e, t) {
+		super();
+		let n = /* @__PURE__ */ new Map();
+		for (let [r, i] of Object.entries(t)) {
+			if (!(i instanceof o)) throw new SpellDefinitionError(`Branch "${r}" must be an object schema.`);
+			let t = i.shape[e];
+			if (t === void 0) n.set(r, i._withShape({
+				...i.shape,
+				[e]: new LiteralSchema(r)
+			}));
+			else if (t instanceof LiteralSchema && t.value === r) n.set(r, i);
+			else throw new SpellDefinitionError(`Branch "${r}" declares a "${e}" field that does not match its discriminator value.`);
+		}
+		this.discriminator = e, this.branches = n;
 	}
-	constructor(e) {
-		super(), this.schemas = Object.freeze([...e]);
+	get kind() {
+		return "discriminatedUnion";
 	}
 	_parse(e, t) {
-		let n = [];
-		for (let r of this.schemas) {
-			let i = r._parseFullSync(e, t);
-			if (i.issues.length === 0) return {
-				data: i.data,
-				issues: [],
-				typeOk: !0
-			};
-			n.push(i.issues);
+		let { messages: n } = t;
+		if (typeof e != "object" || !e || Array.isArray(e)) return invalid(e, issue(i.invalid_type, n.discriminatedUnion.type()));
+		let r = e[this.discriminator], a = typeof r == "string" ? this.branches.get(r) : void 0;
+		if (!a) {
+			let t = [...this.branches.keys()];
+			return invalid(e, issue(i.invalid_discriminator, n.discriminatedUnion.invalidDiscriminator({
+				discriminator: this.discriminator,
+				expected: t
+			}), {
+				discriminator: this.discriminator,
+				expected: t
+			}));
 		}
-		return {
-			data: e,
-			issues: [{
-				code: r.invalid_union,
-				message: t.messages.union.invalid(),
-				params: { errors: n },
-				path: []
-			}],
-			typeOk: !1
-		};
+		return chain(a._run(e, t), (t) => t.issues.length === 0 ? ok(t.value) : invalid(e, ...t.issues));
 	}
-	async _parseAsync(e, t) {
-		let n = [];
-		for (let r of this.schemas) {
-			let i = await r._parseFullAsync(e, t);
-			if (i.issues.length === 0) return {
-				data: i.data,
-				issues: [],
-				typeOk: !0
-			};
-			n.push(i.issues);
-		}
+	_describe() {
+		let e = {};
+		for (let [t, n] of this.branches) defineOwnProperty(e, t, n.definition());
 		return {
-			data: e,
-			issues: [{
-				code: r.invalid_union,
-				message: t.messages.union.invalid(),
-				params: { errors: n },
-				path: []
-			}],
-			typeOk: !1
+			...this._describeBase(),
+			branches: e,
+			discriminator: this.discriminator,
+			kind: "discriminatedUnion"
 		};
 	}
-	_toDescriptorImpl() {
+};
+// src/schemas/intersect.ts
+function deepMerge(t, n) {
+	if (!e(t) || !e(n)) return n;
+	let r = objectFromEntries(Object.entries(t));
+	for (let [e, i] of Object.entries(n)) defineOwnProperty(r, e, deepMerge(t[e], i));
+	return r;
+}
+var IntersectSchema = class extends Schema {
+	schemas;
+	constructor(e) {
+		super(), this.schemas = Object.freeze([...e]);
+	}
+	get kind() {
+		return "intersect";
+	}
+	_parse(e, t) {
+		return chain(all(this.schemas.map((n) => n._run(e, t))), (t) => {
+			let n = t.flatMap((e) => e.issues);
+			return n.length > 0 ? invalid(e, ...n) : ok(t.map((e) => e.value).reduce(deepMerge));
+		});
+	}
+	_describe() {
 		return {
 			...this._describeBase(),
 			branches: this.schemas.map((e) => e.definition()),
-			kind: "union"
+			kind: "intersect"
 		};
 	}
-}, l = class ObjectSchema extends Schema {
-	shape;
-	_isRelaxed;
-	get _kind() {
-		return "object";
+}, LazySchema = class extends Schema {
+	_getter;
+	_resolved;
+	constructor(e) {
+		super(), this._getter = e;
 	}
-	constructor(e, t = !1) {
-		super(), this.shape = Object.freeze(objectFromEntries(Object.entries(e))), this._isRelaxed = t;
-	}
-	_unknownKeys(e) {
-		return Object.keys(e).filter((e) => !Object.hasOwn(this.shape, e));
-	}
-	_strictUnknownKeyIssues(e, t) {
-		if (this._isRelaxed) return [];
-		let n = this._unknownKeys(e);
-		return n.length === 0 ? [] : [{
-			code: r.invalid_keys,
-			message: t.messages.object.invalidKeys({ keys: n }),
-			params: { keys: n },
-			path: []
-		}];
-	}
-	_copyRelaxedUnknownKeys(e, t) {
-		if (this._isRelaxed) for (let n of this._unknownKeys(e)) isUnsafeObjectKey(n) || defineOwnProperty(t, n, e[n]);
-	}
-	_guardObjectInput(e, t) {
-		return typeof e != "object" || !e || Array.isArray(e) ? {
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.object.type(),
-				path: []
-			}],
-			ok: !1
-		} : {
-			obj: e,
-			ok: !0
-		};
+	get kind() {
+		return "lazy";
 	}
-	_createObjectParseContext(e, t) {
+	_parse(e, t) {
+		return this._resolved ??= this._getter(), chain(this._resolved._run(e, t), (t) => t.issues.length === 0 ? ok(t.value) : invalid(e, ...t.issues));
+	}
+	_describe() {
 		return {
-			issues: [...this._strictUnknownKeyIssues(e, t)],
-			output: {}
+			...this._describeBase(),
+			kind: "lazy"
 		};
 	}
-	_rebuildWith(e, t = this._isRelaxed) {
-		return this._copyStateTo(new ObjectSchema(e, t));
+}, MapSchema = class extends Schema {
+	keySchema;
+	valueSchema;
+	constructor(e, t) {
+		super(), this.keySchema = e, this.valueSchema = t;
+	}
+	get kind() {
+		return "map";
 	}
 	_parse(e, t) {
-		let n = this._guardObjectInput(e, t);
-		if (!n.ok) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let { obj: r } = n, { issues: i, output: a } = this._createObjectParseContext(r, t);
-		for (let e of Object.keys(this.shape)) {
-			let n = this.shape[e]._parseFullSync(r[e], t);
-			n.issues.length === 0 ? defineOwnProperty(a, e, n.data) : i.push(...prependIssuePath(n.issues, e));
-		}
-		return this._copyRelaxedUnknownKeys(r, a), {
-			data: a,
-			issues: i,
-			typeOk: !0
-		};
+		return e instanceof Map ? chain(all([...e].map(([e, n]) => all([this.keySchema._run(e, t), this.valueSchema._run(n, t)]))), (e) => {
+			let t = [], n = /* @__PURE__ */ new Map();
+			return e.forEach(([e, r], i) => {
+				t.push(...prefixIssues(e.issues, i), ...prefixIssues(r.issues, i)), e.issues.length === 0 && r.issues.length === 0 && n.set(e.value, r.value);
+			}), {
+				issues: t,
+				typeOk: !0,
+				value: n
+			};
+		}) : invalid(e, issue(i.invalid_type, t.messages.map.type()));
 	}
-	async _parseAsync(e, t) {
-		let n = this._guardObjectInput(e, t);
-		if (!n.ok) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let { obj: r } = n, { issues: i, output: a } = this._createObjectParseContext(r, t), o = Object.keys(this.shape), s = await Promise.all(o.map((e) => this.shape[e]._parseFullAsync(r[e], t)));
-		for (let e = 0; e < o.length; e++) {
-			let t = o[e], n = s[e];
-			n.issues.length === 0 ? defineOwnProperty(a, t, n.data) : i.push(...prependIssuePath(n.issues, t));
-		}
-		return this._copyRelaxedUnknownKeys(r, a), {
-			data: a,
-			issues: i,
-			typeOk: !0
-		};
+	min(e, t) {
+		return this._refine((t) => t.size >= e, (n, r) => issue(i.too_small, resolveMessage(t ?? r.map.min, {
+			min: e,
+			value: n
+		}), { min: e }), (t) => ({ minSize: atLeast(t.minSize, e) }));
 	}
-	partial(...e) {
-		let t = e.length > 0 ? new Set(e) : null;
-		return this._rebuildWith(objectFromEntries(Object.entries(this.shape).map(([e, n]) => [e, t === null || t.has(e) ? n.optional() : n])), this._isRelaxed);
+	max(e, t) {
+		return this._refine((t) => t.size <= e, (n, r) => issue(i.too_big, resolveMessage(t ?? r.map.max, {
+			max: e,
+			value: n
+		}), { max: e }), (t) => ({ maxSize: atMost(t.maxSize, e) }));
 	}
-	optional() {
-		return super.optional();
+	size(e, t) {
+		return this._refine((t) => t.size === e, (n, r) => issue(i.invalid_length, resolveMessage(t ?? r.map.size, {
+			exact: e,
+			value: n
+		}), { exact: e }), (t) => ({
+			maxSize: atMost(t.maxSize, e),
+			minSize: atLeast(t.minSize, e)
+		}));
 	}
-	nullable() {
-		return super.nullable();
+	nonEmpty(e) {
+		return this._refine((e) => e.size > 0, (t, n) => issue(i.too_small, resolveMessage(e ?? n.map.nonEmpty, { value: t }), { min: 1 }), (e) => ({ minSize: atLeast(e.minSize, 1) }));
 	}
-	nullish() {
-		return super.nullish();
+	_describe() {
+		return {
+			...this._describeBase(),
+			...this.state.meta,
+			key: this.keySchema.definition(),
+			kind: "map",
+			value: this.valueSchema.definition()
+		};
 	}
-	required() {
-		return this._rebuildWith(objectFromEntries(Object.entries(this.shape).map(([e, t]) => [e, t.required()])), this._isRelaxed);
+}, NumberSchema = class extends Schema {
+	get kind() {
+		return "number";
 	}
-	extend(e) {
-		return this._rebuildWith(objectFromEntries([...Object.entries(this.shape), ...Object.entries(e)]), this._isRelaxed);
+	_parse(e, t) {
+		return typeof e == "number" && !Number.isNaN(e) ? ok(e) : invalid(e, issue(i.invalid_type, t.messages.number.type()));
 	}
-	pick(...e) {
-		let t = new Set(e);
-		return this._rebuildWith(objectFromEntries(Object.entries(this.shape).filter(([e]) => t.has(e))));
+	min(e, t) {
+		return this._refine((t) => t >= e, (n, r) => issue(i.too_small, resolveMessage(t ?? r.number.min, {
+			min: e,
+			value: n
+		}), { min: e }), (t) => ({ minimum: atLeast(t.minimum, e) }));
 	}
-	omit(...e) {
-		let t = new Set(e);
-		return this._rebuildWith(objectFromEntries(Object.entries(this.shape).filter(([e]) => !t.has(e))));
+	max(e, t) {
+		return this._refine((t) => t <= e, (n, r) => issue(i.too_big, resolveMessage(t ?? r.number.max, {
+			max: e,
+			value: n
+		}), { max: e }), (t) => ({ maximum: atMost(t.maximum, e) }));
 	}
-	defaults() {
-		return this.parse({});
+	positive(e) {
+		return this._refine((e) => e > 0, (t, n) => issue(i.too_small, resolveMessage(e ?? n.number.positive, { value: t }), {
+			exclusive: !0,
+			min: 0
+		}), (e) => ({ exclusiveMinimum: atLeast(e.exclusiveMinimum, 0) }));
 	}
-	partialDefaults() {
-		let e = {};
-		for (let t of Object.keys(this.shape)) {
-			let n = this.shape[t]._parseFullSync(void 0);
-			n.issues.length === 0 && defineOwnProperty(e, t, n.data);
-		}
-		return e;
+	negative(e) {
+		return this._refine((e) => e < 0, (t, n) => issue(i.too_big, resolveMessage(e ?? n.number.negative, { value: t }), {
+			exclusive: !0,
+			max: 0
+		}), (e) => ({ exclusiveMaximum: atMost(e.exclusiveMaximum, 0) }));
 	}
-	requiredFields() {
-		return Object.keys(this.shape).filter((e) => !this.shape[e].isOptional);
+	nonNegative(e) {
+		return this._refine((e) => e >= 0, (t, n) => issue(i.too_small, resolveMessage(e ?? n.number.nonNegative, { value: t }), { min: 0 }), (e) => ({ minimum: atLeast(e.minimum, 0) }));
 	}
-	optionalFields() {
-		return Object.keys(this.shape).filter((e) => this.shape[e].isOptional);
+	nonPositive(e) {
+		return this._refine((e) => e <= 0, (t, n) => issue(i.too_big, resolveMessage(e ?? n.number.nonPositive, { value: t }), { max: 0 }), (e) => ({ maximum: atMost(e.maximum, 0) }));
 	}
-	relaxed() {
-		return this._rebuildWith(this.shape, !0);
+	int(e) {
+		return this._refine(Number.isInteger, (t, n) => issue(i.invalid_integer, resolveMessage(e ?? n.number.int, { value: t })), () => ({ integer: !0 }));
 	}
-	strict() {
-		return this._rebuildWith(this.shape, !1);
+	safe(e) {
+		return this._refine(Number.isSafeInteger, (t, n) => issue(i.invalid_safe, resolveMessage(e ?? n.number.safe, { value: t })), (e) => ({
+			integer: !0,
+			maximum: atMost(e.maximum, 2 ** 53 - 1),
+			minimum: atLeast(e.minimum, -(2 ** 53 - 1))
+		}));
 	}
-	keyof() {
-		return new UnionSchema(Object.keys(this.shape).map((e) => new LiteralSchema(e)));
+	finite(e) {
+		return this._refine(Number.isFinite, (t, n) => issue(i.invalid_finite, resolveMessage(e ?? n.number.finite, { value: t })), () => ({ finite: !0 }));
 	}
-	_toDescriptorImpl() {
-		let e = {};
-		for (let [t, n] of Object.entries(this.shape)) defineOwnProperty(e, t, n.definition());
+	multipleOf(e, t) {
+		return this._refine((t) => Math.abs(Math.round(t / e) - t / e) < 1e-9, (n, r) => issue(i.invalid_multiple_of, resolveMessage(t ?? r.number.multipleOf, {
+			step: e,
+			value: n
+		}), { step: e }), () => ({ multipleOf: e }));
+	}
+	_describe() {
 		return {
 			...this._describeBase(),
-			fields: e,
-			kind: "object",
-			strict: !this._isRelaxed
+			...this.state.meta,
+			kind: "number"
 		};
 	}
-	merge(e) {
-		return this._rebuildWith(objectFromEntries([...Object.entries(this.shape), ...Object.entries(e.shape)]), e._isRelaxed);
-	}
-};
-// src/schemas/raw-or.ts
-function normalizeToSchemas(e) {
-	return e.map((e) => e instanceof Schema ? e : new LiteralSchema(e));
-}
-// src/schemas/record.ts
-var RecordSchema = class extends Schema {
+}, RecordSchema = class extends Schema {
 	keySchema;
 	valueSchema;
-	get _kind() {
-		return "record";
-	}
 	constructor(e, t) {
 		super(), this.keySchema = e, this.valueSchema = t;
 	}
-	_guardRecordInput(e, t) {
-		return typeof e != "object" || !e || Array.isArray(e) ? {
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.object.type(),
-				path: []
-			}],
-			ok: !1
-		} : {
-			ok: !0,
-			value: e
-		};
-	}
-	_parseRecordEntries(e, t) {
-		let n = [], r = {};
-		for (let i of Object.keys(e)) {
-			let a = this.keySchema._parseFullSync(i, t);
-			if (a.issues.length > 0) {
-				n.push(...prependIssuePath(a.issues, i));
-				continue;
-			}
-			let o = a.data;
-			if (isUnsafeObjectKey(o)) continue;
-			let s = this.valueSchema._parseFullSync(e[i], t);
-			s.issues.length === 0 ? defineOwnProperty(r, o, s.data) : n.push(...prependIssuePath(s.issues, i));
-		}
-		return {
-			issues: n,
-			output: r
-		};
+	get kind() {
+		return "record";
 	}
 	_parse(e, t) {
-		let n = this._guardRecordInput(e, t);
-		if (!n.ok) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let { issues: r, output: i } = this._parseRecordEntries(n.value, t);
-		return {
-			data: i,
-			issues: r,
-			typeOk: !0
-		};
-	}
-	async _parseAsync(e, t) {
-		let n = this._guardRecordInput(e, t);
-		if (!n.ok) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let r = n.value, i = Object.keys(r), a = await Promise.all(i.map((e) => Promise.all([this.keySchema._parseFullAsync(e, t), this.valueSchema._parseFullAsync(r[e], t)]))), o = [], s = {};
-		for (let e = 0; e < i.length; e++) {
-			let t = i[e], [n, r] = a[e];
-			if (n.issues.length > 0) {
-				o.push(...prependIssuePath(n.issues, t));
-				continue;
-			}
-			let c = n.data;
-			isUnsafeObjectKey(c) || (r.issues.length === 0 ? defineOwnProperty(s, c, r.data) : o.push(...prependIssuePath(r.issues, t)));
-		}
-		return {
-			data: s,
-			issues: o,
-			typeOk: !0
-		};
+		if (typeof e != "object" || !e || Array.isArray(e)) return invalid(e, issue(i.invalid_type, t.messages.object.type()));
+		let n = e, r = Object.keys(n);
+		return chain(all(r.map((e) => all([this.keySchema._run(e, t), this.valueSchema._run(n[e], t)]))), (e) => {
+			let t = [], n = {};
+			return e.forEach(([e, i], a) => {
+				let o = r[a];
+				if (e.issues.length > 0) {
+					t.push(...prefixIssues(e.issues, o));
+					return;
+				}
+				if (i.issues.length > 0) {
+					t.push(...prefixIssues(i.issues, o));
+					return;
+				}
+				let s = String(e.value);
+				isUnsafeObjectKey(s) || defineOwnProperty(n, s, i.value);
+			}), {
+				issues: t,
+				typeOk: !0,
+				value: n
+			};
+		});
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
 			key: this.keySchema.definition(),
@@ -1606,105 +1061,72 @@ var RecordSchema = class extends Schema {
 	}
 }, SetSchema = class extends Schema {
 	itemSchema;
-	get _kind() {
-		return "set";
-	}
 	constructor(e) {
 		super(), this.itemSchema = e;
 	}
-	_parse(e, t) {
-		if (!(e instanceof Set)) return {
-			data: e,
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.set.type(),
-				path: []
-			}],
-			typeOk: !1
-		};
-		let n = [], i = /* @__PURE__ */ new Set(), a = 0;
-		for (let r of e) {
-			let e = this.itemSchema._parseFullSync(r, t);
-			e.issues.length === 0 ? i.add(e.data) : n.push(...prependIssuePath(e.issues, a)), a += 1;
-		}
-		return {
-			data: i,
-			issues: n,
-			typeOk: !0
-		};
+	get kind() {
+		return "set";
 	}
-	async _parseAsync(e, t) {
-		if (!(e instanceof Set)) return {
-			data: e,
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.set.type(),
-				path: []
-			}],
-			typeOk: !1
-		};
-		let n = [...e], i = await Promise.all(n.map((e) => this.itemSchema._parseFullAsync(e, t))), a = [], o = /* @__PURE__ */ new Set();
-		for (let e = 0; e < i.length; e++) {
-			let t = i[e];
-			t.issues.length === 0 ? o.add(t.data) : a.push(...prependIssuePath(t.issues, e));
-		}
-		return {
-			data: o,
-			issues: a,
-			typeOk: !0
-		};
+	_parse(e, t) {
+		return e instanceof Set ? chain(all([...e].map((e) => this.itemSchema._run(e, t))), (e) => {
+			let t = [], n = /* @__PURE__ */ new Set();
+			return e.forEach((e, r) => {
+				e.issues.length === 0 ? n.add(e.value) : t.push(...prefixIssues(e.issues, r));
+			}), {
+				issues: t,
+				typeOk: !0,
+				value: n
+			};
+		}) : invalid(e, issue(i.invalid_type, t.messages.set.type()));
 	}
 	min(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a.size >= e ? null : fail(r.too_small, resolveMessage(t ?? i.messages.set.min, {
-				min: e,
-				value: a
-			}), { min: e });
-		});
+		return this._refine((t) => t.size >= e, (n, r) => issue(i.too_small, resolveMessage(t ?? r.set.min, {
+			min: e,
+			value: n
+		}), { min: e }), (t) => ({ minSize: atLeast(t.minSize, e) }));
 	}
 	max(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a.size <= e ? null : fail(r.too_big, resolveMessage(t ?? i.messages.set.max, {
-				max: e,
-				value: a
-			}), { max: e });
-		});
+		return this._refine((t) => t.size <= e, (n, r) => issue(i.too_big, resolveMessage(t ?? r.set.max, {
+			max: e,
+			value: n
+		}), { max: e }), (t) => ({ maxSize: atMost(t.maxSize, e) }));
 	}
 	size(e, t) {
-		return this._addConstraint((n, i) => {
-			let a = n;
-			return a.size === e ? null : fail(r.invalid_length, resolveMessage(t ?? i.messages.set.size, {
-				exact: e,
-				value: a
-			}), { exact: e });
-		});
+		return this._refine((t) => t.size === e, (n, r) => issue(i.invalid_length, resolveMessage(t ?? r.set.size, {
+			exact: e,
+			value: n
+		}), { exact: e }), (t) => ({
+			maxSize: atMost(t.maxSize, e),
+			minSize: atLeast(t.minSize, e)
+		}));
 	}
 	nonEmpty(e) {
-		return this._addConstraint((t, n) => t.size > 0 ? null : fail(r.too_small, resolveMessage(e ?? n.messages.set.nonEmpty, { min: 1 }), { min: 1 }));
+		return this._refine((e) => e.size > 0, (t, n) => issue(i.too_small, resolveMessage(e ?? n.set.nonEmpty, { value: t }), { min: 1 }), (e) => ({ minSize: atLeast(e.minSize, 1) }));
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
+			...this.state.meta,
 			items: this.itemSchema.definition(),
 			kind: "set"
 		};
 	}
 };
-// src/formats.ts
-function isEmail(e) {
-	return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(e);
-}
-var u = /* @__PURE__ */ new Set(["http", "https"]);
-function isUrl(e, t) {
+// src/predicates.ts
+function parseUrl(e) {
 	try {
-		let n = new URL(e);
-		return (t ? new Set(t.map((e) => e.toLowerCase())) : u).has(n.protocol.replace(":", "").toLowerCase());
+		return new URL(e);
 	} catch {
-		return !1;
+		return null;
 	}
 }
+function isEmail(e) {
+	return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(e);
+}
+function isUrl(e, t = ["http", "https"]) {
+	let n = parseUrl(e)?.protocol.slice(0, -1).toLowerCase();
+	return n !== void 0 && t.some((e) => e.toLowerCase() === n);
+}
 function isUuid(e) {
 	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(e);
 }
@@ -1717,15 +1139,7 @@ function isIsoDateTime(e) {
 	return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})?$/.test(e) && !Number.isNaN(new Date(e).getTime());
 }
 function isIp(e) {
-	if (/^(\d{1,3}\.){3}\d{1,3}$/.test(e)) return e.split(".").every((e) => {
-		let t = parseInt(e, 10);
-		return t >= 0 && t <= 255;
-	});
-	try {
-		return new URL(`http://[${e}]/`), !0;
-	} catch {
-		return !1;
-	}
+	return /^(\d{1,3}\.){3}\d{1,3}$/.test(e) ? e.split(".").every((e) => Number(e) <= 255) : /^[0-9A-Fa-f:.]+$/.test(e) && parseUrl(`http://[${e}]/`) !== null;
 }
 function isCuid(e) {
 	return /^c[a-z0-9]{8,}$/.test(e);
@@ -1773,453 +1187,280 @@ function isNumeric(e) {
 	return /^[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?$/i.test(e);
 }
 // src/schemas/string.ts
-var d = class StringSchema extends Schema {
-	get _kind() {
+var escapeRegExp = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), StringSchema = class extends Schema {
+	get kind() {
 		return "string";
 	}
-	constructor() {
-		super((e, t) => typeof e == "string" ? null : fail(r.invalid_type, t.messages.string.type()));
+	_parse(e, t) {
+		return typeof e == "string" ? ok(e) : invalid(e, issue(i.invalid_type, t.messages.string.type()));
+	}
+	_format(e, t, n, r) {
+		return this._refine(t, (t, r) => issue(i.invalid_format, resolveMessage(n ?? r.string[e], { value: t }), { format: e }), (t) => ({
+			...r?.(t),
+			formats: [...t.formats ?? [], e]
+		}));
+	}
+	_pattern(e, t, n) {
+		return this._refine(e, n, (e) => ({ patterns: [...e.patterns ?? [], t] }));
 	}
 	min(e, t) {
-		return this._addConstraint((n, i) => n.length >= e ? null : fail(r.too_small, resolveMessage(t ?? i.messages.string.min, {
+		return this._refine((t) => t.length >= e, (n, r) => issue(i.too_small, resolveMessage(t ?? r.string.min, {
 			min: e,
 			value: n
-		}), { min: e }), (t) => {
-			let n = t;
-			return {
-				...n,
-				minLength: n.minLength === void 0 ? e : Math.max(n.minLength, e)
-			};
-		});
+		}), { min: e }), (t) => ({ minLength: atLeast(t.minLength, e) }));
 	}
 	max(e, t) {
-		return this._addConstraint((n, i) => n.length <= e ? null : fail(r.too_big, resolveMessage(t ?? i.messages.string.max, {
+		return this._refine((t) => t.length <= e, (n, r) => issue(i.too_big, resolveMessage(t ?? r.string.max, {
 			max: e,
 			value: n
-		}), { max: e }), (t) => {
-			let n = t;
-			return {
-				...n,
-				maxLength: n.maxLength === void 0 ? e : Math.min(n.maxLength, e)
-			};
-		});
+		}), { max: e }), (t) => ({ maxLength: atMost(t.maxLength, e) }));
 	}
 	length(e, t) {
-		return this._addConstraint((n, i) => n.length === e ? null : fail(r.invalid_length, resolveMessage(t ?? i.messages.string.length, {
+		return this._refine((t) => t.length === e, (n, r) => issue(i.invalid_length, resolveMessage(t ?? r.string.length, {
 			exact: e,
 			value: n
 		}), { exact: e }), (t) => ({
-			...t,
-			maxLength: e,
-			minLength: e
+			maxLength: atMost(t.maxLength, e),
+			minLength: atLeast(t.minLength, e)
 		}));
 	}
 	nonEmpty(e) {
-		return this._addConstraint((t, n) => t.length > 0 ? null : fail(r.too_small, resolveMessage(e ?? n.messages.string.nonEmpty, {
-			min: 1,
-			value: t
-		}), { min: 1 }), (e) => {
-			let t = e;
-			return {
-				...t,
-				minLength: Math.max(t.minLength ?? 0, 1)
-			};
-		});
+		return this._refine((e) => e.length > 0, (t, n) => issue(i.too_small, resolveMessage(e ?? n.string.nonEmpty, { value: t }), { min: 1 }), (e) => ({ minLength: atLeast(e.minLength, 1) }));
 	}
 	startsWith(e, t) {
-		return this._addConstraint((n, i) => n.startsWith(e) ? null : fail(r.invalid_string, resolveMessage(t ?? i.messages.string.startsWith, {
+		return this._pattern((t) => t.startsWith(e), {
+			flags: "",
+			source: `^${escapeRegExp(e)}`
+		}, (n, r) => issue(i.invalid_format, resolveMessage(t ?? r.string.startsWith, {
 			prefix: e,
 			value: n
-		}), { prefix: e }));
+		}), {
+			format: "startsWith",
+			prefix: e
+		}));
 	}
 	endsWith(e, t) {
-		return this._addConstraint((n, i) => n.endsWith(e) ? null : fail(r.invalid_string, resolveMessage(t ?? i.messages.string.endsWith, {
+		return this._pattern((t) => t.endsWith(e), {
+			flags: "",
+			source: `${escapeRegExp(e)}$`
+		}, (n, r) => issue(i.invalid_format, resolveMessage(t ?? r.string.endsWith, {
 			suffix: e,
 			value: n
-		}), { suffix: e }));
+		}), {
+			format: "endsWith",
+			suffix: e
+		}));
 	}
 	includes(e, t) {
-		return this._addConstraint((n, i) => n.includes(e) ? null : fail(r.invalid_string, resolveMessage(t ?? i.messages.string.includes, {
+		return this._pattern((t) => t.includes(e), {
+			flags: "",
+			source: escapeRegExp(e)
+		}, (n, r) => issue(i.invalid_format, resolveMessage(t ?? r.string.includes, {
 			substr: e,
 			value: n
-		}), { includes: e }));
+		}), {
+			format: "includes",
+			includes: e
+		}));
 	}
 	regex(e, t) {
 		let n = new RegExp(e.source, e.flags.replace(/[gy]/g, ""));
-		return this._addConstraint((e, i) => n.test(e) ? null : fail(r.invalid_string, resolveMessage(t ?? i.messages.string.regex, { value: e }), { pattern: n.source }), (e) => {
-			let t = e;
-			return t.pattern === null ? t : t.pattern === void 0 ? {
-				...t,
-				pattern: n.source
-			} : t.pattern === n.source ? t : {
-				...t,
-				pattern: null
-			};
-		});
+		return this._pattern((e) => n.test(e), {
+			flags: n.flags,
+			source: n.source
+		}, (e, r) => issue(i.invalid_format, resolveMessage(t ?? r.string.regex, { value: e }), {
+			format: "regex",
+			pattern: n.source
+		}));
 	}
 	email(e) {
-		return this._addConstraint((t, n) => isEmail(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.email, { value: t }), { format: "email" }), (e) => ({
-			...e,
-			format: "email"
-		}));
+		return this._format("email", isEmail, e);
 	}
 	url(e = {}) {
-		let { message: t, protocols: n = ["http", "https"] } = e;
-		return this._addConstraint((e, i) => isUrl(e, n) ? null : fail(r.invalid_url, resolveMessage(t ?? i.messages.string.url, { value: e }), { format: "url" }), (e) => ({
-			...e,
-			format: "uri"
-		}));
+		let { message: t, protocols: n = ["http", "https"] } = e, r = {
+			flags: "i",
+			source: `^(?:${n.map(escapeRegExp).join("|")}):`
+		};
+		return this._format("url", (e) => isUrl(e, n), t, (e) => ({ patterns: [...e.patterns ?? [], r] }));
 	}
 	uuid(e) {
-		return this._addConstraint((t, n) => isUuid(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.uuid, { value: t }), { format: "uuid" }), (e) => ({
-			...e,
-			format: "uuid"
-		}));
+		return this._format("uuid", isUuid, e);
 	}
 	isoDate(e) {
-		return this._addConstraint((t, n) => isIsoDate(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.date, { value: t }), { format: "iso-date" }), (e) => ({
-			...e,
-			format: "date"
-		}));
+		return this._format("isoDate", isIsoDate, e);
 	}
 	isoDateTime(e) {
-		return this._addConstraint((t, n) => isIsoDateTime(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.dateTime, { value: t }), { format: "iso-datetime" }), (e) => ({
-			...e,
-			format: "date-time"
-		}));
+		return this._format("isoDateTime", isIsoDateTime, e);
+	}
+	time(e) {
+		return this._format("time", isTime, e);
+	}
+	duration(e) {
+		return this._format("duration", isDuration, e);
 	}
 	ip(e) {
-		return this._addConstraint((t, n) => isIp(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.ip, { value: t }), { format: "ip" }));
+		return this._format("ip", isIp, e);
 	}
 	cuid(e) {
-		return this._addConstraint((t, n) => isCuid(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.cuid, { value: t }), { format: "cuid" }));
+		return this._format("cuid", isCuid, e);
 	}
 	cuid2(e) {
-		return this._addConstraint((t, n) => isCuid2(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.cuid2, { value: t }), { format: "cuid2" }));
+		return this._format("cuid2", isCuid2, e);
 	}
 	ulid(e) {
-		return this._addConstraint((t, n) => isUlid(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.ulid, { value: t }), { format: "ulid" }));
+		return this._format("ulid", isUlid, e);
 	}
-	nanoid(e, t) {
-		return this._addConstraint((n, i) => isNanoid(n, e) ? null : fail(r.invalid_string, resolveMessage(t ?? i.messages.string.nanoid, { value: n }), { format: "nanoid" }));
+	nanoid(e = 21, t) {
+		return this._format("nanoid", (t) => isNanoid(t, e), t, (t) => ({
+			maxLength: atMost(t.maxLength, e),
+			minLength: atLeast(t.minLength, e)
+		}));
 	}
 	base64(e) {
-		return this._addConstraint((t, n) => isBase64(t) ? null : fail(r.invalid_base64, resolveMessage(e ?? n.messages.string.base64, { value: t }), { format: "base64" }), (e) => ({
-			...e,
-			contentEncoding: "base64"
-		}));
+		return this._format("base64", isBase64, e);
 	}
 	base64url(e) {
-		return this._addConstraint((t, n) => isBase64url(t) ? null : fail(r.invalid_base64, resolveMessage(e ?? n.messages.string.base64url, { value: t }), { format: "base64url" }));
+		return this._format("base64url", isBase64url, e);
 	}
 	hex(e) {
-		return this._addConstraint((t, n) => isHex(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.hex, { value: t }), { format: "hex" }));
+		return this._format("hex", isHex, e);
 	}
 	hexColor(e) {
-		return this._addConstraint((t, n) => isHexColor(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.hexColor, { value: t }), { format: "hex-color" }));
+		return this._format("hexColor", isHexColor, e);
 	}
 	emoji(e) {
-		return this._addConstraint((t, n) => isEmoji(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.emoji, { value: t }), { format: "emoji" }));
+		return this._format("emoji", isEmoji, e);
 	}
 	jwt(e) {
-		return this._addConstraint((t, n) => isJwt(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.jwt, { value: t }), { format: "jwt" }));
-	}
-	time(e) {
-		return this._addConstraint((t, n) => isTime(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.time, { value: t }), { format: "time" }));
-	}
-	duration(e) {
-		return this._addConstraint((t, n) => isDuration(t) ? null : fail(r.invalid_duration, resolveMessage(e ?? n.messages.string.duration, { value: t }), { format: "duration" }), (e) => ({
-			...e,
-			format: "duration"
-		}));
+		return this._format("jwt", isJwt, e);
 	}
 	semver(e) {
-		return this._addConstraint((t, n) => isSemver(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.semver, { value: t }), { format: "semver" }));
+		return this._format("semver", isSemver, e);
 	}
 	slug(e) {
-		return this._addConstraint((t, n) => isSlug(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.slug, { value: t }), { format: "slug" }));
+		return this._format("slug", isSlug, e);
 	}
 	numeric(e) {
-		return this._addConstraint((t, n) => isNumeric(t) ? null : fail(r.invalid_string, resolveMessage(e ?? n.messages.string.numeric, { value: t }), { format: "numeric" }));
+		return this._format("numeric", isNumeric, e);
 	}
 	trim() {
-		return this.preprocess((e) => typeof e == "string" ? e.trim() : e);
+		return this.transform((e) => e.trim());
 	}
 	lowercase() {
-		return this.preprocess((e) => typeof e == "string" ? e.toLowerCase() : e);
+		return this.transform((e) => e.toLowerCase());
 	}
 	uppercase() {
-		return this.preprocess((e) => typeof e == "string" ? e.toUpperCase() : e);
+		return this.transform((e) => e.toUpperCase());
 	}
-	_toDescriptorImpl() {
-		let e = this._annotations;
+	_describe() {
 		return {
 			...this._describeBase(),
-			...e.contentEncoding === void 0 ? {} : { contentEncoding: e.contentEncoding },
-			...e.format === void 0 ? {} : { format: e.format },
-			...e.maxLength === void 0 ? {} : { maxLength: e.maxLength },
-			...e.minLength === void 0 ? {} : { minLength: e.minLength },
-			...e.pattern === void 0 ? {} : { pattern: e.pattern },
+			...this.state.meta,
 			kind: "string"
 		};
 	}
-	static coerce() {
-		return new StringSchema().preprocess((e) => e == null ? e : String(e));
-	}
-}, f = class TupleSchema extends Schema {
+}, s = class TupleSchema extends Schema {
 	items;
 	restSchema;
-	get _kind() {
-		return "tuple";
-	}
 	constructor(e, t = null) {
-		super(), this.items = e, this.restSchema = t;
+		super(), this.items = Object.freeze([...e]), this.restSchema = t;
+	}
+	get kind() {
+		return "tuple";
 	}
 	rest(e) {
-		return this._copyStateTo(new TupleSchema(this.items, e));
-	}
-	_guardTupleInput(e, t) {
-		return this.restSchema === null && e.length !== this.items.length ? {
-			issues: [{
-				code: r.invalid_length,
-				message: t.messages.tuple.length({ exact: this.items.length }),
-				params: { exact: this.items.length },
-				path: []
-			}],
-			ok: !1
-		} : this.restSchema !== null && e.length < this.items.length ? {
-			issues: [{
-				code: r.too_small,
-				message: t.messages.tuple.min({ min: this.items.length }),
-				params: { min: this.items.length },
-				path: []
-			}],
-			ok: !1
-		} : {
-			ok: !0,
-			value: e
-		};
+		let t = new TupleSchema(this.items, e);
+		return t.state = this.state, t;
 	}
 	_parse(e, t) {
-		if (!Array.isArray(e)) return {
-			data: e,
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.tuple.type(),
-				path: []
-			}],
-			typeOk: !1
-		};
-		let n = this._guardTupleInput(e, t);
-		if (!n.ok) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let i = [], a = [], o = n.value;
-		for (let e = 0; e < this.items.length; e++) {
-			let n = this.items[e]._parseFullSync(o[e], t);
-			n.issues.length === 0 ? a.push(n.data) : (i.push(...prependIssuePath(n.issues, e)), a.push(o[e]));
-		}
-		if (this.restSchema !== null) for (let e = this.items.length; e < o.length; e++) {
-			let n = this.restSchema._parseFullSync(o[e], t);
-			n.issues.length === 0 ? a.push(n.data) : (i.push(...prependIssuePath(n.issues, e)), a.push(o[e]));
-		}
-		return {
-			data: a,
-			issues: i,
-			typeOk: !0
-		};
-	}
-	async _parseAsync(e, t) {
-		if (!Array.isArray(e)) return {
-			data: e,
-			issues: [{
-				code: r.invalid_type,
-				message: t.messages.tuple.type(),
-				path: []
-			}],
-			typeOk: !1
-		};
-		let n = this._guardTupleInput(e, t);
-		if (!n.ok) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let i = n.value, a = [], o = [], s = await Promise.all(this.items.map((e, n) => e._parseFullAsync(i[n], t)));
-		for (let e = 0; e < s.length; e++) {
-			let t = s[e];
-			t.issues.length === 0 ? o.push(t.data) : (a.push(...prependIssuePath(t.issues, e)), o.push(i[e]));
-		}
-		let c = this.restSchema;
-		if (c !== null) {
-			let e = i.slice(this.items.length), n = await Promise.all(e.map((e) => c._parseFullAsync(e, t)));
-			for (let e = 0; e < n.length; e++) {
-				let t = n[e], r = this.items.length + e;
-				t.issues.length === 0 ? o.push(t.data) : (a.push(...prependIssuePath(t.issues, r)), o.push(i[r]));
-			}
-		}
-		return {
-			data: o,
-			issues: a,
-			typeOk: !0
-		};
+		let { messages: n } = t, r = this.items.length;
+		if (!Array.isArray(e)) return invalid(e, issue(i.invalid_type, n.tuple.type()));
+		if (this.restSchema === null && e.length !== r) return invalid(e, issue(i.invalid_length, n.tuple.length({ exact: r }), { exact: r }));
+		if (e.length < r) return invalid(e, issue(i.too_small, n.tuple.min({ min: r }), { min: r }));
+		let a = this.restSchema;
+		return chain(all(e.map((e, n) => (n < r ? this.items[n] : a)._run(e, t))), (t) => {
+			let n = [];
+			return {
+				issues: n,
+				typeOk: !0,
+				value: t.map((t, r) => t.issues.length === 0 ? t.value : (n.push(...prefixIssues(t.issues, r)), e[r]))
+			};
+		});
 	}
-	_toDescriptorImpl() {
+	_describe() {
 		return {
 			...this._describeBase(),
 			items: this.items.map((e) => e.definition()),
 			kind: "tuple",
-			rest: this.restSchema === null ? null : this.restSchema.definition()
+			rest: this.restSchema?.definition() ?? null
 		};
 	}
-}, VariantSchema = class extends Schema {
-	_map;
-	_discriminator;
-	get _kind() {
-		return "variant";
-	}
-	constructor(e, t) {
-		let n = /* @__PURE__ */ new Map();
-		for (let [r, i] of Object.entries(t)) {
-			let t = new LiteralSchema(r), a = i.shape[e];
-			if (a && (!(a instanceof LiteralSchema) || a.value !== r)) throw new SpellError(`s.discriminatedUnion(): branch "${r}" defines a conflicting discriminator schema for "${e}".`);
-			let o = { [e]: t };
-			n.set(r, a ? i : i.extend(o));
-		}
-		super(), this._discriminator = e, this._map = n;
-	}
-	get discriminator() {
-		return this._discriminator;
-	}
-	get variantMap() {
-		return new Map(this._map);
+}, UnionSchema = class extends Schema {
+	schemas;
+	constructor(e) {
+		super(), this.schemas = Object.freeze([...e]);
 	}
-	_resolveVariant(e, t) {
-		if (typeof e != "object" || !e || Array.isArray(e)) return { issues: [{
-			code: r.invalid_type,
-			message: t.messages.variant.type(),
-			path: []
-		}] };
-		let n = e, i = n[this._discriminator], a = this._map.get(i);
-		if (!a) {
-			let e = [...this._map.keys()];
-			return { issues: [{
-				code: r.invalid_variant,
-				message: t.messages.variant.invalidDiscriminator({
-					discriminator: this._discriminator,
-					expected: e
-				}),
-				params: {
-					discriminator: this._discriminator,
-					expected: e
-				},
-				path: []
-			}] };
-		}
-		return {
-			matched: a,
-			obj: n
-		};
+	get kind() {
+		return "union";
 	}
 	_parse(e, t) {
-		let n = this._resolveVariant(e, t);
-		if ("issues" in n) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let r = n.matched._parseFullSync(e, t);
-		return r.issues.length === 0 ? {
-			data: r.data,
-			issues: [],
-			typeOk: !0
-		} : {
-			data: e,
-			issues: r.issues,
-			typeOk: !0
-		};
-	}
-	async _parseAsync(e, t) {
-		let n = this._resolveVariant(e, t);
-		if ("issues" in n) return {
-			data: e,
-			issues: n.issues,
-			typeOk: !1
-		};
-		let r = await n.matched._parseFullAsync(e, t);
-		return r.issues.length === 0 ? {
-			data: r.data,
-			issues: [],
-			typeOk: !0
-		} : {
-			data: e,
-			issues: r.issues,
-			typeOk: !0
-		};
+		let attempt = (n, r) => n === this.schemas.length ? invalid(e, issue(i.invalid_union, t.messages.union.invalid(), { errors: r })) : chain(this.schemas[n]._run(e, t), (e) => e.issues.length === 0 ? ok(e.value) : attempt(n + 1, [...r, e.issues]));
+		return attempt(0, []);
 	}
-	_toDescriptorImpl() {
-		let e = {};
-		for (let [t, n] of this._map.entries()) defineOwnProperty(e, t, n.definition());
+	_describe() {
 		return {
 			...this._describeBase(),
-			branches: e,
-			discriminator: this._discriminator,
-			kind: "variant"
+			branches: this.schemas.map((e) => e.definition()),
+			kind: "union"
 		};
 	}
-}, sArray = (e) => new ArraySchema(e), sBigint = () => new i(), sBoolean = () => new a(), sDate = () => new o(), sEnum = (e) => new EnumSchema(e), sInstanceof = (e) => new InstanceOfSchema(e), sIntersect = (...e) => new IntersectSchema(normalizeToSchemas(e)), sLazy = (e) => new s(e), sLiteral = (e) => new LiteralSchema(e), sMap = (e, t) => new MapSchema(e, t), sNever = () => new NeverSchema(), sNull = () => new LiteralSchema(null), sNumber = () => new c(), sObject = (e) => new l(e), sRecord = (e, t) => new RecordSchema(e, t), sSet = (e) => new SetSchema(e), sString = () => new d(), sTuple = (e) => new f(e), sUndefined = () => new LiteralSchema(void 0);
-function sUnion(...e) {
-	return new UnionSchema(normalizeToSchemas(e));
-}
-var sUnknown = () => new Schema(), sVariant = (e, t) => new VariantSchema(e, t), p = {
-	array: sArray,
-	bigint: sBigint,
-	boolean: sBoolean,
+}, coerceNumber = (e) => {
+	if (typeof e != "string" && typeof e != "boolean") return e;
+	let t = Number(e);
+	return Number.isNaN(t) ? e : t;
+}, coerceBoolean = (e) => e === "true" || e === "1" || e === 1 ? !0 : e === "false" || e === "0" || e === 0 ? !1 : e, coerceBigInt = (e) => {
+	if (typeof e == "number" && !Number.isSafeInteger(e)) return e;
+	if (typeof e == "string") {
+		let t = e.trim();
+		if (t.length === 0 || t.length > 1e3) return e;
+		try {
+			return BigInt(t);
+		} catch {
+			return e;
+		}
+	}
+	return typeof e == "number" ? BigInt(e) : e;
+}, coerceDate = (e) => typeof e == "string" || typeof e == "number" ? new Date(e) : e, coerceString = (e) => e == null ? e : String(e), c = {
+	array: (e) => new ArraySchema(e),
+	bigint: () => new BigIntSchema(),
+	boolean: () => new BooleanSchema(),
 	coerce: {
-		bigint: () => i.coerce(),
-		boolean: () => a.coerce(),
-		date: () => o.coerce(),
-		number: () => c.coerce(),
-		string: () => d.coerce()
+		bigint: () => new BigIntSchema().preprocess(coerceBigInt),
+		boolean: () => new BooleanSchema().preprocess(coerceBoolean),
+		date: () => new DateSchema().preprocess(coerceDate),
+		number: () => new NumberSchema().preprocess(coerceNumber),
+		string: () => new StringSchema().preprocess(coerceString)
 	},
-	date: sDate,
-	discriminatedUnion: sVariant,
-	enum: sEnum,
-	instanceof: sInstanceof,
-	intersect: sIntersect,
-	lazy: sLazy,
-	literal: sLiteral,
-	map: sMap,
-	never: sNever,
-	null: sNull,
-	number: sNumber,
-	object: sObject,
-	record: sRecord,
-	set: sSet,
-	string: sString,
-	tuple: sTuple,
-	undefined: sUndefined,
-	union: sUnion,
-	unknown: sUnknown
+	date: () => new DateSchema(),
+	discriminatedUnion: (e, t) => new DiscriminatedUnionSchema(e, t),
+	enum: (e) => new EnumSchema(e),
+	instanceof: (e) => new InstanceOfSchema(e),
+	intersect: (...e) => new IntersectSchema(e),
+	lazy: (e) => new LazySchema(e),
+	literal: (e) => new LiteralSchema(e),
+	map: (e, t) => new MapSchema(e, t),
+	never: () => new NeverSchema(),
+	null: () => new LiteralSchema(null),
+	number: () => new NumberSchema(),
+	object: (e) => new o(e),
+	record: (e, t) => new RecordSchema(e, t),
+	set: (e) => new SetSchema(e),
+	string: () => new StringSchema(),
+	tuple: (e) => new s(e),
+	undefined: () => new LiteralSchema(void 0),
+	union: (...e) => new UnionSchema(e),
+	unknown: () => new Schema()
 };
-// src/tolerate.ts
-function tolerate(e, ...t) {
-	let n = new Set(t);
-	return e.preprocess((e) => {
-		if (typeof e != "object" || !e) return e;
-		let t = !1;
-		for (let r of Object.keys(e)) if (n.has(r)) {
-			t = !0;
-			break;
-		}
-		if (!t) return e;
-		let r = {};
-		for (let [t, i] of Object.entries(e)) n.has(t) || (r[t] = i);
-		return r;
-	});
-}
-export { r as ErrorCode, Schema, SpellDefinitionError, SpellError, SpellValidationError, createParseContext, joinIssuePath, p as s, tolerate };
+export { i as ErrorCode, Schema, SpellDefinitionError, SpellError, SpellValidationError, createParseContext, joinIssuePath, c as s };
 
 //# sourceMappingURL=spell.js.map