@codemation/core-nodes 1.0.2 → 1.1.0

package/dist/index.cjs

@@ -29,7 +29,527 @@ let __codemation_core_bootstrap = require("@codemation/core/bootstrap");
 __codemation_core_bootstrap = __toESM(__codemation_core_bootstrap);
 let ai = require("ai");
 ai = __toESM(ai);
+let croner = require("croner");
+croner = __toESM(croner);
 
+//#region src/credentials/ApiKeyCredentialType.ts
+/**
+* API key credential that injects a key either as an HTTP header or a query parameter.
+*/
+const apiKeyCredentialType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.api-key",
+	label: "API Key",
+	description: "Authenticates requests by injecting an API key into a header or query parameter.",
+	public: {
+		placement: {
+			label: "Placement",
+			type: "string",
+			helpText: "Where to send the key: \"header\" (default) or \"query\".",
+			placeholder: "header"
+		},
+		name: {
+			label: "Parameter name",
+			type: "string",
+			helpText: "Header or query param name. Defaults to \"X-API-Key\" for headers, \"api_key\" for query.",
+			placeholder: "X-API-Key"
+		}
+	},
+	secret: { apiKey: {
+		label: "API Key",
+		type: "password",
+		required: true,
+		helpText: "The secret API key value."
+	} },
+	async createSession(args) {
+		const apiKey = String(args.material.apiKey ?? "");
+		if (!apiKey) throw new Error("API key credential material is incomplete: apiKey is required.");
+		const isQuery = String(args.publicConfig.placement ?? "header").toLowerCase() === "query";
+		const defaultName = isQuery ? "api_key" : "X-API-Key";
+		const paramName = String(args.publicConfig.name ?? "").trim() || defaultName;
+		return { applyToRequest: (_spec) => {
+			if (isQuery) return { query: { [paramName]: apiKey } };
+			return { headers: { [paramName]: apiKey } };
+		} };
+	},
+	async test(args) {
+		const apiKey = String(args.material.apiKey ?? "");
+		return {
+			status: apiKey.length > 0 ? "healthy" : "failing",
+			message: apiKey.length > 0 ? "API key is configured." : "API key is missing.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
+
+//#endregion
+//#region src/credentials/BasicAuthCredentialType.ts
+/**
+* HTTP Basic authentication credential.
+* Session sets `Authorization: Basic <base64(username:password)>`.
+*/
+const basicAuthCredentialType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.basic-auth",
+	label: "Basic Auth",
+	description: "Authenticates requests using HTTP Basic Authentication (username + password).",
+	public: { username: {
+		label: "Username",
+		type: "string",
+		required: true,
+		helpText: "The username for HTTP Basic Authentication."
+	} },
+	secret: { password: {
+		label: "Password",
+		type: "password",
+		required: true,
+		helpText: "The password for HTTP Basic Authentication."
+	} },
+	async createSession(args) {
+		const username = String(args.publicConfig.username ?? "");
+		const password = String(args.material.password ?? "");
+		if (!username) throw new Error("Basic Auth credential is incomplete: username is required.");
+		const encoded = Buffer.from(`${username}:${password}`).toString("base64");
+		return { applyToRequest: (_spec) => ({ headers: { authorization: `Basic ${encoded}` } }) };
+	},
+	async test(args) {
+		const username = String(args.publicConfig.username ?? "");
+		const password = String(args.material.password ?? "");
+		const ok = username.length > 0 && password.length > 0;
+		return {
+			status: ok ? "healthy" : "failing",
+			message: ok ? "Basic Auth credentials are configured." : "Username or password is missing.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
+
+//#endregion
+//#region src/credentials/BearerTokenCredentialType.ts
+/**
+* Simple Bearer token credential.
+* Session sets `Authorization: Bearer <token>` on every request.
+*/
+const bearerTokenCredentialType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.bearer-token",
+	label: "Bearer Token",
+	description: "Authenticates requests using a static Bearer token in the Authorization header.",
+	public: {},
+	secret: { token: {
+		label: "Token",
+		type: "password",
+		required: true,
+		helpText: "The Bearer token to include in the Authorization header."
+	} },
+	async createSession(args) {
+		const token = String(args.material.token ?? "");
+		if (!token) throw new Error("Bearer token credential material is incomplete: token is required.");
+		return { applyToRequest: (_spec) => ({ headers: { authorization: `Bearer ${token}` } }) };
+	},
+	async test(args) {
+		const token = String(args.material.token ?? "");
+		return {
+			status: token.length > 0 ? "healthy" : "failing",
+			message: token.length > 0 ? "Bearer token is configured." : "Token is missing.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
+
+//#endregion
+//#region src/credentials/OAuth2TokenExchangeFactory.ts
+var OAuth2TokenExchangeFactory = class {
+	async create(args) {
+		const body = new URLSearchParams({
+			grant_type: "client_credentials",
+			client_id: args.clientId
+		});
+		if (args.scopes) body.set("scope", args.scopes);
+		if (args.audience) body.set("audience", args.audience);
+		const encoded = Buffer.from(`${args.clientId}:${args.clientSecret}`).toString("base64");
+		const response = await globalThis.fetch(args.tokenUrl, {
+			method: "POST",
+			headers: {
+				"content-type": "application/x-www-form-urlencoded",
+				authorization: `Basic ${encoded}`
+			},
+			body: body.toString()
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`Token exchange failed (${response.status} ${response.statusText}): ${text}`);
+		}
+		const json = await response.json();
+		const token = String(json["access_token"] ?? "");
+		if (!token) throw new Error("Token exchange response did not include an access_token.");
+		return token;
+	}
+};
+
+//#endregion
+//#region src/credentials/OAuth2ClientCredentialsTypeFactory.ts
+/**
+* OAuth2 client-credentials flow credential.
+*
+* This is a machine-to-machine flow: no user redirect occurs. The session
+* POSTs to the configured `tokenUrl` with `client_credentials` grant, caches
+* the resulting access token for the duration of the session, and injects it
+* as `Authorization: Bearer <token>` on each request.
+*
+* Token caching is per-session only (one createSession call = one token fetch
+* at most). Cross-session caching would require host-level state and is out of
+* scope here. Because the engine creates a fresh session per execution, a new
+* token is fetched once per node activation.
+*
+* NOTE: `auth` is intentionally omitted from the definition. The OAuth2
+* `auth: { kind: "oauth2" }` shape signals an authorization-code / user-redirect
+* flow; using it here would cause the host UI to render an OAuth consent button
+* that goes nowhere. Client-credentials is a purely server-side flow.
+*/
+const oauth2ClientCredentialsType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.oauth2-client-credentials",
+	label: "OAuth2 Client Credentials",
+	description: "Machine-to-machine OAuth2 using the client_credentials grant. Exchanges client ID and secret for a bearer token before each workflow execution.",
+	public: {
+		tokenUrl: {
+			label: "Token URL",
+			type: "string",
+			required: true,
+			helpText: "The token endpoint URL, e.g. https://auth.example.com/oauth/token."
+		},
+		scopes: {
+			label: "Scopes",
+			type: "string",
+			helpText: "Space-separated list of OAuth2 scopes to request (optional)."
+		},
+		audience: {
+			label: "Audience",
+			type: "string",
+			helpText: "Optional audience parameter sent to the token endpoint.",
+			visibility: "advanced"
+		}
+	},
+	secret: {
+		clientId: {
+			label: "Client ID",
+			type: "string",
+			required: true
+		},
+		clientSecret: {
+			label: "Client Secret",
+			type: "password",
+			required: true
+		}
+	},
+	async createSession(args) {
+		const tokenUrl = String(args.publicConfig.tokenUrl ?? "");
+		const clientId = String(args.material.clientId ?? "");
+		const clientSecret = String(args.material.clientSecret ?? "");
+		if (!tokenUrl || !clientId || !clientSecret) throw new Error("OAuth2 client credentials are incomplete: tokenUrl, clientId, and clientSecret are required.");
+		const accessToken = await new OAuth2TokenExchangeFactory().create({
+			tokenUrl,
+			clientId,
+			clientSecret,
+			scopes: String(args.publicConfig.scopes ?? ""),
+			audience: String(args.publicConfig.audience ?? "")
+		});
+		return { applyToRequest: (_spec) => ({ headers: { authorization: `Bearer ${accessToken}` } }) };
+	},
+	async test(args) {
+		const tokenUrl = String(args.publicConfig.tokenUrl ?? "");
+		const clientId = String(args.material.clientId ?? "");
+		const clientSecret = String(args.material.clientSecret ?? "");
+		if (!tokenUrl || !clientId || !clientSecret) return {
+			status: "failing",
+			message: "tokenUrl, clientId, and clientSecret are all required.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		try {
+			await new OAuth2TokenExchangeFactory().create({
+				tokenUrl,
+				clientId,
+				clientSecret,
+				scopes: String(args.publicConfig.scopes ?? ""),
+				audience: String(args.publicConfig.audience ?? "")
+			});
+			return {
+				status: "healthy",
+				message: "Token exchange succeeded.",
+				testedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		} catch (error) {
+			return {
+				status: "failing",
+				message: error instanceof Error ? error.message : String(error),
+				testedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		}
+	}
+});
+
+//#endregion
+//#region src/http/HttpRequestExecutor.ts
+/**
+* Executes a single HTTP request described by {@link HttpRequestSpec}.
+*
+* - Credential sessions provide header/query deltas via `applyToRequest`.
+* - Body encoding is delegated to {@link HttpBodyBuilder}.
+* - URL query merging is delegated to {@link HttpUrlBuilder}.
+* - Binary response bodies: when `download.mode` triggers binary attach, the
+*   `bodyBinaryName` field is set in the result but the body is NOT read here.
+*   Callers that need binary attachment should use `buildRequest` to get the
+*   resolved URL + init and make the fetch + binary attach themselves.
+*
+* Collaborators (`fetch`, body builder, url builder) are injected so callers
+* own construction at composition roots and tests can supply deterministic stubs.
+*/
+var HttpRequestExecutor = class {
+	constructor(fetchFn, bodyBuilder, urlBuilder) {
+		this.fetchFn = fetchFn;
+		this.bodyBuilder = bodyBuilder;
+		this.urlBuilder = urlBuilder;
+	}
+	/**
+	* Builds the fetch init (headers, query, body) from the spec + credential delta,
+	* returning both the resolved URL and the RequestInit so callers can make the
+	* actual fetch call themselves (useful for streaming / binary attach).
+	*/
+	async buildRequest(spec, item) {
+		const credentialDelta = spec.credential?.applyToRequest(spec) ?? {};
+		const mergedHeaders = {
+			...spec.headers ?? {},
+			...credentialDelta.headers ?? {}
+		};
+		const mergedQuery = {
+			...spec.query ?? {},
+			...credentialDelta.query ?? {}
+		};
+		const encodedBody = await this.bodyBuilder.build(spec.body, item, spec.ctx);
+		if (encodedBody && encodedBody.contentType) mergedHeaders["content-type"] = encodedBody.contentType;
+		return {
+			url: this.urlBuilder.build(spec.url, mergedQuery),
+			init: {
+				method: spec.method,
+				headers: mergedHeaders,
+				...encodedBody ? { body: encodedBody.body } : {}
+			}
+		};
+	}
+	/**
+	* Executes an HTTP request and returns parsed result.
+	* For binary downloads (when `shouldAttachBody` is true), the body is NOT consumed
+	* and callers must call `ctx.binary.attach` directly using the resolved URL + init
+	* (available via `buildRequest`).
+	*/
+	async execute(spec, item) {
+		const { url: resolvedUrl, init } = await this.buildRequest(spec, item);
+		const response = await this.fetchFn(resolvedUrl, init);
+		const responseHeaders = this.readHeaders(response.headers);
+		const mimeType = this.resolveMimeType(responseHeaders);
+		const downloadMode = spec.download?.mode ?? "auto";
+		const binaryName = spec.download?.binaryName ?? "body";
+		const shouldDownload = this.shouldAttachBody(downloadMode, mimeType);
+		const isJson = this.isJsonMimeType(mimeType);
+		let json;
+		let text;
+		let bodyBinaryName;
+		if (shouldDownload) bodyBinaryName = binaryName;
+		else if (isJson) try {
+			json = await response.json();
+		} catch {
+			text = await response.text();
+		}
+		else text = await response.text();
+		return {
+			url: resolvedUrl,
+			method: spec.method.toUpperCase(),
+			status: response.status,
+			ok: response.ok,
+			statusText: response.statusText,
+			mimeType,
+			headers: responseHeaders,
+			...json !== void 0 ? { json } : {},
+			...text !== void 0 ? { text } : {},
+			...bodyBinaryName !== void 0 ? { bodyBinaryName } : {}
+		};
+	}
+	readHeaders(headers) {
+		const values = {};
+		headers.forEach((value, key) => {
+			values[key] = value;
+		});
+		return values;
+	}
+	resolveMimeType(headers) {
+		const contentType = headers["content-type"];
+		if (!contentType) return "application/octet-stream";
+		return contentType.split(";")[0]?.trim() || "application/octet-stream";
+	}
+	isJsonMimeType(mimeType) {
+		return mimeType === "application/json" || mimeType.endsWith("+json");
+	}
+	shouldAttachBody(mode, mimeType) {
+		if (mode === "always") return true;
+		if (mode === "never") return false;
+		return mimeType.startsWith("image/") || mimeType.startsWith("audio/") || mimeType.startsWith("video/") || mimeType === "application/pdf";
+	}
+};
+
+//#endregion
+//#region src/http/HttpBodyBuilder.ts
+/**
+* Builds a fetch-compatible `BodyInit` + Content-Type pair from an {@link HttpBodySpec}.
+* Multipart binaries are read from `item.binary` via `ctx.binary.openReadStream`.
+*/
+var HttpBodyBuilder = class {
+	async build(spec, item, ctx) {
+		if (!spec || spec.kind === "none") return;
+		if (spec.kind === "json") return {
+			body: JSON.stringify(spec.data),
+			contentType: "application/json"
+		};
+		if (spec.kind === "form") {
+			const params = new URLSearchParams();
+			for (const [key, value] of Object.entries(spec.data)) params.append(key, value);
+			return {
+				body: params.toString(),
+				contentType: "application/x-www-form-urlencoded"
+			};
+		}
+		if (spec.kind === "multipart") {
+			const formData = new FormData();
+			for (const [key, value] of Object.entries(spec.fields)) formData.append(key, value);
+			if (spec.binaries) for (const [fieldName, binaryRef] of Object.entries(spec.binaries)) {
+				const attachment = item.binary?.[binaryRef];
+				if (attachment) {
+					const readResult = await ctx.binary.openReadStream(attachment);
+					if (readResult) {
+						const reader = readResult.body.getReader();
+						const chunks = [];
+						let done = false;
+						while (!done) {
+							const result = await reader.read();
+							done = result.done;
+							if (result.value) chunks.push(result.value);
+						}
+						const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+						const merged = new Uint8Array(totalLength);
+						let offset = 0;
+						for (const chunk of chunks) {
+							merged.set(chunk, offset);
+							offset += chunk.length;
+						}
+						const blob = new Blob([merged], { type: attachment.mimeType });
+						formData.append(fieldName, blob, attachment.filename ?? binaryRef);
+					}
+				}
+			}
+			return {
+				body: formData,
+				contentType: ""
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/http/HttpUrlBuilder.ts
+/**
+* Merges query parameters into a base URL.
+* Handles both scalar and array values, and preserves any existing params.
+*/
+var HttpUrlBuilder = class {
+	build(baseUrl, query) {
+		if (!query || Object.keys(query).length === 0) return baseUrl;
+		const parsed = new URL(baseUrl);
+		for (const [key, value] of Object.entries(query)) if (Array.isArray(value)) for (const entry of value) parsed.searchParams.append(key, entry);
+		else parsed.searchParams.append(key, value);
+		return parsed.toString();
+	}
+};
+
+//#endregion
+//#region src/authoring/defineRestNode.types.ts
+/**
+* Substitutes `{name}` placeholders in a path template using values from `params`.
+*/
+function substitutePath(template, params) {
+	return template.replace(/\{([^}]+)}/g, (_match, key) => {
+		const value = params[key];
+		return value !== void 0 ? String(value) : `{${key}}`;
+	});
+}
+/**
+* Declarative helper for creating thin API-wrapper nodes.
+*
+* Usage:
+* ```ts
+* export const postMessage = defineRestNode({
+*   key: "slack.post-message",
+*   title: "Send Slack message",
+*   icon: "si:slack",
+*   api: { baseUrl: "https://slack.com/api", path: "/chat.postMessage", method: "POST" },
+*   credentials: { auth: bearerTokenCredentialType },
+*   inputSchema: z.object({ channel: z.string(), text: z.string() }),
+*   request: ({ input }) => ({
+*     body: { kind: "json", data: { channel: input.channel, text: input.text } },
+*   }),
+*   response: ({ json }) => ({ messageTs: (json as any).ts }),
+* });
+* ```
+*
+* - `defineRestNode` is a thin wrapper over `defineNode`; it does not introduce a new runtime kind.
+* - Credential sessions are resolved via the `credentials` binding map (same as `defineNode`).
+* - Path `{placeholder}` substitution is applied from `input` keys before the request is made.
+* - Non-2xx responses throw an `Error` by default (`errorPolicy: "throw"`).
+*/
+function defineRestNode(options) {
+	const errorPolicy = options.errorPolicy ?? "throw";
+	return (0, __codemation_core.defineNode)({
+		key: options.key,
+		title: options.title,
+		description: options.description,
+		icon: options.icon,
+		credentials: options.credentials,
+		inputSchema: options.inputSchema,
+		async execute({ input, item, ctx }, { credentials }) {
+			const credentialSlot = options.credentials ? Object.keys(options.credentials)[0] : void 0;
+			const credential = credentialSlot ? await credentials[credentialSlot]?.() : void 0;
+			const inputRecord = input ?? {};
+			const requestShape = options.request ? await options.request({ input }) : {};
+			const pathParams = {
+				...inputRecord,
+				...requestShape.pathParams ?? {}
+			};
+			const resolvedPath = substitutePath(options.api.path, pathParams);
+			const resolvedUrl = `${options.api.baseUrl}${resolvedPath}`;
+			const result = await new HttpRequestExecutor(globalThis.fetch, new HttpBodyBuilder(), new HttpUrlBuilder()).execute({
+				url: resolvedUrl,
+				method: (options.api.method ?? "GET").toUpperCase(),
+				headers: requestShape.headers,
+				query: requestShape.query,
+				body: requestShape.body,
+				credential,
+				ctx
+			}, item);
+			if (errorPolicy === "throw" && !result.ok) throw new Error(`HTTP ${result.status} ${result.statusText} for ${result.method} ${result.url}`);
+			const responseCtx = {
+				status: result.status,
+				ok: result.ok,
+				statusText: result.statusText,
+				mimeType: result.mimeType,
+				headers: result.headers,
+				...result.json !== void 0 ? { json: result.json } : {},
+				...result.text !== void 0 ? { text: result.text } : {}
+			};
+			if (options.response) return await options.response({
+				...responseCtx,
+				input
+			});
+			return { json: responseCtx };
+		}
+	});
+}
+
+//#endregion
 //#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -148,10 +668,21 @@ function cleanRegex(source) {
 	const end = source.endsWith("$") ? source.length - 1 : source.length;
 	return source.slice(start, end);
 }
+function floatSafeRemainder(val, step) {
+	const valDecCount = (val.toString().split(".")[1] || "").length;
+	const stepString = step.toString();
+	let stepDecCount = (stepString.split(".")[1] || "").length;
+	if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+		const match = stepString.match(/\d?e-(\d?)/);
+		if (match?.[1]) stepDecCount = Number.parseInt(match[1]);
+	}
+	const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+	return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
+}
 const EVALUATING = Symbol("evaluating");
-function defineLazy(object, key, getter) {
+function defineLazy(object$1, key, getter) {
 	let value = void 0;
-	Object.defineProperty(object, key, {
+	Object.defineProperty(object$1, key, {
 		get() {
 			if (value === EVALUATING) return;
 			if (value === void 0) {
@@ -161,11 +692,19 @@ function defineLazy(object, key, getter) {
 			return value;
 		},
 		set(v) {
-			Object.defineProperty(object, key, { value: v });
+			Object.defineProperty(object$1, key, { value: v });
 		},
 		configurable: true
 	});
 }
+function assignProp(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
 function mergeDefs(...defs) {
 	const mergedDescriptors = {};
 	for (const def of defs) {
@@ -174,6 +713,12 @@ function mergeDefs(...defs) {
 	}
 	return Object.defineProperties({}, mergedDescriptors);
 }
+function esc(str) {
+	return JSON.stringify(str);
+}
+function slugify(input) {
+	return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
 const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
 function isObject(data) {
 	return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -202,6 +747,14 @@ function shallowClone(o) {
 	if (Array.isArray(o)) return [...o];
 	return o;
 }
+const propertyKeyTypes = new Set([
+	"string",
+	"number",
+	"symbol"
+]);
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function clone(inst, def, params) {
 	const cl = new inst._zod.constr(def ?? inst._zod.def);
 	if (!def || params?.parent) cl._zod.parent = inst;
@@ -222,6 +775,11 @@ function normalizeParams(_params) {
 	};
 	return params;
 }
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k) => {
+		return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+	});
+}
 const NUMBER_FORMAT_RANGES = {
 	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
 	int32: [-2147483648, 2147483647],
@@ -229,6 +787,130 @@ const NUMBER_FORMAT_RANGES = {
 	float32: [-34028234663852886e22, 34028234663852886e22],
 	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
 };
+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 = {};
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				newShape[key] = currDef.shape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	}));
+}
+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 };
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				delete newShape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	}));
+}
+function extend(schema, shape) {
+	if (!isPlainObject(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	const checks = schema._zod.def.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(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+	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, {
+		get shape() {
+			const _shape = {
+				...a._zod.def.shape,
+				...b._zod.def.shape
+			};
+			assignProp(this, "shape", _shape);
+			return _shape;
+		},
+		get catchall() {
+			return b._zod.def.catchall;
+		},
+		checks: []
+	}));
+}
+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;
+			const shape = { ...oldShape };
+			if (mask) for (const key in mask) {
+				if (!(key in oldShape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				shape[key] = Class ? new Class({
+					type: "optional",
+					innerType: oldShape[key]
+				}) : oldShape[key];
+			}
+			else for (const key in oldShape) shape[key] = Class ? new Class({
+				type: "optional",
+				innerType: oldShape[key]
+			}) : oldShape[key];
+			assignProp(this, "shape", shape);
+			return shape;
+		},
+		checks: []
+	}));
+}
+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({
+			type: "nonoptional",
+			innerType: oldShape[key]
+		});
+		assignProp(this, "shape", shape);
+		return shape;
+	} }));
+}
 function aborted(x, startIndex = 0) {
 	if (x.aborted === true) return true;
 	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
@@ -434,6 +1116,64 @@ const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 };
 const safeDecodeAsync$1 = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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}$/;
