@systemfsoftware/xstate-test 0.0.0-bootstrap.0 → 2.0.0-beta.2

package/dist/schema.mjs

@@ -0,0 +1,822 @@
+import { dual } from "effect/Function";
+import * as DateTime from "effect/DateTime";
+import * as fc from "fast-check";
+// src/schema.ts
+const SUPPORTED_LIBRARIES = "Zod (v3 and v4) and Effect Schema (via `@xstate/test/effect-schema`)";
+function unsupported(message) {
+	throw new Error(`[@xstate/test] ${message}`);
+}
+function unsatisfiable(path, reason) {
+	return unsupported(`Unsatisfiable Zod schema at '${path}': ${reason}. Pass an explicit generator for this payload.`);
+}
+const MAX_FILTER_ATTEMPTS = 1e3;
+/**
+* Like `.filter()`, but throws after `MAX_FILTER_ATTEMPTS` consecutive
+* rejections instead of looping forever. Shrinking filters without a limit.
+*/
+var BoundedFilterArbitrary = class extends fc.Arbitrary {
+	arbitrary;
+	predicate;
+	description;
+	path;
+	constructor(arbitrary, predicate, description, path) {
+		super();
+		this.arbitrary = arbitrary;
+		this.predicate = predicate;
+		this.description = description;
+		this.path = path;
+	}
+	generate(mrng, biasFactor) {
+		for (let attempt = 0; attempt < MAX_FILTER_ATTEMPTS; attempt++) {
+			const generated = this.arbitrary.generate(mrng, biasFactor);
+			if (this.predicate(generated.value)) return generated;
+		}
+		return unsupported(`Could not generate a value satisfying ${this.description} at '${this.path}' after ${MAX_FILTER_ATTEMPTS} attempts. Pass an explicit generator for this payload.`);
+	}
+	canShrinkWithoutContext(value) {
+		return this.arbitrary.canShrinkWithoutContext(value) && this.predicate(value);
+	}
+	shrink(value, context) {
+		return this.arbitrary.shrink(value, context).filter((shrunk) => this.predicate(shrunk.value));
+	}
+};
+function getZodDef(schema) {
+	if (schema === null || typeof schema !== "object" && typeof schema !== "function") return;
+	const candidate = schema;
+	const def = candidate._zod?.def ?? candidate._def;
+	if (def === void 0 || typeof def !== "object") return;
+	return def;
+}
+function getZodKind(def) {
+	if (typeof def.type === "string") return def.type;
+	if (typeof def.typeName === "string") return def.typeName.replace(/^Zod/, "").toLowerCase();
+}
+function getZodShape(def) {
+	const shape = def["shape"];
+	return typeof shape === "function" ? shape() : shape ?? {};
+}
+function isZodOptionalKind(schema) {
+	const def = getZodDef(schema);
+	if (def === void 0) return false;
+	const kind = getZodKind(def);
+	return kind === "optional" || kind === "default" || kind === "prefault";
+}
+function unsupportedCheck(name, kind, path) {
+	return unsupported(`Unsupported Zod check '${name}' on ${kind} at '${path}'. Pass an explicit generator for this payload.`);
+}
+/**
+* Collects the raw check definitions of a schema. Zod v4 wraps each check in a
+* `_zod.def`, and a format schema (`z.email()`, `z.int()`) carries its check on
+* the schema def itself.
+*/
+function getZodCheckDefs(def) {
+	const raw = [];
+	if (typeof def["check"] === "string") raw.push(def);
+	if (Array.isArray(def["checks"])) raw.push(...def["checks"]);
+	return raw.map((check) => check?._zod?.def ?? check);
+}
+function numberFormatChecks(format, name, kind, path) {
+	const bounded = (min, max) => [
+		{ kind: "int" },
+		{
+			kind: "min",
+			value: min,
+			inclusive: true
+		},
+		{
+			kind: "max",
+			value: max,
+			inclusive: true
+		}
+	];
+	switch (format) {
+		case "int":
+		case "safeint": return [{ kind: "int" }];
+		case "int32": return bounded(-2147483648, 2147483647);
+		case "uint32": return bounded(0, 4294967295);
+		case "int64": return bounded(-(2n ** 63n), 2n ** 63n - 1n);
+		case "uint64": return bounded(0n, 2n ** 64n - 1n);
+		case "float64": return [];
+		default: return unsupportedCheck(`${name}:${format}`, kind, path);
+	}
+}
+/** Normalizes every check declared on a schema, per Zod major version. */
+function getZodChecks(def, kind, path) {
+	const checks = [];
+	for (const check of getZodCheckDefs(def)) {
+		const name = typeof check["check"] === "string" ? check["check"] : typeof check["kind"] === "string" ? check["kind"] : void 0;
+		switch (name) {
+			case "greater_than":
+				checks.push({
+					kind: "min",
+					value: check["value"],
+					inclusive: check["inclusive"] !== false
+				});
+				break;
+			case "less_than":
+				checks.push({
+					kind: "max",
+					value: check["value"],
+					inclusive: check["inclusive"] !== false
+				});
+				break;
+			case "min_length":
+			case "min_size":
+				checks.push({
+					kind: "minLength",
+					value: check["minimum"]
+				});
+				break;
+			case "max_length":
+			case "max_size":
+				checks.push({
+					kind: "maxLength",
+					value: check["maximum"]
+				});
+				break;
+			case "length_equals":
+			case "size_equals":
+				checks.push({
+					kind: "length",
+					value: check["length"] ?? check["size"]
+				});
+				break;
+			case "multiple_of":
+				checks.push({
+					kind: "multipleOf",
+					value: check["value"]
+				});
+				break;
+			case "number_format":
+			case "bigint_format":
+				checks.push(...numberFormatChecks(String(check["format"]), name, kind, path));
+				break;
+			case "string_format":
+				checks.push({
+					kind: "format",
+					format: String(check["format"]),
+					...check["pattern"] instanceof RegExp ? { pattern: check["pattern"] } : {},
+					value: check["prefix"] ?? check["suffix"] ?? check["includes"]
+				});
+				break;
+			case "overwrite":
+				if (typeof check["tx"] !== "function") unsupportedCheck(name, kind, path);
+				checks.push({
+					kind: "transform",
+					apply: check["tx"]
+				});
+				break;
+			case "min":
+				checks.push(kind === "string" ? {
+					kind: "minLength",
+					value: check["value"]
+				} : {
+					kind: "min",
+					value: check["value"],
+					inclusive: check["inclusive"] !== false
+				});
+				break;
+			case "max":
+				checks.push(kind === "string" ? {
+					kind: "maxLength",
+					value: check["value"]
+				} : {
+					kind: "max",
+					value: check["value"],
+					inclusive: check["inclusive"] !== false
+				});
+				break;
+			case "length":
+				checks.push({
+					kind: "length",
+					value: check["value"]
+				});
+				break;
+			case "int":
+				checks.push({ kind: "int" });
+				break;
+			case "multipleOf":
+				checks.push({
+					kind: "multipleOf",
+					value: check["value"]
+				});
+				break;
+			case "finite":
+			case "safe": break;
+			case "email":
+			case "uuid":
+			case "url":
+				checks.push({
+					kind: "format",
+					format: name
+				});
+				break;
+			case "regex":
+				if (!(check["regex"] instanceof RegExp)) unsupportedCheck(name, kind, path);
+				checks.push({
+					kind: "format",
+					format: "regex",
+					pattern: check["regex"]
+				});
+				break;
+			case "startsWith":
+				checks.push({
+					kind: "format",
+					format: "starts_with",
+					value: check["value"]
+				});
+				break;
+			case "endsWith":
+				checks.push({
+					kind: "format",
+					format: "ends_with",
+					value: check["value"]
+				});
+				break;
+			case "includes":
+				checks.push({
+					kind: "format",
+					format: "includes",
+					value: check["value"]
+				});
+				break;
+			case "trim":
+				checks.push({
+					kind: "transform",
+					apply: (value) => value.trim()
+				});
+				break;
+			case "toLowerCase":
+				checks.push({
+					kind: "transform",
+					apply: (value) => value.toLowerCase()
+				});
+				break;
+			case "toUpperCase":
+				checks.push({
+					kind: "transform",
+					apply: (value) => value.toUpperCase()
+				});
+				break;
+			default: unsupportedCheck(name ?? "unknown", kind, path);
+		}
+	}
+	return checks;
+}
+/** Reads `minLength`/`maxLength`/`length` checks, rejecting anything else. */
+function zodSizeBounds(checks, path) {
+	const bounds = {};
+	for (const check of checks) switch (check.kind) {
+		case "minLength":
+			bounds.minLength = Math.max(bounds.minLength ?? 0, check.value);
+			break;
+		case "maxLength":
+			bounds.maxLength = Math.min(bounds.maxLength ?? Infinity, check.value);
+			break;
+		case "length":
+			bounds.minLength = check.value;
+			bounds.maxLength = check.value;
+			break;
+		default: unsupportedCheck(check.kind, "collection", path);
+	}
+	return bounds;
+}
+/** Merges the size bounds Zod v3 keeps on the def itself, not in `checks`. */
+function zodLegacySizeBounds(def, bounds) {
+	const read = (value) => typeof value?.value === "number" ? value.value : void 0;
+	const exact = read(def["exactLength"]);
+	const min = exact ?? read(def["minLength"]) ?? read(def["minSize"]);
+	const max = exact ?? read(def["maxLength"]) ?? read(def["maxSize"]);
+	const minLength = min ?? bounds.minLength;
+	const maxLength = max ?? bounds.maxLength;
+	return {
+		...minLength === void 0 ? {} : { minLength },
+		...maxLength === void 0 || maxLength === Infinity ? {} : { maxLength }
+	};
+}
+function toNumber(value) {
+	return typeof value === "bigint" ? Number(value) : value instanceof Date ? value.getTime() : value;
+}
+function zodNumericBounds(checks, kind, path) {
+	const bounds = {
+		minExcluded: false,
+		maxExcluded: false,
+		int: false,
+		multipleOf: []
+	};
+	for (const check of checks) switch (check.kind) {
+		case "min": {
+			const value = toNumber(check.value);
+			if (bounds.min === void 0 || value > bounds.min) {
+				bounds.min = value;
+				bounds.minExcluded = !check.inclusive;
+			} else if (value === bounds.min && !check.inclusive) bounds.minExcluded = true;
+			break;
+		}
+		case "max": {
+			const value = toNumber(check.value);
+			if (bounds.max === void 0 || value < bounds.max) {
+				bounds.max = value;
+				bounds.maxExcluded = !check.inclusive;
+			} else if (value === bounds.max && !check.inclusive) bounds.maxExcluded = true;
+			break;
+		}
+		case "int":
+			bounds.int = true;
+			break;
+		case "multipleOf":
+			bounds.multipleOf.push(toNumber(check.value));
+			break;
+		default: unsupportedCheck(check.kind, kind, path);
+	}
+	return bounds;
+}
+const INT_SPAN = 2 ** 31 - 1;
+function integerRange(bounds) {
+	let min = bounds.min === void 0 ? -INT_SPAN : Math.ceil(bounds.min) + (bounds.minExcluded && Number.isInteger(bounds.min) ? 1 : 0);
+	let max = bounds.max === void 0 ? INT_SPAN : Math.floor(bounds.max) - (bounds.maxExcluded && Number.isInteger(bounds.max) ? 1 : 0);
+	min = Math.max(min, -Number.MAX_SAFE_INTEGER);
+	max = Math.min(max, Number.MAX_SAFE_INTEGER);
+	return {
+		min,
+		max
+	};
+}
+function gcd(a, b) {
+	while (b !== 0n) [a, b] = [b, a % b];
+	return a;
+}
+/** Reads a finite, non-zero number as the exact fraction of its decimal form. */
+function toFraction(value) {
+	if (!Number.isFinite(value) || value === 0) return;
+	const match = /^(\d+)(?:\.(\d+))?(?:e([+-]\d+))?$/.exec(String(Math.abs(value)));
+	if (match === null) return;
+	const [, whole, decimals = "", exponent = "0"] = match;
+	const scale = Number(exponent) - decimals.length;
+	const numerator = BigInt(whole + decimals) * (scale > 0 ? 10n ** BigInt(scale) : 1n);
+	const denominator = scale < 0 ? 10n ** BigInt(-scale) : 1n;
+	const divisor = gcd(numerator, denominator);
+	return [numerator / divisor, denominator / divisor];
+}
+/**
+* Combines every `multipleOf` step (and `int`, a step of 1) into their least
+* common multiple, as an exact fraction.
+*/
+function combinedStep(bounds, path) {
+	const steps = bounds.int ? [...bounds.multipleOf, 1] : bounds.multipleOf;
+	let result;
+	for (const step of steps) {
+		const fraction = toFraction(step);
+		if (fraction === void 0) return unsupported(`Unsupported Zod multipleOf(${step}) on number at '${path}'. Pass an explicit generator for this payload.`);
+		if (result === void 0) {
+			result = fraction;
+			continue;
+		}
+		const [a, b] = result;
+		const [c, d] = fraction;
+		result = [a / gcd(a, c) * c, gcd(b, d)];
+	}
+	if (result === void 0 || result[0] > BigInt(Number.MAX_SAFE_INTEGER) || result[1] > BigInt(Number.MAX_SAFE_INTEGER)) return unsupported(`Unsupported Zod multipleOf combination (${steps.join(", ")}) on number at '${path}': no common multiple can be generated exactly. Pass an explicit generator for this payload.`);
+	return result;
+}
+function zodMultipleOfArbitrary(bounds, path) {
+	const [stepNumerator, stepDenominator] = combinedStep(bounds, path);
+	const numerator = Number(stepNumerator);
+	const denominator = Number(stepDenominator);
+	const valueOf = (factor) => factor * numerator / denominator;
+	const step = numerator / denominator;
+	const limit = Math.min(INT_SPAN, Math.floor(Number.MAX_SAFE_INTEGER / numerator));
+	const aboveMin = (value) => bounds.min === void 0 || (bounds.minExcluded ? value > bounds.min : value >= bounds.min);
+	const belowMax = (value) => bounds.max === void 0 || (bounds.maxExcluded ? value < bounds.max : value <= bounds.max);
+	let min = bounds.min === void 0 ? -limit : Math.max(-limit, Math.ceil(bounds.min / step) - 1);
+	let max = bounds.max === void 0 ? limit : Math.min(limit, Math.floor(bounds.max / step) + 1);
+	while (min <= max && !aboveMin(valueOf(min))) min++;
+	while (max >= min && !belowMax(valueOf(max))) max--;
+	if (min > max) unsupported(`Zod number at '${path}' declares a multipleOf that no value in its range satisfies.`);
+	return fc.integer({
+		min,
+		max
+	}).map(valueOf);
+}
+function zodNumberArbitrary(def, kind, path) {
+	const bounds = zodNumericBounds(getZodChecks(def, kind, path), kind, path);
+	const format = def["format"];
+	if (!bounds.int && typeof format === "string" && (format.includes("int") || kind === "int")) bounds.int = true;
+	if (bounds.multipleOf.length !== 0) return zodMultipleOfArbitrary(bounds, path);
+	if (bounds.int) {
+		const { min, max } = integerRange(bounds);
+		if (min > max) unsupported(`Zod number at '${path}' declares an empty integer range.`);
+		return fc.integer({
+			min,
+			max
+		});
+	}
+	if (bounds.max === 0 && bounds.maxExcluded) {
+		bounds.max = -Number.MIN_VALUE;
+		bounds.maxExcluded = false;
+	}
+	if (bounds.min === 0 && bounds.minExcluded) {
+		bounds.min = Number.MIN_VALUE;
+		bounds.minExcluded = false;
+	}
+	if (bounds.min !== void 0 && bounds.max !== void 0 && (bounds.min > bounds.max || bounds.min === bounds.max && (bounds.minExcluded || bounds.maxExcluded))) unsatisfiable(path, "the numeric range is empty");
+	return fc.double({
+		noNaN: true,
+		noDefaultInfinity: true,
+		...bounds.min === void 0 ? {} : {
+			min: bounds.min,
+			minExcluded: bounds.minExcluded
+		},
+		...bounds.max === void 0 ? {} : {
+			max: bounds.max,
+			maxExcluded: bounds.maxExcluded
+		}
+	});
+}
+function zodBigIntArbitrary(def, kind, path) {
+	let min;
+	let max;
+	for (const check of getZodChecks(def, kind, path)) switch (check.kind) {
+		case "min": {
+			const value = BigInt(check.value) + (check.inclusive ? 0n : 1n);
+			min = min === void 0 || value > min ? value : min;
+			break;
+		}
+		case "max": {
+			const value = BigInt(check.value) - (check.inclusive ? 0n : 1n);
+			max = max === void 0 || value < max ? value : max;
+			break;
+		}
+		case "int": break;
+		default: unsupportedCheck(check.kind, "bigint", path);
+	}
+	if (min !== void 0 && max !== void 0 && min > max) unsatisfiable(path, "the bigint range is empty");
+	return fc.bigInt({
+		...min === void 0 ? {} : { min },
+		...max === void 0 ? {} : { max }
+	});
+}
+function zodDateArbitrary(def, kind, path) {
+	let min;
+	let max;
+	for (const check of getZodChecks(def, kind, path)) switch (check.kind) {
+		case "min": {
+			const value = DateTime.toDate(DateTime.makeUnsafe(toNumber(check.value) + (check.inclusive ? 0 : 1)));
+			min = min === void 0 || value > min ? value : min;
+			break;
+		}
+		case "max": {
+			const value = DateTime.toDate(DateTime.makeUnsafe(toNumber(check.value) - (check.inclusive ? 0 : 1)));
+			max = max === void 0 || value < max ? value : max;
+			break;
+		}
+		default: unsupportedCheck(check.kind, "date", path);
+	}
+	if (min !== void 0 && max !== void 0 && min > max) unsatisfiable(path, "the date range is empty");
+	return fc.date({
+		noInvalidDate: true,
+		...min === void 0 ? {} : { min },
+		...max === void 0 ? {} : { max }
+	});
+}
+const ALPHANUMERIC = fc.constantFrom(..."abcdefghijklmnopqrstuvwxyz0123456789".split(""));
+const EMAIL_SUFFIX = ".co";
+/** `a@b.co`, the shortest address Zod accepts. */
+const EMAIL_MIN_LENGTH = 6;
+/**
+* `fc.emailAddress()` covers RFC 5322, which is wider than the address Zod
+* accepts, so a conservative address within the length bounds is generated
+* instead.
+*/
+function emailArbitrary(minLength, maxLength) {
+	const fixed = 4;
+	const min = Math.max(2, minLength - fixed);
+	const max = Math.min(Math.max(20, min), maxLength - fixed);
+	if (min > max) return;
+	const part = (length) => fc.string({
+		unit: ALPHANUMERIC,
+		minLength: length,
+		maxLength: length
+	});
+	return fc.integer({
+		min,
+		max
+	}).chain((total) => fc.integer({
+		min: 1,
+		max: total - 1
+	}).chain((local) => fc.tuple(part(local), part(total - local)))).map(([local, domain]) => `${local}@${domain}${EMAIL_SUFFIX}`);
+}
+const UUID_LENGTH = 36;
+/** The generator for a named format or pattern, honoring length bounds. */
+function stringFormatArbitrary(check, minLength, maxLength, path) {
+	switch (check.format) {
+		case "email": {
+			const arbitrary = emailArbitrary(minLength, maxLength);
+			if (arbitrary === void 0) unsatisfiable(path, `an email address has at least ${EMAIL_MIN_LENGTH} characters, outside the length bounds ${minLength}..${maxLength}`);
+			return arbitrary;
+		}
+		case "uuid":
+		case "guid":
+			if (minLength > UUID_LENGTH || maxLength < UUID_LENGTH) unsatisfiable(path, `a ${check.format} has ${UUID_LENGTH} characters, outside the length bounds ${minLength}..${maxLength}`);
+			return check.pattern !== void 0 ? fc.stringMatching(check.pattern) : fc.uuid();
+		case "url": return fc.webUrl();
+		default:
+			if (check.pattern === void 0) return unsupportedCheck(check.format === "regex" ? "regex" : `string_format:${check.format}`, "string", path);
+			return fc.stringMatching(check.pattern);
+	}
+}
+function zodStringArbitrary(def, kind, path) {
+	let minLength;
+	let maxLength;
+	let prefix = "";
+	let suffix = "";
+	let infix = "";
+	const formats = [];
+	const transforms = [];
+	for (const check of getZodChecks(def, kind, path)) switch (check.kind) {
+		case "minLength":
+			minLength = Math.max(minLength ?? 0, check.value);
+			break;
+		case "maxLength":
+			maxLength = Math.min(maxLength ?? Infinity, check.value);
+			break;
+		case "length":
+			minLength = check.value;
+			maxLength = check.value;
+			break;
+		case "transform":
+			transforms.push(check.apply);
+			break;
+		case "format":
+			switch (check.format) {
+				case "starts_with":
+					prefix += check.value ?? "";
+					break;
+				case "ends_with":
+					suffix = (check.value ?? "") + suffix;
+					break;
+				case "includes":
+					infix += check.value ?? "";
+					break;
+				default: formats.push(check);
+			}
+			break;
+		default: unsupportedCheck(check.kind, "string", path);
+	}
+	if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) unsatisfiable(path, `the minimum length ${minLength} exceeds the maximum length ${maxLength}`);
+	if (formats.length > 1) unsupported(`Unsupported combination of Zod string formats ${formats.map((check) => `'${check.format}'`).join(" and ")} at '${path}'. Pass an explicit generator for this payload.`);
+	const format = formats[0];
+	if (format !== void 0 && (prefix.length > 0 || suffix.length > 0 || infix.length > 0)) unsupported(`Unsupported combination of Zod string format '${format.format}' with startsWith/endsWith/includes at '${path}'. Pass an explicit generator for this payload.`);
+	let arbitrary;
+	if (format !== void 0) arbitrary = stringFormatArbitrary(format, minLength ?? 0, maxLength ?? Infinity, path);
+	else {
+		const fixed = prefix.length + infix.length + suffix.length;
+		const innerMax = maxLength === void 0 || maxLength === Infinity ? void 0 : maxLength - fixed;
+		if (innerMax !== void 0 && innerMax < 0) unsupported(`Zod string at '${path}' declares a maxLength shorter than its required substrings.`);
+		arbitrary = fc.string({
+			minLength: Math.max(0, (minLength ?? 0) - fixed),
+			...innerMax === void 0 ? {} : { maxLength: innerMax }
+		}).map((value) => prefix + infix + value + suffix);
+	}
+	if (transforms.length !== 0) arbitrary = arbitrary.map((value) => transforms.reduce((result, transform) => transform(result), value));
+	if ((minLength !== void 0 || maxLength !== void 0 && maxLength !== Infinity) && (format !== void 0 || transforms.length !== 0)) arbitrary = new BoundedFilterArbitrary(arbitrary, (value) => value.length >= (minLength ?? 0) && value.length <= (maxLength ?? Infinity), `the length bounds ${minLength ?? 0}..${maxLength ?? Infinity}`, path);
+	return arbitrary;
+}
+/**
+* The values of an enum, without the reverse mappings (`{ 0: 'A' }`) that
+* TypeScript adds to numeric enums.
+*/
+function zodEnumValues(def) {
+	if (Array.isArray(def["values"])) return def["values"];
+	const entries = def["entries"] ?? def["values"] ?? {};
+	return Object.entries(entries).filter(([key, value]) => !(typeof value === "string" && String(Number(key)) === key && entries[value] === Number(key))).map(([, value]) => value);
+}
+function zodLiteralValues(def) {
+	return Array.isArray(def["values"]) ? def["values"] : [def["value"]];
+}
+/** An upper bound on the number of distinct values a schema accepts. */
+function zodDomainSize(schema) {
+	const def = getZodDef(schema);
+	if (def === void 0) return Infinity;
+	switch (getZodKind(def)) {
+		case "literal": return zodLiteralValues(def).length;
+		case "enum":
+		case "nativeenum": return zodEnumValues(def).length;
+		case "boolean": return 2;
+		case "null":
+		case "undefined":
+		case "void": return 1;
+		case "union": return (def["options"] ?? []).reduce((size, option) => size + zodDomainSize(option), 0);
+		case "optional":
+		case "nullable": return zodDomainSize(def["innerType"]) + 1;
+		case "default":
+		case "prefault":
+		case "catch":
+		case "readonly":
+		case "nonoptional": return zodDomainSize(def["innerType"]);
+		default: return Infinity;
+	}
+}
+function checkSizeBounds(bounds, path) {
+	if (bounds.minLength !== void 0 && bounds.maxLength !== void 0 && bounds.minLength > bounds.maxLength) unsatisfiable(path, `the minimum size ${bounds.minLength} exceeds the maximum size ${bounds.maxLength}`);
+}
+function isZodExactOptional(schema) {
+	return (schema._zod?.traits)?.has("$ZodExactOptional") === true;
+}
+function fromZod(schema, path, convertingZodDefs) {
+	const def = getZodDef(schema);
+	if (def === void 0) unsupported(`Expected a Zod schema at '${path}'.`);
+	if (convertingZodDefs.has(def)) unsupported(`Recursive Zod schema at '${path}'. Recursive schemas cannot be derived; pass an explicit generator for this payload.`);
+	convertingZodDefs.add(def);
+	try {
+		return fromZodDef(schema, def, path, convertingZodDefs);
+	} finally {
+		convertingZodDefs.delete(def);
+	}
+}
+function fromZodDef(schema, def, path, convertingZodDefs) {
+	const kind = getZodKind(def);
+	switch (kind) {
+		case "string": return zodStringArbitrary(def, kind, path);
+		case "number":
+		case "int": return zodNumberArbitrary(def, kind, path);
+		case "bigint": return zodBigIntArbitrary(def, kind, path);
+		case "boolean": return fc.boolean();
+		case "date": return zodDateArbitrary(def, kind, path);
+		case "null": return fc.constant(null);
+		case "undefined":
+		case "void": return fc.constant(void 0);
+		case "any":
+		case "unknown": return fc.anything();
+		case "literal": {
+			const values = zodLiteralValues(def);
+			if (values.length === 0) unsupported(`Zod literal at '${path}' declares no values.`);
+			return fc.constantFrom(...values);
+		}
+		case "enum":
+		case "nativeenum": {
+			const values = zodEnumValues(def);
+			if (values.length === 0) unsupported(`Zod enum at '${path}' declares no values.`);
+			return fc.constantFrom(...values);
+		}
+		case "union": {
+			const options = def["options"] ?? [];
+			if (options.length === 0) unsupported(`Zod union at '${path}' declares no options.`);
+			return fc.oneof(...options.map((option, index) => fromZod(option, `${path}|${String(index)}`, convertingZodDefs)));
+		}
+		case "array": {
+			const bounds = zodLegacySizeBounds(def, zodSizeBounds(getZodChecks(def, kind, path), path));
+			checkSizeBounds(bounds, path);
+			return fc.array(fromZod(def["element"] ?? def.type, `${path}[]`, convertingZodDefs), bounds);
+		}
+		case "set": {
+			const bounds = zodLegacySizeBounds(def, zodSizeBounds(getZodChecks(def, kind, path), path));
+			checkSizeBounds(bounds, path);
+			const domainSize = zodDomainSize(def["valueType"]);
+			if ((bounds.minLength ?? 0) > domainSize) unsatisfiable(path, `the set needs at least ${bounds.minLength} distinct elements, but its element schema accepts only ${domainSize}`);
+			return fc.uniqueArray(fromZod(def["valueType"], `${path}[]`, convertingZodDefs), bounds).map((values) => new Set(values));
+		}
+		case "tuple": {
+			const items = def["items"] ?? [];
+			return fc.tuple(...items.map((item, index) => fromZod(item, `${path}[${index}]`, convertingZodDefs)));
+		}
+		case "record": {
+			const keys = def["keyType"]?._zod?.values;
+			if (keys !== void 0) {
+				const model = {};
+				for (const key of keys) {
+					if (typeof key !== "string" && typeof key !== "number") unsupported(`Unsupported Zod record key ${String(key)} at '${path}'. Pass an explicit generator for this payload.`);
+					model[String(key)] = fromZod(def["valueType"], `${path}.${key}`, convertingZodDefs);
+				}
+				return fc.record(model);
+			}
+			return fc.dictionary(fromZod(def["keyType"], `${path}.<key>`, convertingZodDefs), fromZod(def["valueType"], `${path}.<value>`, convertingZodDefs));
+		}
+		case "optional": return isZodExactOptional(schema) ? fromZod(def["innerType"], path, convertingZodDefs) : fc.option(fromZod(def["innerType"], path, convertingZodDefs), { nil: void 0 });
+		case "nullable": return fc.option(fromZod(def["innerType"], path, convertingZodDefs), { nil: null });
+		case "default":
+		case "prefault":
+		case "catch":
+		case "readonly":
+		case "nonoptional": return fromZod(def["innerType"], path, convertingZodDefs);
+		case "lazy":
+			if (typeof def["getter"] !== "function") return unsupported(`Zod lazy schema at '${path}' has no getter.`);
+			return fromZod(def["getter"](), path, convertingZodDefs);
+		case "object":
+		case "interface": return zodObjectArbitrary(getZodShape(def), path, convertingZodDefs);
+		default: return unsupported(`Unsupported Zod schema kind '${kind ?? "unknown"}' at '${path}'.`);
+	}
+}
+function zodObjectArbitrary(shape, path, convertingZodDefs) {
+	const model = {};
+	const requiredKeys = [];
+	for (const [key, value] of Object.entries(shape)) {
+		model[key] = fromZod(value, path.length > 0 ? `${path}.${key}` : key, convertingZodDefs);
+		if (!isZodOptionalKind(value)) requiredKeys.push(key);
+	}
+	return fc.record(model, { requiredKeys });
+}
+function isZodSchema(schema) {
+	const def = getZodDef(schema);
+	return def !== void 0 && getZodKind(def) !== void 0;
+}
+/** ------------------------------------------------------------ Generic --- */
+const zodConverter = (schema, path) => isZodSchema(schema) ? fromZod(schema, path, /* @__PURE__ */ new Set()) : void 0;
+function isEffectSchema(schema) {
+	if (schema === null || typeof schema !== "object" && typeof schema !== "function") return false;
+	const ast = schema.ast;
+	return ast !== void 0 && ast !== null;
+}
+/**
+* `types<...>()` declares a payload's TypeScript type and nothing else, so no
+* generator can be derived from it. Implicit derivation skips these; explicit
+* `eventsFromSchemas()` still reports them.
+*
+* @internal
+*/
+function isTypeOnlySchema(schema) {
+	return isStandardSchema(schema) && schema["~standard"].vendor === "xstate.types";
+}
+function isStandardSchema(schema) {
+	return schema !== null && (typeof schema === "object" || typeof schema === "function") && "~standard" in schema;
+}
+/**
+* Converts a declared payload schema into a FastCheck arbitrary. Only schema
+* libraries whose structure can be inspected are supported; a Standard Schema
+* alone only validates, so nothing can be generated from it.
+*
+* @experimental
+*/
+function arbitraryFromSchema(schema, options = {}, path = "") {
+	const converters = [...options.converters ?? [], zodConverter];
+	for (const converter of converters) {
+		const arbitrary = converter(schema, path);
+		if (arbitrary !== void 0) return arbitrary;
+	}
+	const fallback = options.fallback?.(schema, path);
+	if (fallback !== void 0) return fallback;
+	if (isEffectSchema(schema)) return unsupported(`Effect Schema found at '${path}'. Import \`eventsFromSchemas\` from '@xstate/test/effect-schema' to generate from Effect Schemas.`);
+	if (isTypeOnlySchema(schema)) return unsupported(`The schema at '${path}' is a type-only schema (\`types<...>()\`). Type-only declarations carry no runtime structure, so no generator can be derived. Declare a runtime schema (${SUPPORTED_LIBRARIES}) or pass an explicit generator.`);
+	if (isStandardSchema(schema)) return unsupported(`The schema at '${path}' implements Standard Schema but is not a recognized schema library. Standard Schema only validates, so no generator can be derived. Supported libraries: ${SUPPORTED_LIBRARIES}. Pass a \`fallback\` converter to handle it.`);
+	return unsupported(`Unrecognized schema at '${path}'. Supported libraries: ${SUPPORTED_LIBRARIES}. Pass a \`fallback\` converter to \`eventsFromSchemas()\` to handle other schemas, or an explicit generator in \`events\`.`);
+}
+/** Strips a top-level `type` key; event-map keys supply the event type. */
+function stripType(arbitrary, eventType) {
+	return arbitrary.map((value) => {
+		if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`Property event "${eventType}" generated a non-object payload (${typeof value === "string" ? JSON.stringify(value) : String(value)}). Event payloads must be plain objects; use a \`resolve\` function to map generated values onto an event payload.`);
+		const { type: _type, ...payload } = value;
+		return payload;
+	});
+}
+/** Mirrors xstate's event descriptor matching (`'user.*'`, `'*'`). */
+function matchesEventDescriptor(eventType, descriptor) {
+	if (descriptor === eventType || descriptor === "*") return true;
+	if (!descriptor.endsWith(".*")) return false;
+	const descriptorTokens = descriptor.split(".");
+	const eventTokens = eventType.split(".");
+	for (let index = 0; index < descriptorTokens.length; index++) {
+		if (descriptorTokens[index] === "*") return index === descriptorTokens.length - 1;
+		if (descriptorTokens[index] !== eventTokens[index]) return false;
+	}
+	return true;
+}
+/** Whether a data-first `eventsFromSchemas` argument is a state machine. */
+const isStateMachineArgument = (value) => typeof value === "object" && value !== null && "transition" in value;
+/**
+* Derives event generators from the event schemas declared on a machine
+* (`setup({ schemas: { events } })` or `createMachine({ schemas: { events } })`).
+*
+* Type-only event declarations (`types.events`) are erased at runtime and
+* cannot be used here.
+*
+* @experimental
+*/
+const eventsFromSchemas = dual((args) => args.length >= 2 || isStateMachineArgument(args[0]), function eventsFromSchemas(machine, options = {}) {
+	const schemas = machine.schemas?.events ?? {};
+	const wildcards = Object.keys(schemas).filter((key) => key.includes("*"));
+	const generators = {};
+	for (const [eventType, schema] of Object.entries(schemas)) {
+		if (eventType.includes("*")) continue;
+		generators[eventType] = stripType(arbitraryFromSchema(schema, options, eventType), eventType);
+	}
+	for (const eventType of machine.events) {
+		if (typeof eventType !== "string" || eventType.includes("*") || eventType.startsWith("xstate.") || eventType.startsWith("@xstate.") || generators[eventType] !== void 0) continue;
+		const descriptor = wildcards.find((key) => matchesEventDescriptor(eventType, key));
+		if (descriptor !== void 0) generators[eventType] = stripType(arbitraryFromSchema(schemas[descriptor], options, eventType), eventType);
+		else if ((options.eventsWithoutSchema ?? "empty") === "empty") generators[eventType] = fc.constant({});
+	}
+	return generators;
+});
+/**
+* Merges derived generators with explicit ones. Explicit entries win for event
+* types declared in both.
+*
+* @experimental
+*/
+const mergeEventGenerators = dual(2, function mergeEventGenerators(derived, explicit) {
+	return {
+		...derived,
+		...explicit
+	};
+});
+export { arbitraryFromSchema, eventsFromSchemas, isTypeOnlySchema, mergeEventGenerators };