@oomol-lab/open-flow 0.1.0-beta.70 → 0.1.0-beta.72

package/dist/common/workflow.js

@@ -725,7 +725,7 @@ $constructor("$ZodError", initializer$1, void 0, { Parent: Error });
 /** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
 * ("toString", "constructor") would otherwise read through to the prototype, and assigning
 * "__proto__" would hit the setter instead of creating a key. */
-function node$1(obj, key, make) {
+function node(obj, key, make) {
 	if (!Object.prototype.hasOwnProperty.call(obj, key)) {
 		if (key === "__proto__") Object.defineProperty(obj, key, {
 			value: make(),
@@ -740,7 +740,7 @@ function node$1(obj, key, make) {
 function flattenError(error, mapper = (issue) => issue.message) {
 	const fieldErrors = {};
 	const formErrors = [];
-	for (const sub of error.issues) if (sub.path.length > 0) node$1(fieldErrors, sub.path[0], () => []).push(mapper(sub));
+	for (const sub of error.issues) if (sub.path.length > 0) node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
 	else formErrors.push(mapper(sub));
 	return {
 		formErrors,
@@ -1043,7 +1043,7 @@ function timeSource(args) {
 function time$1(args) {
 	return new RegExp(`^${timeSource(args)}$`);
 }
-function datetime$1(args) {
+function datetime(args) {
 	const opts = ["Z"];
 	if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
 	const qualified = `${timeSource({
@@ -1694,7 +1694,7 @@ var $ZodKSUID = /*@__PURE__*/ $constructor("$ZodKSUID", (inst, def) => {
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODateTime = /*@__PURE__*/ $constructor("$ZodISODateTime", (inst, def) => {
-	def.pattern ?? (def.pattern = datetime$1(def));
+	def.pattern ?? (def.pattern = datetime(def));
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def) => {
@@ -2275,70 +2275,6 @@ var $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def) => {
 		});
 	};
 });
-function discriminatorMap(def) {
-	const map = /* @__PURE__ */ new Map();
-	for (const option of def.options) {
-		const values = option._zod.propValues?.[def.discriminator];
-		if (!values || values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
-		for (const value of values) if (map.has(value)) {
-			if (value !== void 0) throw new Error(`Duplicate discriminator value "${String(value)}"`);
-			map.set(value, null);
-		} else map.set(value, option);
-	}
-	return map;
-}
-var $ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
-	def.inclusive = false;
-	$ZodUnion.init(inst, def);
-	const _super = inst._zod.parse;
-	defineLazyInternal(inst, "propValues", (zod) => {
-		const propValues = {};
-		let undefinedCount = 0;
-		for (const option of zod.def.options) {
-			const pv = option._zod.propValues;
-			if (!pv || Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${zod.def.options.indexOf(option)}"`);
-			if (pv[zod.def.discriminator]?.has(void 0)) undefinedCount++;
-			for (const [k, v] of Object.entries(pv)) {
-				if (!Object.prototype.hasOwnProperty.call(propValues, k)) assignProp(propValues, k, /* @__PURE__ */ new Set());
-				for (const val of v) propValues[k].add(val);
-			}
-		}
-		if (!zod.def.unionFallback && undefinedCount > 1) propValues[zod.def.discriminator]?.delete(void 0);
-		return propValues;
-	});
-	def.options.forEach((option, i) => {
-		const propShape = rawShape(option._zod.def);
-		if (propShape && !Object.prototype.hasOwnProperty.call(propShape, def.discriminator)) throw new Error(`Invalid discriminated union option at index "${i}"`);
-	});
-	const disc = cached(() => discriminatorMap(def));
-	inst._zod.parse = (payload, ctx) => {
-		const input = payload.value;
-		if (!isObject$1(input)) {
-			payload.issues.push({
-				code: "invalid_type",
-				expected: "object",
-				input,
-				inst
-			});
-			return payload;
-		}
-		const value = input?.[def.discriminator];
-		const opt = disc.value.get(value);
-		if (opt && (value !== void 0 || ctx.direction !== "backward")) return opt._zod.run(payload, ctx);
-		if (def.unionFallback || ctx.direction === "backward") return _super(payload, ctx);
-		payload.issues.push({
-			code: "invalid_union",
-			errors: [],
-			note: "No matching discriminator",
-			discriminator: def.discriminator,
-			options: Array.from(disc.value.keys()).filter((value) => disc.value.get(value) !== null),
-			input,
-			path: [def.discriminator],
-			inst
-		});
-		return payload;
-	};
-});
 var $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -2804,9 +2740,6 @@ function handlePipeResult(left, next, ctx) {
 		issues: left.issues
 	}, ctx);
 }
-var $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
-	$ZodPipe.init(inst, def);
-});
 var $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazyInternal(inst, "propValues", (zod) => zod.def.innerType._zod.propValues);
@@ -5390,18 +5323,6 @@ function union(options, params) {
 		...normalizeParams(params)
 	});
 }