+const xid = /^[0-9a-vA-V]{20}$/;
+const ksuid = /^[A-Za-z0-9]{27}$/;
+const nanoid = /^[a-zA-Z0-9_-]{21}$/;
+/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
+const duration$1 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
+const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+/** Returns a regex for validating an RFC 9562/4122 UUID.
+*
+* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
+const uuid = (version$1) => {
+	if (!version$1) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+	return /* @__PURE__ */ new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version$1}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+};
+/** Practical email validation */
+const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+const _emoji$1 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+function emoji() {
+	return new RegExp(_emoji$1, "u");
+}
+const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,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-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+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 = /^\+[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) {
+	const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
+	return typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+}
+function time$1(args) {
+	return /* @__PURE__ */ new RegExp(`^${timeSource(args)}$`);
+}
+function datetime$1(args) {
+	const time$2 = timeSource({ precision: args.precision });
+	const opts = ["Z"];
+	if (args.local) opts.push("");
+	if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
+	const timeRegex = `${time$2}(?:${opts.join("|")})`;
+	return /* @__PURE__ */ new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+}
+const string$1 = (params) => {
+	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
+};
+const integer = /^-?\d+$/;
+const number$1 = /^-?\d+(?:\.\d+)?$/;
+const lowercase = /^[^A-Z]*$/;
+const uppercase = /^[^a-z]*$/;
+
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
 const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
