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

package/dist/common/flow-semantics.js

@@ -1930,7 +1930,7 @@ function timeSource(args) {
 function time(args) {
 	return new RegExp(`^${timeSource(args)}$`);
 }
-function datetime(args) {
+function datetime$1(args) {
 	const opts = ["Z"];
 	if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
 	const qualified = `${timeSource({
@@ -2581,7 +2581,7 @@ var $ZodKSUID = /*@__PURE__*/ $constructor("$ZodKSUID", (inst, def) => {
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODateTime = /*@__PURE__*/ $constructor("$ZodISODateTime", (inst, def) => {
-	def.pattern ?? (def.pattern = datetime(def));
+	def.pattern ?? (def.pattern = datetime$1(def));
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def) => {
@@ -6577,6 +6577,11 @@ function preprocess(fn, schema) {
 		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);
+}
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
 	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);
@@ -6621,6 +6626,33 @@ var triggerScheduleSchema = array(union([object$1({
 	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()
+})]);
+/** Static business configuration; the deployment owns the allowed wait lifetime. */
+var waitAutoContinueSchema = 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",
@@ -6632,6 +6664,98 @@ var webhookMethods = [
 function webhookSupportsBody(method) {
 	return method !== "GET";
 }
+//#endregion
+//#region src/flow/common/webhookResponse.ts
+var webhookResponseTimeout = {
+	defaultMs: 3e4,
+	minMs: 1e3,
+	maxMs: 6e4
+};
+var webhookStatusCodePort = {
+	jsonSchema: { type: "number" },
+	nullable: true
+};
+function webhookResponseAllowsBody(status) {
+	return status !== 204 && status !== 205 && status !== 304;
+}
+var webhookHeaderValuePort = {
+	jsonSchema: { type: [
+		"string",
+		"number",
+		"boolean"
+	] },
+	nullable: true
+};
+var webhookHeadersPort = {
+	jsonSchema: {
+		type: "object",
+		additionalProperties: { type: [
+			"string",
+			"number",
+			"boolean"
+		] }
+	},
+	nullable: true
+};
+function workflowOutputsPort(outputs) {
+	return {
+		jsonSchema: {
+			type: "object",
+			properties: Object.fromEntries(outputs.map((port) => [port.handle, port.jsonSchema])),
+			additionalProperties: false,
+			required: outputs.map((port) => port.handle)
+		},
+		nullable: false
+	};
+}
+/** Header names are case-insensitive; never silently combine duplicate business fields. */
+function webhookHeaderNameIssue(name, names) {
+	if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return "invalid";
+	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
+}
+/** Fixed inputs belong to the node, not author-supplied definitions. */
+var webhookResponseInputs = [
+	{
+		handle: "body",
+		jsonSchema: {},
+		nullable: true,
+		value: ""
+	},
+	{
+		handle: "statusCode",
+		jsonSchema: { type: "number" },
+		nullable: false,
+		value: 200
+	},
+	{
+		handle: "headers",
+		jsonSchema: webhookHeadersPort.jsonSchema,
+		nullable: false,
+		value: {}
+	}
+];
+function validWebhookStatus(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 200 && value <= 599 && webhookResponseAllowsBody(value);
+}
+/** Portable validation also runs in the isolated engine, which has no HTTP globals. */
+function webhookHeaderValues(source) {
+	if (source == null || typeof source !== "object" || Array.isArray(source)) return;
+	const headers = {};
+	const names = [];
+	for (const [name, value] of Object.entries(source)) {
+		if (webhookHeaderNameIssue(name, names) != null) return;
+		if (typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value))) return;
+		const text = String(value);
+		if ([...text].some((character) => character.charCodeAt(0) > 255 || /[\0\r\n]/.test(character))) return;
+		names.push(name);
+		Object.defineProperty(headers, name, {
+			value: text,
+			enumerable: true,
+			configurable: true
+		});
+	}
+	return headers;
+}
 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();
@@ -6859,9 +6983,24 @@ var webhookOptions = object$1({
 	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(),
-	responseStatusCode: number().int().min(200).max(599).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),
@@ -6916,6 +7055,12 @@ var base = {
 	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"),
@@ -6948,7 +7093,8 @@ var node = union([
 	strictObject({
 		...base,
 		kind: literal("wait"),
-		...wait
+		...wait,
+		autoContinue: waitAutoContinueDraftSchema.optional()
 	}).omit({ timeoutMs: true }),
 	object$1({
 		...trigger,
@@ -7035,7 +7181,8 @@ object$1({
 		literal(6),
 		literal(7),
 		literal(8),
-		literal(9)
+		literal(9),
+		literal(10)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -7160,8 +7307,14 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		before: object$1(wait),
-		value: object$1(wait)
+		before: strictObject({
+			...wait,
+			autoContinue: waitAutoContinueDraftSchema.optional()
+		}),
+		value: strictObject({
+			...wait,
+			autoContinue: waitAutoContinueDraftSchema.optional()
+		})
 	},
 	"graph.node.webhook.set": {
 		...at,
@@ -11434,9 +11587,11 @@ function normalizeTriggerOutputs(trigger, outputs) {
 }
 //#endregion
 //#region src/execution/common/engineContract.ts
-var currentEngineContract = "open-flow-engine/v6";
-var nodejsEngineContract = "open-flow-engine/v6/nodejs-compat-v1";
+var currentEngineContract = "open-flow-engine/v7";
+var nodejsEngineContract = "open-flow-engine/v7/nodejs-compat-v1";
 var currentContract = {
+	waitAutoContinue: true,
+	webhookResponses: true,
 	platformExports: /* @__PURE__ */ new Set(["engineContract", "identity"]),
 	platformModule: "open-flow:platform",
 	platformSource: `export const engineContract = ${JSON.stringify(currentEngineContract)}
@@ -11476,8 +11631,16 @@ export function identity(value) { return value }
 `
 };
 function findEngineContract(contract) {
-	if (contract == "open-flow-engine/v6") return currentContract;
-	if (contract == "open-flow-engine/v6/nodejs-compat-v1") return nodejsContract;
+	if (contract == "open-flow-engine/v7") return currentContract;
+	if (contract == "open-flow-engine/v7/nodejs-compat-v1") return nodejsContract;
+	if (contract == "open-flow-engine/v6" || contract == "open-flow-engine/v6/nodejs-compat-v1") return {
+		...contract == "open-flow-engine/v6" ? currentContract : nodejsContract,
+		waitAutoContinue: false,
+		webhookResponses: false,
+		platformSource: `export const engineContract = ${JSON.stringify(contract)}
+export function identity(value) { return value }
+`
+	};
 }
 //#endregion
 //#region src/flow/common/agent.ts
@@ -11841,6 +12004,10 @@ function canonicalNode(value) {
 		} }
 	};
 	switch (value.kind) {
+		case "webhook-response": return {
+			...common,
+			kind: value.kind
+		};
 		case "outputs": return {
 			...common,
 			kind: value.kind,
@@ -11882,7 +12049,8 @@ function canonicalNode(value) {
 			...common,
 			inputDefinitions: canonicalPorts(value.inputDefinitions),
 			kind: value.kind,
-			prompt: value.prompt
+			prompt: value.prompt,
+			...value.kind == "wait" && value.autoContinue != null ? { autoContinue: { ...value.autoContinue } } : {}
 		};
 	}
 }
@@ -11994,9 +12162,20 @@ function canonicalTriggerDefinition(snapshot) {
 function canonicalWebhookOptions(value) {
 	return {
 		...value.allowedOrigins == null ? {} : { allowedOrigins: value.allowedOrigins },
+		...value.responseBody == null ? {} : { responseBody: {
+			kind: value.responseBody.kind,
+			...value.responseBody.kind === "workflow-outputs" ? value.responseBody.output == null ? {} : { output: value.responseBody.output } : value.responseBody.nodeId == null ? {} : { nodeId: value.responseBody.nodeId },
+			...value.responseBody.timeoutMs == null ? {} : { timeoutMs: value.responseBody.timeoutMs }
+		} },
 		...value.responseData == null ? {} : { responseData: value.responseData },
 		...value.responseHeaders == null ? {} : { responseHeaders: value.responseHeaders },
-		...value.responseStatusCode == null ? {} : { responseStatusCode: value.responseStatusCode }
+		...value.responseHeadersSource == null ? {} : { responseHeadersSource: {
+			kind: value.responseHeadersSource.kind,
+			...value.responseHeadersSource.output == null ? {} : { output: value.responseHeadersSource.output }
+		} },
+		...value.responseHeaderOutputs == null ? {} : { responseHeaderOutputs: value.responseHeaderOutputs },
+		...value.responseStatusCode == null ? {} : { responseStatusCode: value.responseStatusCode },
+		...value.responseStatusCodeOutput == null ? {} : { responseStatusCodeOutput: value.responseStatusCodeOutput }
 	};
 }
 function canonicalTriggerSchedule(value) {
@@ -12112,6 +12291,68 @@ function graphDiagnostic(code, message, path, values, mismatch) {
 		...values == null ? {} : { values }
 	};
 }
+/** Execution reachability is independent of data bindings and selected runtime branches. */
+function executionReachableNodes(graph, source) {
+	const reachable = /* @__PURE__ */ new Set([source]);
+	for (const id of reachable) for (const edge of graph.edges) if (edge.source === id) reachable.add(edge.target);
+	return reachable;
+}
+function webhookResponseDiagnostics(graph, triggerId, path = `/document/graph/nodes/${triggerId}`) {
+	const trigger = graph.nodes[triggerId];
+	if (trigger?.kind != "webhook") return [];
+	const options = trigger.options ?? {};
+	const response = options.responseBody;
+	const statusOutput = options.responseStatusCodeOutput;
+	const statusPath = `${path}/options/responseStatusCodeOutput`;
+	const diagnostics = [];
+	const headersSource = options.responseHeadersSource;
+	const headerOutputs = options.responseHeaderOutputs;
+	const headersPath = `${path}/options/${headersSource == null ? "responseHeaderOutputs" : "responseHeadersSource"}`;
+	if (response?.kind !== "workflow-outputs") {
+		if (statusOutput != null) diagnostics.push(graphDiagnostic("trigger.webhook-response-status-source", "Choose workflow outputs as the response source to use a status output.", statusPath));
+		if (headersSource != null || headerOutputs != null) diagnostics.push(graphDiagnostic("trigger.webhook-response-headers-source", "Choose workflow outputs as the response source to use dynamic headers.", headersPath));
+		if (response?.kind === "webhook-response") {
+			const location = `${path}/options/responseBody/nodeId`;
+			const { nodeId } = response;
+			if (nodeId == null || graph.nodes[nodeId]?.kind !== "webhook-response") diagnostics.push(graphDiagnostic("trigger.webhook-response-node-missing", "Select a Webhook Response node.", location));
+			else if (!executionReachableNodes(graph, triggerId).has(nodeId)) diagnostics.push(graphDiagnostic("trigger.webhook-response-node-unreachable", "Connect this Webhook to the selected Webhook Response node.", location));
+		}
+		return diagnostics;
+	}
+	if (headersSource == null) for (const [headers, location] of [[options.responseHeaders, `${path}/options/responseHeaders`], [headerOutputs, headersPath]]) {
+		const names = [];
+		for (const name of Object.keys(headers ?? {})) {
+			if (webhookHeaderNameIssue(name, names) != null) diagnostics.push(graphDiagnostic("trigger.webhook-response-header-name", "Use valid, unique HTTP header names.", location));
+			names.push(name);
+		}
+	}
+	const responsePath = `${path}/options/responseBody`;
+	const outputs = Object.entries(graph.nodes).filter(([, node]) => node.kind == "outputs");
+	if (outputs.length == 0) diagnostics.push(graphDiagnostic("trigger.webhook-response-outputs-missing", "Add a workflow Outputs node for the HTTP response.", responsePath));
+	else if (outputs.length == 1) {
+		const output = outputs[0];
+		if (!executionReachableNodes(graph, triggerId).has(output[0])) diagnostics.push(graphDiagnostic("trigger.webhook-response-unreachable", "Connect this Webhook to the workflow Outputs node.", responsePath));
+		const field = response.output;
+		if (field != null && output[1].kind == "outputs" && !output[1].outputDefs.some((port) => port.handle == field)) diagnostics.push(graphDiagnostic("trigger.webhook-response-output-missing", `Workflow output "${field}" does not exist.`, `${responsePath}/output`, { output: field }));
+		if (statusOutput != null && output[1].kind == "outputs") {
+			const port = output[1].outputDefs.find((candidate) => candidate.handle == statusOutput);
+			if (port == null) diagnostics.push(graphDiagnostic("trigger.webhook-response-status-output-missing", `Workflow status output "${statusOutput}" does not exist.`, statusPath, { output: statusOutput }));
+			else if (!portsAssignable(port, webhookStatusCodePort)) diagnostics.push(graphDiagnostic("trigger.webhook-response-status-output-type", "Choose a numeric workflow output for the response status code.", statusPath));
+		}
+		if (output[1].kind == "outputs") {
+			const fields = output[1].outputDefs;
+			const checkHeaderSource = (headerField, target, location) => {
+				const port = headerField == null ? workflowOutputsPort(fields) : fields.find((candidate) => candidate.handle == headerField);
+				if (port == null) diagnostics.push(graphDiagnostic("trigger.webhook-response-header-output-missing", `Workflow output "${headerField}" does not exist.`, location, { output: headerField }));
+				else if (!portsAssignable(port, target)) diagnostics.push(graphDiagnostic("trigger.webhook-response-header-output-type", "Choose a compatible workflow output for the response headers.", location));
+			};
+			if (headersSource != null) checkHeaderSource(headersSource.output, webhookHeadersPort, headersPath);
+			else for (const [name, headerField] of Object.entries(headerOutputs ?? {})) checkHeaderSource(headerField, webhookHeaderValuePort, `${headersPath}/${name.replaceAll("~", "~0").replaceAll("/", "~1")}`);
+		}
+	}
+	if (statusOutput == null && !webhookResponseAllowsBody(options.responseStatusCode ?? 200)) diagnostics.push(graphDiagnostic("trigger.webhook-response-status-invalid", "Choose a response status code that permits a body.", `${path}/options/responseStatusCode`));
+	return diagnostics;
+}
 function validateTrigger(triggerId, trigger, path, diagnostics) {
 	if (trigger.kind == "start") return;
 	const outputs = triggerOutputDefinitions(trigger);
@@ -12142,6 +12383,7 @@ function validateTrigger(triggerId, trigger, path, diagnostics) {
 }
 function nodeInputPorts(node) {
 	switch (node.kind) {
+		case "webhook-response": return portsByHandle(webhookResponseInputs);
 		case "outputs": return portsByHandle(node.outputDefs);
 		case "condition": return conditionInputPorts(node);
 		case "value": return {};
@@ -12188,7 +12430,8 @@ function resolutionOutputPorts(node) {
 				pattern: "\\S"
 			},
 			...Object.fromEntries(actions.map((action) => [`${action}Url`, { type: "string" }])),
-			expiresAt: { type: "string" }
+			expiresAt: { type: "string" },
+			...node.kind == "wait" && node.autoContinue != null ? { autoContinueAt: { type: "string" } } : {}
 		}),
 		...Object.fromEntries(actions.map((action) => [action, objectPort({
 			inputs,
@@ -12200,6 +12443,7 @@ function resolutionOutputPorts(node) {
 }
 function nodeOutputPorts(node) {
 	switch (node.kind) {
+		case "webhook-response":
 		case "outputs":
 		case "condition": return {};
 		case "value": return portsByHandle(node.values);
@@ -12406,6 +12650,10 @@ function validateResolution(nodeId, node, path, diagnostics) {
 		"name",
 		"prompt"
 	]);
+	if (node.kind == "wait") {
+		fields.add("autoContinue");
+		if (node.autoContinue != null && !waitAutoContinueSchema.safeParse(node.autoContinue).success) diagnostics.push(graphDiagnostic("wait.auto-continue-invalid", "Enter a positive integer duration or a timestamp with an explicit timezone.", `${path}/autoContinue`));
+	}
 	const label = node.kind == "wait" ? "Wait" : "Approval";
 	const unsupported = Object.keys(node).filter((field) => !fields.has(field));
 	if (unsupported.length > 0) diagnostics.push(graphDiagnostic(`${node.kind}.field-unsupported`, `${label} node "${nodeId}" contains unsupported fields: ${unsupported.join(", ")}.`, path, {
@@ -12421,6 +12669,15 @@ function validateGraph(graph, document, path, diagnostics) {
 	const errorTriggers = Object.entries(graph.nodes).filter(([, node]) => node.kind == "error");
 	if (errorTriggers.length > 1) for (const [nodeId] of errorTriggers) diagnostics.push(graphDiagnostic("graph.error-trigger-duplicate", "A graph can contain only one Flow Error node.", `${path}/nodes/${nodeId}`));
 	const outputNodes = Object.entries(graph.nodes).filter(([, node]) => node.kind == "outputs");
+	for (const [nodeId, node] of Object.entries(graph.nodes)) {
+		if (node.kind == "webhook") diagnostics.push(...webhookResponseDiagnostics(graph, nodeId, `${path}/nodes/${nodeId}`));
+		if (node.kind === "webhook-response") {
+			const status = node.inputs.statusCode;
+			if (status?.kind === "value" && !validWebhookStatus(status.value)) diagnostics.push(graphDiagnostic("webhook.response-status-invalid", "Use an integer status from 200 to 599, excluding 204, 205 and 304.", `${path}/nodes/${nodeId}/inputs/statusCode`));
+			const headers = node.inputs.headers;
+			if (headers?.kind === "value" && (webhookHeaderValues(headers.value) == null || Object.values(headers.value).some((value) => typeof value !== "string"))) diagnostics.push(graphDiagnostic("webhook.response-headers-invalid", "Use valid, unique HTTP header names and single-line text values.", `${path}/nodes/${nodeId}/inputs/headers`));
+		}
+	}
 	if (outputNodes.length > 1) for (const [nodeId] of outputNodes) diagnostics.push(graphDiagnostic("graph.outputs-duplicate", "A graph can contain only one Outputs node.", `${path}/nodes/${nodeId}`));
 	const startTriggers = Object.entries(graph.nodes).filter(([, node]) => node.kind == "manual" || node.kind == "start");
 	if (startTriggers.length > 1) for (const [nodeId] of startTriggers) diagnostics.push(graphDiagnostic("graph.start-trigger-duplicate", "A graph can contain only one Start Trigger.", `${path}/nodes/${nodeId}`));
@@ -24482,6 +24739,8 @@ async function prepareFlow(revision, engineContract, triggerId) {
 		};
 		revision = runRevision(revision, triggerId);
 	}
+	if (!engine.webhookResponses && Object.values(revision.document.graph.nodes).some((node) => node.kind === "webhook-response" || node.kind === "webhook" && node.options?.responseBody?.kind === "webhook-response")) return { kind: "engine-unsupported" };
+	if (!engine.waitAutoContinue && Object.values(revision.document.graph.nodes).some((node) => node.kind == "wait" && node.autoContinue != null)) return { kind: "engine-unsupported" };
 	const validation = await validateFlow(revision, engine);
 	if (!validation.valid) return {
 		kind: "flow-invalid",

package/dist/common/integration-trigger.js

@@ -1930,7 +1930,7 @@ function timeSource(args) {
 function time(args) {
 	return new RegExp(`^${timeSource(args)}$`);
 }
-function datetime(args) {
+function datetime$1(args) {
 	const opts = ["Z"];
 	if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
 	const qualified = `${timeSource({
@@ -2581,7 +2581,7 @@ var $ZodKSUID = /*@__PURE__*/ $constructor("$ZodKSUID", (inst, def) => {
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODateTime = /*@__PURE__*/ $constructor("$ZodISODateTime", (inst, def) => {
-	def.pattern ?? (def.pattern = datetime(def));
+	def.pattern ?? (def.pattern = datetime$1(def));
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def) => {
@@ -6578,6 +6578,11 @@ function preprocess(fn, 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 src/decision/common/decision.ts
 var decisionLimits = {
 	choice: 255,
@@ -6697,6 +6702,32 @@ var triggerScheduleSchema = array(union([object({
 	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",
@@ -6705,6 +6736,24 @@ var webhookMethods = [
 	"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();
@@ -6932,9 +6981,24 @@ 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$2(text, text).optional(),
-	responseStatusCode: number().int().min(200).max(599).optional()
+	responseHeadersSource: strictObject({
+		kind: literal("workflow-outputs"),
+		output: text.optional()
+	}).optional(),
+	responseHeaderOutputs: record$2(text, text).optional(),
+	responseStatusCode: number().int().min(200).max(599).optional(),
+	responseStatusCodeOutput: text.optional()
 });
 var webhook = {
 	bodyFields: array(input),
@@ -6989,6 +7053,12 @@ var base = {
 	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"),
@@ -7021,7 +7091,8 @@ var node = union([
 	strictObject({
 		...base,
 		kind: literal("wait"),
-		...wait
+		...wait,
+		autoContinue: waitAutoContinueDraftSchema.optional()
 	}).omit({ timeoutMs: true }),
 	object({
 		...trigger,
@@ -7108,7 +7179,8 @@ object({
 		literal(6),
 		literal(7),
 		literal(8),
-		literal(9)
+		literal(9),
+		literal(10)
 	]),
 	document,
 	modules: record$2(text, module)
@@ -7233,8 +7305,14 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		before: object(wait),
-		value: object(wait)
+		before: strictObject({
+			...wait,
+			autoContinue: waitAutoContinueDraftSchema.optional()
+		}),
+		value: strictObject({
+			...wait,
+			autoContinue: waitAutoContinueDraftSchema.optional()
+		})
 	},
 	"graph.node.webhook.set": {
 		...at,

package/dist/common/liveDetails.d.ts

@@ -37,9 +37,24 @@ declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             allowedMethods: z.ZodOptional<z.ZodNever>;
             allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
             noResponseBody: z.ZodOptional<z.ZodNever>;
+            responseBody: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"workflow-outputs">;
+                output: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"webhook-response">;
+                nodeId: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>], "kind">>;
             responseData: z.ZodOptional<z.ZodString>;
             responseHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            responseHeadersSource: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"workflow-outputs">;
+                output: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            responseHeaderOutputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             responseStatusCode: z.ZodOptional<z.ZodNumber>;
+            responseStatusCodeOutput: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         body: z.ZodRecord<z.ZodString, z.ZodObject<{
             schema: z.ZodOptional<z.ZodJSONSchema>;

package/dist/common/mcp.d.ts

@@ -161,7 +161,7 @@ export declare const mcpTools: {
                     value: {
                         revision?: string | undefined;
                         query: string;
-                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "workflow" | undefined;
+                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "webhook-response" | "workflow" | undefined;
                         offset: number;
                         limit: number;
                         flowId: string;
@@ -193,7 +193,7 @@ export declare const mcpTools: {
                 };
                 validate(value: unknown): {
                     value: {
-                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "workflow" | undefined;
+                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "webhook-response" | "workflow" | undefined;
                         action?: string | undefined;
                         flowId?: string | undefined;
                     };
@@ -321,7 +321,7 @@ export declare const mcpTools: {
                         edits: ({
                             op: "node.add";
                             as: string;
-                            type: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "workflow";
+                            type: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "webhook-response" | "workflow";
                             name: string;
                             onError?: "error" | "stop" | undefined;
                             retry?: {