-var ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def) => {
-	ZodUnion.init(inst, def);
-	$ZodDiscriminatedUnion.init(inst, def);
-});
-function discriminatedUnion(discriminator, options, params) {
-	return new ZodDiscriminatedUnion({
-		type: "union",
-		options,
-		discriminator,
-		...normalizeParams(params)
-	});
-}
 var ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
 	$ZodIntersection.init(inst, def);
 	ZodType.init(inst, def);
@@ -5422,7 +5343,7 @@ var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record$1(keyType, valueType, params) {
+function record(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
 		keyType: string(),
@@ -5631,10 +5552,6 @@ function pipe(in_, out) {
 		out
 	});
 }
-var ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
-	ZodPipe.init(inst, def);
-	$ZodPreprocess.init(inst, def);
-});
 var ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
@@ -5670,7 +5587,7 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
-function json$1(params) {
+function json(params) {
 	const jsonSchema = lazy(() => {
 		return union([
 			string(params),
@@ -5678,23 +5595,11 @@ function json$1(params) {
 			boolean(),
 			_null(),
 			array(jsonSchema),
-			record$1(string(), jsonSchema)
+			record(string(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
 }
-function preprocess(fn, schema) {
-	return new ZodPreprocess({
-		type: "pipe",
-		in: transform(fn),
-		out: schema
-	});
-}
-//#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/iso.js
-function datetime(params) {
-	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
-}
 //#endregion
 //#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
@@ -6576,819 +6481,6 @@ var Validator = class {
 	}
 };
 //#endregion
-//#region src/decision/common/decision.ts
-var decisionLimits = {
-	choice: 255,
-	score: 10
-};
-/** Ordered prefixes are shared by authoring, schemas, validation, and execution. */
-function limitDecisionQuestion(question) {
-	if (question.type === "noul" || question.criteria.length <= decisionLimits[question.type]) return question;
-	if (question.type === "choice") return {
-		...question,
-		criteria: question.criteria.slice(0, decisionLimits.choice)
-	};
-	return {
-		...question,
-		criteria: question.criteria.slice(0, decisionLimits.score)
-	};
-}
-function limitDecisionQuestions(questions) {
-	const limited = questions.map(limitDecisionQuestion);
-	return limited.every((question, i) => question === questions[i]) ? questions : limited;
-}
-/** Loading an oversized task also updates its previously generated output schemas. */
-function limitDecisionTask(task) {
-	if (task.executor.kind !== "decision") return task;
-	const original = task.executor.questions;
-	const questions = limitDecisionQuestions(original);
-	if (questions === original) return task;
-	const outputs = task.outputs.map((port) => {
-		if (!("handle" in port)) return port;
-		const index = original.findIndex((question) => question.name === port.handle);
-		if (index < 0 || original[index] === questions[index] || !dequal(port.jsonSchema, answerSchema(original[index]))) return port;
-		return {
-			...port,
-			jsonSchema: decisionAnswerSchema(questions[index])
-		};
-	});
-	return {
-		...task,
-		executor: {
-			...task.executor,
-			questions
-		},
-		outputs
-	};
-}
-var probability = {
-	type: "number",
-	minimum: 0,
-	maximum: 1
-};
-function decisionAnswerSchema(question) {
-	return answerSchema(limitDecisionQuestion(question));
-}
-function answerSchema(question) {
-	const properties = { type: { const: question.type } };
-	if (question.type === "noul") properties.noul = probability;
-	else {
-		const keys = question.type === "choice" ? question.criteria.map((item) => item.name) : question.criteria.map((_, index) => String(index));
-		properties.confidence = probability;
-		properties.probabilities = {
-			type: "object",
-			properties: Object.fromEntries(keys.map((key) => [key, probability])),
-			required: keys,
-			additionalProperties: false
-		};
-		if (question.type === "choice") properties.choice = {
-			type: "string",
-			...keys.length ? { enum: keys } : {}
-		};
-		else {
-			properties.score = {
-				type: "number",
-				minimum: 0,
-				maximum: Math.max(0, keys.length - 1)
-			};
-			properties.legend = {
-				type: "object",
-				properties: Object.fromEntries(keys.map((key) => [key, { type: "string" }])),
-				required: keys,
-				additionalProperties: false
-			};
-		}
-	}
-	return {
-		type: "object",
-		properties,
-		required: Object.keys(properties)
-	};
-}
-//#endregion
-//#region src/flow/common/retry.ts
-var nodeRetryLimits = {
-	maxRetries: 5,
-	minIntervalMs: 1e3,
-	maxIntervalMs: 6e4,
-	intervalStepMs: 1e3
-};
-var retryConfigurationSchema = strictObject({
-	maxRetries: number().int().min(0).max(nodeRetryLimits.maxRetries),
-	intervalMs: number().int().min(nodeRetryLimits.minIntervalMs).max(nodeRetryLimits.maxIntervalMs).multipleOf(nodeRetryLimits.intervalStepMs)
-});
-//#endregion
-//#region src/flow/common/triggerScheduleSchema.ts
-var triggerScheduleSchema = array(union([object({
-	type: literal("cron"),
-	expression: string(),
-	timezone: string()
-}), object({
-	type: literal("every"),
-	unit: _enum([
-		"day",
-		"hour",
-		"minute",
-		"month",
-		"week"
-	]),
-	value: number()
-})]));
-//#endregion
-//#region src/localization/common/timeZone.ts
-/** Validate a named timezone using the same runtime data used for date conversion. */
-function isTimeZone(value) {
-	try {
-		Intl.DateTimeFormat("en", { timeZone: value });
-		return true;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/flow/common/wait.ts
-/** Drafts retain incomplete values; semantic validation gates publication and execution. */
-var waitAutoContinueDraftSchema = discriminatedUnion("kind", [strictObject({
-	kind: literal("after"),
-	durationMs: number().nullable()
-}), strictObject({
-	kind: literal("at"),
-	at: string(),
-	timezone: string().optional()
-})]);
-discriminatedUnion("kind", [waitAutoContinueDraftSchema.options[0].extend({ durationMs: number().int().positive().max(Number.MAX_SAFE_INTEGER) }), waitAutoContinueDraftSchema.options[1].extend({
-	at: datetime({ offset: true }),
-	timezone: string().refine(isTimeZone, "Select a valid IANA timezone.").optional()
-})]);
-//#endregion
-//#region src/flow/common/webhookMethod.ts
-var webhookMethods = [
-	"GET",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE"
-];
-//#endregion
-//#region src/flow/common/webhookResponse.ts
-var webhookResponseTimeout = {
-	defaultMs: 3e4,
-	minMs: 1e3,
-	maxMs: 6e4
-};
-({
-	jsonSchema: {
-		type: "object",
-		additionalProperties: { type: [
-			"string",
-			"number",
-			"boolean"
-		] }
-	},
-	nullable: true
-}).jsonSchema;
-var text = string();
-var actionConnection = text.describe("Account selection: omit while unconfigured; use an account ID to select it; use \"\" to explicitly defer configuration. Deferred Actions fail if called; deferred Agent tools are excluded from the callable tool set. Not supported by Triggers.");
-var json = json$1();
-var strings = array(text);
-var port = object({
-	description: text.optional(),
-	jsonSchema: json,
-	nullable: boolean(),
-	handle: text
-});
-var workflowInputDefs = array(port.strict());
-var input = port.extend({ value: json.optional() });
-var group = object({
-	collapsed: boolean().optional(),
-	group: text
-});
-var source = union([object({
-	kind: literal("node"),
-	nodeId: text,
-	output: text,
-	system: literal(true).optional(),
-	field: text.optional()
-}), object({
-	kind: literal("binding"),
-	bindingId: text
-})]);
-var fixedInput = union([object({ kind: literal("unset") }), object({
-	kind: literal("value"),
-	value: json
-})]);
-var mapping = union([fixedInput, object({
-	kind: literal("sources"),
-	sources: array(source)
-})]);
-var inputs = record$1(text, mapping);
-var ports = {
-	inputs: array(union([input, group])),
-	outputs: array(union([port, group]))
-};
-var capability = union([
-	strictObject({
-		kind: literal("connector"),
-		action: text,
-		connectionId: text.optional(),
-		connections: array(strictObject({
-			connectionId: text,
-			alias: text.optional()
-		}))
-	}),
-	strictObject({
-		kind: literal("connector"),
-		mode: literal("shared")
-	}),
-	strictObject({
-		kind: literal("connector"),
-		mode: literal("independent"),
-		actions: array(strictObject({
-			action: text,
-			connectionId: actionConnection.optional()
-		}))
-	}),
-	strictObject({
-		kind: literal("connector"),
-		actionHints: array(text).optional(),
-		connectionHints: array(strictObject({
-			action: text,
-			connectionId: text,
-			alias: text.optional()
-		})).optional()
-	})
-]);
-var inline = object({
-	...ports,
-	name: text,
-	moduleId: text,
-	capabilities: array(capability).optional()
-});
-var agentValue = union([object({
-	kind: literal("value"),
-	value: json
-}), object({
-	kind: literal("input"),
-	input: text
-})]);
-var agentInput = union([agentValue, object({ kind: literal("model") })]);
-var decisionQuestion = discriminatedUnion("type", [
-	strictObject({
-		name: text,
-		instructions: text,
-		type: literal("noul"),
-		criteria: strictObject({
-			true: text.optional(),
-			false: text.optional()
-		}).optional()
-	}),
-	strictObject({
-		name: text,
-		instructions: text,
-		type: literal("choice"),
-		criteria: array(strictObject({
-			name: text,
-			description: text
-		}))
-	}),
-	strictObject({
-		name: text,
-		instructions: text,
-		type: literal("score"),
-		criteria: strings
-	})
-]);
-var managedFields = object({
-	...ports,
-	name: text,
-	executor: union([
-		object({
-			kind: literal("connector"),
-			action: text,
-			connectionId: actionConnection.optional(),
-			outputMode: literal("value").optional()
-		}),
-		object({
-			kind: literal("openapi"),
-			sourceUrl: text,
-			method: text,
-			path: text,
-			serverUrl: text,
-			document: json,
-			auth: array(object({
-				id: text,
-				type: _enum([
-					"bearer",
-					"basic",
-					"apiKey"
-				]),
-				name: text.optional(),
-				in: _enum(["header", "query"]).optional()
-			}))
-		}),
-		strictObject({
-			kind: literal("decision"),
-			questions: array(decisionQuestion)
-		}),
-		object({
-			kind: literal("llm"),
-			mode: _enum(["chat", "json"])
-		}),
-		object({
-			kind: literal("agent"),
-			code: boolean().optional(),
-			model: text,
-			prompt: text,
-			maxRounds: number(),
-			tools: array(object({
-				id: text,
-				name: text,
-				description: text,
-				action: text,
-				connectionId: actionConnection.optional(),
-				approval: boolean(),
-				inputs: array(input.extend({ source: agentInput }))
-			})),
-			notification: object({
-				action: text,
-				connectionId: actionConnection.optional(),
-				inputDefinitions: array(input),
-				messageHandle: text,
-				inputs: record$1(text, agentValue)
-			}).optional()
-		}),
-		strictObject({
-			kind: literal("workflow"),
-			flowId: text,
-			revisionId: text
-		})
-	])
-});
-var managed = managedFields.transform(limitDecisionTask);
-var operand = union([object({
-	kind: literal("value"),
-	value: json.optional(),
-	jsonSchema: json.optional()
-}), object({
-	kind: literal("source"),
-	source
-})]);
-var condition = {
-	matchMode: _enum(["first", "all"]),
-	cases: array(object({
-		description: text.optional(),
-		output: text,
-		groups: array(object({ expressions: array(object({
-			left: operand,
-			operator: _enum([
-				"!=",
-				"<",
-				"<=",
-				"==",
-				">",
-				">=",
-				"contains",
-				"endsWith",
-				"hasKey",
-				"hasValue",
-				"isEmpty",
-				"isFalse",
-				"isNotEmpty",
-				"isNotNull",
-				"isNull",
-				"isTrue",
-				"notContains",
-				"notHasKey",
-				"notHasValue",
-				"startsWith"
-			]),
-			right: operand.optional()
-		})) }))
-	}))
-};
-var wait = {
-	inputDefinitions: array(input),
-	prompt: text
-};
-var webhookOptions = object({
-	allowedMethods: never().optional(),
-	allowedOrigins: strings.optional(),
-	noResponseBody: never().optional(),
-	responseBody: discriminatedUnion("kind", [strictObject({
-		kind: literal("workflow-outputs"),
-		output: text.optional(),
-		timeoutMs: number().int().min(webhookResponseTimeout.minMs).max(webhookResponseTimeout.maxMs).optional()
-	}), strictObject({
-		kind: literal("webhook-response"),
-		nodeId: text.optional(),
-		timeoutMs: number().int().min(webhookResponseTimeout.minMs).max(webhookResponseTimeout.maxMs).optional()
-	})]).optional(),
-	responseData: text.optional(),
-	responseHeaders: record$1(text, text).optional(),
-	responseHeadersSource: strictObject({
-		kind: literal("workflow-outputs"),
-		output: text.optional()
-	}).optional(),
-	responseHeaderOutputs: record$1(text, text).optional(),
-	responseStatusCode: number().int().min(200).max(599).optional(),
-	responseStatusCodeOutput: text.optional()
-});
-var webhook = {
-	bodyFields: array(input),
-	method: _enum(webhookMethods),
-	options: webhookOptions.optional()
-};
-var definition = {
-	configInputs: ports.inputs,
-	definitionVersion: literal(2),
-	description: text,
-	displayName: text,
-	key: text,
-	name: text,
-	outputs: array(port).refine((definitions) => new Set(definitions.map((output) => output.handle)).size === definitions.length, "Duplicate Trigger output handle."),
-	provider: text
-};
-var endpoint = object({
-	body: object({
-		allowArray: boolean(),
-		allowEmpty: boolean(),
-		formats: array(_enum([
-			"form",
-			"json",
-			"multipart",
-			"text"
-		]))
-	}),
-	methods: array(_enum([
-		"DELETE",
-		"GET",
-		"HEAD",
-		"PATCH",
-		"POST",
-		"PUT"
-	])),
-	successStatus: number()
-});
-var sourceFlowIds = array(text.min(1)).refine((ids) => new Set(ids).size === ids.length, "Duplicate source Flow ID.");
-var trigger = {
-	name: text,
-	description: text.optional(),
-	icon: text.optional()
-};
-var base = {
-	maxExecutions: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
-	inputs,
-	name: text.optional(),
-	description: text.optional(),
-	icon: text.optional(),
-	timeoutMs: number().optional(),
-	retry: retryConfigurationSchema.optional(),
-	onError: _enum(["stop", "error"]).optional()
-};
-var node = union([
-	strictObject({
-		...base,
-		kind: literal("webhook-response"),
-		retry: never().optional(),
-		onError: never().optional()
-	}),
-	strictObject({
-		...base,
-		kind: literal("outputs"),
-		outputDefs: array(port.strict()),
-		outputMappings: inputs
-	}).omit({ inputs: true }),
-	object({
-		...base,
-		inputs: record$1(text, never()),
-		kind: literal("condition"),
-		...condition
-	}),
-	object({
-		...base,
-		inputs: unknown().transform(() => ({})).default({}),
-		kind: literal("value"),
-		values: array(input)
-	}),
-	object({
-		...base,
-		kind: literal("task"),
-		task: union([inline, managed]),
-		additionalInputs: array(input).optional()
-	}),
-	strictObject({
-		...base,
-		kind: literal("approval"),
-		...wait
-	}).omit({ timeoutMs: true }),
-	strictObject({
-		...base,
-		kind: literal("wait"),
-		...wait,
-		autoContinue: waitAutoContinueDraftSchema.optional()
-	}).omit({ timeoutMs: true }),
-	object({
-		...trigger,
-		kind: literal("manual")
-	}),
-	strictObject({
-		...trigger,
-		kind: literal("start"),
-		inputDefs: workflowInputDefs
-	}),
-	strictObject({
-		...trigger,
-		kind: literal("error"),
-		sourceFlowIds: sourceFlowIds.optional()
-	}),
-	object({
-		...trigger,
-		kind: literal("webhook"),
-		...webhook
-	}),
-	object({
-		...trigger,
-		kind: literal("cron"),
-		cronTimes: triggerScheduleSchema
-	}),
-	object({
-		...trigger,
-		kind: literal("poll"),
-		connectionId: text.min(1).optional(),
-		config: record$1(text, fixedInput),
-		definition: object({
-			...definition,
-			type: literal("poll")
-		}),
-		pollTimes: triggerScheduleSchema
-	}),
-	object({
-		...trigger,
-		kind: literal("integration"),
-		connectionId: text.min(1).optional(),
-		config: record$1(text, fixedInput),
-		definition: object({
-			...definition,
-			type: literal("integration"),
-			endpoint
-		})
-	})
-]);
-strictObject(condition), strictObject(wait), strictObject(webhook), managedFields.shape.executor.options[0].omit({ kind: true }).strict(), managedFields.shape.executor.options[1].omit({ kind: true }).strict(), managedFields.shape.executor.options[2].omit({ kind: true }).strict(), managedFields.shape.executor.options[3].omit({ kind: true }).strict(), managedFields.shape.executor.options[4].omit({
-	kind: true,
-	notification: true
-}).strict();
-var edge = object({
-	source: text,
-	target: text,
-	sourceHandle: text.optional()
-});
-var at = {
-	nodeId: text,
-	target: never().optional()
-};
-var graph = object({
-	nodes: record$1(text, node),
-	edges: array(edge).default([])
-});
-var binding = object({
-	kind: literal("variable"),
-	target: text
-});
-var module = object({
-	name: text,
-	imports: strings,
-	source: text
-});
-var document = preprocess(normalizeDocument, object({
-	bindings: record$1(text, binding),
-	graph
-}));
-object({
-	modelVersion: union([
-		literal(2),
-		literal(4),
-		literal(5),
-		literal(6),
-		literal(7),
-		literal(8),
-		literal(9),
-		literal(10)
-	]),
-	document,
-	modules: record$1(text, module)
-}).extend({
-	kind: literal("open-flow-flow-revision"),
-	version: literal(1)
-});
-function normalizeDocument(value) {
-	const candidate = record(value);
-	if (candidate.tasks !== void 0 && (candidate.tasks === null || typeof candidate.tasks !== "object" || Array.isArray(candidate.tasks) || Object.keys(candidate.tasks).length > 0)) throw new TypeError("Independent Task definitions are no longer supported.");
-	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record(candidateNode), "taskId"))) throw new TypeError("Task references are no longer supported.");
-	const subflows = candidate.subflows;
-	if (subflows !== void 0 && (subflows === null || typeof subflows !== "object" || Array.isArray(subflows) || Object.keys(subflows).length > 0)) throw new TypeError("Subflows are no longer supported.");
-	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
-	if ([
-		"inputDefs",
-		"outputDefs",
-		"outputMappings"
-	].some((field) => Object.hasOwn(candidate, field))) throw new TypeError("Workflow interface configuration must belong to Start and Outputs nodes.");
-	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind == "start" && Object.hasOwn(record(candidateNode), "parameters"))) throw new TypeError("Legacy Start.parameters is unsupported; configure node.inputDefs.");
-	return value;
-}
-function record(value) {
-	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
-}
-var shapes = {
-	"graph.trigger.sources.set": {
-		nodeId: text,
-		before: sourceFlowIds.optional(),
-		value: sourceFlowIds.optional()
-	},
-	"binding.create": {
-		bindingId: text,
-		binding
-	},
-	"binding.delete": { bindingId: text },
-	"binding.target.set": {
-		bindingId: text,
-		before: text,
-		value: text
-	},
-	"graph.edge.connect": {
-		edge,
-		target: never().optional()
-	},
-	"graph.edge.disconnect": {
-		edge,
-		target: never().optional()
-	},
-	"graph.node.create": {
-		...at,
-		node
-	},
-	"graph.node.replace": {
-		...at,
-		before: node,
-		node
-	},
-	"graph.node.delete": at,
-	"graph.node.field.set": union([
-		object({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: literal("retry"),
-			before: retryConfigurationSchema.optional(),
-			value: retryConfigurationSchema.optional()
-		}),
-		object({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: literal("connectionId"),
-			before: text.min(1).optional(),
-			value: text.min(1).optional()
-		}),
-		object({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: _enum([
-				"description",
-				"icon",
-				"name",
-				"onError"
-			]),
-			before: text.optional(),
-			value: text.optional()
-		}),
-		object({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: literal("maxExecutions"),
-			before: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
-			value: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
-		}),
-		object({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: literal("timeoutMs"),
-			before: number().optional(),
-			value: number().optional()
-		})
-	]),
-	"graph.node.input.set": {
-		...at,
-		handle: text,
-		before: mapping.optional(),
-		value: mapping.optional()
-	},
-	"graph.node.additional-inputs.set": {
-		...at,
-		before: array(input).optional(),
-		value: array(input).optional()
-	},
-	"graph.node.condition.set": {
-		...at,
-		before: object(condition),
-		value: object(condition)
-	},
-	"graph.node.values.set": {
-		...at,
-		before: array(input),
-		value: array(input)
-	},
-	"graph.node.resolution.set": {
-		...at,
-		before: strictObject({
-			...wait,
-			autoContinue: waitAutoContinueDraftSchema.optional()
-		}),
-		value: strictObject({
-			...wait,
-			autoContinue: waitAutoContinueDraftSchema.optional()
-		})
-	},
-	"graph.node.webhook.set": {
-		...at,
-		before: object(webhook),
-		value: object(webhook)
-	},
-	"graph.node.task.ports.set": {
-		...at,
-		before: object(ports),
-		value: object(ports)
-	},
-	"graph.node.task.name.set": {
-		...at,
-		before: text,
-		value: text
-	},
-	"graph.node.task.capabilities.set": {
-		...at,
-		before: array(capability).optional(),
-		value: array(capability).optional()
-	},
-	"graph.trigger.config.set": {
-		nodeId: text,
-		name: text,
-		before: fixedInput.optional(),
-		value: fixedInput.optional()
-	},
-	"graph.trigger.schedule.set": {
-		nodeId: text,
-		before: triggerScheduleSchema,
-		value: triggerScheduleSchema
-	},
-	"module.create": {
-		moduleId: text,
-		module
-	},
-	"module.delete": { moduleId: text },
-	"module.rename": {
-		moduleId: text,
-		before: text,
-		name: text
-	},
-	"module.source.replace": {
-		moduleId: text,
-		beforeImports: strings,
-		beforeSource: text,
-		imports: strings,
-		source: text
-	},
-	"graph.node.task.set": {
-		...at,
-		before: union([inline, managed]),
-		value: union([inline, managed])
-	}
-};
-array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object({
-	kind: literal(kind),
-	...shape
-})])).values()])).min(1);
-//#endregion
-//#region src/flow/common/change.ts
-var schemaKeywords = /* @__PURE__ */ new Set([
-	"const",
-	"enum",
-	"exclusiveMaximum",
-	"exclusiveMinimum",
-	"maximum",
-	"maxItems",
-	"maxLength",
-	"maxProperties",
-	"minimum",
-	"minItems",
-	"minLength",
-	"minProperties",
-	"multipleOf",
-	"pattern",
-	"required",
-	"type"
-]);
-function isSchemaKeyword(value) {
-	return schemaKeywords.has(value);
-}
-//#endregion
 //#region src/json-schema-subset/utils.ts
 var nextId = 0;
 function createId() {
@@ -10299,6 +9391,29 @@ function resolveLocalRefs(schema) {
 	return visit(schema, /* @__PURE__ */ new Set());
 }
 //#endregion
+//#region src/flow/common/schemaKeywords.ts
+var schemaKeywords = /* @__PURE__ */ new Set([
+	"const",
+	"enum",
+	"exclusiveMaximum",
+	"exclusiveMinimum",
+	"maximum",
+	"maxItems",
+	"maxLength",
+	"maxProperties",
+	"minimum",
+	"minItems",
+	"minLength",
+	"minProperties",
+	"multipleOf",
+	"pattern",
+	"required",
+	"type"
+]);
+function isSchemaKeyword(value) {
+	return schemaKeywords.has(value);
+}
+//#endregion
 //#region src/flow/common/schema.ts
 function jsonEqual(left, right) {
 	if (left === right) return true;
@@ -10419,7 +9534,7 @@ function comparePorts(source, target) {
 //#region src/workflow/common/workflow.ts
 var portSchema = object({
 	handle: string().min(1),
-	jsonSchema: json$1(),
+	jsonSchema: json(),
 	nullable: boolean(),
 	description: string().optional()
 });