@@ -442,6 +1182,145 @@ const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
 	inst._zod.def = def;
 	(_a$1 = inst._zod).onattach ?? (_a$1.onattach = []);
 });
+const numericOriginMap = {
+	number: "number",
+	bigint: "bigint",
+	object: "date"
+};
+const $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const origin = numericOriginMap[typeof def.value];
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+		if (def.value < curr) if (def.inclusive) bag.maximum = def.value;
+		else bag.exclusiveMaximum = def.value;
+	});
+	inst._zod.check = (payload) => {
+		if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
+		payload.issues.push({
+			origin,
+			code: "too_big",
+			maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const origin = numericOriginMap[typeof def.value];
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+		if (def.value > curr) if (def.inclusive) bag.minimum = def.value;
+		else bag.exclusiveMinimum = def.value;
+	});
+	inst._zod.check = (payload) => {
+		if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
+		payload.issues.push({
+			origin,
+			code: "too_small",
+			minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		var _a$1;
+		(_a$1 = inst$1._zod.bag).multipleOf ?? (_a$1.multipleOf = def.value);
+	});
+	inst._zod.check = (payload) => {
+		if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
+		if (typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0) return;
+		payload.issues.push({
+			origin: typeof payload.value,
+			code: "not_multiple_of",
+			divisor: def.value,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	def.format = def.format || "float64";
+	const isInt = def.format?.includes("int");
+	const origin = isInt ? "int" : "number";
+	const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.format = def.format;
+		bag.minimum = minimum;
+		bag.maximum = maximum;
+		if (isInt) bag.pattern = integer;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (isInt) {
+			if (!Number.isInteger(input)) {
+				payload.issues.push({
+					expected: origin,
+					format: def.format,
+					code: "invalid_type",
+					continue: false,
+					input,
+					inst
+				});
+				return;
+			}
+			if (!Number.isSafeInteger(input)) {
+				if (input > 0) payload.issues.push({
+					input,
+					code: "too_big",
+					maximum: Number.MAX_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				else payload.issues.push({
+					input,
+					code: "too_small",
+					minimum: Number.MIN_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				return;
+			}
+		}
+		if (input < minimum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_small",
+			minimum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+		if (input > maximum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_big",
+			maximum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
 const $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
 	var _a$1;
 	$ZodCheck.init(inst, def);
@@ -530,17 +1409,166 @@ const $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEqual
 		});
 	};
 });
-const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+const $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+	var _a$1, _b;
 	$ZodCheck.init(inst, def);
-	inst._zod.check = (payload) => {
-		payload.value = def.tx(payload.value);
-	};
-});
-
-//#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js
-const version = {
-	major: 4,
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.format = def.format;
+		if (def.pattern) {
+			bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+			bag.patterns.add(def.pattern);
+		}
+	});
+	if (def.pattern) (_a$1 = inst._zod).check ?? (_a$1.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: def.format,
+			input: payload.value,
+			...def.pattern ? { pattern: def.pattern.toString() } : {},
+			inst,
+			continue: !def.abort
+		});
+	});
+	else (_b = inst._zod).check ?? (_b.check = () => {});
+});
+const $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "regex",
+			input: payload.value,
+			pattern: def.pattern.toString(),
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
+	def.pattern ?? (def.pattern = lowercase);
+	$ZodCheckStringFormat.init(inst, def);
+});
+const $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
+	def.pattern ?? (def.pattern = uppercase);
+	$ZodCheckStringFormat.init(inst, def);
+});
+const $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const escapedRegex = escapeRegex(def.includes);
+	const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
+	def.pattern = pattern;
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.includes(def.includes, def.position)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "includes",
+			includes: def.includes,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const pattern = /* @__PURE__ */ new RegExp(`^${escapeRegex(def.prefix)}.*`);
+	def.pattern ?? (def.pattern = pattern);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.startsWith(def.prefix)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "starts_with",
+			prefix: def.prefix,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const pattern = /* @__PURE__ */ new RegExp(`.*${escapeRegex(def.suffix)}$`);
+	def.pattern ?? (def.pattern = pattern);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.endsWith(def.suffix)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "ends_with",
+			suffix: def.suffix,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	inst._zod.check = (payload) => {
+		payload.value = def.tx(payload.value);
+	};
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/doc.js
+var Doc = class {
+	constructor(args = []) {
+		this.content = [];
+		this.indent = 0;
+		if (this) this.args = args;
+	}
+	indented(fn) {
+		this.indent += 1;
+		fn(this);
+		this.indent -= 1;
+	}
+	write(arg) {
+		if (typeof arg === "function") {
+			arg(this, { execution: "sync" });
+			arg(this, { execution: "async" });
+			return;
+		}
+		const lines = arg.split("\n").filter((x) => x);
+		const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+		const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+		for (const line of dedented) this.content.push(line);
+	}
+	compile() {
+		const F = Function;
+		const args = this?.args;
+		const lines = [...(this?.content ?? [``]).map((x) => `  ${x}`)];
+		return new F(...args, lines.join("\n"));
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js
+const version = {
+	major: 4,
 	minor: 3,
 	patch: 6
 };
@@ -635,10 +1663,308 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 		version: 1
 	}));
 });
