@vite-hub/workflow 0.0.4 → 0.1.0

package/dist/operations.js

@@ -0,0 +1,887 @@
+import { t as internalErrorDiagnostics } from "./error-diagnostics-A_8Kp-48.js";
+import * as v from "valibot";
+//#region ../internal/src/standard-schema.ts
+function readOwn(value, key) {
+	if (value === null || Object(value) !== value) return;
+	try {
+		return Reflect.get(Object(value), key);
+	} catch {
+		return;
+	}
+}
+function isRecord(value) {
+	return value !== null && Object(value) === value && !Array.isArray(value);
+}
+/**
+* Read a Standard JSON Schema projection without throwing.
+*
+* Returns `undefined` when the schema has no `~standard.jsonSchema`, when the library cannot represent the type
+* (Zod throws for `Date`), or when the projection is not an object. Callers decide how to fall back.
+*/
+function standardJsonSchema(schema, direction, target = "draft-2020-12", libraryOptions) {
+	const jsonSchema = readOwn(readOwn(schema, "~standard"), "jsonSchema");
+	const project = readOwn(jsonSchema, direction);
+	if (typeof project !== "function") return;
+	try {
+		const result = project.call(jsonSchema, libraryOptions ? {
+			target,
+			libraryOptions
+		} : { target });
+		return isRecord(result) ? result : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@valibot+to-json-schema@1.8.0_valibot@1.5.0_typescript@6.0.3_/node_modules/@valibot/to-json-schema/dist/index.mjs
+/**
+* Adds an error message to the errors array.
+*
+* @param errors The array of error messages.
+* @param message The error message to add.
+*
+* @returns The new errors.
+*/
+function addError(errors, message) {
+	if (errors) {
+		errors.push(message);
+		return errors;
+	}
+	return [message];
+}
+const ESCAPE_REGEX = /[.*+?^${}()|[\]\\]/g;
+/**
+* Escapes special regex characters in a string.
+*
+* @param string The string to escape.
+*
+* @returns The escaped string.
+*/
+function escapeRegExp(string) {
+	return string.replace(ESCAPE_REGEX, "\\$&");
+}
+/**
+* Throws an error or logs a warning based on the configuration.
+*
+* @param message The message to throw or log.
+* @param config The conversion configuration.
+*/
+function handleError(message, config) {
+	switch (config?.errorMode) {
+		case "ignore": break;
+		case "warn":
+			console.warn(message);
+			break;
+		default: throw new Error(message);
+	}
+}
+/**
+* Whether a value is JSON compatible for a const keyword.
+*
+* @param value The value to check.
+*
+* @returns Whether the value is JSON compatible.
+*/
+function isJsonConstValue(value) {
+	return typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || typeof value === "string";
+}
+/**
+* Whether values are JSON compatible for an enum keyword.
+*
+* @param values The values to check.
+*
+* @returns Whether the values are JSON compatible.
+*/
+function isJsonEnumValues(values) {
+	return values.every(isJsonConstValue);
+}
+/**
+* Schema reference map with collision-free reference ID allocation.
+*/
+var ReferenceMap = class extends Map {
+	/**
+	* Creates an empty schema reference map.
+	*/
+	constructor() {
+		super();
+		this.count = 0;
+		this.usedIds = /* @__PURE__ */ new Set();
+	}
+	/**
+	* Adds a schema reference and reserves its ID.
+	*
+	* @param schema The Valibot schema.
+	* @param referenceId The reference ID.
+	*
+	* @returns The reference map.
+	*/
+	set(schema, referenceId) {
+		this.usedIds.add(referenceId);
+		return super.set(schema, referenceId);
+	}
+	/**
+	* Creates a reference ID that is not yet used.
+	*
+	* @param definitions The JSON Schema definitions.
+	*
+	* @returns The unused reference ID.
+	*/
+	createId(definitions) {
+		while (this.usedIds.has(`${this.count}`) || `${this.count}` in definitions) this.count++;
+		return `${this.count++}`;
+	}
+};
+/**
+* Returns the stricter lower bound.
+*
+* @param current The current lower bound.
+* @param value The new lower bound.
+*
+* @returns The stricter lower bound.
+*/
+function getLowerBound(current, value) {
+	if (typeof current !== "number" || !Number.isFinite(current) || value > current) return value;
+	return current;
+}
+/**
+* Returns the stricter upper bound.
+*
+* @param current The current upper bound.
+* @param value The new upper bound.
+*
+* @returns The stricter upper bound.
+*/
+function getUpperBound(current, value) {
+	if (typeof current !== "number" || !Number.isFinite(current) || value < current) return value;
+	return current;
+}
+/**
+* Returns the combined not restriction.
+*
+* @param current The current not restriction.
+* @param value The new not restriction.
+*
+* @returns The combined not restriction.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getNotRestriction(current, value) {
+	return current !== void 0 ? { anyOf: [current, value] } : value;
+}
+/**
+* Intersects allowed values with an existing enum restriction.
+*
+* @param jsonSchema The JSON Schema object.
+* @param values The allowed values.
+*/
+function intersectEnum(jsonSchema, values) {
+	let enumValues = jsonSchema.enum ?? values;
+	if (jsonSchema.enum) {
+		const valueSet = new Set(values);
+		enumValues = enumValues.filter((value) => valueSet.has(value));
+	}
+	if (enumValues.length) jsonSchema.enum = [...new Set(enumValues)];
+	else {
+		delete jsonSchema.enum;
+		jsonSchema.not = /* @__PURE__ */ getNotRestriction(jsonSchema.not, {});
+	}
+}
+/**
+* Converts any supported Valibot action to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotAction The Valibot action object.
+* @param config The conversion configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function convertAction(jsonSchema, valibotAction, config) {
+	if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
+	let errors;
+	switch (valibotAction.type) {
+		case "base64":
+			jsonSchema.contentEncoding = "base64";
+			break;
+		case "bic":
+		case "cuid2":
+		case "decimal":
+		case "digits":
+		case "domain":
+		case "emoji":
+		case "hash":
+		case "hexadecimal":
+		case "hex_color":
+		case "isrc":
+		case "iso_time_second":
+		case "iso_week":
+		case "ksuid":
+		case "mac":
+		case "mac48":
+		case "mac64":
+		case "nanoid":
+		case "octal":
+		case "slug":
+		case "ulid":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "description":
+			jsonSchema.description = valibotAction.description;
+			break;
+		case "email":
+		case "rfc_email":
+			jsonSchema.format = "email";
+			break;
+		case "ends_with":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = `${escapeRegExp(valibotAction.requirement)}$`;
+			break;
+		case "empty":
+			if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = 0;
+			}
+			break;
+		case "entries":
+			if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
+				errors = addError(errors, "The requirement of the \"entries\" action must be a non-negative integer.");
+				break;
+			}
+			jsonSchema.minProperties = getLowerBound(jsonSchema.minProperties, valibotAction.requirement);
+			jsonSchema.maxProperties = getUpperBound(jsonSchema.maxProperties, valibotAction.requirement);
+			break;
+		case "examples":
+			if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.examples];
+			else jsonSchema.examples = valibotAction.examples;
+			break;
+		case "gt_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
+				errors = addError(errors, `The "gt_value" action is not supported on type "${jsonSchema.type}".`);
+				break;
+			}
+			if (!Number.isFinite(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"gt_value\" action is not JSON compatible.");
+				break;
+			}
+			if (config?.target === "openapi-3.0") {
+				errors = addError(errors, "The \"gt_value\" action is not supported for OpenAPI 3.0.");
+				break;
+			}
+			jsonSchema.exclusiveMinimum = getLowerBound(jsonSchema.exclusiveMinimum, valibotAction.requirement);
+			break;
+		case "includes":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = escapeRegExp(valibotAction.requirement);
+			break;
+		case "integer":
+			jsonSchema.type = "integer";
+			break;
+		case "ipv4":
+			jsonSchema.format = "ipv4";
+			break;
+		case "ipv6":
+			jsonSchema.format = "ipv6";
+			break;
+		case "iso_date":
+			jsonSchema.format = "date";
+			break;
+		case "iso_date_time":
+		case "iso_timestamp":
+			jsonSchema.format = "date-time";
+			break;
+		case "iso_time":
+			jsonSchema.format = "time";
+			break;
+		case "jws_compact":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "length":
+			if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
+				errors = addError(errors, "The requirement of the \"length\" action must be a non-negative integer.");
+				break;
+			}
+			if (jsonSchema.type === "array") {
+				jsonSchema.minItems = getLowerBound(jsonSchema.minItems, valibotAction.requirement);
+				jsonSchema.maxItems = getUpperBound(jsonSchema.maxItems, valibotAction.requirement);
+			} else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = getLowerBound(jsonSchema.minLength, valibotAction.requirement);
+				jsonSchema.maxLength = getUpperBound(jsonSchema.maxLength, valibotAction.requirement);
+			}
+			break;
+		case "lt_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
+				errors = addError(errors, `The "lt_value" action is not supported on type "${jsonSchema.type}".`);
+				break;
+			}
+			if (!Number.isFinite(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"lt_value\" action is not JSON compatible.");
+				break;
+			}
+			if (config?.target === "openapi-3.0") {
+				errors = addError(errors, "The \"lt_value\" action is not supported for OpenAPI 3.0.");
+				break;
+			}
+			jsonSchema.exclusiveMaximum = getUpperBound(jsonSchema.exclusiveMaximum, valibotAction.requirement);
+			break;
+		case "max_entries":
+			if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
+				errors = addError(errors, "The requirement of the \"max_entries\" action must be a non-negative integer.");
+				break;
+			}
+			jsonSchema.maxProperties = getUpperBound(jsonSchema.maxProperties, valibotAction.requirement);
+			break;
+		case "max_length":
+			if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
+				errors = addError(errors, "The requirement of the \"max_length\" action must be a non-negative integer.");
+				break;
+			}
+			if (jsonSchema.type === "array") jsonSchema.maxItems = getUpperBound(jsonSchema.maxItems, valibotAction.requirement);
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = getUpperBound(jsonSchema.maxLength, valibotAction.requirement);
+			}
+			break;
+		case "max_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
+				errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
+				break;
+			}
+			if (!Number.isFinite(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"max_value\" action is not JSON compatible.");
+				break;
+			}
+			jsonSchema.maximum = getUpperBound(jsonSchema.maximum, valibotAction.requirement);
+			break;
+		case "metadata":
+			if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
+			if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
+			if (Array.isArray(valibotAction.metadata.examples)) if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.metadata.examples];
+			else jsonSchema.examples = valibotAction.metadata.examples;
+			for (const key of Object.keys(valibotAction.metadata)) if (key !== "title" && key !== "description" && key !== "examples" && key !== "__proto__") jsonSchema[key] = valibotAction.metadata[key];
+			break;
+		case "min_entries":
+			if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
+				errors = addError(errors, "The requirement of the \"min_entries\" action must be a non-negative integer.");
+				break;
+			}
+			jsonSchema.minProperties = getLowerBound(jsonSchema.minProperties, valibotAction.requirement);
+			break;
+		case "min_length":
+			if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
+				errors = addError(errors, "The requirement of the \"min_length\" action must be a non-negative integer.");
+				break;
+			}
+			if (jsonSchema.type === "array") jsonSchema.minItems = getLowerBound(jsonSchema.minItems, valibotAction.requirement);
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = getLowerBound(jsonSchema.minLength, valibotAction.requirement);
+			}
+			break;
+		case "min_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
+				errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
+				break;
+			}
+			if (!Number.isFinite(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"min_value\" action is not JSON compatible.");
+				break;
+			}
+			jsonSchema.minimum = getLowerBound(jsonSchema.minimum, valibotAction.requirement);
+			break;
+		case "multiple_of":
+			jsonSchema.multipleOf = valibotAction.requirement;
+			break;
+		case "non_empty":
+			if (jsonSchema.type === "array") jsonSchema.minItems = getLowerBound(jsonSchema.minItems, 1);
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = getLowerBound(jsonSchema.minLength, 1);
+			}
+			break;
+		case "not_value":
+			if (!isJsonConstValue(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"not_value\" action is not JSON compatible.");
+				break;
+			}
+			jsonSchema.not = /* @__PURE__ */ getNotRestriction(jsonSchema.not, config?.target === "openapi-3.0" ? { enum: [valibotAction.requirement] } : { const: valibotAction.requirement });
+			break;
+		case "not_values":
+			if (!isJsonEnumValues(valibotAction.requirement)) {
+				errors = addError(errors, "A requirement of the \"not_values\" action is not JSON compatible.");
+				break;
+			}
+			if (valibotAction.requirement.length) jsonSchema.not = /* @__PURE__ */ getNotRestriction(jsonSchema.not, { enum: [...new Set(valibotAction.requirement)] });
+			break;
+		case "regex":
+			if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "safe_integer":
+			jsonSchema.type = "integer";
+			jsonSchema.minimum = getLowerBound(jsonSchema.minimum, Number.MIN_SAFE_INTEGER);
+			jsonSchema.maximum = getUpperBound(jsonSchema.maximum, Number.MAX_SAFE_INTEGER);
+			break;
+		case "starts_with":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = `^${escapeRegExp(valibotAction.requirement)}`;
+			break;
+		case "title":
+			jsonSchema.title = valibotAction.title;
+			break;
+		case "url":
+			jsonSchema.format = "uri";
+			break;
+		case "uuid":
+			jsonSchema.format = "uuid";
+			break;
+		case "value":
+			if (!isJsonConstValue(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"value\" action is not JSON compatible.");
+				break;
+			}
+			if (config?.target === "openapi-3.0") intersectEnum(jsonSchema, [valibotAction.requirement]);
+			else if ("const" in jsonSchema && jsonSchema.const !== valibotAction.requirement) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with a different "const" restriction.`);
+			else jsonSchema.const = valibotAction.requirement;
+			break;
+		case "values":
+			if (!isJsonEnumValues(valibotAction.requirement)) {
+				errors = addError(errors, "A requirement of the \"values\" action is not JSON compatible.");
+				break;
+			}
+			intersectEnum(jsonSchema, valibotAction.requirement);
+			break;
+		default: errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideAction) {
+		const actionOverride = config.overrideAction({
+			valibotAction,
+			jsonSchema,
+			errors
+		});
+		if (actionOverride) return { ...actionOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+/**
+* Flattens a Valibot pipe by recursively expanding nested pipes.
+*
+* @param pipe The pipeline to flatten.
+*
+* @returns A flat pipeline.
+*/
+function flattenPipe(pipe) {
+	return pipe.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
+}
+/**
+* Returns the JSON Pointer reference for a definition key.
+*
+* @param referenceId The unescaped definition key.
+*
+* @returns The encoded JSON Pointer fragment.
+*/
+function getDefinitionRef(referenceId) {
+	return `#/$defs/${referenceId.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+/**
+* Converts any supported Valibot schema to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotSchema The Valibot schema object.
+* @param config The conversion configuration.
+* @param context The conversion context.
+* @param skipRef Whether to skip using a reference.
+*
+* @returns The converted JSON Schema.
+*/
+function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
+	if (!skipRef) {
+		const referenceId = context.referenceMap.get(valibotSchema);
+		if (referenceId) {
+			jsonSchema.$ref = getDefinitionRef(referenceId);
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			return jsonSchema;
+		}
+	}
+	if ("pipe" in valibotSchema) {
+		const flatPipe = flattenPipe(valibotSchema.pipe);
+		let startIndex = 0;
+		let stopIndex = flatPipe.length - 1;
+		if (config?.typeMode === "input") {
+			const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "to_bigint" || item.type === "to_boolean" || item.type === "to_date" || item.type === "to_number" || item.type === "to_string" || item.type === "transform"));
+			if (inputStopIndex !== -1) stopIndex = inputStopIndex;
+		} else if (config?.typeMode === "output") {
+			const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
+			if (outputStartIndex !== -1) startIndex = outputStartIndex;
+		}
+		for (let index = startIndex; index <= stopIndex; index++) {
+			const valibotPipeItem = flatPipe[index];
+			if (valibotPipeItem.kind === "schema") {
+				if (index > startIndex) handleError("Set the \"typeMode\" config to \"input\" or \"output\" to convert pipelines with multiple schemas.", config);
+				jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
+			} else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
+		}
+		return jsonSchema;
+	}
+	let errors;
+	switch (valibotSchema.type) {
+		case "boolean":
+			jsonSchema.type = "boolean";
+			break;
+		case "null":
+			if (config?.target === "openapi-3.0") jsonSchema.enum = [null];
+			else jsonSchema.type = "null";
+			break;
+		case "number":
+			jsonSchema.type = "number";
+			break;
+		case "string":
+			jsonSchema.type = "string";
+			break;
+		case "array":
+			jsonSchema.type = "array";
+			jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
+			break;
+		case "tuple":
+		case "tuple_with_rest":
+		case "loose_tuple":
+		case "strict_tuple":
+			jsonSchema.type = "array";
+			if (config?.target === "openapi-3.0") {
+				jsonSchema.items = { anyOf: [] };
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.items.anyOf.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.items.anyOf.push(convertSchema({}, valibotSchema.rest, config, context));
+				else if (valibotSchema.type === "strict_tuple" || valibotSchema.type === "tuple") jsonSchema.maxItems = valibotSchema.items.length;
+			} else if (config?.target === "draft-2020-12") {
+				jsonSchema.prefixItems = [];
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.prefixItems.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.items = convertSchema({}, valibotSchema.rest, config, context);
+				else if (valibotSchema.type === "strict_tuple") jsonSchema.items = false;
+			} else {
+				jsonSchema.items = [];
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
+				else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
+			}
+			break;
+		case "object":
+		case "object_with_rest":
+		case "loose_object":
+		case "strict_object":
+			jsonSchema.type = "object";
+			jsonSchema.properties = {};
+			jsonSchema.required = [];
+			for (const key in valibotSchema.entries) {
+				const entry = valibotSchema.entries[key];
+				jsonSchema.properties[key] = convertSchema({}, entry, config, context);
+				if (entry.type !== "exact_optional" && entry.type !== "nullish" && entry.type !== "optional") jsonSchema.required.push(key);
+			}
+			if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
+			else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
+			break;
+		case "record":
+			if (config?.target === "openapi-3.0" && "pipe" in valibotSchema.key) errors = addError(errors, "The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.");
+			if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
+			jsonSchema.type = "object";
+			if (config?.target !== "openapi-3.0") jsonSchema.propertyNames = convertSchema({}, valibotSchema.key, config, context);
+			jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
+			break;
+		case "any":
+		case "unknown": break;
+		case "never":
+			jsonSchema.not = {};
+			break;
+		case "nullable":
+		case "nullish":
+			if (config?.target === "openapi-3.0") {
+				const innerSchema = convertSchema({}, valibotSchema.wrapped, config, context);
+				Object.assign(jsonSchema, innerSchema);
+				jsonSchema.nullable = true;
+			} else jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
+			if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
+			break;
+		case "exact_optional":
+		case "optional":
+		case "undefinedable":
+			jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
+			if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
+			break;
+		case "literal":
+			if (!isJsonConstValue(valibotSchema.literal)) {
+				errors = addError(errors, "The value of the \"literal\" schema is not JSON compatible.");
+				break;
+			}
+			if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotSchema.literal];
+			else jsonSchema.const = valibotSchema.literal;
+			break;
+		case "enum":
+		case "picklist": {
+			const options = valibotSchema.options;
+			if (!options.every((option) => typeof option === "string" || typeof option === "number" && Number.isFinite(option))) {
+				errors = addError(errors, `An option of the "${valibotSchema.type}" schema is not JSON compatible.`);
+				break;
+			}
+			jsonSchema.enum = options;
+			if (options.every((option) => typeof option === "string")) jsonSchema.type = "string";
+			else if (options.every((option) => typeof option === "number")) jsonSchema.type = "number";
+			else if (config?.target !== "openapi-3.0") jsonSchema.type = ["string", "number"];
+			break;
+		}
+		case "union":
+			jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "variant":
+			jsonSchema.oneOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "intersect":
+			jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "lazy": {
+			let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
+			if (!wrappedValibotSchema) {
+				wrappedValibotSchema = valibotSchema.getter(void 0);
+				context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
+			}
+			let referenceId = context.referenceMap.get(wrappedValibotSchema);
+			if (!referenceId) {
+				referenceId = context.referenceMap.createId(context.definitions);
+				context.referenceMap.set(wrappedValibotSchema, referenceId);
+				context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
+			}
+			jsonSchema.$ref = getDefinitionRef(referenceId);
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema: wrappedValibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			break;
+		}
+		default: errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideSchema) {
+		const schemaOverride = config.overrideSchema({
+			...context,
+			referenceId: context.referenceMap.get(valibotSchema),
+			valibotSchema,
+			jsonSchema,
+			errors
+		});
+		if (schemaOverride) return { ...schemaOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+/**
+* Converts a Valibot schema to the JSON Schema format.
+*
+* @param schema The Valibot schema object.
+* @param config The JSON Schema configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function toJsonSchema(schema, config) {
+	const context = {
+		definitions: {},
+		referenceMap: new ReferenceMap(),
+		getterMap: /* @__PURE__ */ new Map()
+	};
+	const definitions = config?.definitions ?? void 0;
+	if (definitions) {
+		for (const key in definitions) context.referenceMap.set(definitions[key], key);
+		for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
+	}
+	const jsonSchema = convertSchema({}, schema, config, context);
+	const target = config?.target ?? "draft-07";
+	if (target === "draft-2020-12") jsonSchema.$schema = "https://json-schema.org/draft/2020-12/schema";
+	else if (target === "draft-07") jsonSchema.$schema = "http://json-schema.org/draft-07/schema#";
+	if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
+	return jsonSchema;
+}
+//#endregion
+//#region ../internal/src/valibot.ts
+const valibotTargets = /* @__PURE__ */ new Set([
+	"draft-07",
+	"draft-2020-12",
+	"openapi-3.0"
+]);
+function isValibotTarget(value) {
+	return valibotTargets.has(String(value));
+}
+/**
+* Add Standard JSON Schema conversion to a plain Valibot schema. Valibot schemas validate as Standard Schema but carry
+* no JSON Schema, so forms, tools, and model providers would get no shape for them. Other schemas, Valibot schemas that
+* already convert, and async Valibot schemas return unchanged. The copy keeps every Valibot property, so validation
+* does not change.
+*
+* `target` fixes the JSON Schema dialect. Without it, each conversion uses the dialect that the caller asks for.
+*/
+function withValibotJsonSchema(schema, options = {}) {
+	const standard = schema["~standard"];
+	if (standard.vendor !== "valibot" || Reflect.get(schema, "async") === true) return schema;
+	if (Object.hasOwn(standard, "jsonSchema") && standard.jsonSchema) return schema;
+	const convert = (typeMode) => (request) => {
+		const target = options.target ?? request.target;
+		if (!isValibotTarget(target)) throw new Error(`[vitehub] Valibot cannot convert a schema to the ${String(target)} JSON Schema target.`);
+		return toJsonSchema(schema, {
+			target,
+			typeMode,
+			errorMode: "ignore"
+		});
+	};
+	return {
+		...schema,
+		"~standard": {
+			...standard,
+			jsonSchema: {
+				input: convert("input"),
+				output: convert("output")
+			}
+		}
+	};
+}
+//#endregion
+//#region ../internal/src/operations.ts
+const nameFormat = /^[a-z][a-z0-9-]*\.[a-z][a-z0-9-]*$/;
+const kinds = /* @__PURE__ */ new Set([
+	"read",
+	"write",
+	"destructive"
+]);
+function isObject(value) {
+	return value !== null && Object(value) === value && !Array.isArray(value);
+}
+function invalidDefinition(name, reason) {
+	return internalErrorDiagnostics.INTERNAL_R0020({ message: `[vitehub] Operation ${JSON.stringify(name)} is invalid: ${reason}` });
+}
+function checkDefinition(definition) {
+	if (!isObject(definition)) throw invalidDefinition(void 0, "defineOperation() takes an object.");
+	const { name } = definition;
+	if (String(name) !== name || !nameFormat.test(name)) throw invalidDefinition(name, "the name must look like `section.verb`, in lower case.");
+	if (String(definition.description) !== definition.description || !definition.description) throw invalidDefinition(name, "add a one sentence description.");
+	const { section } = definition;
+	if (section !== false && !(section instanceof Function) && (String(section) !== section || !section)) throw invalidDefinition(name, "section must be a Console section id, a function, or false.");
+	if (!kinds.has(String(definition.kind))) throw invalidDefinition(name, "kind must be \"read\", \"write\", or \"destructive\".");
+	const input = definition.input;
+	if (!isObject(input) || !isObject(input["~standard"]) || !(input["~standard"].validate instanceof Function)) throw invalidDefinition(name, "input must be a Standard Schema, such as a valibot object.");
+	if (!(definition.run instanceof Function)) throw invalidDefinition(name, "run must be a function.");
+	const { maxRequestBytes } = definition;
+	if (maxRequestBytes !== void 0 && (!Number.isInteger(maxRequestBytes) || Number(maxRequestBytes) < 65536)) throw invalidDefinition(name, `maxRequestBytes can only raise the limit above ${defaultRequestBytes} bytes (64 KiB).`);
+	if (definition.readOnlyWhen !== void 0 && !(definition.readOnlyWhen instanceof Function)) throw invalidDefinition(name, "readOnlyWhen must be a function.");
+}
+/** The default limit of a call, in bytes. */
+const defaultRequestBytes = 65536;
+/** Input keys that the generated CLI commands read themselves. */
+const reservedOperationFlags = [
+	"input",
+	"json",
+	"timeout",
+	"url",
+	"yes"
+];
+/**
+* Define one operation. The Console, the CLI, MCP, and agent tools call the same definition. Contribute it with
+* `vitehub: { operations: [{ module, export }] }` on a Vite plugin.
+*/
+function defineOperation(definition) {
+	checkDefinition(definition);
+	const defined = {
+		...definition,
+		input: withValibotJsonSchema(definition.input)
+	};
+	const properties = operationInputJsonSchema(defined).properties;
+	const clashes = isObject(properties) ? Object.keys(properties).filter((key) => reservedOperationFlags.includes(key)) : [];
+	if (clashes.length) throw invalidDefinition(definition.name, `the input key ${clashes.map((key) => JSON.stringify(key)).join(", ")} is a CLI flag of every command (${reservedOperationFlags.join(", ")}). Rename it.`);
+	return defined;
+}
+/** JSON Schema of the input, for CLI flags and MCP tool schemas. Falls back to an open object. */
+function operationInputJsonSchema(operation) {
+	return standardJsonSchema(operation.input, "input") ?? { type: "object" };
+}
+//#endregion
+//#region src/operations.ts
+const runtime = () => import("./operations-B_rYG71W.js");
+const name = v.pipe(v.string(), v.check((value) => value.trim() !== "", "Name a Workflow."));
+const runId = v.pipe(v.string(), v.check((value) => value.trim() !== "", "Pass the id of a run."));
+const maxRequestBytes = 1048576;
+function defineWorkflowOperation(definition) {
+	return defineOperation({
+		...definition,
+		cli: {
+			namespace: "workflow",
+			...definition.cli
+		},
+		section: "workflows",
+		user: false
+	});
+}
+/** The `workflow.*` operations: start, get, cancel, and resume. The Console, `vitehub workflow`, and agents run them. */
+const workflowOperations = [
+	defineWorkflowOperation({
+		cli: { positional: ["workflow"] },
+		description: "Start a Workflow run by name. The payload is any JSON value.",
+		input: v.object({
+			payload: v.optional(v.unknown()),
+			workflow: name
+		}),
+		invoke: true,
+		kind: "write",
+		maxRequestBytes,
+		name: "workflow.start",
+		run: async (input) => (await runtime()).runWorkflowOperation("start", input)
+	}),
+	defineWorkflowOperation({
+		cli: { positional: ["runId"] },
+		description: "Show the status and result of a Workflow run. Pass `workflow` for a run that this runtime did not start.",
+		input: v.object({
+			runId,
+			workflow: v.optional(name)
+		}),
+		kind: "read",
+		name: "workflow.get",
+		run: async (input) => (await runtime()).runWorkflowOperation("get", input)
+	}),
+	defineWorkflowOperation({
+		cli: { positional: ["runId"] },
+		description: "Cancel a Workflow run. Only providers that support cancellation accept it.",
+		input: v.object({
+			runId,
+			workflow: v.optional(name)
+		}),
+		kind: "destructive",
+		name: "workflow.cancel",
+		run: async (input) => (await runtime()).runWorkflowOperation("cancel", input)
+	}),
+	defineWorkflowOperation({
+		cli: { positional: ["token"] },
+		description: "Resume a Workflow signal with its opaque token. The payload is any JSON value.",
+		input: v.object({
+			payload: v.optional(v.unknown()),
+			token: v.pipe(v.string(), v.check((value) => value.trim() !== "", "Pass the signal token."))
+		}),
+		invoke: true,
+		kind: "write",
+		maxRequestBytes,
+		name: "workflow.resume",
+		run: async (input) => (await runtime()).runWorkflowOperation("resume", input)
+	})
+];
+//#endregion
+export { workflowOperations };