@inkeep/agents-manage-mcp 0.40.0 → 0.41.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/core.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/core.js
 /** A special constant with type `never` */
 const NEVER = Object.freeze({ status: "aborted" });
 function $constructor(name, initializer$2, params) {
@@ -60,7 +60,7 @@ function config(newConfig) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/util.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
 	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
@@ -208,6 +208,8 @@ const NUMBER_FORMAT_RANGES = {
 };
 function pick(schema, mask) {
 	const currDef = schema._zod.def;
+	const checks = currDef.checks;
+	if (checks && checks.length > 0) throw new Error(".pick() cannot be used on object schemas containing refinements");
 	return clone(schema, mergeDefs(schema._zod.def, {
 		get shape() {
 			const newShape = {};
@@ -224,6 +226,8 @@ function pick(schema, mask) {
 }
 function omit(schema, mask) {
 	const currDef = schema._zod.def;
+	const checks = currDef.checks;
+	if (checks && checks.length > 0) throw new Error(".omit() cannot be used on object schemas containing refinements");
 	return clone(schema, mergeDefs(schema._zod.def, {
 		get shape() {
 			const newShape = { ...schema._zod.def.shape };
@@ -241,33 +245,29 @@ function omit(schema, mask) {
 function extend(schema, shape) {
 	if (!isPlainObject$1(shape)) throw new Error("Invalid input to extend: expected a plain object");
 	const checks = schema._zod.def.checks;
-	if (checks && checks.length > 0) throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
-	return clone(schema, mergeDefs(schema._zod.def, {
-		get shape() {
-			const _shape = {
-				...schema._zod.def.shape,
-				...shape
-			};
-			assignProp(this, "shape", _shape);
-			return _shape;
-		},
-		checks: []
-	}));
+	if (checks && checks.length > 0) {
+		const existingShape = schema._zod.def.shape;
+		for (const key in shape) if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+	}
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const _shape = {
+			...schema._zod.def.shape,
+			...shape
+		};
+		assignProp(this, "shape", _shape);
+		return _shape;
+	} }));
 }
 function safeExtend(schema, shape) {
 	if (!isPlainObject$1(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
-	return clone(schema, {
-		...schema._zod.def,
-		get shape() {
-			const _shape = {
-				...schema._zod.def.shape,
-				...shape
-			};
-			assignProp(this, "shape", _shape);
-			return _shape;
-		},
-		checks: schema._zod.def.checks
-	});
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const _shape = {
+			...schema._zod.def.shape,
+			...shape
+		};
+		assignProp(this, "shape", _shape);
+		return _shape;
+	} }));
 }
 function merge(a, b) {
 	return clone(a, mergeDefs(a._zod.def, {
@@ -286,6 +286,8 @@ function merge(a, b) {
 	}));
 }
 function partial(Class, schema, mask) {
+	const checks = schema._zod.def.checks;
+	if (checks && checks.length > 0) throw new Error(".partial() cannot be used on object schemas containing refinements");
 	return clone(schema, mergeDefs(schema._zod.def, {
 		get shape() {
 			const oldShape = schema._zod.def.shape;
@@ -309,27 +311,24 @@ function partial(Class, schema, mask) {
 	}));
 }
 function required(Class, schema, mask) {
-	return clone(schema, mergeDefs(schema._zod.def, {
-		get shape() {
-			const oldShape = schema._zod.def.shape;
-			const shape = { ...oldShape };
-			if (mask) for (const key in mask) {
-				if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
-				if (!mask[key]) continue;
-				shape[key] = new Class({
-					type: "nonoptional",
-					innerType: oldShape[key]
-				});
-			}
-			else for (const key in oldShape) shape[key] = new Class({
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const oldShape = schema._zod.def.shape;
+		const shape = { ...oldShape };
+		if (mask) for (const key in mask) {
+			if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
+			if (!mask[key]) continue;
+			shape[key] = new Class({
 				type: "nonoptional",
 				innerType: oldShape[key]
 			});
-			assignProp(this, "shape", shape);
-			return shape;
-		},
-		checks: []
-	}));
+		}
+		else for (const key in oldShape) shape[key] = new Class({
+			type: "nonoptional",
+			innerType: oldShape[key]
+		});
+		assignProp(this, "shape", shape);
+		return shape;
+	} }));
 }
 function aborted(x, startIndex = 0) {
 	if (x.aborted === true) return true;
@@ -375,7 +374,7 @@ function issue(...args$113) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/errors.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/errors.js
 const initializer$1 = (inst, def) => {
 	inst.name = "$ZodError";
 	Object.defineProperty(inst, "_zod", {
@@ -486,7 +485,7 @@ function prettifyError(error) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/parse.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/parse.js
 const _parse = (_Err) => (schema, value, _ctx, _params) => {
 	const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
 	const result = schema._zod.run({
@@ -590,7 +589,7 @@ const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 const safeDecodeAsync$1 = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/regexes.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/regexes.js
 const cuid = /^[cC][^\s-]{8,}$/;
 const cuid2 = /^[0-9a-z]+$/;
 const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
@@ -620,7 +619,7 @@ const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-
 const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 const base64url = /^[A-Za-z0-9_-]*$/;
-const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+const e164 = /^\+[1-9]\d{6,14}$/;
 const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
 const date$1 = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
 function timeSource(args$113) {
@@ -643,13 +642,13 @@ const string$1 = (params) => {
 	return /* @__PURE__ */ new RegExp(`^${regex}$`);
 };
 const integer = /^-?\d+$/;
-const number$1 = /^-?\d+(?:\.\d+)?/;
+const number$1 = /^-?\d+(?:\.\d+)?$/;
 const boolean$2 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/checks.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/checks.js
 const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
 	var _a$1;
 	inst._zod ?? (inst._zod = {});
@@ -675,7 +674,7 @@ const $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (ins
 		payload.issues.push({
 			origin,
 			code: "too_big",
-			maximum: def.value,
+			maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
 			input: payload.value,
 			inclusive: def.inclusive,
 			inst,
@@ -697,7 +696,7 @@ const $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan"
 		payload.issues.push({
 			origin,
 			code: "too_small",
-			minimum: def.value,
+			minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
 			input: payload.value,
 			inclusive: def.inclusive,
 			inst,
@@ -759,6 +758,7 @@ const $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberForma
 					note: "Integers must be within the safe integer range.",
 					inst,
 					origin,
+					inclusive: true,
 					continue: !def.abort
 				});
 				else payload.issues.push({
@@ -768,6 +768,7 @@ const $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberForma
 					note: "Integers must be within the safe integer range.",
 					inst,
 					origin,
+					inclusive: true,
 					continue: !def.abort
 				});
 				return;
@@ -787,7 +788,9 @@ const $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberForma
 			input,
 			code: "too_big",
 			maximum,
-			inst
+			inclusive: true,
+			inst,
+			continue: !def.abort
 		});
 	};
 });
@@ -1004,7 +1007,7 @@ const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (i
 });
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/doc.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/doc.js
 var Doc = class {
 	constructor(args$113 = []) {
 		this.content = [];
@@ -1036,15 +1039,15 @@ var Doc = class {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/versions.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/versions.js
 const version = {
 	major: 4,
-	minor: 1,
-	patch: 13
+	minor: 3,
+	patch: 5
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/schemas.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/schemas.js
 const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 	var _a$1;
 	inst ?? (inst = {});
@@ -1120,7 +1123,7 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 			return runChecks(result, checks, ctx);
 		};
 	}
-	inst["~standard"] = {
+	defineLazy(inst, "~standard", () => ({
 		validate: (value) => {
 			try {
 				const r = safeParse$2(inst, value);
@@ -1131,7 +1134,7 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 		},
 		vendor: "zod",
 		version: 1
-	};
+	}));
 });
 const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
 	$ZodType.init(inst, def);
@@ -1489,8 +1492,11 @@ const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
 		return payload;
 	};
 });
-function handlePropertyResult(result, final, key, input) {
-	if (result.issues.length) final.issues.push(...prefixIssues(key, result.issues));
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
+	if (result.issues.length) {
+		if (isOptionalOut && !(key in input)) return;
+		final.issues.push(...prefixIssues(key, result.issues));
+	}
 	if (result.value === void 0) {
 		if (key in input) final.value[key] = void 0;
 	} else final.value[key] = result.value;
@@ -1512,6 +1518,7 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
 	const keySet = def.keySet;
 	const _catchall = def.catchall._zod;
 	const t = _catchall.def.type;
+	const isOptionalOut = _catchall.optout === "optional";
 	for (const key in input) {
 		if (keySet.has(key)) continue;
 		if (t === "never") {
@@ -1522,8 +1529,8 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
 			value: input[key],
 			issues: []
 		}, ctx);
-		if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input)));
-		else handlePropertyResult(r, payload, key, input);
+		if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input, isOptionalOut)));
+		else handlePropertyResult(r, payload, key, input, isOptionalOut);
 	}
 	if (unrecognized.length) payload.issues.push({
 		code: "unrecognized_keys",
@@ -1578,12 +1585,14 @@ const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
 		const proms = [];
 		const shape = value.shape;
 		for (const key of value.keys) {
-			const r = shape[key]._zod.run({
+			const el = shape[key];
+			const isOptionalOut = el._zod.optout === "optional";
+			const r = el._zod.run({
 				value: input[key],
 				issues: []
 			}, ctx);
-			if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input)));
-			else handlePropertyResult(r, payload, key, input);
+			if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input, isOptionalOut)));
+			else handlePropertyResult(r, payload, key, input, isOptionalOut);
 		}
 		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
 		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
@@ -1612,8 +1621,28 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
 		for (const key of normalized.keys) {
 			const id = ids[key];
 			const k = esc(key);
+			const isOptionalOut = shape[key]?._zod?.optout === "optional";
 			doc.write(`const ${id} = ${parseStr(key)};`);
-			doc.write(`
+			if (isOptionalOut) doc.write(`
+        if (${id}.issues.length) {
+          if (${k} in input) {
+            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${k}, ...iss.path] : [${k}]
+            })));
+          }
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+			else doc.write(`
         if (${id}.issues.length) {
           payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
@@ -1621,7 +1650,6 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
           })));
         }
         
-        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -1795,8 +1823,25 @@ function mergeValues(a, b) {
 	};
 }
 function handleIntersectionResults(result, left, right) {
-	if (left.issues.length) result.issues.push(...left.issues);
-	if (right.issues.length) result.issues.push(...right.issues);
+	const unrecKeys = /* @__PURE__ */ new Map();
+	let unrecIssue;
+	for (const iss of left.issues) if (iss.code === "unrecognized_keys") {
+		unrecIssue ?? (unrecIssue = iss);
+		for (const k of iss.keys) {
+			if (!unrecKeys.has(k)) unrecKeys.set(k, {});
+			unrecKeys.get(k).l = true;
+		}
+	} else result.issues.push(iss);
+	for (const iss of right.issues) if (iss.code === "unrecognized_keys") for (const k of iss.keys) {
+		if (!unrecKeys.has(k)) unrecKeys.set(k, {});
+		unrecKeys.get(k).r = true;
+	}
+	else result.issues.push(iss);
+	const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+	if (bothKeys.length && unrecIssue) result.issues.push({
+		...unrecIssue,
+		keys: bothKeys
+	});
 	if (aborted(result)) return result;
 	const merged = mergeValues(left.value, right.value);
 	if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
@@ -1851,13 +1896,22 @@ const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 			payload.value = {};
 			for (const key of Reflect.ownKeys(input)) {
 				if (key === "__proto__") continue;
-				const keyResult = def.keyType._zod.run({
+				let keyResult = def.keyType._zod.run({
 					value: key,
 					issues: []
 				}, ctx);
 				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number")) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
 				if (keyResult.issues.length) {
-					payload.issues.push({
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
 						code: "invalid_key",
 						origin: "record",
 						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
@@ -1865,7 +1919,6 @@ const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 						path: [key],
 						inst
 					});
-					payload.value[keyResult.value] = keyResult.value;
 					continue;
 				}
 				const result = def.valueType._zod.run({
@@ -1946,6 +1999,14 @@ const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) =>
 		return def.innerType._zod.run(payload, ctx);
 	};
 });
+const $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
+	inst._zod.parse = (payload, ctx) => {
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
 const $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
@@ -2130,7 +2191,7 @@ function handleRefineResult(result, payload, input, inst) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/registries.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/registries.js
 var _a;
 var $ZodRegistry = class {
 	constructor() {
@@ -2140,10 +2201,7 @@ var $ZodRegistry = class {
 	add(schema, ..._meta) {
 		const meta$2 = _meta[0];
 		this._map.set(schema, meta$2);
-		if (meta$2 && typeof meta$2 === "object" && "id" in meta$2) {
-			if (this._idmap.has(meta$2.id)) throw new Error(`ID ${meta$2.id} already exists in the registry`);
-			this._idmap.set(meta$2.id, schema);
-		}
+		if (meta$2 && typeof meta$2 === "object" && "id" in meta$2) this._idmap.set(meta$2.id, schema);
 		return this;
 	}
 	clear() {
@@ -2181,13 +2239,15 @@ function registry() {
 const globalRegistry = globalThis.__zod_globalRegistry;
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/api.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/api.js
+/* @__NO_SIDE_EFFECTS__ */
 function _string(Class, params) {
 	return new Class({
 		type: "string",
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _email(Class, params) {
 	return new Class({
 		type: "string",
@@ -2197,6 +2257,7 @@ function _email(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _guid(Class, params) {
 	return new Class({
 		type: "string",
@@ -2206,6 +2267,7 @@ function _guid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _uuid(Class, params) {
 	return new Class({
 		type: "string",
@@ -2215,6 +2277,7 @@ function _uuid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _uuidv4(Class, params) {
 	return new Class({
 		type: "string",
@@ -2225,6 +2288,7 @@ function _uuidv4(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _uuidv6(Class, params) {
 	return new Class({
 		type: "string",
@@ -2235,6 +2299,7 @@ function _uuidv6(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _uuidv7(Class, params) {
 	return new Class({
 		type: "string",
@@ -2245,6 +2310,7 @@ function _uuidv7(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _url(Class, params) {
 	return new Class({
 		type: "string",
@@ -2254,6 +2320,7 @@ function _url(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _emoji(Class, params) {
 	return new Class({
 		type: "string",
@@ -2263,6 +2330,7 @@ function _emoji(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _nanoid(Class, params) {
 	return new Class({
 		type: "string",
@@ -2272,6 +2340,7 @@ function _nanoid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _cuid(Class, params) {
 	return new Class({
 		type: "string",
@@ -2281,6 +2350,7 @@ function _cuid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _cuid2(Class, params) {
 	return new Class({
 		type: "string",
@@ -2290,6 +2360,7 @@ function _cuid2(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _ulid(Class, params) {
 	return new Class({
 		type: "string",
@@ -2299,6 +2370,7 @@ function _ulid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _xid(Class, params) {
 	return new Class({
 		type: "string",
@@ -2308,6 +2380,7 @@ function _xid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _ksuid(Class, params) {
 	return new Class({
 		type: "string",
@@ -2317,6 +2390,7 @@ function _ksuid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _ipv4(Class, params) {
 	return new Class({
 		type: "string",
@@ -2326,6 +2400,7 @@ function _ipv4(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _ipv6(Class, params) {
 	return new Class({
 		type: "string",
@@ -2335,6 +2410,7 @@ function _ipv6(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _cidrv4(Class, params) {
 	return new Class({
 		type: "string",
@@ -2344,6 +2420,7 @@ function _cidrv4(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _cidrv6(Class, params) {
 	return new Class({
 		type: "string",
@@ -2353,6 +2430,7 @@ function _cidrv6(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _base64(Class, params) {
 	return new Class({
 		type: "string",
@@ -2362,6 +2440,7 @@ function _base64(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _base64url(Class, params) {
 	return new Class({
 		type: "string",
@@ -2371,6 +2450,7 @@ function _base64url(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _e164(Class, params) {
 	return new Class({
 		type: "string",
@@ -2380,6 +2460,7 @@ function _e164(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _jwt(Class, params) {
 	return new Class({
 		type: "string",
@@ -2389,6 +2470,7 @@ function _jwt(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _isoDateTime(Class, params) {
 	return new Class({
 		type: "string",
@@ -2400,6 +2482,7 @@ function _isoDateTime(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _isoDate(Class, params) {
 	return new Class({
 		type: "string",
@@ -2408,6 +2491,7 @@ function _isoDate(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _isoTime(Class, params) {
 	return new Class({
 		type: "string",
@@ -2417,6 +2501,7 @@ function _isoTime(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _isoDuration(Class, params) {
 	return new Class({
 		type: "string",
@@ -2425,6 +2510,7 @@ function _isoDuration(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _number(Class, params) {
 	return new Class({
 		type: "number",
@@ -2432,6 +2518,7 @@ function _number(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _int(Class, params) {
 	return new Class({
 		type: "number",
@@ -2441,12 +2528,14 @@ function _int(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _boolean(Class, params) {
 	return new Class({
 		type: "boolean",
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _coercedBoolean(Class, params) {
 	return new Class({
 		type: "boolean",
@@ -2454,18 +2543,22 @@ function _coercedBoolean(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _any(Class) {
 	return new Class({ type: "any" });
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _never(Class, params) {
 	return new Class({
 		type: "never",
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _lt(value, params) {
 	return new $ZodCheckLessThan({
 		check: "less_than",
@@ -2474,6 +2567,7 @@ function _lt(value, params) {
 		inclusive: false
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _lte(value, params) {
 	return new $ZodCheckLessThan({
 		check: "less_than",
@@ -2482,6 +2576,7 @@ function _lte(value, params) {
 		inclusive: true
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _gt(value, params) {
 	return new $ZodCheckGreaterThan({
 		check: "greater_than",
@@ -2490,6 +2585,7 @@ function _gt(value, params) {
 		inclusive: false
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _gte(value, params) {
 	return new $ZodCheckGreaterThan({
 		check: "greater_than",
@@ -2498,6 +2594,7 @@ function _gte(value, params) {
 		inclusive: true
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _multipleOf(value, params) {
 	return new $ZodCheckMultipleOf({
 		check: "multiple_of",
@@ -2505,6 +2602,7 @@ function _multipleOf(value, params) {
 		value
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _maxLength(maximum, params) {
 	return new $ZodCheckMaxLength({
 		check: "max_length",
@@ -2512,6 +2610,7 @@ function _maxLength(maximum, params) {
 		maximum
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _minLength(minimum, params) {
 	return new $ZodCheckMinLength({
 		check: "min_length",
@@ -2519,6 +2618,7 @@ function _minLength(minimum, params) {
 		minimum
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _length(length, params) {
 	return new $ZodCheckLengthEquals({
 		check: "length_equals",
@@ -2526,6 +2626,7 @@ function _length(length, params) {
 		length
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _regex(pattern, params) {
 	return new $ZodCheckRegex({
 		check: "string_format",
@@ -2534,6 +2635,7 @@ function _regex(pattern, params) {
 		pattern
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _lowercase(params) {
 	return new $ZodCheckLowerCase({
 		check: "string_format",
@@ -2541,6 +2643,7 @@ function _lowercase(params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _uppercase(params) {
 	return new $ZodCheckUpperCase({
 		check: "string_format",
@@ -2548,6 +2651,7 @@ function _uppercase(params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _includes(includes, params) {
 	return new $ZodCheckIncludes({
 		check: "string_format",
@@ -2556,6 +2660,7 @@ function _includes(includes, params) {
 		includes
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _startsWith(prefix, params) {
 	return new $ZodCheckStartsWith({
 		check: "string_format",
@@ -2564,6 +2669,7 @@ function _startsWith(prefix, params) {
 		prefix
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _endsWith(suffix, params) {
 	return new $ZodCheckEndsWith({
 		check: "string_format",
@@ -2572,27 +2678,34 @@ function _endsWith(suffix, params) {
 		suffix
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _overwrite(tx) {
 	return new $ZodCheckOverwrite({
 		check: "overwrite",
 		tx
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _normalize(form) {
-	return _overwrite((input) => input.normalize(form));
+	return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _trim() {
-	return _overwrite((input) => input.trim());
+	return /* @__PURE__ */ _overwrite((input) => input.trim());
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _toLowerCase() {
-	return _overwrite((input) => input.toLowerCase());
+	return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _toUpperCase() {
-	return _overwrite((input) => input.toUpperCase());
+	return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _slugify() {
-	return _overwrite((input) => slugify(input));
+	return /* @__PURE__ */ _overwrite((input) => slugify(input));
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _array(Class, element, params) {
 	return new Class({
 		type: "array",
@@ -2600,6 +2713,7 @@ function _array(Class, element, params) {
 		...normalizeParams(params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _custom(Class, fn, _params) {
 	const norm = normalizeParams(_params);
 	norm.abort ?? (norm.abort = true);
@@ -2610,6 +2724,7 @@ function _custom(Class, fn, _params) {
 		...norm
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _refine(Class, fn, _params) {
 	return new Class({
 		type: "custom",
@@ -2618,8 +2733,9 @@ function _refine(Class, fn, _params) {
 		...normalizeParams(_params)
 	});
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _superRefine(fn) {
-	const ch = _check((payload) => {
+	const ch = /* @__PURE__ */ _check((payload) => {
 		payload.addIssue = (issue$1) => {
 			if (typeof issue$1 === "string") payload.issues.push(issue(issue$1, payload.value, ch._zod.def));
 			else {
@@ -2636,6 +2752,7 @@ function _superRefine(fn) {
 	});
 	return ch;
 }
+/* @__NO_SIDE_EFFECTS__ */
 function _check(fn, params) {
 	const ch = new $ZodCheck({
 		check: "custom",
@@ -2644,6 +2761,7 @@ function _check(fn, params) {
 	ch._zod.check = fn;
 	return ch;
 }
+/* @__NO_SIDE_EFFECTS__ */
 function describe$1(description) {
 	const ch = new $ZodCheck({ check: "describe" });
 	ch._zod.onattach = [(inst) => {
@@ -2656,6 +2774,7 @@ function describe$1(description) {
 	ch._zod.check = () => {};
 	return ch;
 }
+/* @__NO_SIDE_EFFECTS__ */
 function meta$1(metadata) {
 	const ch = new $ZodCheck({ check: "meta" });
 	ch._zod.onattach = [(inst) => {
@@ -2670,7 +2789,547 @@ function meta$1(metadata) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/classic/iso.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/to-json-schema.js
+function initializeContext(params) {
+	let target = params?.target ?? "draft-2020-12";
+	if (target === "draft-4") target = "draft-04";
+	if (target === "draft-7") target = "draft-07";
+	return {
+		processors: params.processors ?? {},
+		metadataRegistry: params?.metadata ?? globalRegistry,
+		target,
+		unrepresentable: params?.unrepresentable ?? "throw",
+		override: params?.override ?? (() => {}),
+		io: params?.io ?? "output",
+		counter: 0,
+		seen: /* @__PURE__ */ new Map(),
+		cycles: params?.cycles ?? "ref",
+		reused: params?.reused ?? "inline",
+		external: params?.external ?? void 0
+	};
+}
+function process(schema, ctx, _params = {
+	path: [],
+	schemaPath: []
+}) {
+	var _a$1;
+	const def = schema._zod.def;
+	const seen = ctx.seen.get(schema);
+	if (seen) {
+		seen.count++;
+		if (_params.schemaPath.includes(schema)) seen.cycle = _params.path;
+		return seen.schema;
+	}
+	const result = {
+		schema: {},
+		count: 1,
+		cycle: void 0,
+		path: _params.path
+	};
+	ctx.seen.set(schema, result);
+	const overrideSchema = schema._zod.toJSONSchema?.();
+	if (overrideSchema) result.schema = overrideSchema;
+	else {
+		const params = {
+			..._params,
+			schemaPath: [..._params.schemaPath, schema],
+			path: _params.path
+		};
+		if (schema._zod.processJSONSchema) schema._zod.processJSONSchema(ctx, result.schema, params);
+		else {
+			const _json = result.schema;
+			const processor = ctx.processors[def.type];
+			if (!processor) throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+			processor(schema, ctx, _json, params);
+		}
+		const parent = schema._zod.parent;
+		if (parent) {
+			if (!result.ref) result.ref = parent;
+			process(parent, ctx, params);
+			ctx.seen.get(parent).isParent = true;
+		}
+	}
+	const meta$2 = ctx.metadataRegistry.get(schema);
+	if (meta$2) Object.assign(result.schema, meta$2);
+	if (ctx.io === "input" && isTransforming(schema)) {
+		delete result.schema.examples;
+		delete result.schema.default;
+	}
+	if (ctx.io === "input" && result.schema._prefault) (_a$1 = result.schema).default ?? (_a$1.default = result.schema._prefault);
+	delete result.schema._prefault;
+	return ctx.seen.get(schema).schema;
+}
+function extractDefs(ctx, schema) {
+	const root = ctx.seen.get(schema);
+	if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+	const idToSchema = /* @__PURE__ */ new Map();
+	for (const entry of ctx.seen.entries()) {
+		const id = ctx.metadataRegistry.get(entry[0])?.id;
+		if (id) {
+			const existing = idToSchema.get(id);
+			if (existing && existing !== entry[0]) throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+			idToSchema.set(id, entry[0]);
+		}
+	}
+	const makeURI = (entry) => {
+		const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+		if (ctx.external) {
+			const externalId = ctx.external.registry.get(entry[0])?.id;
+			const uriGenerator = ctx.external.uri ?? ((id$1) => id$1);
+			if (externalId) return { ref: uriGenerator(externalId) };
+			const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+			entry[1].defId = id;
+			return {
+				defId: id,
+				ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}`
+			};
+		}
+		if (entry[1] === root) return { ref: "#" };
+		const defUriPrefix = `#/${defsSegment}/`;
+		const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+		return {
+			defId,
+			ref: defUriPrefix + defId
+		};
+	};
+	const extractToDef = (entry) => {
+		if (entry[1].schema.$ref) return;
+		const seen = entry[1];
+		const { ref, defId } = makeURI(entry);
+		seen.def = { ...seen.schema };
+		if (defId) seen.defId = defId;
+		const schema$1 = seen.schema;
+		for (const key in schema$1) delete schema$1[key];
+		schema$1.$ref = ref;
+	};
+	if (ctx.cycles === "throw") for (const entry of ctx.seen.entries()) {
+		const seen = entry[1];
+		if (seen.cycle) throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
+
+Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
+	}
+	for (const entry of ctx.seen.entries()) {
+		const seen = entry[1];
+		if (schema === entry[0]) {
+			extractToDef(entry);
+			continue;
+		}
+		if (ctx.external) {
+			const ext = ctx.external.registry.get(entry[0])?.id;
+			if (schema !== entry[0] && ext) {
+				extractToDef(entry);
+				continue;
+			}
+		}
+		if (ctx.metadataRegistry.get(entry[0])?.id) {
+			extractToDef(entry);
+			continue;
+		}
+		if (seen.cycle) {
+			extractToDef(entry);
+			continue;
+		}
+		if (seen.count > 1) {
+			if (ctx.reused === "ref") {
+				extractToDef(entry);
+				continue;
+			}
+		}
+	}
+}
+function finalize(ctx, schema) {
+	const root = ctx.seen.get(schema);
+	if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+	const flattenRef = (zodSchema) => {
+		const seen = ctx.seen.get(zodSchema);
+		if (seen.ref === null) return;
+		const schema$1 = seen.def ?? seen.schema;
+		const _cached = { ...schema$1 };
+		const ref = seen.ref;
+		seen.ref = null;
+		if (ref) {
+			flattenRef(ref);
+			const refSeen = ctx.seen.get(ref);
+			const refSchema = refSeen.schema;
+			if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+				schema$1.allOf = schema$1.allOf ?? [];
+				schema$1.allOf.push(refSchema);
+			} else Object.assign(schema$1, refSchema);
+			Object.assign(schema$1, _cached);
+			if (zodSchema._zod.parent === ref) for (const key in schema$1) {
+				if (key === "$ref" || key === "allOf") continue;
+				if (!(key in _cached)) delete schema$1[key];
+			}
+			if (refSchema.$ref) for (const key in schema$1) {
+				if (key === "$ref" || key === "allOf") continue;
+				if (key in refSeen.def && JSON.stringify(schema$1[key]) === JSON.stringify(refSeen.def[key])) delete schema$1[key];
+			}
+		}
+		const parent = zodSchema._zod.parent;
+		if (parent && parent !== ref) {
+			flattenRef(parent);
+			const parentSeen = ctx.seen.get(parent);
+			if (parentSeen?.schema.$ref) {
+				schema$1.$ref = parentSeen.schema.$ref;
+				if (parentSeen.def) for (const key in schema$1) {
+					if (key === "$ref" || key === "allOf") continue;
+					if (key in parentSeen.def && JSON.stringify(schema$1[key]) === JSON.stringify(parentSeen.def[key])) delete schema$1[key];
+				}
+			}
+		}
+		ctx.override({
+			zodSchema,
+			jsonSchema: schema$1,
+			path: seen.path ?? []
+		});
+	};
+	for (const entry of [...ctx.seen.entries()].reverse()) flattenRef(entry[0]);
+	const result = {};
+	if (ctx.target === "draft-2020-12") result.$schema = "https://json-schema.org/draft/2020-12/schema";
+	else if (ctx.target === "draft-07") result.$schema = "http://json-schema.org/draft-07/schema#";
+	else if (ctx.target === "draft-04") result.$schema = "http://json-schema.org/draft-04/schema#";
+	else if (ctx.target === "openapi-3.0") {}
+	if (ctx.external?.uri) {
+		const id = ctx.external.registry.get(schema)?.id;
+		if (!id) throw new Error("Schema is missing an `id` property");
+		result.$id = ctx.external.uri(id);
+	}
+	Object.assign(result, root.def ?? root.schema);
+	const defs = ctx.external?.defs ?? {};
+	for (const entry of ctx.seen.entries()) {
+		const seen = entry[1];
+		if (seen.def && seen.defId) defs[seen.defId] = seen.def;
+	}
+	if (ctx.external) {} else if (Object.keys(defs).length > 0) if (ctx.target === "draft-2020-12") result.$defs = defs;
+	else result.definitions = defs;
+	try {
+		const finalized = JSON.parse(JSON.stringify(result));
+		Object.defineProperty(finalized, "~standard", {
+			value: {
+				...schema["~standard"],
+				jsonSchema: {
+					input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+					output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+				}
+			},
+			enumerable: false,
+			writable: false
+		});
+		return finalized;
+	} catch (_err) {
+		throw new Error("Error converting schema to JSON.");
+	}
+}
+function isTransforming(_schema, _ctx) {
+	const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
+	if (ctx.seen.has(_schema)) return false;
+	ctx.seen.add(_schema);
+	const def = _schema._zod.def;
+	if (def.type === "transform") return true;
+	if (def.type === "array") return isTransforming(def.element, ctx);
+	if (def.type === "set") return isTransforming(def.valueType, ctx);
+	if (def.type === "lazy") return isTransforming(def.getter(), ctx);
+	if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") return isTransforming(def.innerType, ctx);
+	if (def.type === "intersection") return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+	if (def.type === "record" || def.type === "map") return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+	if (def.type === "pipe") return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+	if (def.type === "object") {
+		for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;
+		return false;
+	}
+	if (def.type === "union") {
+		for (const option of def.options) if (isTransforming(option, ctx)) return true;
+		return false;
+	}
+	if (def.type === "tuple") {
+		for (const item of def.items) if (isTransforming(item, ctx)) return true;
+		if (def.rest && isTransforming(def.rest, ctx)) return true;
+		return false;
+	}
+	return false;
+}
+/**
+* Creates a toJSONSchema method for a schema instance.
+* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+*/
+const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
+	const ctx = initializeContext({
+		...params,
+		processors
+	});
+	process(schema, ctx);
+	extractDefs(ctx, schema);
+	return finalize(ctx, schema);
+};
+const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
+	const { libraryOptions, target } = params ?? {};
+	const ctx = initializeContext({
+		...libraryOptions ?? {},
+		target,
+		io,
+		processors
+	});
+	process(schema, ctx);
+	extractDefs(ctx, schema);
+	return finalize(ctx, schema);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/json-schema-processors.js
+const formatMap = {
+	guid: "uuid",
+	url: "uri",
+	datetime: "date-time",
+	json_string: "json-string",
+	regex: ""
+};
+const stringProcessor = (schema, ctx, _json, _params) => {
+	const json$1 = _json;
+	json$1.type = "string";
+	const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+	if (typeof minimum === "number") json$1.minLength = minimum;
+	if (typeof maximum === "number") json$1.maxLength = maximum;
+	if (format) {
+		json$1.format = formatMap[format] ?? format;
+		if (json$1.format === "") delete json$1.format;
+		if (format === "time") delete json$1.format;
+	}
+	if (contentEncoding) json$1.contentEncoding = contentEncoding;
+	if (patterns && patterns.size > 0) {
+		const regexes = [...patterns];
+		if (regexes.length === 1) json$1.pattern = regexes[0].source;
+		else if (regexes.length > 1) json$1.allOf = [...regexes.map((regex) => ({
+			...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
+			pattern: regex.source
+		}))];
+	}
+};
+const numberProcessor = (schema, ctx, _json, _params) => {
+	const json$1 = _json;
+	const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+	if (typeof format === "string" && format.includes("int")) json$1.type = "integer";
+	else json$1.type = "number";
+	if (typeof exclusiveMinimum === "number") if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+		json$1.minimum = exclusiveMinimum;
+		json$1.exclusiveMinimum = true;
+	} else json$1.exclusiveMinimum = exclusiveMinimum;
+	if (typeof minimum === "number") {
+		json$1.minimum = minimum;
+		if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") if (exclusiveMinimum >= minimum) delete json$1.minimum;
+		else delete json$1.exclusiveMinimum;
+	}
+	if (typeof exclusiveMaximum === "number") if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+		json$1.maximum = exclusiveMaximum;
+		json$1.exclusiveMaximum = true;
+	} else json$1.exclusiveMaximum = exclusiveMaximum;
+	if (typeof maximum === "number") {
+		json$1.maximum = maximum;
+		if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") if (exclusiveMaximum <= maximum) delete json$1.maximum;
+		else delete json$1.exclusiveMaximum;
+	}
+	if (typeof multipleOf === "number") json$1.multipleOf = multipleOf;
+};
+const booleanProcessor = (_schema, _ctx, json$1, _params) => {
+	json$1.type = "boolean";
+};
+const neverProcessor = (_schema, _ctx, json$1, _params) => {
+	json$1.not = {};
+};
+const anyProcessor = (_schema, _ctx, _json, _params) => {};
+const unknownProcessor = (_schema, _ctx, _json, _params) => {};
+const enumProcessor = (schema, _ctx, json$1, _params) => {
+	const def = schema._zod.def;
+	const values = getEnumValues(def.entries);
+	if (values.every((v) => typeof v === "number")) json$1.type = "number";
+	if (values.every((v) => typeof v === "string")) json$1.type = "string";
+	json$1.enum = values;
+};
+const customProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
+};
+const transformProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Transforms cannot be represented in JSON Schema");
+};
+const arrayProcessor = (schema, ctx, _json, params) => {
+	const json$1 = _json;
+	const def = schema._zod.def;
+	const { minimum, maximum } = schema._zod.bag;
+	if (typeof minimum === "number") json$1.minItems = minimum;
+	if (typeof maximum === "number") json$1.maxItems = maximum;
+	json$1.type = "array";
+	json$1.items = process(def.element, ctx, {
+		...params,
+		path: [...params.path, "items"]
+	});
+};
+const objectProcessor = (schema, ctx, _json, params) => {
+	const json$1 = _json;
+	const def = schema._zod.def;
+	json$1.type = "object";
+	json$1.properties = {};
+	const shape = def.shape;
+	for (const key in shape) json$1.properties[key] = process(shape[key], ctx, {
+		...params,
+		path: [
+			...params.path,
+			"properties",
+			key
+		]
+	});
+	const allKeys = new Set(Object.keys(shape));
+	const requiredKeys = new Set([...allKeys].filter((key) => {
+		const v = def.shape[key]._zod;
+		if (ctx.io === "input") return v.optin === void 0;
+		else return v.optout === void 0;
+	}));
+	if (requiredKeys.size > 0) json$1.required = Array.from(requiredKeys);
+	if (def.catchall?._zod.def.type === "never") json$1.additionalProperties = false;
+	else if (!def.catchall) {
+		if (ctx.io === "output") json$1.additionalProperties = false;
+	} else if (def.catchall) json$1.additionalProperties = process(def.catchall, ctx, {
+		...params,
+		path: [...params.path, "additionalProperties"]
+	});
+};
+const unionProcessor = (schema, ctx, json$1, params) => {
+	const def = schema._zod.def;
+	const isExclusive = def.inclusive === false;
+	const options = def.options.map((x, i) => process(x, ctx, {
+		...params,
+		path: [
+			...params.path,
+			isExclusive ? "oneOf" : "anyOf",
+			i
+		]
+	}));
+	if (isExclusive) json$1.oneOf = options;
+	else json$1.anyOf = options;
+};
+const intersectionProcessor = (schema, ctx, json$1, params) => {
+	const def = schema._zod.def;
+	const a = process(def.left, ctx, {
+		...params,
+		path: [
+			...params.path,
+			"allOf",
+			0
+		]
+	});
+	const b = process(def.right, ctx, {
+		...params,
+		path: [
+			...params.path,
+			"allOf",
+			1
+		]
+	});
+	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
+	json$1.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
+};
+const recordProcessor = (schema, ctx, _json, params) => {
+	const json$1 = _json;
+	const def = schema._zod.def;
+	json$1.type = "object";
+	const keyType = def.keyType;
+	const patterns = keyType._zod.bag?.patterns;
+	if (def.mode === "loose" && patterns && patterns.size > 0) {
+		const valueSchema = process(def.valueType, ctx, {
+			...params,
+			path: [
+				...params.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		json$1.patternProperties = {};
+		for (const pattern of patterns) json$1.patternProperties[pattern.source] = valueSchema;
+	} else {
+		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json$1.propertyNames = process(def.keyType, ctx, {
+			...params,
+			path: [...params.path, "propertyNames"]
+		});
+		json$1.additionalProperties = process(def.valueType, ctx, {
+			...params,
+			path: [...params.path, "additionalProperties"]
+		});
+	}
+	const keyValues = keyType._zod.values;
+	if (keyValues) {
+		const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+		if (validKeyValues.length > 0) json$1.required = validKeyValues;
+	}
+};
+const nullableProcessor = (schema, ctx, json$1, params) => {
+	const def = schema._zod.def;
+	const inner = process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	if (ctx.target === "openapi-3.0") {
+		seen.ref = def.innerType;
+		json$1.nullable = true;
+	} else json$1.anyOf = [inner, { type: "null" }];
+};
+const nonoptionalProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+};
+const defaultProcessor = (schema, ctx, json$1, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	json$1.default = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const prefaultProcessor = (schema, ctx, json$1, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	if (ctx.io === "input") json$1._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const catchProcessor = (schema, ctx, json$1, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	let catchValue;
+	try {
+		catchValue = def.catchValue(void 0);
+	} catch {
+		throw new Error("Dynamic catch values are not supported in JSON Schema");
+	}
+	json$1.default = catchValue;
+};
+const pipeProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
+	process(innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = innerType;
+};
+const readonlyProcessor = (schema, ctx, json$1, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	json$1.readOnly = true;
+};
+const optionalProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+};
+const lazyProcessor = (schema, ctx, _json, params) => {
+	const innerType = schema._zod.innerType;
+	process(innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = innerType;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/iso.js
 const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
 	$ZodISODateTime.init(inst, def);
 	ZodStringFormat.init(inst, def);
@@ -2701,7 +3360,7 @@ function duration(params) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/classic/errors.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/errors.js
 const initializer = (inst, issues) => {
 	$ZodError.init(inst, issues);
 	inst.name = "ZodError";
@@ -2725,7 +3384,7 @@ const ZodError = $constructor("ZodError", initializer);
 const ZodRealError = $constructor("ZodError", initializer, { Parent: Error });
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/classic/parse.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/parse.js
 const parse = /* @__PURE__ */ _parse(ZodRealError);
 const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const safeParse$1 = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -2740,9 +3399,14 @@ const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/classic/schemas.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/schemas.js
 const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	$ZodType.init(inst, def);
+	Object.assign(inst["~standard"], { jsonSchema: {
+		input: createStandardJSONSchemaMethod(inst, "input"),
+		output: createStandardJSONSchemaMethod(inst, "output")
+	} });
+	inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
 	inst.def = def;
 	inst.type = def.type;
 	Object.defineProperty(inst, "_def", { value: def });
@@ -2751,8 +3415,9 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 			check: ch,
 			def: { check: "custom" },
 			onattach: []
-		} } : ch)] }));
+		} } : ch)] }), { parent: true });
 	};
