acpx 0.13.2 → 0.14.0

package/dist/{flows-BiRKgCnW.js → flows-DEook1GU.js}

@@ -1,11 +1,12 @@
-import { d as createSessionWithClient, f as cancelSessionPrompt, o as runOnce, s as sendSessionDirect, t as createOutputFormatter } from "./output-DiPPprGk.js";
-import { Dt as TimeoutError, Et as InterruptedError, Ot as withInterrupt, Tt as textPrompt, Y as resolveSessionRecord, Yt as PERMISSION_MODES, Zt as SESSION_RECORD_SCHEMA, _ as recordPromptSubmission, dt as defaultSessionEventLog, g as recordClientOperation, h as createSessionConversation, kt as withTimeout, p as cloneSessionAcpxState, v as recordSessionUpdate, wt as promptToDisplayText } from "./live-checkpoint-Gw2oGjhe.js";
+import { d as createSessionWithClient, f as cancelSessionPrompt, o as runOnce, s as sendSessionDirect, t as createOutputFormatter } from "./output-jb0298L8.js";
+import { Dt as TimeoutError, Et as InterruptedError, F as runTimedExecFile, Ot as withInterrupt, Tt as textPrompt, Y as resolveSessionRecord, Yt as PERMISSION_MODES, Zt as SESSION_RECORD_SCHEMA, _ as recordPromptSubmission, dt as defaultSessionEventLog, g as recordClientOperation, h as createSessionConversation, kt as withTimeout, p as cloneSessionAcpxState, v as recordSessionUpdate, wt as promptToDisplayText } from "./live-checkpoint-BW9JivEG.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import os from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 import { ZodError, z } from "zod";
 import { spawn } from "node:child_process";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region src/flows/authoring.ts
 const FLOW_DEFINITION_BRAND = Symbol.for("acpx.flow.definition");
 function markDefinedFlow(definition) {
@@ -228,7 +229,137 @@ function checkpoint(definition = {}) {
 	return node;
 }
 //#endregion
+//#region src/flows/executors/shell-process.ts
+const KILL_GRACE_MS = 1e3;
+async function readPosixProcesses() {
+	return (await runTimedExecFile("ps", ["-eo", "pid=,ppid=,pgid=,stat="])).trim().split("\n").map((line) => {
+		const [pid, parent, group, state = ""] = line.trim().split(/\s+/u);
+		return {
+			pid: Number(pid),
+			parent: Number(parent),
+			group: Number(group),
+			state
+		};
+	}).filter((entry) => Number.isInteger(entry.pid) && entry.pid > 0);
+}
+function isLive(entry) {
+	return entry.state.length > 0 && !entry.state.startsWith("Z");
+}
+function rememberOwnedProcesses(rows, root, owned) {
+	for (const entry of rows) if (entry.group === root) owned.add(entry.pid);
+	for (const parent of owned) for (const entry of rows) if (entry.parent === parent) owned.add(entry.pid);
+}
+function signalPid(pid, signal) {
+	try {
+		process.kill(pid, signal);
+	} catch (error) {
+		if (error.code !== "ESRCH") throw error;
+	}
+}
+async function signalGroup(root, signal) {
+	try {
+		process.kill(-root, signal);
+	} catch (error) {
+		const code = error.code;
+		if (code === "ESRCH") return;
+		if (code === "EPERM" && !(await readPosixProcesses()).some((entry) => entry.group === root && isLive(entry))) return;
+		throw error;
+	}
+}
+async function signalOwned(root, owned, signal) {
+	const rows = await readPosixProcesses();
+	rememberOwnedProcesses(rows, root, owned);
+	await signalGroup(root, signal);
+	for (const entry of rows) if (owned.has(entry.pid) && entry.group !== root && isLive(entry)) signalPid(entry.pid, signal);
+}
+async function waitForOwned(root, owned) {
+	const deadline = Date.now() + KILL_GRACE_MS;
+	do {
+		const rows = await readPosixProcesses();
+		rememberOwnedProcesses(rows, root, owned);
+		if (!rows.some((entry) => owned.has(entry.pid) && isLive(entry))) return true;
+		await setTimeout$1(25);
+	} while (Date.now() < deadline);
+	return false;
+}
+async function forceKnownProcesses(root, owned) {
+	const results = await Promise.allSettled([signalGroup(root, "SIGKILL"), ...[...owned].map(async (pid) => signalPid(pid, "SIGKILL"))]);
+	const errors = [];
+	for (const result of results) if (result.status === "rejected") errors.push(result.reason);
+	if (errors.length > 0) throw new AggregateError(errors, "Known shell processes could not be stopped", { cause: errors[0] });
+}
+async function stopPosixTree(pid, signal) {
+	const owned = /* @__PURE__ */ new Set([pid]);
+	try {
+		await signalOwned(pid, owned, signal);
+		if (await waitForOwned(pid, owned)) return;
+		await signalOwned(pid, owned, "SIGKILL");
+		if (!await waitForOwned(pid, owned)) throw new Error("Shell process tree did not terminate after SIGKILL");
+	} catch (error) {
+		try {
+			await forceKnownProcesses(pid, owned);
+		} catch (cleanupError) {
+			throw new AggregateError([error, cleanupError], "Shell process cleanup failed", { cause: cleanupError });
+		}
+		throw error;
+	}
+}
+async function stopWindowsTree(child) {
+	if (child.pid == null || child.exitCode != null || child.signalCode != null) return;
+	try {
+		await runTimedExecFile("taskkill", [
+			"/pid",
+			String(child.pid),
+			"/t",
+			"/f"
+		], { windowsHide: true });
+	} catch (error) {
+		child.kill("SIGKILL");
+		throw error;
+	}
+}
+async function waitForShellClose(closed) {
+	try {
+		await withTimeout(closed, KILL_GRACE_MS);
+	} catch (cause) {
+		throw new Error("Shell process streams did not close after termination", { cause });
+	}
+}
+async function stopShellProcess(child, closed, signal) {
+	try {
+		if (child.pid != null) {
+			if (process.platform === "win32") await stopWindowsTree(child);
+			else await stopPosixTree(child.pid, signal);
+		}
+	} catch (error) {
+		try {
+			await waitForShellClose(closed);
+		} catch (closeError) {
+			throw new AggregateError([error, closeError], "Shell process cleanup failed", { cause: closeError });
+		}
+		throw error;
+	}
+	await waitForShellClose(closed);
+}
+function hasShellProcesses(child) {
+	if (child.pid == null) return false;
+	if (process.platform === "win32") return child.exitCode == null && child.signalCode == null;
+	try {
+		process.kill(-child.pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+//#endregion
 //#region src/flows/executors/shell.ts
+function writeShellStdin(child, stdin) {
+	const stream = child.stdin;
+	if (!stream) return;
+	stream.on("error", () => {});
+	if (stdin != null && stream.writable && !stream.writableEnded) stream.write(stdin);
+	if (stream.writable && !stream.writableEnded) stream.end();
+}
 function formatShellActionSummary(spec) {
 	return `shell: ${renderShellCommand(spec.command, spec.args ?? [])}`;
 }
@@ -241,39 +372,46 @@ function createShellFailureError(spec, args, exitCode, signal, stderr) {
 	const details = stderr.length > 0 ? `\n${stderr.trim()}` : "";
 	return /* @__PURE__ */ new Error(`Shell action failed (${renderShellCommand(spec.command, args)}): ${status}${details}`);
 }
-function rejectIfShellFailed(spec, args, result, timedOut) {
-	if (timedOut) return new TimeoutError(spec.timeoutMs ?? 0);
+/**
+* Resolve a shell-action timeout.
+* Non-positive values match withTimeout: no deadline (undefined).
+* Positive values arm SIGTERM/SIGKILL after that many ms.
+*/
+function resolveShellActionTimeoutMs(timeoutMs) {
+	if (timeoutMs == null || !(timeoutMs > 0)) return;
+	return timeoutMs;
+}
+async function withShellAbort(run, signal) {
+	signal.throwIfAborted();
+	let rejectAbort = () => {};
+	const aborted = new Promise((_resolve, reject) => {
+		rejectAbort = reject;
+	});
+	const onAbort = () => rejectAbort(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([run(), aborted]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+function rejectIfShellFailed(spec, args, result, timedOut, timeoutMs) {
+	if (timedOut) return new TimeoutError(timeoutMs ?? spec.timeoutMs ?? 0);
 	if (((result.exitCode ?? 0) !== 0 || result.signal != null) && spec.allowNonZeroExit !== true) return createShellFailureError(spec, args, result.exitCode, result.signal, result.stderr);
 }
-async function runShellAction(spec) {
-	const cwd = spec.cwd ?? process.cwd();
-	const args = spec.args ?? [];
-	const startMs = Date.now();
-	const child = spawn(spec.command, args, {
-		cwd,
-		env: {
-			...process.env,
-			...spec.env
-		},
-		shell: spec.shell,
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		],
-		windowsHide: true
-	});
+function waitForShellExit(child, spec, args, cwd, startMs, timeoutMs, timedOut) {
 	let stdout = "";
 	let stderr = "";
-	let timedOut = false;
-	let timeout;
-	const finish = new Promise((resolve, reject) => {
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
+	const stdoutStream = child.stdout;
+	const stderrStream = child.stderr;
+	if (!stdoutStream || !stderrStream) throw new Error("Shell action child is missing stdio pipes");
+	return new Promise((resolve, reject) => {
+		stdoutStream.setEncoding("utf8");
+		stderrStream.setEncoding("utf8");
+		stdoutStream.on("data", (chunk) => {
 			stdout += chunk;
 		});
-		child.stderr.on("data", (chunk) => {
+		stderrStream.on("data", (chunk) => {
 			stderr += chunk;
 		});
 		child.once("error", reject);
@@ -289,7 +427,7 @@ async function runShellAction(spec) {
 				signal,
 				durationMs: Date.now() - startMs
 			};
-			const error = rejectIfShellFailed(spec, args, result, timedOut);
+			const error = rejectIfShellFailed(spec, args, result, timedOut(), timeoutMs);
 			if (error) {
 				reject(error);
 				return;
@@ -297,19 +435,99 @@ async function runShellAction(spec) {
 			resolve(result);
 		});
 	});
-	if (spec.stdin != null) child.stdin.write(spec.stdin);
-	child.stdin.end();
-	if (spec.timeoutMs != null && spec.timeoutMs > 0) timeout = setTimeout(() => {
+}
+function createShellTermination(child, timeoutMs, options) {
+	const closed = new Promise((resolve) => child.once("close", () => resolve()));
+	let rejectCleanup = () => {};
+	const cleanupFailure = new Promise((_resolve, reject) => {
+		rejectCleanup = reject;
+	});
+	let termination;
+	let timedOut = false;
+	let released = false;
+	let deadline;
+	let monitor;
+	let unregister;
+	const clearDeadline = () => {
+		if (deadline) clearTimeout(deadline);
+	};
+	const release = () => {
+		if (released) return;
+		released = true;
+		clearDeadline();
+		if (monitor) clearInterval(monitor);
+		options.signal?.removeEventListener("abort", onAbort);
+		unregister?.();
+	};
+	const cancel = (signal) => {
+		if (termination) return termination;
+		if (released) return Promise.resolve();
 		timedOut = true;
-		child.kill("SIGTERM");
-		setTimeout(() => {
-			child.kill("SIGKILL");
-		}, 1e3).unref();
-	}, spec.timeoutMs);
+		termination = stopShellProcess(child, closed, signal).finally(release);
+		termination.catch(rejectCleanup);
+		return termination;
+	};
+	const onAbort = () => {
+		cancel(options.terminationSignal ?? "SIGTERM");
+	};
+	options.signal?.addEventListener("abort", onAbort, { once: true });
+	if (timeoutMs != null) deadline = setTimeout(() => {
+		cancel("SIGTERM");
+	}, timeoutMs);
+	unregister = options.registerOwner?.({
+		cancel,
+		release
+	});
+	if (unregister) child.once("close", () => {
+		if (released || termination) return;
+		const prune = () => {
+			if (!termination && !hasShellProcesses(child)) release();
+		};
+		monitor = setInterval(prune, 100);
+		monitor.unref();
+		prune();
+	});
+	return {
+		timedOut: () => timedOut,
+		cleanupFailure,
+		async dispose() {
+			clearDeadline();
+			try {
+				await termination;
+			} finally {
+				if (!unregister) release();
+			}
+		}
+	};
+}
+async function runShellAction(spec, options = {}) {
+	if (options?.signal?.aborted) throw options.signal.reason;
+	const cwd = spec.cwd ?? process.cwd();
+	const args = spec.args ?? [];
+	const startMs = Date.now();
+	const timeoutMs = resolveShellActionTimeoutMs(spec.timeoutMs);
+	const child = spawn(spec.command, args, {
+		cwd,
+		env: {
+			...process.env,
+			...spec.env
+		},
+		shell: spec.shell,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true,
+		detached: process.platform !== "win32"
+	});
+	const termination = createShellTermination(child, timeoutMs, options);
+	const finish = waitForShellExit(child, spec, args, cwd, startMs, timeoutMs, termination.timedOut);
+	writeShellStdin(child, spec.stdin);
 	try {
-		return await finish;
+		return await Promise.race([finish, termination.cleanupFailure]);
 	} finally {
-		if (timeout) clearTimeout(timeout);
+		await termination.dispose();
 	}
 }
 //#endregion
@@ -1020,6 +1238,9 @@ var FlowRunner = class {
 	services;
 	store;
 	pendingPersistentSessionClients = /* @__PURE__ */ new Map();
+	shellInterrupts = /* @__PURE__ */ new Map();
+	runInterruptions = /* @__PURE__ */ new Map();
+	shellOwners = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.resolveAgent = options.resolveAgent;
 		this.defaultCwd = options.resolveAgent(void 0).cwd;
@@ -1068,19 +1289,84 @@ var FlowRunner = class {
 			inputArtifact
 		});
 		try {
-			return await withInterrupt(async () => await this.executeFlowRun(flow, input, runDir, state), async () => {
-				await persistRunFailure(this.store, runDir, state, new InterruptedError());
-			});
+			return await this.runWithShellOwnership(flow, input, runDir, state);
 		} finally {
 			await this.closePendingPersistentSessionClients();
 		}
 	}
+	async runWithShellOwnership(flow, input, runDir, state) {
+		let execution;
+		let cancellation;
+		let interruption;
+		const result = await withInterrupt(() => {
+			execution = this.executeFlowRun(flow, input, runDir, state);
+			return execution;
+		}, async (signal) => {
+			const reason = interruption ?? new InterruptedError();
+			interruption = reason;
+			this.runInterruptions.set(runDir, reason);
+			cancellation ??= this.cancelShellOwners(runDir, signal);
+			cancellation.catch(() => {});
+			const interruptShell = this.shellInterrupts.get(runDir);
+			if (interruptShell) {
+				interruptShell(reason, signal);
+				await execution?.catch(() => {});
+			}
+		}).then((value) => ({
+			ok: true,
+			value
+		}), (error) => ({
+			ok: false,
+			error
+		}));
+		try {
+			try {
+				await cancellation;
+			} catch (cleanupError) {
+				const failure = result.ok || result.error === cleanupError ? cleanupError : new AggregateError([result.error, cleanupError], "Shell cleanup failed during interruption", { cause: cleanupError });
+				await persistRunFailure(this.store, runDir, state, failure);
+				throw failure;
+			}
+			if (result.ok && !interruption) return result.value;
+			const failure = result.ok ? interruption : result.error;
+			if (interruption) await persistRunFailure(this.store, runDir, state, failure);
+			throw failure;
+		} finally {
+			this.releaseShellOwners(runDir);
+		}
+	}
+	registerShellOwner(runDir, owner) {
+		let owners = this.shellOwners.get(runDir);
+		if (!owners) {
+			owners = /* @__PURE__ */ new Set();
+			this.shellOwners.set(runDir, owners);
+		}
+		owners.add(owner);
+		const registered = owners;
+		return () => {
+			registered.delete(owner);
+			if (registered.size === 0) this.shellOwners.delete(runDir);
+		};
+	}
+	async cancelShellOwners(runDir, signal) {
+		const owners = [...this.shellOwners.get(runDir) ?? []];
+		const results = await Promise.allSettled(owners.map((owner) => owner.cancel(signal)));
+		const errors = [];
+		for (const result of results) if (result.status === "rejected") errors.push(result.reason);
+		if (errors.length > 0) throw new AggregateError(errors, "Shell process cleanup failed", { cause: errors[0] });
+	}
+	releaseShellOwners(runDir) {
+		for (const owner of this.shellOwners.get(runDir) ?? []) owner.release();
+		this.shellOwners.delete(runDir);
+	}
 	async executeFlowRun(flow, input, runDir, state) {
 		let current = flow.startAt;
 		const attemptCounts = /* @__PURE__ */ new Map();
 		try {
 			while (current) {
+				this.throwIfRunInterrupted(runDir);
 				const step = await this.executeFlowStep(flow, input, runDir, state, current, attemptCounts);
+				this.throwIfRunInterrupted(runDir, step.executionError);
 				const waiting = await this.maybeCompleteCheckpointStep(runDir, state, step);
 				if (waiting) return waiting;
 				await this.recordFlowStepOutcome(runDir, state, step);
@@ -1088,10 +1374,16 @@ var FlowRunner = class {
 			}
 			return await this.completeFlowRun(runDir, state);
 		} catch (error) {
-			await persistRunFailure(this.store, runDir, state, error);
+			if (!this.runInterruptions.has(runDir)) await persistRunFailure(this.store, runDir, state, error);
 			throw error;
+		} finally {
+			this.runInterruptions.delete(runDir);
 		}
 	}
+	throwIfRunInterrupted(runDir, error) {
+		const interrupted = this.runInterruptions.get(runDir);
+		if (interrupted) throw error ?? interrupted;
+	}
 	async executeFlowStep(flow, input, runDir, state, nodeId, attemptCounts) {
 		const node = flow.nodes[nodeId];
 		if (!node) throw new Error(`Unknown flow node: ${nodeId}`);
@@ -1126,7 +1418,9 @@ var FlowRunner = class {
 	async executeStartedFlowStep(params) {
 		const context = makeFlowNodeContext(params.state, params.input, this.services);
 		try {
+			this.throwIfRunInterrupted(params.runDir);
 			const executed = await this.executeNode(params.runDir, params.state, params.flow, params.nodeId, params.node, context);
+			this.throwIfRunInterrupted(params.runDir);
 			return await this.createSuccessfulFlowStep(params, executed);
 		} catch (error) {
 			return await this.createFailedFlowStep(params, error);
@@ -1279,12 +1573,27 @@ var FlowRunner = class {
 			agentInfo: null,
 			trace: { action: { actionType: "function" } }
 		};
-		const { output, rawText, trace } = await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, async () => {
+		const shellAbort = new AbortController();
+		let runningOwner;
+		const shellControl = {
+			signal: shellAbort.signal,
+			registerOwner: (owner) => {
+				runningOwner = owner;
+				return this.registerShellOwner(runDir, owner);
+			}
+		};
+		this.shellInterrupts.set(runDir, (reason, signal) => {
+			shellControl.terminationSignal = signal;
+			shellAbort.abort(reason);
+		});
+		let runningShell;
+		const { output, rawText, trace } = await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, () => withShellAbort(async () => {
 			const execution = await Promise.resolve(node.exec(context));
+			shellAbort.signal.throwIfAborted();
 			const effectiveExecution = {
 				...execution,
 				cwd: resolveShellActionCwd(this.defaultCwd, execution.cwd),
-				timeoutMs: execution.timeoutMs ?? nodeTimeoutMs
+				timeoutMs: resolveShellActionTimeoutMs(execution.timeoutMs ?? nodeTimeoutMs)
 			};
 			updateStatusDetail(state, formatShellActionSummary(effectiveExecution));
 			await this.store.writeLive(runDir, state, {
@@ -1294,6 +1603,7 @@ var FlowRunner = class {
 				attemptId: state.currentAttemptId,
 				payload: { statusDetail: state.statusDetail }
 			});
+			shellAbort.signal.throwIfAborted();
 			await this.store.appendTrace(runDir, state, {
 				scope: "action",
 				type: "action_prepared",
@@ -1306,7 +1616,9 @@ var FlowRunner = class {
 					cwd: effectiveExecution.cwd
 				} }
 			});
-			const result = await runShellAction(effectiveExecution);
+			runningShell = runShellAction(effectiveExecution, shellControl);
+			const result = await runningShell;
+			shellAbort.signal.throwIfAborted();
 			const stdoutArtifact = await this.store.writeArtifact(runDir, state, result.stdout, {
 				mediaType: "text/plain",
 				extension: "txt",
@@ -1319,6 +1631,7 @@ var FlowRunner = class {
 				nodeId: state.currentNode,
 				attemptId: state.currentAttemptId
 			});
+			shellAbort.signal.throwIfAborted();
 			await this.store.appendTrace(runDir, state, {
 				scope: "action",
 				type: "action_completed",
@@ -1351,9 +1664,11 @@ var FlowRunner = class {
 				stdoutArtifact,
 				stderrArtifact
 			};
+			shellAbort.signal.throwIfAborted();
 			let parsedOutput;
 			try {
 				parsedOutput = node.parse ? await node.parse(result, context) : result;
+				shellAbort.signal.throwIfAborted();
 			} catch (error) {
 				throw attachStepTrace(error, trace);
 			}
@@ -1362,6 +1677,17 @@ var FlowRunner = class {
 				rawText: result.combinedOutput,
 				trace
 			};
+		}, shellAbort.signal)).catch(async (error) => {
+			shellAbort.abort(error);
+			try {
+				await runningOwner?.cancel(shellControl.terminationSignal ?? "SIGTERM");
+				await runningShell;
+			} catch (cleanupError) {
+				if (!(cleanupError instanceof TimeoutError) && cleanupError !== error) throw new AggregateError([error, cleanupError], "Shell action cleanup failed", { cause: cleanupError });
+			}
+			throw error;
+		}).finally(() => {
+			this.shellInterrupts.delete(runDir);
 		});
 		return {
 			output,
@@ -1520,17 +1846,23 @@ var FlowRunner = class {
 		const heartbeatMs = Math.max(0, Math.round(node.heartbeatMs ?? DEFAULT_FLOW_HEARTBEAT_MS));
 		let timer;
 		let active = true;
+		let heartbeatPending = false;
 		const heartbeat = async () => {
-			if (!active) return;
-			state.lastHeartbeatAt = isoNow$1();
-			state.updatedAt = state.lastHeartbeatAt;
-			await this.store.writeLive(runDir, state, {
-				scope: "node",
-				type: "node_heartbeat",
-				nodeId,
-				attemptId: state.currentAttemptId,
-				payload: { statusDetail: state.statusDetail }
-			});
+			if (!active || heartbeatPending) return;
+			heartbeatPending = true;
+			try {
+				state.lastHeartbeatAt = isoNow$1();
+				state.updatedAt = state.lastHeartbeatAt;
+				await this.store.writeLive(runDir, state, {
+					scope: "node",
+					type: "node_heartbeat",
+					nodeId,
+					attemptId: state.currentAttemptId,
+					payload: { statusDetail: state.statusDetail }
+				});
+			} finally {
+				heartbeatPending = false;
+			}
 		};
 		if (heartbeatMs > 0) timer = setInterval(() => {
 			heartbeat().catch(() => {});
@@ -1927,4 +2259,4 @@ function formatDecisionPrompt(question, choices, field) {
 //#endregion
 export { parseStrictJsonObject as a, validateFlowDefinition as c, checkpoint as d, compute as f, isDefinedFlow as h, parseJsonObject as i, acp as l, shell as m, decisionEdge as n, FlowRunner as o, defineFlow as p, extractJsonObject as r, flowRunsBaseDir as s, decision as t, action as u };
 
-//# sourceMappingURL=flows-BiRKgCnW.js.map
+//# sourceMappingURL=flows-DEook1GU.js.map