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

package/dist/common/run-events.js

@@ -1,3 +1,47 @@
+//#region src/flow/common/webhookResponse.ts
+function webhookResponseAllowsBody(status) {
+	return status !== 204 && status !== 205 && status !== 304;
+}
+var webhookHeadersPort = {
+	jsonSchema: {
+		type: "object",
+		additionalProperties: { type: [
+			"string",
+			"number",
+			"boolean"
+		] }
+	},
+	nullable: true
+};
+/** 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";
+}
+webhookHeadersPort.jsonSchema;
+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;
+}
+//#endregion
 //#region src/execution/common/events.ts
 var encoder = new TextEncoder();
 var nodeKinds = /* @__PURE__ */ new Set([
@@ -12,7 +56,8 @@ var nodeKinds = /* @__PURE__ */ new Set([
 	"value",
 	"wait",
 	"outputs",
-	"workflow"
+	"workflow",
+	"webhook-response"
 ]);
 function object(value, description) {
 	if (value == null || typeof value != "object" || Array.isArray(value)) throw new TypeError(`${description} must be an object.`);
@@ -167,7 +212,8 @@ function createEventProjector(platformRunId, nodeFailureCodes) {
 				case "node.completed": return {
 					kind: type,
 					payload,
-					value: object(event.outputs, "Runtime node.completed outputs")
+					value: object(event.outputs, "Runtime node.completed outputs"),
+					...event.response == null || context.rawRunId !== platformRunId ? {} : { response: responseSnapshot(event.response) }
 				};
 				case "node.started": {
 					jobs.set(JSON.stringify([context.rawRunId, event.jobId]), context.nodeId);
@@ -234,5 +280,16 @@ function createEventProjector(platformRunId, nodeFailureCodes) {
 		throw new TypeError(`Runtime event type ${JSON.stringify(type)} is not supported.`);
 	};
 }
+function responseSnapshot(value) {
+	const source = object(value, "Runtime response");
+	const headers = webhookHeaderValues(source.headers);
+	if (!validWebhookStatus(source.status) || typeof source.body !== "string" || !["text/plain;charset=UTF-8", "application/json"].includes(String(source.contentType)) || headers == null) throw new TypeError("Invalid runtime response.");
+	return {
+		status: source.status,
+		body: source.body,
+		contentType: String(source.contentType),
+		headers
+	};
+}
 //#endregion
 export { createEventProjector, projectExecutionId, message as sanitizeRuntimeErrorMessage };

package/dist/common/runtime-contract.js

@@ -23,9 +23,11 @@ function dequal(foo, bar) {
 }
 //#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)}
@@ -65,8 +67,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/execution/common/runtime.ts

package/dist/common/scheduler.d.ts

@@ -1,10 +1,12 @@
-import type { ConnectorCapability, JsonValue, WaitAction } from '../browser/flow-change.js';
+import type { ConnectorCapability, JsonValue, WaitAction, WaitAutoContinue } from '../browser/flow-change.js';
 import type { PreparedFlow } from './flow-semantics.js';
+import type { WebhookResponseSnapshot } from './webhook-response.js';
 import type { PreviousNode } from '../index.js';
 import type { AgentCheckpoint } from './runtime-contract.js';
 import * as Effect from 'effect/Effect';
 export declare const withWaitNotificationMessage: (value: JsonValue) => JsonValue;
 export declare const normalizeWaitComment: (value?: string | null) => string | null;
+export declare const waitAutoContinueAt: (config: WaitAutoContinue, waitingSince: number) => number;
 export interface WaitResolution {
     readonly action: WaitAction;
     readonly resolvedAt: string;
@@ -28,7 +30,7 @@ export type SchedulerEvent = {
     readonly inputs: Readonly<Record<string, JsonValue>>;
     readonly jobId: string;
     readonly nodeId: string;
-    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow';
+    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow' | 'webhook-response';
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';
@@ -38,6 +40,7 @@ export type SchedulerEvent = {
     readonly outputs: Readonly<Record<string, JsonValue>>;
     readonly runId: string;
     readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
+    readonly response?: WebhookResponseSnapshot;
     readonly type: 'node.completed';
 } | {
     readonly code: string;
@@ -86,6 +89,7 @@ export interface PendingWait {
     readonly pending?: JsonValue;
 }
 export interface WaitRequest {
+    readonly autoContinue?: WaitAutoContinue;
     readonly jobId: string;
     readonly nodeId: string;
     readonly value: JsonValue;

package/dist/common/scheduler.js

@@ -1035,7 +1035,7 @@ function timeSource(args) {
 function time$1(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({
@@ -1686,7 +1686,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) => {
@@ -5683,6 +5683,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 ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
 	const typeofa = typeof a;
@@ -9506,6 +9511,39 @@ 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$1(),
+	timezone: string$1().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$1().refine(isTimeZone, "Select a valid IANA timezone.").optional()
+})]);
+/** Resolve one registration's intent; the deployment separately enforces its lifetime. */
+function waitAutoContinueAt$1(config, waitingSince) {
+	const timing = waitAutoContinueSchema.parse(config);
+	const at = timing.kind == "after" ? waitingSince + timing.durationMs : Date.parse(timing.at);
+	return Math.max(waitingSince, at);
+}
+//#endregion
 //#region src/flow/common/webhookMethod.ts
 var webhookMethods = [
 	"GET",
@@ -9517,6 +9555,84 @@ var webhookMethods = [
 function webhookSupportsBody(method) {
 	return method !== "GET";
 }
+//#endregion
+//#region src/flow/common/webhookResponse.ts
+var webhookResponseTimeout = {
+	defaultMs: 3e4,
+	minMs: 1e3,
+	maxMs: 6e4
+};
+function webhookResponseAllowsBody(status) {
+	return status !== 204 && status !== 205 && status !== 304;
+}
+var webhookHeadersPort = {
+	jsonSchema: {
+		type: "object",
+		additionalProperties: { type: [
+			"string",
+			"number",
+			"boolean"
+		] }
+	},
+	nullable: true
+};
+/** 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;
+}
+function encodeWebhookBody(value) {
+	return typeof value === "string" ? {
+		body: value,
+		contentType: "text/plain;charset=UTF-8"
+	} : {
+		body: JSON.stringify(value),
+		contentType: "application/json"
+	};
+}
 var text = string$1();
 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();
@@ -9744,9 +9860,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$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),
@@ -9801,6 +9932,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"),
@@ -9833,7 +9970,8 @@ var node = union([
 	strictObject({
 		...base,
 		kind: literal("wait"),
-		...wait
+		...wait,
+		autoContinue: waitAutoContinueDraftSchema.optional()
 	}).omit({ timeoutMs: true }),
 	object({
 		...trigger,
@@ -9920,7 +10058,8 @@ object({
 		literal(6),
 		literal(7),
 		literal(8),
-		literal(9)
+		literal(9),
+		literal(10)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -10045,8 +10184,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,
@@ -10654,6 +10799,7 @@ function isResolutionNode(node) {
 }
 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 {};
@@ -10700,7 +10846,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,
@@ -10712,6 +10859,7 @@ function resolutionOutputPorts(node) {
 }
 function nodeOutputPorts(node) {
 	switch (node.kind) {
+		case "webhook-response":
 		case "outputs":
 		case "condition": return {};
 		case "value": return portsByHandle(node.values);
@@ -11058,6 +11206,7 @@ function withWaitNotificationMessage$1(value) {
 		pageUrl,
 		message: source.message === void 0 ? [
 			source.prompt,
+			...typeof source.autoContinueAt == "string" ? [`Automatically continues at: ${source.autoContinueAt}`] : [],
 			`Expires at: ${source.expiresAt}`,
 			`Review request: ${pageUrl}`
 		].join("\n\n") : source.message
@@ -11067,6 +11216,7 @@ function withWaitNotificationMessage$1(value) {
 //#region src/execution/common/scheduler.ts
 var withWaitNotificationMessage = withWaitNotificationMessage$1;
 var normalizeWaitComment = normalizeWaitComment$1;
+var waitAutoContinueAt = waitAutoContinueAt$1;
 var PortValidationError = class extends Error {};
 function usesPending(graph, nodeId) {
 	return graph.edges.some((edge) => edge.source == nodeId && edge.sourceHandle == "pending") || Object.values(graph.nodes).some((node) => !isTriggerNode(node) && Object.values(nodeInputMappings(node)).some((mapping) => mapping.kind == "sources" && mapping.sources.some((source) => source.kind == "node" && source.nodeId == nodeId && source.output == "pending")));
@@ -11471,7 +11621,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			const systemFrame = dependencies.systemInputValues(nodeId);
 			return Object.fromEntries(Object.entries(nodeInputPorts(node)).map(([handle, port]) => [handle, resolveInput(mappings[handle], port, launch[nodeId]?.[handle], `Node "${nodeId}" input "${handle}"`, frame, node.kind == "condition", systemFrame)]));
 		};
-		const commit = (nodeId, jobId, outputs, releasedHandles = Object.keys(outputs), failure) => Effect.uninterruptible(Effect.gen(function* () {
+		const commit = (nodeId, jobId, outputs, releasedHandles = Object.keys(outputs), failure, response) => Effect.uninterruptible(Effect.gen(function* () {
 			const node = target.graph.nodes[nodeId];
 			const systemOutputs = nodeSystemOutputPorts(node).error == null ? void 0 : { error: failure == null ? null : {
 				code: failure.code,
@@ -11489,6 +11639,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				outputs,
 				runId,
 				...system,
+				...response == null ? {} : { response },
 				type: "node.completed"
 			} : {
 				...failure,
@@ -11531,6 +11682,21 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				});
 				let outputs;
 				switch (node.kind) {
+					case "webhook-response": {
+						const status = nodeInputs.statusCode;
+						if (!validWebhookStatus(status)) return yield* Effect.fail(new NodeValidationError("webhook.response-status-invalid", "Invalid HTTP response status."));
+						const headers = webhookHeaderValues(nodeInputs.headers);
+						if (headers == null) return yield* Effect.fail(new NodeValidationError("webhook.response-headers-invalid", "Invalid HTTP response headers."));
+						return {
+							kind: "completed",
+							outputs: {},
+							response: {
+								...encodeWebhookBody(nodeInputs.body),
+								status,
+								headers
+							}
+						};
+					}
 					case "outputs":
 						outputs = nodeInputs;
 						break;
@@ -11655,6 +11821,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				value,
 				waitId,
 				notify,
+				...node.kind == "wait" && node.autoContinue != null ? { autoContinue: node.autoContinue } : {},
 				actions: isResolutionNode(node) ? resolutionActions(node) : ["approve", "reject"],
 				prompt: isResolutionNode(node) ? node.prompt : JSON.stringify(value, null, 2),
 				...isResolutionNode(node) ? {} : { notification: agentNotice(node, agents[jobId].input) }
@@ -11686,7 +11853,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			pendingCalls.delete(jobId);
 			if (result.kind == "completed") {
 				delete agents[jobId];
-				return commit(nodeId, jobId, result.outputs, result.releasedHandles);
+				return commit(nodeId, jobId, result.outputs, result.releasedHandles, void 0, result.response);
 			}
 			agents[jobId] = result.agent;
 			return createWait(nodeId, jobId, result.value);
@@ -11935,4 +12102,4 @@ function runFlow(prepared, options) {
 	});
 }
 //#endregion
-export { PortValidationError, decodeFlowRunCheckpoint, normalizeWaitComment, runFlow, waitRetentionMs, withWaitNotificationMessage };
+export { PortValidationError, decodeFlowRunCheckpoint, normalizeWaitComment, runFlow, waitAutoContinueAt, waitRetentionMs, withWaitNotificationMessage };

package/dist/common/webhook-response.d.ts

@@ -0,0 +1,43 @@
+import type { InputPort, JsonValue, Port, PortDefinition } from '../browser/flow-change.js';
+export declare const webhookResponseTimeout: {
+    readonly defaultMs: 30000;
+    readonly minMs: 1000;
+    readonly maxMs: 60000;
+};
+export declare const webhookStatusCodePort: {
+    readonly jsonSchema: {
+        readonly type: 'number';
+    };
+    readonly nullable: true;
+};
+export declare function webhookResponseAllowsBody(status: number): boolean;
+export declare const webhookHeaderValuePort: {
+    readonly jsonSchema: {
+        readonly type: readonly ['string', 'number', 'boolean'];
+    };
+    readonly nullable: true;
+};
+export declare const webhookHeadersPort: {
+    readonly jsonSchema: {
+        readonly type: 'object';
+        readonly additionalProperties: {
+            readonly type: readonly ['string', 'number', 'boolean'];
+        };
+    };
+    readonly nullable: true;
+};
+export declare function workflowOutputsPort(outputs: readonly Port[]): PortDefinition;
+/** Header names are case-insensitive; never silently combine duplicate business fields. */
+export declare function webhookHeaderNameIssue(name: string, names: readonly string[]): 'invalid' | 'duplicate' | undefined;
+/** Fixed inputs belong to the node, not author-supplied definitions. */
+export declare const webhookResponseInputs: readonly InputPort[];
+export interface WebhookResponseSnapshot {
+    readonly body: string;
+    readonly contentType: string;
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+}
+export declare function validWebhookStatus(value: unknown): value is number;
+/** Portable validation also runs in the isolated engine, which has no HTTP globals. */
+export declare function webhookHeaderValues(source: unknown): Readonly<Record<string, string>> | undefined;
+export declare function encodeWebhookBody(value: JsonValue): Pick<WebhookResponseSnapshot, 'body' | 'contentType'>;

package/dist/common/webhook-trigger.d.ts

@@ -1,6 +1,18 @@
 import type { JsonValue, WebhookBodyField, WebhookMethod, WebhookOptions } from '../browser/flow-change.js';
 export { webhookSupportsBody } from './trigger-contract.js';
+export { webhookResponseAllowsBody, webhookResponseTimeout } from './webhook-response.js';
+export type { WebhookResponseSnapshot } from './webhook-response.js';
 export declare const maximumWebhookBodyBytes: number;
+/** Serialize only declared workflow business outputs, never node logs or execution metadata. */
+export declare function webhookResponseBody(result: unknown, source: Extract<NonNullable<WebhookOptions['responseBody']>, {
+    kind: 'workflow-outputs';
+}>): {
+    readonly body: string;
+    readonly contentType: string;
+} | undefined;
+export declare function webhookResponseStatusCode(result: unknown, output: string): number | undefined;
+/** Project business headers before the HTTP layer applies its deployment-owned header policy. */
+export declare function webhookResponseHeaders(result: unknown, options: WebhookOptions): Readonly<Record<string, string>> | undefined;
 export declare function webhookEndpointId(url: URL): string | undefined;
 export declare function webhookOccurrenceId(endpointId: string, runtimeVersion: number, key: string | null): Promise<string | undefined>;
 export interface WebhookConformanceFixture {