+	inst.with = inst.check;
 	inst.clone = (def$1, params) => clone(inst, def$1, params);
 	inst.brand = () => inst;
 	inst.register = ((reg, meta$2) => {
@@ -2776,6 +3441,7 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	inst.superRefine = (refinement) => inst.check(superRefine(refinement));
 	inst.overwrite = (fn) => inst.check(_overwrite(fn));
 	inst.optional = () => optional(inst);
+	inst.exactOptional = () => exactOptional(inst);
 	inst.nullable = () => nullable(inst);
 	inst.nullish = () => optional(nullable(inst));
 	inst.nonoptional = (params) => nonoptional(inst, params);
@@ -2807,12 +3473,14 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	};
 	inst.isOptional = () => inst.safeParse(void 0).success;
 	inst.isNullable = () => inst.safeParse(null).success;
+	inst.apply = (fn) => fn(inst);
 	return inst;
 });
 /** @internal */
 const _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
 	$ZodString.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => stringProcessor(inst, ctx, json$1, params);
 	const bag = inst._zod.bag;
 	inst.format = bag.format ?? null;
 	inst.minLength = bag.minimum ?? null;
@@ -2950,6 +3618,7 @@ const ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
 const ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
 	$ZodNumber.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => numberProcessor(inst, ctx, json$1, params);
 	inst.gt = (value, params) => inst.check(_gt(value, params));
 	inst.gte = (value, params) => inst.check(_gte(value, params));
 	inst.min = (value, params) => inst.check(_gte(value, params));