+const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
+	inst._zod.parse = (payload, _) => {
+		if (def.coerce) try {
+			payload.value = String(payload.value);
+		} catch (_$1) {}
+		if (typeof payload.value === "string") return payload;
+		payload.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	$ZodString.init(inst, def);
+});
+const $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
+	def.pattern ?? (def.pattern = guid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
+	if (def.version) {
+		const v = {
+			v1: 1,
+			v2: 2,
+			v3: 3,
+			v4: 4,
+			v5: 5,
+			v6: 6,
+			v7: 7,
+			v8: 8
+		}[def.version];
+		if (v === void 0) throw new Error(`Invalid UUID version: "${def.version}"`);
+		def.pattern ?? (def.pattern = uuid(v));
+	} else def.pattern ?? (def.pattern = uuid());
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
+	def.pattern ?? (def.pattern = email);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		try {
+			const trimmed = payload.value.trim();
+			const url = new URL(trimmed);
+			if (def.hostname) {
+				def.hostname.lastIndex = 0;
+				if (!def.hostname.test(url.hostname)) payload.issues.push({
+					code: "invalid_format",
+					format: "url",
+					note: "Invalid hostname",
+					pattern: def.hostname.source,
+					input: payload.value,
+					inst,
+					continue: !def.abort
+				});
+			}
+			if (def.protocol) {
+				def.protocol.lastIndex = 0;
+				if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) payload.issues.push({
+					code: "invalid_format",
+					format: "url",
+					note: "Invalid protocol",
+					pattern: def.protocol.source,
+					input: payload.value,
+					inst,
+					continue: !def.abort
+				});
+			}
+			if (def.normalize) payload.value = url.href;
+			else payload.value = trimmed;
+			return;
+		} catch (_) {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "url",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+const $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
+	def.pattern ?? (def.pattern = emoji());
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
+	def.pattern ?? (def.pattern = nanoid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
+	def.pattern ?? (def.pattern = cuid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
+	def.pattern ?? (def.pattern = cuid2);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
+	def.pattern ?? (def.pattern = ulid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
+	def.pattern ?? (def.pattern = xid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
+	def.pattern ?? (def.pattern = ksuid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
+	def.pattern ?? (def.pattern = datetime$1(def));
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
+	def.pattern ?? (def.pattern = date$1);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
+	def.pattern ?? (def.pattern = time$1(def));
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
+	def.pattern ?? (def.pattern = duration$1);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
+	def.pattern ?? (def.pattern = ipv4);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.format = `ipv4`;
+});
+const $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
+	def.pattern ?? (def.pattern = ipv6);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.format = `ipv6`;
+	inst._zod.check = (payload) => {
+		try {
+			new URL(`http://[${payload.value}]`);
+		} catch {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "ipv6",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+const $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
+	def.pattern ?? (def.pattern = cidrv4);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
+	def.pattern ?? (def.pattern = cidrv6);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		const parts = payload.value.split("/");
+		try {
+			if (parts.length !== 2) throw new Error();
+			const [address, prefix] = parts;
+			if (!prefix) throw new Error();
+			const prefixNum = Number(prefix);
+			if (`${prefixNum}` !== prefix) throw new Error();
+			if (prefixNum < 0 || prefixNum > 128) throw new Error();
+			new URL(`http://[${address}]`);
+		} catch {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "cidrv6",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+function isValidBase64(data) {
+	if (data === "") return true;
+	if (data.length % 4 !== 0) return false;
+	try {
+		atob(data);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
+	def.pattern ?? (def.pattern = base64);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.contentEncoding = "base64";
+	inst._zod.check = (payload) => {
+		if (isValidBase64(payload.value)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "base64",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+function isValidBase64URL(data) {
+	if (!base64url.test(data)) return false;
+	const base64$1 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
+	return isValidBase64(base64$1.padEnd(Math.ceil(base64$1.length / 4) * 4, "="));
+}
+const $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
+	def.pattern ?? (def.pattern = base64url);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.contentEncoding = "base64url";
+	inst._zod.check = (payload) => {
+		if (isValidBase64URL(payload.value)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "base64url",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
+	def.pattern ?? (def.pattern = e164);
+	$ZodStringFormat.init(inst, def);
+});
+function isValidJWT(token, algorithm = null) {
+	try {
+		const tokensParts = token.split(".");
+		if (tokensParts.length !== 3) return false;
+		const [header] = tokensParts;
+		if (!header) return false;
+		const parsedHeader = JSON.parse(atob(header));
+		if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
+		if (!parsedHeader.alg) return false;
+		if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+const $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		if (isValidJWT(payload.value, def.alg)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "jwt",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Number(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+		const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+		payload.issues.push({
+			expected: "number",
+			code: "invalid_type",
+			input,
+			inst,
+			...received ? { received } : {}
+		});
+		return payload;
+	};
+});
+const $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
+	$ZodCheckNumberFormat.init(inst, def);
+	$ZodNumber.init(inst, def);
+});
 const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
 });
+const $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		payload.issues.push({
+			expected: "never",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
 function handleArrayResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
@@ -671,6 +1997,207 @@ const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
 		return payload;
 	};
 });
+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;
+}
+function normalizeDef(def) {
+	const keys = Object.keys(def.shape);
+	for (const k of keys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+	const okeys = optionalKeys(def.shape);
+	return {
+		...def,
+		keys,
+		keySet: new Set(keys),
+		numKeys: keys.length,
+		optionalKeys: new Set(okeys)
+	};
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+	const unrecognized = [];
+	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") {
+			unrecognized.push(key);
+			continue;
+		}
+		const r = _catchall.run({
+			value: input[key],
+			issues: []
+		}, ctx);
+		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",
+		keys: unrecognized,
+		input,
+		inst
+	});
+	if (!proms.length) return payload;
+	return Promise.all(proms).then(() => {
+		return payload;
+	});
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (!Object.getOwnPropertyDescriptor(def, "shape")?.get) {
+		const sh = def.shape;
+		Object.defineProperty(def, "shape", { get: () => {
+			const newSh = { ...sh };
+			Object.defineProperty(def, "shape", { value: newSh });
+			return newSh;
+		} });
+	}
+	const _normalized = cached(() => normalizeDef(def));
+	defineLazy(inst._zod, "propValues", () => {
+		const shape = def.shape;
+		const propValues = {};
+		for (const key in shape) {
+			const field = shape[key]._zod;
+			if (field.values) {
+				propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+				for (const v of field.values) propValues[key].add(v);
+			}
+		}
+		return propValues;
+	});
+	const isObject$1 = isObject;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = {};
+		const proms = [];
+		const shape = value.shape;
+		for (const key of value.keys) {
+			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, 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);
+	};
+});
+const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
+	$ZodObject.init(inst, def);
+	const superParse = inst._zod.parse;
+	const _normalized = cached(() => normalizeDef(def));
+	const generateFastpass = (shape) => {
+		const doc = new Doc([
+			"shape",
+			"payload",
+			"ctx"
+		]);
+		const normalized = _normalized.value;
+		const parseStr = (key) => {
+			const k = esc(key);
+			return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+		};
+		doc.write(`const input = payload.value;`);
+		const ids = Object.create(null);
+		let counter = 0;
+		for (const key of normalized.keys) ids[key] = `key_${counter++}`;
+		doc.write(`const newResult = {};`);
+		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)};`);
+			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,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+		}
+		doc.write(`payload.value = newResult;`);
+		doc.write(`return payload;`);
+		const fn = doc.compile();
+		return (payload, ctx) => fn(shape, payload, ctx);
+	};
+	let fastpass;
+	const isObject$1 = isObject;
+	const jit = !globalConfig.jitless;
+	const allowsEval$1 = allowsEval;
+	const fastEnabled = jit && allowsEval$1.value;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+			if (!fastpass) fastpass = generateFastpass(def.shape);
+			payload = fastpass(payload, ctx);
+			if (!catchall) return payload;
+			return handleCatchall([], input, payload, ctx, value, inst);
+		}
+		return superParse(payload, ctx);
+	};
+});
 function handleUnionResults(results, final, inst, ctx) {
 	for (const result of results) if (result.issues.length === 0) {
 		final.value = result.value;
@@ -826,6 +2353,115 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[key] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				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) {
+					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) {
+					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())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[keyResult.value] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+	$ZodType.init(inst, def);
+	const values = getEnumValues(def.entries);
+	const valuesSet = new Set(values);
+	inst._zod.values = valuesSet;
+	inst._zod.pattern = /* @__PURE__ */ new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (valuesSet.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -1101,31 +2737,422 @@ const globalRegistry = globalThis.__zod_globalRegistry;
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js
 /* @__NO_SIDE_EFFECTS__ */
-function _unknown(Class) {
-	return new Class({ type: "unknown" });
+function _string(Class, params) {
+	return new Class({
+		type: "string",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _email(Class, params) {
+	return new Class({
+		type: "string",
+		format: "email",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _guid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "guid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v4",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v6",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv7(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v7",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _url(Class, params) {
+	return new Class({
+		type: "string",
+		format: "url",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _emoji(Class, params) {
+	return new Class({
+		type: "string",
+		format: "emoji",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _nanoid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "nanoid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid2(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cuid2",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ulid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ulid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _xid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "xid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ksuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ksuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ipv4",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ipv6",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cidrv4",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cidrv6",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64(Class, params) {
+	return new Class({
+		type: "string",
+		format: "base64",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64url(Class, params) {
+	return new Class({
+		type: "string",
+		format: "base64url",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _e164(Class, params) {
+	return new Class({
+		type: "string",
+		format: "e164",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _jwt(Class, params) {
+	return new Class({
+		type: "string",
+		format: "jwt",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDateTime(Class, params) {
+	return new Class({
+		type: "string",
+		format: "datetime",
+		check: "string_format",
+		offset: false,
+		local: false,
+		precision: null,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDate(Class, params) {
+	return new Class({
+		type: "string",
+		format: "date",
+		check: "string_format",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoTime(Class, params) {
+	return new Class({
+		type: "string",
+		format: "time",
+		check: "string_format",
+		precision: null,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDuration(Class, params) {
+	return new Class({
+		type: "string",
+		format: "duration",
+		check: "string_format",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _number(Class, params) {
+	return new Class({
+		type: "number",
+		checks: [],
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _int(Class, params) {
+	return new Class({
+		type: "number",
+		check: "number_format",
+		abort: false,
+		format: "safeint",
+		...normalizeParams(params)
+	});
+}
+/* @__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",
+		...normalizeParams(params),
+		value,
+		inclusive: false
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lte(value, params) {
+	return new $ZodCheckLessThan({
+		check: "less_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _gt(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: false
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _gte(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _multipleOf(value, params) {
+	return new $ZodCheckMultipleOf({
+		check: "multiple_of",
+		...normalizeParams(params),
+		value
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _maxLength(maximum, params) {
+	return new $ZodCheckMaxLength({
+		check: "max_length",
+		...normalizeParams(params),
+		maximum
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _minLength(minimum, params) {
+	return new $ZodCheckMinLength({
+		check: "min_length",
+		...normalizeParams(params),
+		minimum
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _length(length, params) {
+	return new $ZodCheckLengthEquals({
+		check: "length_equals",
+		...normalizeParams(params),
+		length
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _regex(pattern, params) {
+	return new $ZodCheckRegex({
+		check: "string_format",
+		format: "regex",
+		...normalizeParams(params),
+		pattern
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lowercase(params) {
+	return new $ZodCheckLowerCase({
+		check: "string_format",
+		format: "lowercase",
+		...normalizeParams(params)
+	});
 }
 /* @__NO_SIDE_EFFECTS__ */
-function _maxLength(maximum, params) {
-	return new $ZodCheckMaxLength({
-		check: "max_length",
+function _uppercase(params) {
+	return new $ZodCheckUpperCase({
+		check: "string_format",
+		format: "uppercase",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _includes(includes, params) {
+	return new $ZodCheckIncludes({
+		check: "string_format",
+		format: "includes",
 		...normalizeParams(params),
-		maximum
+		includes
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
-function _minLength(minimum, params) {
-	return new $ZodCheckMinLength({
-		check: "min_length",
+function _startsWith(prefix, params) {
+	return new $ZodCheckStartsWith({
+		check: "string_format",
+		format: "starts_with",
 		...normalizeParams(params),
-		minimum
+		prefix
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
-function _length(length, params) {
-	return new $ZodCheckLengthEquals({
-		check: "length_equals",
+function _endsWith(suffix, params) {
+	return new $ZodCheckEndsWith({
+		check: "string_format",
+		format: "ends_with",
 		...normalizeParams(params),
-		length
+		suffix
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
@@ -1136,6 +3163,26 @@ function _overwrite(tx) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
+function _normalize(form) {
+	return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _trim() {
+	return /* @__PURE__ */ _overwrite((input) => input.trim());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toLowerCase() {
+	return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toUpperCase() {
+	return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _slugify() {
+	return /* @__PURE__ */ _overwrite((input) => slugify(input));
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _array(Class, element, params) {
 	return new Class({
 		type: "array",
@@ -2010,9 +4057,9 @@ let AIAgentExecutionHelpersFactory = class AIAgentExecutionHelpersFactory$1 {
 	/**
 	* `@cfworker/json-schema` iterates `schema.required` with `for...of`; it must be a string array or absent.
 	*/
-	sanitizeJsonSchemaRequiredKeywordsForCfworker(node$16) {
-		if (!node$16 || typeof node$16 !== "object" || Array.isArray(node$16)) return;
-		const o = node$16;
+	sanitizeJsonSchemaRequiredKeywordsForCfworker(node$20) {
+		if (!node$20 || typeof node$20 !== "object" || Array.isArray(node$20)) return;
+		const o = node$20;
 		const req = o.required;
 		if (req !== void 0 && !Array.isArray(req)) delete o.required;
 		else if (Array.isArray(req)) {
@@ -2062,17 +4109,17 @@ let OpenAiStrictJsonSchemaFactory = class OpenAiStrictJsonSchemaFactory$1 {
 		this.executionHelpers = executionHelpers;
 	}
 	createStructuredOutputRecord(schema, options) {
-		const record = this.executionHelpers.createJsonSchemaRecord(schema, {
+		const record$1 = this.executionHelpers.createJsonSchemaRecord(schema, {
 			schemaName: options.schemaName,
 			requireObjectRoot: false
 		});
-		this.strictifyRecursive(record);
-		if (options.title !== void 0) record.title = options.title;
-		return record;
+		this.strictifyRecursive(record$1);
+		if (options.title !== void 0) record$1.title = options.title;
+		return record$1;
 	}
-	strictifyRecursive(node$16) {
-		if (!node$16 || typeof node$16 !== "object" || Array.isArray(node$16)) return;
-		const o = node$16;
+	strictifyRecursive(node$20) {
+		if (!node$20 || typeof node$20 !== "object" || Array.isArray(node$20)) return;
+		const o = node$20;
 		this.stripOpenAiRejectedKeywords(o);
 		if (this.isObjectNode(o)) {
 			const props = this.readPropertiesObject(o);
@@ -2302,6 +4349,37 @@ AgentStructuredOutputRepairPromptFactory = _AgentStructuredOutputRepairPromptFac
 	__decorateMetadata("design:paramtypes", [typeof (_ref$4 = typeof AIAgentExecutionHelpersFactory !== "undefined" && AIAgentExecutionHelpersFactory) === "function" ? _ref$4 : Object])
 ], AgentStructuredOutputRepairPromptFactory);
 
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js
+const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
+	$ZodISODateTime.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function datetime(params) {
+	return _isoDateTime(ZodISODateTime, params);
+}
+const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
+	$ZodISODate.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function date(params) {
+	return _isoDate(ZodISODate, params);
+}
+const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
+	$ZodISOTime.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function time(params) {
+	return _isoTime(ZodISOTime, params);
+}
+const ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
+	$ZodISODuration.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function duration(params) {
+	return _isoDuration(ZodISODuration, params);
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js
 const initializer = (inst, issues) => {
@@ -2419,6 +4497,181 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	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, params) => stringProcessor(inst, ctx, json, params);
+	const bag = inst._zod.bag;
+	inst.format = bag.format ?? null;
+	inst.minLength = bag.minimum ?? null;
+	inst.maxLength = bag.maximum ?? null;
+	inst.regex = (...args) => inst.check(_regex(...args));
+	inst.includes = (...args) => inst.check(_includes(...args));
+	inst.startsWith = (...args) => inst.check(_startsWith(...args));
+	inst.endsWith = (...args) => inst.check(_endsWith(...args));
+	inst.min = (...args) => inst.check(_minLength(...args));
+	inst.max = (...args) => inst.check(_maxLength(...args));
+	inst.length = (...args) => inst.check(_length(...args));
+	inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
+	inst.lowercase = (params) => inst.check(_lowercase(params));
+	inst.uppercase = (params) => inst.check(_uppercase(params));
+	inst.trim = () => inst.check(_trim());
+	inst.normalize = (...args) => inst.check(_normalize(...args));
+	inst.toLowerCase = () => inst.check(_toLowerCase());
+	inst.toUpperCase = () => inst.check(_toUpperCase());
+	inst.slugify = () => inst.check(_slugify());
+});
+const ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
+	$ZodString.init(inst, def);
+	_ZodString.init(inst, def);
+	inst.email = (params) => inst.check(_email(ZodEmail, params));
+	inst.url = (params) => inst.check(_url(ZodURL, params));
+	inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
+	inst.emoji = (params) => inst.check(_emoji(ZodEmoji, params));
+	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+	inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
+	inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
+	inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
+	inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
+	inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
+	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+	inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
+	inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
+	inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
+	inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
+	inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
+	inst.xid = (params) => inst.check(_xid(ZodXID, params));
+	inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
+	inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
+	inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
+	inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
+	inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
+	inst.e164 = (params) => inst.check(_e164(ZodE164, params));
+	inst.datetime = (params) => inst.check(datetime(params));
+	inst.date = (params) => inst.check(date(params));
+	inst.time = (params) => inst.check(time(params));
+	inst.duration = (params) => inst.check(duration(params));
+});
+function string(params) {
+	return _string(ZodString, params);
+}
+const ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	_ZodString.init(inst, def);
+});
+const ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
+	$ZodEmail.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
+	$ZodGUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
+	$ZodUUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
+	$ZodURL.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
+	$ZodEmoji.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
+	$ZodNanoID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
+	$ZodCUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
+	$ZodCUID2.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
+	$ZodULID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
+	$ZodXID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
+	$ZodKSUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
+	$ZodIPv4.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
+	$ZodIPv6.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
+	$ZodCIDRv4.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
+	$ZodCIDRv6.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
+	$ZodBase64.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
+	$ZodBase64URL.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
+	$ZodE164.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
+	$ZodJWT.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, 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));
+	inst.lt = (value, params) => inst.check(_lt(value, params));
+	inst.lte = (value, params) => inst.check(_lte(value, params));
+	inst.max = (value, params) => inst.check(_lte(value, params));
+	inst.int = (params) => inst.check(int(params));
+	inst.safe = (params) => inst.check(int(params));
+	inst.positive = (params) => inst.check(_gt(0, params));
+	inst.nonnegative = (params) => inst.check(_gte(0, params));
+	inst.negative = (params) => inst.check(_lt(0, params));
+	inst.nonpositive = (params) => inst.check(_lte(0, params));
+	inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
+	inst.step = (value, params) => inst.check(_multipleOf(value, params));
+	inst.finite = () => inst;
+	const bag = inst._zod.bag;
+	inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+	inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+	inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? .5);
+	inst.isFinite = true;
+	inst.format = bag.format ?? null;
+});
+function number(params) {
+	return _number(ZodNumber, params);
+}
+const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
+	$ZodNumberFormat.init(inst, def);
+	ZodNumber.init(inst, def);
+});
+function int(params) {
+	return _int(ZodNumberFormat, params);
+}
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -2427,6 +4680,14 @@ const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 function unknown() {
 	return _unknown(ZodUnknown);
 }
+const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
+	$ZodNever.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
+});
+function never(params) {
+	return _never(ZodNever, params);
+}
 const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 	$ZodArray.init(inst, def);
 	ZodType.init(inst, def);
@@ -2441,6 +4702,53 @@ const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 function array(element, params) {
 	return _array(ZodArray, element, params);
 }
+const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
+	$ZodObjectJIT.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
+	defineLazy(inst, "shape", () => {
+		return def.shape;
+	});
+	inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
+	inst.catchall = (catchall) => inst.clone({
+		...inst._zod.def,
+		catchall
+	});
+	inst.passthrough = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.loose = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.strict = () => inst.clone({
+		...inst._zod.def,
+		catchall: never()
+	});
+	inst.strip = () => inst.clone({
+		...inst._zod.def,
+		catchall: void 0
+	});
+	inst.extend = (incoming) => {
+		return extend(inst, incoming);
+	};
+	inst.safeExtend = (incoming) => {
+		return safeExtend(inst, incoming);
+	};
+	inst.merge = (other) => merge(inst, other);
+	inst.pick = (mask) => pick(inst, mask);
+	inst.omit = (mask) => omit(inst, mask);
+	inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
+	inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
+});
+function object(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape: shape ?? {},
+		...normalizeParams(params)
+	});
+}
 const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
 	$ZodUnion.init(inst, def);
 	ZodType.init(inst, def);
@@ -2466,6 +4774,58 @@ function intersection(left, right) {
 		right
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
+const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
+	$ZodEnum.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
+	inst.enum = def.entries;
+	inst.options = Object.values(def.entries);
+	const keys = new Set(Object.keys(def.entries));
+	inst.extract = (values, params) => {
+		const newEntries = {};
+		for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+	inst.exclude = (values, params) => {
+		const newEntries = { ...def.entries };
+		for (const value of values) if (keys.has(value)) delete newEntries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+});
+function _enum(values, params) {
+	return new ZodEnum({
+		type: "enum",
+		entries: Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values,
+		...normalizeParams(params)
+	});
+}
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
 	$ZodTransform.init(inst, def);
 	ZodType.init(inst, def);
@@ -4053,6 +6413,52 @@ var AIAgent = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/AssertionNode.ts
+let AssertionNode = class AssertionNode$1 {
+	kind = "node";
+	outputPorts = ["main"];
+	async execute(args) {
+		const ctx = args.ctx;
+		const config$1 = ctx.config;
+		try {
+			return [...await config$1.assertions(args.item, ctx)];
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return [{
+				name: config$1.name ?? "assertion",
+				score: 0,
+				errored: true,
+				message
+			}];
+		}
+	}
+};
+AssertionNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], AssertionNode);
+
+//#endregion
+//#region src/nodes/assertion.ts
+/**
+* Generic assertion node — the "callback" form. For declarative shorthands (StringEquals,
+* JudgeByAgent) compose this with helpers added in later phases. Sets `emitsAssertions: true`
+* so host-side persisters know to record its outputs as `TestAssertion` rows.
+*/
+var Assertion = class {
+	kind = "node";
+	type = AssertionNode;
+	icon;
+	name;
+	id;
+	emitsAssertions = true;
+	assertions;
+	constructor(options) {
+		this.name = options.name ?? "Assertion";
+		this.id = options.id;
+		this.icon = options.icon ?? "lucide:check-circle";
+		this.assertions = options.assertions;
+	}
+};
+
 //#endregion
 //#region src/nodes/CallbackResultNormalizerFactory.ts
 var CallbackResultNormalizer = class {
@@ -4122,32 +6528,79 @@ let HttpRequestNode = class HttpRequestNode$1 {
 	}
 	async executeItem(item, ctx) {
 		const url = this.resolveUrl(item, ctx);
-		const response = await fetch(url, { method: ctx.config.method });
+		const credential = await this.resolveCredential(ctx);
+		const spec = {
+			url,
+			method: ctx.config.method,
+			headers: ctx.config.args.headers,
+			query: ctx.config.args.query,
+			body: ctx.config.args.body,
+			credential,
+			download: {
+				mode: ctx.config.downloadMode,
+				binaryName: ctx.config.binaryName
+			},
+			ctx
+		};
+		const { url: resolvedUrl, init } = await new HttpRequestExecutor(globalThis.fetch, new HttpBodyBuilder(), new HttpUrlBuilder()).buildRequest(spec, item);
+		const response = await globalThis.fetch(resolvedUrl, init);
 		const headers = this.readHeaders(response.headers);
 		const mimeType = this.resolveMimeType(headers);
-		const bodyBinaryName = ctx.config.binaryName;
-		const shouldAttachBody = this.shouldAttachBody(ctx.config.downloadMode, mimeType);
-		let outputItem = { json: {
-			url,
+		const binaryName = ctx.config.binaryName;
+		if (this.shouldAttachBody(ctx.config.downloadMode, mimeType)) {
+			const outputJson = {
+				url: resolvedUrl,
+				method: ctx.config.method,
+				ok: response.ok,
+				status: response.status,
+				statusText: response.statusText,
+				mimeType,
+				headers,
+				bodyBinaryName: binaryName
+			};
+			const attachment = await ctx.binary.attach({
+				name: binaryName,
+				body: response.body ? response.body : new Uint8Array(await response.arrayBuffer()),
+				mimeType,
+				filename: this.resolveFilename(resolvedUrl, headers)
+			});
+			let outputItem = { json: outputJson };
+			outputItem = ctx.binary.withAttachment(outputItem, binaryName, attachment);
+			return outputItem;
+		}
+		const isJson = this.isJsonMimeType(mimeType);
+		let json;
+		let text;
+		if (isJson) try {
+			json = await response.json();
+		} catch {
+			text = await response.text();
+		}
+		else text = await response.text();
+		return { json: {
+			url: resolvedUrl,
 			method: ctx.config.method,
 			ok: response.ok,
 			status: response.status,
 			statusText: response.statusText,
 			mimeType,
 			headers,
-			...shouldAttachBody ? { bodyBinaryName } : {}
+			...json !== void 0 ? { json } : {},
+			...text !== void 0 ? { text } : {}
 		} };
-		if (!shouldAttachBody) return outputItem;
-		const attachment = await ctx.binary.attach({
-			name: bodyBinaryName,
-			body: response.body ? response.body : new Uint8Array(await response.arrayBuffer()),
-			mimeType,
-			filename: this.resolveFilename(url, headers)
-		});
-		outputItem = ctx.binary.withAttachment(outputItem, bodyBinaryName, attachment);
-		return outputItem;
+	}
+	async resolveCredential(ctx) {
+		const slotKey = ctx.config.args.credentialSlot;
+		if (!slotKey) return;
+		try {
+			return await ctx.getCredential(slotKey);
+		} catch {
+			return;
+		}
 	}
 	resolveUrl(item, ctx) {
+		const literalUrl = ctx.config.args.url;
+		if (literalUrl && literalUrl.trim().length > 0) return literalUrl.trim();
 		const candidate = this.asRecord(item.json)[ctx.config.urlField];
 		if (typeof candidate !== "string" || candidate.trim() === "") throw new Error(`HttpRequest node expected item.json.${ctx.config.urlField} to contain a URL string.`);
 		return candidate;
@@ -4168,6 +6621,9 @@ let HttpRequestNode = class HttpRequestNode$1 {
 		if (!contentType) return "application/octet-stream";
 		return contentType.split(";")[0]?.trim() || "application/octet-stream";
 	}
+	isJsonMimeType(mimeType) {
+		return mimeType === "application/json" || mimeType.endsWith("+json");
+	}
 	shouldAttachBody(mode, mimeType) {
 		if (mode === "always") return true;
 		if (mode === "never") return false;
@@ -4194,6 +6650,16 @@ HttpRequestNode = __decorate([(0, __codemation_core.node)({ packageName: "@codem
 
 //#endregion
 //#region src/nodes/httpRequest.ts
+/**
+* The built-in HTTP request credential type IDs accepted by the `HttpRequest` node.
+* These match the four generic credential types shipped with `@codemation/core-nodes`.
+*/
+const HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES = [
+	bearerTokenCredentialType.definition.typeId,
+	apiKeyCredentialType.definition.typeId,
+	basicAuthCredentialType.definition.typeId,
+	oauth2ClientCredentialsType.definition.typeId
+];
 var HttpRequest = class {
 	kind = "node";
 	type = HttpRequestNode;
@@ -4219,6 +6685,16 @@ var HttpRequest = class {
 	get downloadMode() {
 		return this.args.downloadMode ?? "auto";
 	}
+	getCredentialRequirements() {
+		if (!this.args.credentialSlot) return [];
+		return [{
+			slotKey: this.args.credentialSlot,
+			label: "Authentication",
+			acceptedTypes: HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES,
+			optional: true,
+			helpText: "Optional credential for authenticating the HTTP request."
+		}];
+	}
 };
 
 //#endregion
@@ -4344,6 +6820,40 @@ var If = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/IsTestRunNode.ts
+let IsTestRunNode = class IsTestRunNode$1 {
+	kind = "node";
+	execute(args) {
+		const isTest = args.ctx.testContext !== void 0;
+		return (0, __codemation_core.emitPorts)({
+			true: isTest ? [args.item] : [],
+			false: isTest ? [] : [args.item]
+		});
+	}
+};
+IsTestRunNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], IsTestRunNode);
+
+//#endregion
+//#region src/nodes/isTestRun.ts
+/**
+* Branches per-item on whether the current run is a test run. Output ports: `true`, `false`.
+* The wire payload is unchanged — this is a router, not a transform.
+*/
+var IsTestRun = class {
+	kind = "node";
+	type = IsTestRunNode;
+	execution = { hint: "local" };
+	icon = "lucide:flask-conical";
+	declaredOutputPorts = ["true", "false"];
+	name;
+	id;
+	constructor(name = "Is test run?", id) {
+		this.name = name;
+		this.id = id;
+	}
+};
+
 //#endregion
 //#region src/nodes/SwitchNode.ts
 let SwitchNode = class SwitchNode$1 {
@@ -4408,6 +6918,75 @@ var Split = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/CronTriggerNode.ts
+let CronTriggerNode = class CronTriggerNode$1 {
+	kind = "trigger";
+	outputPorts = ["main"];
+	async setup(ctx) {
+		const job = ctx.config.createJob(async (self) => {
+			const scheduledFor = self.currentRun()?.toISOString() ?? ctx.now().toISOString();
+			await ctx.emit([{ json: {
+				firedAt: ctx.now().toISOString(),
+				scheduledFor
+			} }]);
+		});
+		ctx.registerCleanup({ stop: () => {
+			job.stop();
+		} });
+	}
+	async execute(items, _ctx) {
+		return { main: items };
+	}
+	async getTestItems(ctx) {
+		const nowIso = ctx.now().toISOString();
+		return [{ json: {
+			firedAt: nowIso,
+			scheduledFor: nowIso
+		} }];
+	}
+};
+CronTriggerNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], CronTriggerNode);
+
+//#endregion
+//#region src/nodes/CronTriggerFactory.ts
+/**
+* Schedules a workflow on a standard cron expression.
+*
+* Each tick emits one item: `{ firedAt: string, scheduledFor: string }` — both ISO-8601 timestamps.
+* `firedAt` is the wall-clock moment the callback ran; `scheduledFor` is the cron-computed
+* firing instant (these differ when the job was delayed).
+*
+* Timezone defaults to UTC when omitted — cron without an explicit TZ is a DST footgun.
+*/
+var CronTrigger = class {
+	kind = "trigger";
+	type = CronTriggerNode;
+	icon = "lucide:clock";
+	id;
+	constructor(name, args, id) {
+		this.name = name;
+		this.args = args;
+		new croner.Cron(args.schedule, {
+			paused: true,
+			timezone: args.timezone
+		});
+		this.id = id;
+	}
+	get schedule() {
+		return this.args.schedule;
+	}
+	get timezone() {
+		return this.args.timezone;
+	}
+	createJob(callback) {
+		return new croner.Cron(this.args.schedule, {
+			timezone: this.args.timezone,
+			protect: true
+		}, callback);
+	}
+};
+
 //#endregion
 //#region src/nodes/ManualTriggerNode.ts
 let ManualTriggerNode = class ManualTriggerNode$1 {
@@ -4639,6 +7218,52 @@ var SubWorkflow = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/TestTriggerNode.ts
+let TestTriggerNode = class TestTriggerNode$1 {
+	kind = "trigger";
+	outputPorts = ["main"];
+	async setup(_ctx) {}
+	async execute(items, _ctx) {
+		return { main: items };
+	}
+};
+TestTriggerNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], TestTriggerNode);
+
+//#endregion
+//#region src/nodes/testTrigger.ts
+/**
+* Trigger config for a test fixture source. Drop one (or more) of these on the canvas alongside
+* a workflow's live triggers; clicking "Run tests" on the Tests tab invokes
+* {@link TestTriggerOptions.generateItems} via the TestSuiteOrchestrator.
+*/
+var TestTrigger = class {
+	kind = "trigger";
+	triggerKind = "test";
+	type = TestTriggerNode;
+	icon;
+	name;
+	id;
+	concurrency;
+	description;
+	generateItems;
+	caseLabel;
+	credentialRequirements;
+	constructor(options) {
+		this.name = options.name ?? "Test trigger";
+		this.id = options.id;
+		this.icon = options.icon ?? "lucide:flask-conical";
+		this.concurrency = options.concurrency;
+		this.description = options.description;
+		this.credentialRequirements = options.credentialRequirements ?? [];
+		this.generateItems = options.generateItems;
+		this.caseLabel = options.caseLabel;
+	}
+	getCredentialRequirements() {
+		return this.credentialRequirements;
+	}
+};
+
 //#endregion
 //#region src/nodes/WaitDurationFactory.ts
 var WaitDuration = class {
@@ -4819,10 +7444,10 @@ var WorkflowDefinedNodeResolver = class {
 //#endregion
 //#region src/workflowAuthoring/WorkflowDurationParser.types.ts
 var WorkflowDurationParser = class {
-	static parse(duration) {
-		if (typeof duration === "number") return Number.isFinite(duration) && duration > 0 ? Math.floor(duration) : 0;
-		const match = duration.trim().toLowerCase().match(/^(\d+)(ms|s|m|h)$/);
-		if (!match) throw new Error(`Unsupported wait duration "${duration}". Use a number of milliseconds or values like "500ms", "2s", "5m".`);
+	static parse(duration$2) {
+		if (typeof duration$2 === "number") return Number.isFinite(duration$2) && duration$2 > 0 ? Math.floor(duration$2) : 0;
+		const match = duration$2.trim().toLowerCase().match(/^(\d+)(ms|s|m|h)$/);
+		if (!match) throw new Error(`Unsupported wait duration "${duration$2}". Use a number of milliseconds or values like "500ms", "2s", "5m".`);
 		const value = Number(match[1]);
 		const unit = match[2];
 		if (unit === "ms") return value;
@@ -4848,8 +7473,8 @@ var WorkflowBranchBuilder = class WorkflowBranchBuilder {
 	}
 	wait(nameOrDuration, durationOrUndefined, id) {
 		const name = typeof nameOrDuration === "string" && durationOrUndefined !== void 0 ? nameOrDuration : "Wait";
-		const duration = durationOrUndefined ?? nameOrDuration;
-		return this.then(new Wait(name, WorkflowDurationParser.parse(duration), id));
+		const duration$2 = durationOrUndefined ?? nameOrDuration;
+		return this.then(new Wait(name, WorkflowDurationParser.parse(duration$2), id));
 	}
 	split(nameOrGetter, getElementsOrUndefined, id) {
 		const name = typeof nameOrGetter === "string" ? nameOrGetter : "Split";
@@ -4894,8 +7519,8 @@ var WorkflowChain = class WorkflowChain {
 	}
 	wait(nameOrDuration, durationOrUndefined, id) {
 		const name = typeof nameOrDuration === "string" && durationOrUndefined !== void 0 ? nameOrDuration : "Wait";
-		const duration = durationOrUndefined ?? nameOrDuration;
-		return this.then(new Wait(name, WorkflowDurationParser.parse(duration), id));
+		const duration$2 = durationOrUndefined ?? nameOrDuration;
+		return this.then(new Wait(name, WorkflowDurationParser.parse(duration$2), id));
 	}
 	split(nameOrGetter, getElementsOrUndefined, id) {
 		const name = typeof nameOrGetter === "string" ? nameOrGetter : "Split";
@@ -4995,9 +7620,9 @@ var AIAgentConnectionWorkflowExpander = class {
 		const connectionsByParentAndName = this.createConnectionsByParentAndName(workflow$1);
 		const extraNodes = [];
 		let connectionsChanged = false;
-		for (const node$16 of workflow$1.nodes) {
-			if (node$16.type !== AIAgentNode || !__codemation_core.AgentConfigInspector.isAgentNodeConfig(node$16.config)) continue;
-			for (const connectionNode of __codemation_core.AgentConnectionNodeCollector.collect(node$16.id, node$16.config)) {
+		for (const node$20 of workflow$1.nodes) {
+			if (node$20.type !== AIAgentNode || !__codemation_core.AgentConfigInspector.isAgentNodeConfig(node$20.config)) continue;
+			for (const connectionNode of __codemation_core.AgentConnectionNodeCollector.collect(node$20.id, node$20.config)) {
 				if (!existingChildIds.has(connectionNode.nodeId)) {
 					this.assertNoIdCollision(workflow$1, extraNodes, existingChildIds, connectionNode.nodeId);
 					extraNodes.push({
@@ -5076,6 +7701,129 @@ var ConnectionCredentialNodeConfigFactory = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/collections/collectionInsertNode.types.ts
+const collectionInsertNode = (0, __codemation_core.defineNode)({
+	key: "collection-insert",
+	title: "Collection: Insert",
+	description: "Insert a new row into a collection.",
+	icon: "lucide:boxes",
+	configSchema: object({
+		collectionName: string(),
+		data: record(string(), unknown())
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		return await store.insert(config$1.data);
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionGetNode.types.ts
+const collectionGetNode = (0, __codemation_core.defineNode)({
+	key: "collection-get",
+	title: "Collection: Get",
+	description: "Get a single row by id from a collection.",
+	icon: "lucide:layers",
+	configSchema: object({
+		collectionName: string(),
+		id: string()
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		const row = await store.get(config$1.id);
+		if (row === null) return [];
+		return row;
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionFindOneNode.types.ts
+const collectionFindOneNode = (0, __codemation_core.defineNode)({
+	key: "collection-find-one",
+	title: "Collection: Find One",
+	description: "Find a single row matching a filter in a collection.",
+	icon: "lucide:filter",
+	configSchema: object({
+		collectionName: string(),
+		where: record(string(), unknown())
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		const row = await store.findOne(config$1.where);
+		if (row === null) return [];
+		return row;
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionListNode.types.ts
+const collectionListNode = (0, __codemation_core.defineNode)({
+	key: "collection-list",
+	title: "Collection: List",
+	description: "List rows from a collection with optional pagination and filtering.",
+	icon: "lucide:split",
+	configSchema: object({
+		collectionName: string(),
+		limit: number().int().positive().optional(),
+		offset: number().int().nonnegative().optional(),
+		where: record(string(), unknown()).optional()
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		const { rows } = await store.list({
+			limit: config$1.limit,
+			offset: config$1.offset,
+			where: config$1.where
+		});
+		return [...rows];
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionUpdateNode.types.ts
+const collectionUpdateNode = (0, __codemation_core.defineNode)({
+	key: "collection-update",
+	title: "Collection: Update",
+	description: "Update a row by id in a collection.",
+	icon: "lucide:square-pen",
+	configSchema: object({
+		collectionName: string(),
+		id: string(),
+		patch: record(string(), unknown())
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		return await store.update(config$1.id, config$1.patch);
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionDeleteNode.types.ts
+const collectionDeleteNode = (0, __codemation_core.defineNode)({
+	key: "collection-delete",
+	title: "Collection: Delete",
+	description: "Delete a row by id from a collection.",
+	icon: "lucide:braces",
+	configSchema: object({
+		collectionName: string(),
+		id: string()
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		return {
+			deleted: (await store.delete(config$1.id)).deleted,
+			id: config$1.id
+		};
+	}
+});
+
 //#endregion
 exports.AIAgent = AIAgent;
 exports.AIAgentConnectionWorkflowExpander = AIAgentConnectionWorkflowExpander;
@@ -5133,6 +7881,13 @@ Object.defineProperty(exports, 'AggregateNode', {
     return AggregateNode;
   }
 });
+exports.Assertion = Assertion;
+Object.defineProperty(exports, 'AssertionNode', {
+  enumerable: true,
+  get: function () {
+    return AssertionNode;
+  }
+});
 exports.Callback = Callback;
 Object.defineProperty(exports, 'CallbackNode', {
   enumerable: true,
@@ -5150,6 +7905,13 @@ Object.defineProperty(exports, 'ConnectionCredentialNode', {
 });
 exports.ConnectionCredentialNodeConfig = ConnectionCredentialNodeConfig;
 exports.ConnectionCredentialNodeConfigFactory = ConnectionCredentialNodeConfigFactory;
+exports.CronTrigger = CronTrigger;
+Object.defineProperty(exports, 'CronTriggerNode', {
+  enumerable: true,
+  get: function () {
+    return CronTriggerNode;
+  }
+});
 exports.Filter = Filter;
 Object.defineProperty(exports, 'FilterNode', {
   enumerable: true,
@@ -5157,6 +7919,7 @@ Object.defineProperty(exports, 'FilterNode', {
     return FilterNode;
   }
 });
+exports.HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES = HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES;
 exports.HttpRequest = HttpRequest;
 Object.defineProperty(exports, 'HttpRequestNode', {
   enumerable: true,
@@ -5171,6 +7934,13 @@ Object.defineProperty(exports, 'IfNode', {
     return IfNode;
   }
 });
+exports.IsTestRun = IsTestRun;
+Object.defineProperty(exports, 'IsTestRunNode', {
+  enumerable: true,
+  get: function () {
+    return IsTestRunNode;
+  }
+});
 exports.ManualTrigger = ManualTrigger;
 Object.defineProperty(exports, 'ManualTriggerNode', {
   enumerable: true,
@@ -5234,6 +8004,13 @@ Object.defineProperty(exports, 'SwitchNode', {
     return SwitchNode;
   }
 });
+exports.TestTrigger = TestTrigger;
+Object.defineProperty(exports, 'TestTriggerNode', {
+  enumerable: true,
+  get: function () {
+    return TestTriggerNode;
+  }
+});
 exports.Wait = Wait;
 exports.WaitDuration = WaitDuration;
 Object.defineProperty(exports, 'WaitNode', {
@@ -5254,7 +8031,18 @@ Object.defineProperty(exports, 'WebhookTriggerNode', {
 exports.WorkflowAuthoringBuilder = WorkflowAuthoringBuilder;
 exports.WorkflowBranchBuilder = WorkflowBranchBuilder;
 exports.WorkflowChain = WorkflowChain;
+exports.apiKeyCredentialType = apiKeyCredentialType;
+exports.basicAuthCredentialType = basicAuthCredentialType;
+exports.bearerTokenCredentialType = bearerTokenCredentialType;
+exports.collectionDeleteNode = collectionDeleteNode;
+exports.collectionFindOneNode = collectionFindOneNode;
+exports.collectionGetNode = collectionGetNode;
+exports.collectionInsertNode = collectionInsertNode;
+exports.collectionListNode = collectionListNode;
+exports.collectionUpdateNode = collectionUpdateNode;
 exports.createWorkflowBuilder = createWorkflowBuilder;
+exports.defineRestNode = defineRestNode;
+exports.oauth2ClientCredentialsType = oauth2ClientCredentialsType;
 exports.openAiChatModelPresets = openAiChatModelPresets;
 exports.registerCoreNodes = registerCoreNodes;
 exports.workflow = workflow;