@loopstack/loopstack-studio 0.21.0 → 0.21.1

package/dist/node_modules/zod/v4/core/checks.js

@@ -0,0 +1,283 @@
+import { $constructor } from "./core.js";
+import { NUMBER_FORMAT_RANGES, escapeRegex, floatSafeRemainder, getLengthableOrigin, nullish } from "./util.js";
+import { integer, lowercase, uppercase } from "./regexes.js";
+const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (t, y) => {
+	var b;
+	t._zod ??= {}, t._zod.def = y, (b = t._zod).onattach ?? (b.onattach = []);
+});
+var numericOriginMap = {
+	number: "number",
+	bigint: "bigint",
+	object: "date"
+};
+const $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (t, y) => {
+	$ZodCheck.init(t, y);
+	let b = numericOriginMap[typeof y.value];
+	t._zod.onattach.push((t) => {
+		let b = t._zod.bag, x = (y.inclusive ? b.maximum : b.exclusiveMaximum) ?? Infinity;
+		y.value < x && (y.inclusive ? b.maximum = y.value : b.exclusiveMaximum = y.value);
+	}), t._zod.check = (x) => {
+		(y.inclusive ? x.value <= y.value : x.value < y.value) || x.issues.push({
+			origin: b,
+			code: "too_big",
+			maximum: typeof y.value == "object" ? y.value.getTime() : y.value,
+			input: x.value,
+			inclusive: y.inclusive,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (t, y) => {
+	$ZodCheck.init(t, y);
+	let b = numericOriginMap[typeof y.value];
+	t._zod.onattach.push((t) => {
+		let b = t._zod.bag, x = (y.inclusive ? b.minimum : b.exclusiveMinimum) ?? -Infinity;
+		y.value > x && (y.inclusive ? b.minimum = y.value : b.exclusiveMinimum = y.value);
+	}), t._zod.check = (x) => {
+		(y.inclusive ? x.value >= y.value : x.value > y.value) || x.issues.push({
+			origin: b,
+			code: "too_small",
+			minimum: typeof y.value == "object" ? y.value.getTime() : y.value,
+			input: x.value,
+			inclusive: y.inclusive,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (t, y) => {
+	$ZodCheck.init(t, y), t._zod.onattach.push((t) => {
+		var b;
+		(b = t._zod.bag).multipleOf ?? (b.multipleOf = y.value);
+	}), t._zod.check = (b) => {
+		if (typeof b.value != typeof y.value) throw Error("Cannot mix number and bigint in multiple_of check.");
+		(typeof b.value == "bigint" ? b.value % y.value === BigInt(0) : floatSafeRemainder(b.value, y.value) === 0) || b.issues.push({
+			origin: typeof b.value,
+			code: "not_multiple_of",
+			divisor: y.value,
+			input: b.value,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (t, b) => {
+	$ZodCheck.init(t, b), b.format = b.format || "float64";
+	let x = b.format?.includes("int"), S = x ? "int" : "number", [C, T] = NUMBER_FORMAT_RANGES[b.format];
+	t._zod.onattach.push((t) => {
+		let y = t._zod.bag;
+		y.format = b.format, y.minimum = C, y.maximum = T, x && (y.pattern = integer);
+	}), t._zod.check = (y) => {
+		let w = y.value;
+		if (x) {
+			if (!Number.isInteger(w)) {
+				y.issues.push({
+					expected: S,
+					format: b.format,
+					code: "invalid_type",
+					continue: !1,
+					input: w,
+					inst: t
+				});
+				return;
+			}
+			if (!Number.isSafeInteger(w)) {
+				w > 0 ? y.issues.push({
+					input: w,
+					code: "too_big",
+					maximum: 2 ** 53 - 1,
+					note: "Integers must be within the safe integer range.",
+					inst: t,
+					origin: S,
+					inclusive: !0,
+					continue: !b.abort
+				}) : y.issues.push({
+					input: w,
+					code: "too_small",
+					minimum: -(2 ** 53 - 1),
+					note: "Integers must be within the safe integer range.",
+					inst: t,
+					origin: S,
+					inclusive: !0,
+					continue: !b.abort
+				});
+				return;
+			}
+		}
+		w < C && y.issues.push({
+			origin: "number",
+			input: w,
+			code: "too_small",
+			minimum: C,
+			inclusive: !0,
+			inst: t,
+			continue: !b.abort
+		}), w > T && y.issues.push({
+			origin: "number",
+			input: w,
+			code: "too_big",
+			maximum: T,
+			inclusive: !0,
+			inst: t,
+			continue: !b.abort
+		});
+	};
+}), $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (t, y) => {
+	var b;
+	$ZodCheck.init(t, y), (b = t._zod.def).when ?? (b.when = (t) => {
+		let y = t.value;
+		return !nullish(y) && y.length !== void 0;
+	}), t._zod.onattach.push((t) => {
+		let b = t._zod.bag.maximum ?? Infinity;
+		y.maximum < b && (t._zod.bag.maximum = y.maximum);
+	}), t._zod.check = (b) => {
+		let x = b.value;
+		if (x.length <= y.maximum) return;
+		let C = getLengthableOrigin(x);
+		b.issues.push({
+			origin: C,
+			code: "too_big",
+			maximum: y.maximum,
+			inclusive: !0,
+			input: x,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (t, y) => {
+	var b;
+	$ZodCheck.init(t, y), (b = t._zod.def).when ?? (b.when = (t) => {
+		let y = t.value;
+		return !nullish(y) && y.length !== void 0;
+	}), t._zod.onattach.push((t) => {
+		let b = t._zod.bag.minimum ?? -Infinity;
+		y.minimum > b && (t._zod.bag.minimum = y.minimum);
+	}), t._zod.check = (b) => {
+		let x = b.value;
+		if (x.length >= y.minimum) return;
+		let C = getLengthableOrigin(x);
+		b.issues.push({
+			origin: C,
+			code: "too_small",
+			minimum: y.minimum,
+			inclusive: !0,
+			input: x,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (t, y) => {
+	var b;
+	$ZodCheck.init(t, y), (b = t._zod.def).when ?? (b.when = (t) => {
+		let y = t.value;
+		return !nullish(y) && y.length !== void 0;
+	}), t._zod.onattach.push((t) => {
+		let b = t._zod.bag;
+		b.minimum = y.length, b.maximum = y.length, b.length = y.length;
+	}), t._zod.check = (b) => {
+		let x = b.value, C = x.length;
+		if (C === y.length) return;
+		let w = getLengthableOrigin(x), T = C > y.length;
+		b.issues.push({
+			origin: w,
+			...T ? {
+				code: "too_big",
+				maximum: y.length
+			} : {
+				code: "too_small",
+				minimum: y.length
+			},
+			inclusive: !0,
+			exact: !0,
+			input: b.value,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (t, y) => {
+	var b, x;
+	$ZodCheck.init(t, y), t._zod.onattach.push((t) => {
+		let b = t._zod.bag;
+		b.format = y.format, y.pattern && (b.patterns ??= /* @__PURE__ */ new Set(), b.patterns.add(y.pattern));
+	}), y.pattern ? (b = t._zod).check ?? (b.check = (b) => {
+		y.pattern.lastIndex = 0, !y.pattern.test(b.value) && b.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: y.format,
+			input: b.value,
+			...y.pattern ? { pattern: y.pattern.toString() } : {},
+			inst: t,
+			continue: !y.abort
+		});
+	}) : (x = t._zod).check ?? (x.check = () => {});
+}), $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (t, y) => {
+	$ZodCheckStringFormat.init(t, y), t._zod.check = (b) => {
+		y.pattern.lastIndex = 0, !y.pattern.test(b.value) && b.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "regex",
+			input: b.value,
+			pattern: y.pattern.toString(),
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (t, y) => {
+	y.pattern ??= lowercase, $ZodCheckStringFormat.init(t, y);
+}), $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (t, y) => {
+	y.pattern ??= uppercase, $ZodCheckStringFormat.init(t, y);
+}), $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (t, y) => {
+	$ZodCheck.init(t, y);
+	let x = escapeRegex(y.includes), S = new RegExp(typeof y.position == "number" ? `^.{${y.position}}${x}` : x);
+	y.pattern = S, t._zod.onattach.push((t) => {
+		let y = t._zod.bag;
+		y.patterns ??= /* @__PURE__ */ new Set(), y.patterns.add(S);
+	}), t._zod.check = (b) => {
+		b.value.includes(y.includes, y.position) || b.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "includes",
+			includes: y.includes,
+			input: b.value,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (t, y) => {
+	$ZodCheck.init(t, y);
+	let x = /* @__PURE__ */ RegExp(`^${escapeRegex(y.prefix)}.*`);
+	y.pattern ??= x, t._zod.onattach.push((t) => {
+		let y = t._zod.bag;
+		y.patterns ??= /* @__PURE__ */ new Set(), y.patterns.add(x);
+	}), t._zod.check = (b) => {
+		b.value.startsWith(y.prefix) || b.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "starts_with",
+			prefix: y.prefix,
+			input: b.value,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (t, y) => {
+	$ZodCheck.init(t, y);
+	let x = /* @__PURE__ */ RegExp(`.*${escapeRegex(y.suffix)}$`);
+	y.pattern ??= x, t._zod.onattach.push((t) => {
+		let y = t._zod.bag;
+		y.patterns ??= /* @__PURE__ */ new Set(), y.patterns.add(x);
+	}), t._zod.check = (b) => {
+		b.value.endsWith(y.suffix) || b.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "ends_with",
+			suffix: y.suffix,
+			input: b.value,
+			inst: t,
+			continue: !y.abort
+		});
+	};
+}), $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (t, y) => {
+	$ZodCheck.init(t, y), t._zod.check = (t) => {
+		t.value = y.tx(t.value);
+	};
+});
+export { $ZodCheck, $ZodCheckEndsWith, $ZodCheckGreaterThan, $ZodCheckIncludes, $ZodCheckLengthEquals, $ZodCheckLessThan, $ZodCheckLowerCase, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckOverwrite, $ZodCheckRegex, $ZodCheckStartsWith, $ZodCheckStringFormat, $ZodCheckUpperCase };

package/dist/node_modules/zod/v4/core/core.js

@@ -0,0 +1,44 @@
+Object.freeze({ status: "aborted" });
+function $constructor(e, t, n) {
+	function r(n, r) {
+		if (n._zod || Object.defineProperty(n, "_zod", {
+			value: {
+				def: r,
+				constr: o,
+				traits: /* @__PURE__ */ new Set()
+			},
+			enumerable: !1
+		}), n._zod.traits.has(e)) return;
+		n._zod.traits.add(e), t(n, r);
+		let i = o.prototype, a = Object.keys(i);
+		for (let e = 0; e < a.length; e++) {
+			let t = a[e];
+			t in n || (n[t] = i[t].bind(n));
+		}
+	}
+	let i = n?.Parent ?? Object;
+	class a extends i {}
+	Object.defineProperty(a, "name", { value: e });
+	function o(e) {
+		var t;
+		let i = n?.Parent ? new a() : this;
+		r(i, e), (t = i._zod).deferred ?? (t.deferred = []);
+		for (let e of i._zod.deferred) e();
+		return i;
+	}
+	return Object.defineProperty(o, "init", { value: r }), Object.defineProperty(o, Symbol.hasInstance, { value: (t) => n?.Parent && t instanceof n.Parent ? !0 : t?._zod?.traits?.has(e) }), Object.defineProperty(o, "name", { value: e }), o;
+}
+var $ZodAsyncError = class extends Error {
+	constructor() {
+		super("Encountered Promise during synchronous parse. Use .parseAsync() instead.");
+	}
+}, $ZodEncodeError = class extends Error {
+	constructor(e) {
+		super(`Encountered unidirectional transform during encode: ${e}`), this.name = "ZodEncodeError";
+	}
+};
+const globalConfig = {};
+function config(e) {
+	return e && Object.assign(globalConfig, e), globalConfig;
+}
+export { $ZodAsyncError, $ZodEncodeError, $constructor, config, globalConfig };

package/dist/node_modules/zod/v4/core/doc.js

@@ -0,0 +1,21 @@
+var Doc = class {
+	constructor(e = []) {
+		this.content = [], this.indent = 0, this && (this.args = e);
+	}
+	indented(e) {
+		this.indent += 1, e(this), --this.indent;
+	}
+	write(e) {
+		if (typeof e == "function") {
+			e(this, { execution: "sync" }), e(this, { execution: "async" });
+			return;
+		}
+		let t = e.split("\n").filter((e) => e), n = Math.min(...t.map((e) => e.length - e.trimStart().length)), r = t.map((e) => e.slice(n)).map((e) => " ".repeat(this.indent * 2) + e);
+		for (let e of r) this.content.push(e);
+	}
+	compile() {
+		let e = Function, t = this?.args, n = [...(this?.content ?? [""]).map((e) => `  ${e}`)];
+		return new e(...t, n.join("\n"));
+	}
+};
+export { Doc };

package/dist/node_modules/zod/v4/core/errors.js

@@ -0,0 +1,40 @@
+import { $constructor } from "./core.js";
+import { jsonStringifyReplacer } from "./util.js";
+var initializer = (e, i) => {
+	e.name = "$ZodError", Object.defineProperty(e, "_zod", {
+		value: e._zod,
+		enumerable: !1
+	}), Object.defineProperty(e, "issues", {
+		value: i,
+		enumerable: !1
+	}), e.message = JSON.stringify(i, jsonStringifyReplacer, 2), Object.defineProperty(e, "toString", {
+		value: () => e.message,
+		enumerable: !1
+	});
+};
+const $ZodError = $constructor("$ZodError", initializer), $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+function flattenError(e, r = (e) => e.message) {
+	let i = {}, a = [];
+	for (let o of e.issues) o.path.length > 0 ? (i[o.path[0]] = i[o.path[0]] || [], i[o.path[0]].push(r(o))) : a.push(r(o));
+	return {
+		formErrors: a,
+		fieldErrors: i
+	};
+}
+function formatError(e, r = (e) => e.message) {
+	let i = { _errors: [] }, a = (e) => {
+		for (let o of e.issues) if (o.code === "invalid_union" && o.errors.length) o.errors.map((e) => a({ issues: e }));
+		else if (o.code === "invalid_key") a({ issues: o.issues });
+		else if (o.code === "invalid_element") a({ issues: o.issues });
+		else if (o.path.length === 0) i._errors.push(r(o));
+		else {
+			let e = i, a = 0;
+			for (; a < o.path.length;) {
+				let i = o.path[a];
+				a === o.path.length - 1 ? (e[i] = e[i] || { _errors: [] }, e[i]._errors.push(r(o))) : e[i] = e[i] || { _errors: [] }, e = e[i], a++;
+			}
+		}
+	};
+	return a(e), i;
+}
+export { $ZodError, $ZodRealError, flattenError, formatError };

package/dist/node_modules/zod/v4/core/json-schema-processors.js

@@ -0,0 +1,305 @@
+import { getEnumValues } from "./util.js";
+import { extractDefs, finalize, initializeContext, process } from "./to-json-schema.js";
+var formatMap = {
+	guid: "uuid",
+	url: "uri",
+	datetime: "date-time",
+	json_string: "json-string",
+	regex: ""
+};
+const stringProcessor = (l, F, I, L) => {
+	let R = I;
+	R.type = "string";
+	let { minimum: B, maximum: V, format: H, patterns: U, contentEncoding: W } = l._zod.bag;
+	if (typeof B == "number" && (R.minLength = B), typeof V == "number" && (R.maxLength = V), H && (R.format = formatMap[H] ?? H, R.format === "" && delete R.format, H === "time" && delete R.format), W && (R.contentEncoding = W), U && U.size > 0) {
+		let l = [...U];
+		l.length === 1 ? R.pattern = l[0].source : l.length > 1 && (R.allOf = [...l.map((l) => ({
+			...F.target === "draft-07" || F.target === "draft-04" || F.target === "openapi-3.0" ? { type: "string" } : {},
+			pattern: l.source
+		}))]);
+	}
+}, numberProcessor = (l, F, I, L) => {
+	let R = I, { minimum: z, maximum: B, format: V, multipleOf: H, exclusiveMaximum: U, exclusiveMinimum: W } = l._zod.bag;
+	typeof V == "string" && V.includes("int") ? R.type = "integer" : R.type = "number", typeof W == "number" && (F.target === "draft-04" || F.target === "openapi-3.0" ? (R.minimum = W, R.exclusiveMinimum = !0) : R.exclusiveMinimum = W), typeof z == "number" && (R.minimum = z, typeof W == "number" && F.target !== "draft-04" && (W >= z ? delete R.minimum : delete R.exclusiveMinimum)), typeof U == "number" && (F.target === "draft-04" || F.target === "openapi-3.0" ? (R.maximum = U, R.exclusiveMaximum = !0) : R.exclusiveMaximum = U), typeof B == "number" && (R.maximum = B, typeof U == "number" && F.target !== "draft-04" && (U <= B ? delete R.maximum : delete R.exclusiveMaximum)), typeof H == "number" && (R.multipleOf = H);
+}, booleanProcessor = (l, F, I, L) => {
+	I.type = "boolean";
+}, bigintProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("BigInt cannot be represented in JSON Schema");
+}, symbolProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Symbols cannot be represented in JSON Schema");
+}, nullProcessor = (l, F, I, L) => {
+	F.target === "openapi-3.0" ? (I.type = "string", I.nullable = !0, I.enum = [null]) : I.type = "null";
+}, undefinedProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Undefined cannot be represented in JSON Schema");
+}, voidProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Void cannot be represented in JSON Schema");
+}, neverProcessor = (l, F, I, L) => {
+	I.not = {};
+}, anyProcessor = (l, F, I, L) => {}, unknownProcessor = (l, F, I, L) => {}, dateProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Date cannot be represented in JSON Schema");
+}, enumProcessor = (F, I, L, R) => {
+	let z = F._zod.def, B = getEnumValues(z.entries);
+	B.every((l) => typeof l == "number") && (L.type = "number"), B.every((l) => typeof l == "string") && (L.type = "string"), L.enum = B;
+}, literalProcessor = (l, F, I, L) => {
+	let R = l._zod.def, z = [];
+	for (let l of R.values) if (l === void 0) {
+		if (F.unrepresentable === "throw") throw Error("Literal `undefined` cannot be represented in JSON Schema");
+	} else if (typeof l == "bigint") {
+		if (F.unrepresentable === "throw") throw Error("BigInt literals cannot be represented in JSON Schema");
+		z.push(Number(l));
+	} else z.push(l);
+	if (z.length !== 0) if (z.length === 1) {
+		let l = z[0];
+		I.type = l === null ? "null" : typeof l, F.target === "draft-04" || F.target === "openapi-3.0" ? I.enum = [l] : I.const = l;
+	} else z.every((l) => typeof l == "number") && (I.type = "number"), z.every((l) => typeof l == "string") && (I.type = "string"), z.every((l) => typeof l == "boolean") && (I.type = "boolean"), z.every((l) => l === null) && (I.type = "null"), I.enum = z;
+}, nanProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("NaN cannot be represented in JSON Schema");
+}, templateLiteralProcessor = (l, F, I, L) => {
+	let R = I, z = l._zod.pattern;
+	if (!z) throw Error("Pattern not found in template literal");
+	R.type = "string", R.pattern = z.source;
+}, fileProcessor = (l, F, I, L) => {
+	let R = I, z = {
+		type: "string",
+		format: "binary",
+		contentEncoding: "binary"
+	}, { minimum: B, maximum: V, mime: H } = l._zod.bag;
+	B !== void 0 && (z.minLength = B), V !== void 0 && (z.maxLength = V), H ? H.length === 1 ? (z.contentMediaType = H[0], Object.assign(R, z)) : (Object.assign(R, z), R.anyOf = H.map((l) => ({ contentMediaType: l }))) : Object.assign(R, z);
+}, successProcessor = (l, F, I, L) => {
+	I.type = "boolean";
+}, customProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Custom types cannot be represented in JSON Schema");
+}, functionProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Function types cannot be represented in JSON Schema");
+}, transformProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Transforms cannot be represented in JSON Schema");
+}, mapProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Map cannot be represented in JSON Schema");
+}, setProcessor = (l, F, I, L) => {
+	if (F.unrepresentable === "throw") throw Error("Set cannot be represented in JSON Schema");
+}, arrayProcessor = (l, F, I, L) => {
+	let z = I, B = l._zod.def, { minimum: V, maximum: H } = l._zod.bag;
+	typeof V == "number" && (z.minItems = V), typeof H == "number" && (z.maxItems = H), z.type = "array", z.items = process(B.element, F, {
+		...L,
+		path: [...L.path, "items"]
+	});
+}, objectProcessor = (l, F, I, L) => {
+	let z = I, B = l._zod.def;
+	z.type = "object", z.properties = {};
+	let V = B.shape;
+	for (let l in V) z.properties[l] = process(V[l], F, {
+		...L,
+		path: [
+			...L.path,
+			"properties",
+			l
+		]
+	});
+	let H = new Set(Object.keys(V)), U = new Set([...H].filter((l) => {
+		let I = B.shape[l]._zod;
+		return F.io === "input" ? I.optin === void 0 : I.optout === void 0;
+	}));
+	U.size > 0 && (z.required = Array.from(U)), B.catchall?._zod.def.type === "never" ? z.additionalProperties = !1 : B.catchall ? B.catchall && (z.additionalProperties = process(B.catchall, F, {
+		...L,
+		path: [...L.path, "additionalProperties"]
+	})) : F.io === "output" && (z.additionalProperties = !1);
+}, unionProcessor = (l, F, I, L) => {
+	let z = l._zod.def, B = z.inclusive === !1, V = z.options.map((l, I) => process(l, F, {
+		...L,
+		path: [
+			...L.path,
+			B ? "oneOf" : "anyOf",
+			I
+		]
+	}));
+	B ? I.oneOf = V : I.anyOf = V;
+}, intersectionProcessor = (l, F, I, L) => {
+	let z = l._zod.def, B = process(z.left, F, {
+		...L,
+		path: [
+			...L.path,
+			"allOf",
+			0
+		]
+	}), V = process(z.right, F, {
+		...L,
+		path: [
+			...L.path,
+			"allOf",
+			1
+		]
+	}), H = (l) => "allOf" in l && Object.keys(l).length === 1;
+	I.allOf = [...H(B) ? B.allOf : [B], ...H(V) ? V.allOf : [V]];
+}, tupleProcessor = (l, F, I, L) => {
+	let z = I, B = l._zod.def;
+	z.type = "array";
+	let V = F.target === "draft-2020-12" ? "prefixItems" : "items", H = F.target === "draft-2020-12" || F.target === "openapi-3.0" ? "items" : "additionalItems", U = B.items.map((l, I) => process(l, F, {
+		...L,
+		path: [
+			...L.path,
+			V,
+			I
+		]
+	})), W = B.rest ? process(B.rest, F, {
+		...L,
+		path: [
+			...L.path,
+			H,
+			...F.target === "openapi-3.0" ? [B.items.length] : []
+		]
+	}) : null;
+	F.target === "draft-2020-12" ? (z.prefixItems = U, W && (z.items = W)) : F.target === "openapi-3.0" ? (z.items = { anyOf: U }, W && z.items.anyOf.push(W), z.minItems = U.length, W || (z.maxItems = U.length)) : (z.items = U, W && (z.additionalItems = W));
+	let { minimum: G, maximum: K } = l._zod.bag;
+	typeof G == "number" && (z.minItems = G), typeof K == "number" && (z.maxItems = K);
+}, recordProcessor = (l, F, I, L) => {
+	let z = I, B = l._zod.def;
+	z.type = "object";
+	let V = B.keyType, H = V._zod.bag?.patterns;
+	if (B.mode === "loose" && H && H.size > 0) {
+		let l = process(B.valueType, F, {
+			...L,
+			path: [
+				...L.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		z.patternProperties = {};
+		for (let F of H) z.patternProperties[F.source] = l;
+	} else (F.target === "draft-07" || F.target === "draft-2020-12") && (z.propertyNames = process(B.keyType, F, {
+		...L,
+		path: [...L.path, "propertyNames"]
+	})), z.additionalProperties = process(B.valueType, F, {
+		...L,
+		path: [...L.path, "additionalProperties"]
+	});
+	let U = V._zod.values;
+	if (U) {
+		let l = [...U].filter((l) => typeof l == "string" || typeof l == "number");
+		l.length > 0 && (z.required = l);
+	}
+}, nullableProcessor = (l, F, I, L) => {
+	let z = l._zod.def, B = process(z.innerType, F, L), V = F.seen.get(l);
+	F.target === "openapi-3.0" ? (V.ref = z.innerType, I.nullable = !0) : I.anyOf = [B, { type: "null" }];
+}, nonoptionalProcessor = (l, F, I, L) => {
+	let z = l._zod.def;
+	process(z.innerType, F, L);
+	let B = F.seen.get(l);
+	B.ref = z.innerType;
+}, defaultProcessor = (l, F, I, L) => {
+	let z = l._zod.def;
+	process(z.innerType, F, L);
+	let B = F.seen.get(l);
+	B.ref = z.innerType, I.default = JSON.parse(JSON.stringify(z.defaultValue));
+}, prefaultProcessor = (l, F, I, L) => {
+	let z = l._zod.def;
+	process(z.innerType, F, L);
+	let B = F.seen.get(l);
+	B.ref = z.innerType, F.io === "input" && (I._prefault = JSON.parse(JSON.stringify(z.defaultValue)));
+}, catchProcessor = (l, F, I, L) => {
+	let z = l._zod.def;
+	process(z.innerType, F, L);
+	let B = F.seen.get(l);
+	B.ref = z.innerType;
+	let V;
+	try {
+		V = z.catchValue(void 0);
+	} catch {
+		throw Error("Dynamic catch values are not supported in JSON Schema");
+	}
+	I.default = V;
+}, pipeProcessor = (l, F, I, L) => {
+	let z = l._zod.def, B = F.io === "input" ? z.in._zod.def.type === "transform" ? z.out : z.in : z.out;
+	process(B, F, L);
+	let V = F.seen.get(l);
+	V.ref = B;
+}, readonlyProcessor = (l, F, I, L) => {
+	let z = l._zod.def;
+	process(z.innerType, F, L);
+	let B = F.seen.get(l);
+	B.ref = z.innerType, I.readOnly = !0;
+}, promiseProcessor = (l, F, I, L) => {
+	let z = l._zod.def;
+	process(z.innerType, F, L);
+	let B = F.seen.get(l);
+	B.ref = z.innerType;
+}, optionalProcessor = (l, F, I, L) => {
+	let z = l._zod.def;
+	process(z.innerType, F, L);
+	let B = F.seen.get(l);
+	B.ref = z.innerType;
+}, lazyProcessor = (l, F, I, L) => {
+	let z = l._zod.innerType;
+	process(z, F, L);
+	let B = F.seen.get(l);
+	B.ref = z;
+}, allProcessors = {
+	string: stringProcessor,
+	number: numberProcessor,
+	boolean: booleanProcessor,
+	bigint: bigintProcessor,
+	symbol: symbolProcessor,
+	null: nullProcessor,
+	undefined: undefinedProcessor,
+	void: voidProcessor,
+	never: neverProcessor,
+	any: anyProcessor,
+	unknown: unknownProcessor,
+	date: dateProcessor,
+	enum: enumProcessor,
+	literal: literalProcessor,
+	nan: nanProcessor,
+	template_literal: templateLiteralProcessor,
+	file: fileProcessor,
+	success: successProcessor,
+	custom: customProcessor,
+	function: functionProcessor,
+	transform: transformProcessor,
+	map: mapProcessor,
+	set: setProcessor,
+	array: arrayProcessor,
+	object: objectProcessor,
+	union: unionProcessor,
+	intersection: intersectionProcessor,
+	tuple: tupleProcessor,
+	record: recordProcessor,
+	nullable: nullableProcessor,
+	nonoptional: nonoptionalProcessor,
+	default: defaultProcessor,
+	prefault: prefaultProcessor,
+	catch: catchProcessor,
+	pipe: pipeProcessor,
+	readonly: readonlyProcessor,
+	promise: promiseProcessor,
+	optional: optionalProcessor,
+	lazy: lazyProcessor
+};
+function toJSONSchema(l, z) {
+	if ("_idmap" in l) {
+		let B = l, V = initializeContext({
+			...z,
+			processors: allProcessors
+		}), H = {};
+		for (let l of B._idmap.entries()) {
+			let [F, I] = l;
+			process(I, V);
+		}
+		let U = {};
+		V.external = {
+			registry: B,
+			uri: z?.uri,
+			defs: H
+		};
+		for (let l of B._idmap.entries()) {
+			let [L, R] = l;
+			extractDefs(V, R), U[L] = finalize(V, R);
+		}
+		return Object.keys(H).length > 0 && (U.__shared = { [V.target === "draft-2020-12" ? "$defs" : "definitions"]: H }), { schemas: U };
+	}
+	let B = initializeContext({
+		...z,
+		processors: allProcessors
+	});
+	return process(l, B), extractDefs(B, l), finalize(B, l);
+}
+export { arrayProcessor, booleanProcessor, catchProcessor, customProcessor, defaultProcessor, enumProcessor, intersectionProcessor, lazyProcessor, literalProcessor, neverProcessor, nonoptionalProcessor, nullProcessor, nullableProcessor, numberProcessor, objectProcessor, optionalProcessor, pipeProcessor, prefaultProcessor, readonlyProcessor, recordProcessor, stringProcessor, toJSONSchema, transformProcessor, unionProcessor, unknownProcessor };