@@ -2985,6 +3654,7 @@ function int(params) {
 const ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
 	$ZodBoolean.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => booleanProcessor(inst, ctx, json$1, params);
 });
 function boolean$1(params) {
 	return _boolean(ZodBoolean, params);
@@ -2992,6 +3662,7 @@ function boolean$1(params) {
 const ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
 	$ZodAny.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => anyProcessor(inst, ctx, json$1, params);
 });
 function any() {
 	return _any(ZodAny);
@@ -2999,6 +3670,7 @@ function any() {
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => unknownProcessor(inst, ctx, json$1, params);
 });
 function unknown() {
 	return _unknown(ZodUnknown);
@@ -3006,6 +3678,7 @@ function unknown() {
 const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
 	$ZodNever.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => neverProcessor(inst, ctx, json$1, params);
 });
 function never(params) {
 	return _never(ZodNever, params);
@@ -3013,6 +3686,7 @@ function never(params) {
 const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 	$ZodArray.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => arrayProcessor(inst, ctx, json$1, params);
 	inst.element = def.element;
 	inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
 	inst.nonempty = (params) => inst.check(_minLength(1, params));
@@ -3026,6 +3700,7 @@ function array(element, params) {
 const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
 	$ZodObjectJIT.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => objectProcessor(inst, ctx, json$1, params);
 	defineLazy(inst, "shape", () => {
 		return def.shape;
 	});
@@ -3072,6 +3747,7 @@ function object(shape, params) {
 const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
 	$ZodUnion.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => unionProcessor(inst, ctx, json$1, params);
 	inst.options = def.options;
 });
 function union(options, params) {
@@ -3084,6 +3760,7 @@ function union(options, params) {
 const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
 	$ZodIntersection.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => intersectionProcessor(inst, ctx, json$1, params);
 });
 function intersection(left, right) {
 	return new ZodIntersection({
@@ -3095,6 +3772,7 @@ function intersection(left, right) {
 const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
 	$ZodRecord.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => recordProcessor(inst, ctx, json$1, params);
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
@@ -3109,6 +3787,7 @@ function record(keyType, valueType, params) {
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => enumProcessor(inst, ctx, json$1, params);
 	inst.enum = def.entries;
 	inst.options = Object.values(def.entries);
 	const keys = new Set(Object.keys(def.entries));
@@ -3145,6 +3824,7 @@ function _enum(values, params) {
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
 	$ZodTransform.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => transformProcessor(inst, ctx, json$1, params);
 	inst._zod.parse = (payload, _ctx) => {
 		if (_ctx.direction === "backward") throw new $ZodEncodeError(inst.constructor.name);
 		payload.addIssue = (issue$1) => {
@@ -3176,6 +3856,7 @@ function transform(fn) {
 const ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
 	$ZodOptional.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => optionalProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -3184,9 +3865,22 @@ function optional(innerType) {
 		innerType
 	});
 }
+const ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
+	$ZodExactOptional.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => optionalProcessor(inst, ctx, json$1, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function exactOptional(innerType) {
+	return new ZodExactOptional({
+		type: "optional",
+		innerType
+	});
+}
 const ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
 	$ZodNullable.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => nullableProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -3198,6 +3892,7 @@ function nullable(innerType) {
 const ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
 	$ZodDefault.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => defaultProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.innerType;
 	inst.removeDefault = inst.unwrap;
 });
@@ -3213,6 +3908,7 @@ function _default(innerType, defaultValue) {
 const ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
 	$ZodPrefault.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => prefaultProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -3227,6 +3923,7 @@ function prefault(innerType, defaultValue) {
 const ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
 	$ZodNonOptional.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => nonoptionalProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -3239,6 +3936,7 @@ function nonoptional(innerType, params) {
 const ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
 	$ZodCatch.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => catchProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.innerType;
 	inst.removeCatch = inst.unwrap;
 });
@@ -3252,6 +3950,7 @@ function _catch(innerType, catchValue) {
 const ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
 	$ZodPipe.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => pipeProcessor(inst, ctx, json$1, params);
 	inst.in = def.in;
 	inst.out = def.out;
 });
@@ -3265,6 +3964,7 @@ function pipe(in_, out) {
 const ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => readonlyProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -3276,6 +3976,7 @@ function readonly(innerType) {
 const ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
 	$ZodLazy.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => lazyProcessor(inst, ctx, json$1, params);
 	inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -3287,6 +3988,7 @@ function lazy(getter) {
 const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
 	$ZodCustom.init(inst, def);
 	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json$1, params) => customProcessor(inst, ctx, json$1, params);
 });
 function custom(fn, _params) {
 	return _custom(ZodCustom, fn ?? (() => true), _params);
@@ -3301,7 +4003,7 @@ const describe = describe$1;
 const meta = meta$1;
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/classic/coerce.js
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/coerce.js
 function boolean(params) {
 	return _coercedBoolean(ZodBoolean, params);
 }
@@ -4140,7 +4842,10 @@ var HeaderForwardingHook = class {
 	async beforeRequest(_hookCtx, request) {
 		if (Object.keys(this.headersToForward).length === 0) return request;
 		const newHeaders = new Headers(request.headers);
-		for (const [key, value] of Object.entries(this.headersToForward)) if (!newHeaders.has(key)) newHeaders.set(key, value);
+		for (const [key, value] of Object.entries(this.headersToForward)) {
+			const existingValue = newHeaders.get(key);
+			if (!existingValue || key === "cookie" && existingValue === "") newHeaders.set(key, value);
+		}
 		return new Request(request, { headers: newHeaders });
 	}
 };