@oisincoveney/pipeline 3.24.2 → 3.24.3

package/dist/runtime/services/opencode-runtime-server-service.js

@@ -2,14 +2,8 @@ import { OpencodeServerStartupError, openOpencodeServer } from "../opencode-serv
 import { Context, Effect, Layer } from "effect";
 //#region src/runtime/services/opencode-runtime-server-service.ts
 var OpencodeRuntimeServerService = class extends Context.Service()("OpencodeRuntimeServerService") {};
-const OpencodeRuntimeServerServiceLive = Layer.succeed(OpencodeRuntimeServerService, { open: (input) => Effect.tryPromise({
-	catch: (error) => error,
-	try: () => openRuntimeServer(input)
-}) });
-function openRuntimeServer(input) {
-	return (input.openServer ?? startServer)(input);
-}
-async function startServer(input) {
+const startupMessage = (error) => `${error.message}. Confirm the opencode binary is installed and recent enough to expose 'opencode serve', or set OPENCODE_SERVER_URL to an already-running server.`;
+const startServer = async (input) => {
 	try {
 		return await openOpencodeServer({
 			directory: input.worktreePath,
@@ -19,9 +13,13 @@ async function startServer(input) {
 		if (error instanceof OpencodeServerStartupError) throw new OpencodeServerStartupError(startupMessage(error), { cause: error });
 		throw error;
 	}
-}
-function startupMessage(error) {
-	return `${error.message}. Confirm the opencode binary is installed and recent enough to expose 'opencode serve', or set OPENCODE_SERVER_URL to an already-running server.`;
-}
+};
+const openRuntimeServer = async (input) => {
+	return await (input.openServer ?? startServer)(input);
+};
+const OpencodeRuntimeServerServiceLive = Layer.succeed(OpencodeRuntimeServerService, { open: (input) => Effect.tryPromise({
+	catch: (error) => error,
+	try: async () => await openRuntimeServer(input)
+}) });
 //#endregion
 export { OpencodeRuntimeServerService, OpencodeRuntimeServerServiceLive };

package/dist/runtime/services/opencode-sdk-service.js

@@ -3,22 +3,22 @@ import { createOpencode, createOpencodeClient } from "@opencode-ai/sdk/v2";
 //#region src/runtime/services/opencode-sdk-service.ts
 var OpencodeSdkService = class extends Context.Service()("OpencodeSdkService") {};
 const OpencodeSdkServiceLive = Layer.succeed(OpencodeSdkService, {
+	abortSession: (client, args) => Effect.tryPromise({
+		catch: (error) => error,
+		try: async () => await (client.session.abort?.(args) ?? Promise.resolve())
+	}),
 	createClient: (opts) => Effect.try(() => createOpencodeClient(opts)),
 	createSession: (client, args) => Effect.tryPromise({
 		catch: (error) => error,
-		try: () => client.session.create(args)
+		try: async () => await client.session.create(args)
 	}),
 	promptSession: (client, args) => Effect.tryPromise({
 		catch: (error) => error,
-		try: () => client.session.prompt(args)
+		try: async () => await client.session.prompt(args)
 	}),
 	spawnServer: (args, spawn = createOpencode) => Effect.tryPromise({
 		catch: (error) => error,
-		try: () => spawn(args)
-	}),
-	abortSession: (client, args) => Effect.tryPromise({
-		catch: (error) => error,
-		try: () => client.session.abort?.(args) ?? Promise.resolve(void 0)
+		try: async () => await spawn(args)
 	}),
 	subscribeEvents: (client) => Effect.tryPromise({
 		catch: (error) => error,

package/dist/runtime/services/repo-io-service.js

@@ -1,13 +1,14 @@
-import { Cause, Context, Effect, Layer, Option } from "effect";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { Cause, Context, Effect, Layer, Option } from "effect";
 import { Language, Parser } from "web-tree-sitter";
 //#region src/runtime/services/repo-io-service.ts
 let parserInitPromise = null;
-function initializeParser() {
+const initializeParser = async () => {
 	parserInitPromise ??= Parser.init();
-	return parserInitPromise;
-}
+	await parserInitPromise;
+};
 var RepoIoService = class extends Context.Service()("RepoIoService") {};
+const direntCompare = (a, b) => a.name.localeCompare(b.name);
 const RepoIoServiceLive = Layer.succeed(RepoIoService, {
 	createParser: () => Effect.tryPromise({
 		catch: (error) => error,
@@ -23,7 +24,7 @@ const RepoIoServiceLive = Layer.succeed(RepoIoService, {
 	}),
 	loadLanguage: (path) => Effect.tryPromise({
 		catch: (error) => error,
-		try: () => Language.load(path)
+		try: async () => await Language.load(path)
 	}),
 	readDir: (path) => Effect.try({
 		catch: (error) => error,
@@ -31,18 +32,15 @@ const RepoIoServiceLive = Layer.succeed(RepoIoService, {
 	}),
 	readText: (path) => Effect.try({
 		catch: (error) => error,
-		try: () => readFileSync(path, "utf8")
+		try: () => readFileSync(path, "utf-8")
 	})
 });
-function direntCompare(a, b) {
-	return a.name.localeCompare(b.name);
-}
-function runRepoIoSync(program) {
+const runRepoIoSync = (program) => {
 	const exit = Effect.runSyncExit(Effect.provide(program, RepoIoServiceLive));
 	if (exit._tag === "Success") return exit.value;
 	const originalError = Option.getOrUndefined(Cause.findErrorOption(exit.cause));
-	if (originalError) throw originalError;
+	if (originalError !== void 0) throw originalError;
 	throw Cause.squash(exit.cause);
-}
+};
 //#endregion
 export { RepoIoService, RepoIoServiceLive, runRepoIoSync };

package/dist/runtime/services/run-journal-file-service.js

@@ -1,6 +1,6 @@
-import { Context, Effect, Layer } from "effect";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { Context, Effect, Layer, Option } from "effect";
 //#region src/runtime/services/run-journal-file-service.ts
 var RunJournalFileService = class extends Context.Service()("RunJournalFileService") {};
 Layer.succeed(RunJournalFileService, {
@@ -13,7 +13,7 @@ Layer.succeed(RunJournalFileService, {
 	}),
 	readTextIfExists: (path) => Effect.try({
 		catch: (error) => error,
-		try: () => existsSync(path) ? readFileSync(path, "utf8") : void 0
+		try: () => existsSync(path) ? Option.some(readFileSync(path, "utf-8")) : Option.none()
 	})
 });
 //#endregion

package/dist/runtime/services/runner-command-io-service.js

@@ -1,16 +1,20 @@
+import { parseResultWithSchema } from "../../schema-boundary.js";
 import { prepareOpencodeCredentials } from "../../credentials/runner.js";
 import { commitAndPushNodeRef, mergeDependencyRefs, prepareRunnerGitWorkspace, promoteFinalRef } from "../../run-state/git-refs.js";
 import { runScheduledWorkflowTask } from "../../pipeline-runtime.js";
 import { resolveRunnerEventSinkAuthToken } from "../../runner-command-contract.js";
 import { createRunnerEventSink } from "../../runner-event-sink.js";
-import { Context, Effect, Layer, Schedule } from "effect";
+import * as Effect from "effect/Effect";
 import { existsSync, readFileSync } from "node:fs";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
 import { execa } from "execa";
 //#region src/runtime/services/runner-command-io-service.ts
 const TERMINAL_FLUSH_RETRY_LIMIT = 60;
 const TERMINAL_FLUSH_RETRY_DELAY = "1 second";
 const TERMINAL_FLUSH_TIMEOUT = "60 seconds";
-function createRunnerCommandEventSink({ fetch, payload }) {
+const createRunnerCommandEventSink = ({ fetch, payload }) => {
 	const authToken = resolveRunnerEventSinkAuthToken({ authTokenFile: payload.events.authTokenFile });
 	return createRunnerEventSink({
 		authHeader: payload.events.authHeader,
@@ -19,84 +23,76 @@ function createRunnerCommandEventSink({ fetch, payload }) {
 		runId: payload.run.id,
 		url: payload.events.url
 	});
-}
-function flushRunnerCommandSink(sink, reportError) {
-	return Effect.gen(function* () {
-		const io = yield* RunnerCommandIoService;
-		const result = yield* Effect.result(flushSinkWithTerminalRetry(io.flushSink, sink));
-		if (result._tag === "Success") return;
-		reportError(errorMessage(result.failure));
-	});
-}
-function flushSinkWithTerminalRetry(flushSink, sink) {
-	return flushSink(sink).pipe(Effect.retry(terminalFlushRetrySchedule()), Effect.timeout(TERMINAL_FLUSH_TIMEOUT));
-}
-function terminalFlushRetrySchedule() {
-	return Schedule.spaced(TERMINAL_FLUSH_RETRY_DELAY).pipe(Schedule.both(Schedule.recurs(TERMINAL_FLUSH_RETRY_LIMIT)));
-}
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
+};
+const terminalFlushRetrySchedule = () => Schedule.spaced(TERMINAL_FLUSH_RETRY_DELAY).pipe(Schedule.both(Schedule.recurs(TERMINAL_FLUSH_RETRY_LIMIT)));
+const flushSinkWithTerminalRetry = (flushSink, sink) => flushSink(sink).pipe(Effect.retry(terminalFlushRetrySchedule()), Effect.timeout(TERMINAL_FLUSH_TIMEOUT));
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
 var RunnerCommandIoService = class extends Context.Service()("RunnerCommandIoService") {};
+const flushRunnerCommandSink = (sink, reportError) => Effect.gen(function* effectBody() {
+	const io = yield* RunnerCommandIoService;
+	const result = yield* Effect.result(flushSinkWithTerminalRetry(io.flushSink, sink));
+	if (result._tag === "Success") return;
+	reportError(errorMessage(result.failure));
+});
 const RunnerCommandIoServiceLive = Layer.succeed(RunnerCommandIoService, {
 	commitAndPushNodeRef: (options) => Effect.tryPromise({
-		try: () => commitAndPushNodeRef(options),
-		catch: (error) => error
+		catch: (error) => error,
+		try: async () => await commitAndPushNodeRef(options)
 	}),
 	exists: (path) => Effect.try({
-		try: () => existsSync(path),
-		catch: (error) => error
+		catch: (error) => error,
+		try: () => existsSync(path)
 	}),
 	flushSink: (sink) => Effect.tryPromise({
-		try: () => sink.flush(),
-		catch: (error) => error
+		catch: (error) => error,
+		try: async () => {
+			await sink.flush();
+		}
 	}),
 	mergeDependencyRefs: (options) => Effect.tryPromise({
-		try: () => mergeDependencyRefs(options),
-		catch: (error) => error
+		catch: (error) => error,
+		try: async () => {
+			await mergeDependencyRefs(options);
+		}
 	}),
 	prepareOpencodeCredentials: () => Effect.try({
-		try: () => prepareOpencodeCredentials(),
-		catch: (error) => error
+		catch: (error) => error,
+		try: () => prepareOpencodeCredentials()
 	}),
 	prepareRunnerGitWorkspace: (payload, options) => Effect.tryPromise({
-		try: () => prepareRunnerGitWorkspace(payload, options),
-		catch: (error) => error
+		catch: (error) => error,
+		try: async () => await prepareRunnerGitWorkspace(payload, options)
 	}),
 	promoteFinalRef: (options) => Effect.tryPromise({
-		try: () => promoteFinalRef(options),
-		catch: (error) => error
+		catch: (error) => error,
+		try: async () => await promoteFinalRef(options)
 	}),
 	readText: (path) => Effect.try({
-		try: () => readFileSync(path, "utf8"),
-		catch: (error) => error
+		catch: (error) => error,
+		try: () => readFileSync(path, "utf-8")
 	}),
 	runScheduledWorkflowTask: (options) => Effect.tryPromise({
-		try: () => runScheduledWorkflowTask(options),
-		catch: (error) => error
+		catch: (error) => error,
+		try: async () => await runScheduledWorkflowTask(options)
 	}),
 	runSetupCommand: (command, args, options) => Effect.tryPromise({
-		try: () => execa(command, args, {
+		catch: (error) => error,
+		try: async () => await execa(command, args, {
 			cwd: options.cwd,
 			env: options.env,
 			reject: false
-		}),
-		catch: (error) => error
+		})
 	})
 });
 const EXIT_VALIDATION = 64;
-function isOutputStream(value) {
-	return typeof value === "object" && value !== null && "write" in value && typeof value.write === "function";
-}
-function flushAndReport(sink, stderr) {
-	return flushRunnerCommandSink(sink, (message) => stderr.write(`runner event flush failed: ${message}\n`));
-}
-function runValidatedRunnerCommand(schema, rawOptions, toEffect) {
-	const parsed = schema.safeParse(rawOptions);
+const isOutputStream = (value) => typeof value === "object" && value !== null && "write" in value && typeof value.write === "function";
+const flushAndReport = (sink, stderr) => flushRunnerCommandSink(sink, (message) => stderr.write(`runner event flush failed: ${message}\n`));
+const runValidatedRunnerCommand = async (schema, rawOptions, toEffect) => {
+	const parsed = parseResultWithSchema(schema, rawOptions, { onExcessProperty: "error" });
 	const stderr = rawOptions.stderr ?? process.stderr;
-	if (parsed.success) return Effect.runPromise(Effect.provide(toEffect(parsed.data, stderr), RunnerCommandIoServiceLive));
+	if (parsed.ok) return await Effect.runPromise(Effect.provide(toEffect(parsed.value, stderr), RunnerCommandIoServiceLive));
 	stderr.write(`${parsed.error.message}\n`);
-	return Promise.resolve(EXIT_VALIDATION);
-}
+	return EXIT_VALIDATION;
+};
 //#endregion
 export { RunnerCommandIoService, RunnerCommandIoServiceLive, createRunnerCommandEventSink, flushAndReport, isOutputStream, runValidatedRunnerCommand };

package/dist/runtime/services/runner-event-sink-http-service.js

@@ -4,8 +4,8 @@ import ky, { isHTTPError } from "ky";
 var EventSinkHttpError = class extends Data.TaggedError("EventSinkHttpError") {
 	constructor(status, message) {
 		super({
-			status,
-			message
+			message,
+			status
 		});
 	}
 };
@@ -26,42 +26,37 @@ const RETRYABLE_STATUS_CODES = [
 	511
 ];
 const REQUEST_TIMEOUT_MS = 1e4;
-function authHeaderName(request) {
-	return request.authHeader ?? "Authorization";
-}
-function httpErrorData(error) {
-	return formatHttpErrorData(isHTTPError(error) ? error.data : void 0);
-}
-function formatHttpErrorData(data) {
+const authHeaderName = (request) => request.authHeader ?? "Authorization";
+const formatHttpErrorData = (data) => {
 	if (typeof data === "string") return data;
 	return data === void 0 ? "" : JSON.stringify(data);
-}
-function toError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-function toHttpError(error) {
+};
+const httpErrorData = (error) => {
+	return formatHttpErrorData(isHTTPError(error) ? error.data : void 0);
+};
+const toError = (error) => error instanceof Error ? error : new Error(String(error));
+const toHttpError = (error) => {
 	const data = httpErrorData(error);
 	const status = isHTTPError(error) ? error.response.status : 0;
 	return new EventSinkHttpError(status, `Event sink responded with ${status}${data ? `: ${data}` : ""}`);
-}
-function mapPostError(error) {
-	return isHTTPError(error) ? toHttpError(error) : toError(error);
-}
-function kyFetchAdapter(fetchImpl) {
-	return async (input, init) => {
-		const request = new Request(input, init);
-		return fetchImpl(request.url, {
-			body: await request.clone().text(),
-			headers: request.headers,
-			method: request.method,
-			signal: request.signal
-		});
-	};
-}
-function postBatch(request) {
-	return Effect.tryPromise({
-		catch: mapPostError,
-		try: () => ky.post(request.url, {
+};
+const mapPostError = (error) => isHTTPError(error) ? toHttpError(error) : toError(error);
+const kyFetchAdapter = (fetchImpl) => async (input, init) => {
+	const request = new Request(input, init);
+	return await fetchImpl(request.url, {
+		body: await request.clone().text(),
+		headers: request.headers,
+		method: request.method,
+		signal: request.signal
+	});
+};
+const totalTimeoutMs = (request) => {
+	return (request.maxRetries + 1) * REQUEST_TIMEOUT_MS + request.maxRetries * request.retryDelayMs;
+};
+const postBatch = (request) => Effect.tryPromise({
+	catch: mapPostError,
+	try: async () => {
+		await ky.post(request.url, {
 			fetch: kyFetchAdapter(request.fetch),
 			headers: { [authHeaderName(request)]: `Bearer ${request.authToken}` },
 			json: { events: request.events },
@@ -74,12 +69,9 @@ function postBatch(request) {
 			},
 			timeout: REQUEST_TIMEOUT_MS,
 			totalTimeout: totalTimeoutMs(request)
-		}).then(() => void 0)
-	});
-}
-function totalTimeoutMs(request) {
-	return (request.maxRetries + 1) * REQUEST_TIMEOUT_MS + request.maxRetries * request.retryDelayMs;
-}
+		}).then(() => {});
+	}
+});
 var RunnerEventSinkHttpService = class extends Context.Service()("RunnerEventSinkHttpService") {};
 const RunnerEventSinkHttpServiceLive = Layer.succeed(RunnerEventSinkHttpService, { postBatch });
 //#endregion

package/dist/runtime/step/step-node.js

@@ -1,4 +1,5 @@
 import "../scheduler.js";
+import * as Option$2 from "effect/Option";
 import "effect";
 //#region src/runtime/step/step-node.ts
 /**
@@ -7,12 +8,10 @@ import "effect";
 * settled — a failed node is not re-emitted as ready, and a failed dependency
 * blocks its dependents via {@link computeReadyNodeIds}'s default check.
 */
-function collectStoredResults(input) {
-	return input.nodes.flatMap((node) => {
-		const record = input.store.get(input.runId, node.id);
-		return record ? [record.result] : [];
-	});
-}
+const collectStoredResults = (input) => input.nodes.flatMap((node) => {
+	const record = input.store.get(input.runId, node.id);
+	return Option$2.isSome(record) ? [record.value.result] : [];
+});
 /**
 * Build the {@link NextNodeEnvelope} for a SPECIFIC node — everything that node
 * needs to execute, made explicit and serializable. Returns `undefined` when the
@@ -20,34 +19,35 @@ function collectStoredResults(input) {
 * outputs of the node's direct `needs` — a failed upstream has no meaningful
 * output to hand the next executor. Pure: all store reads come from `input.store`.
 */
-function buildEnvelopeForNode(input, nodeId) {
+const buildEnvelopeForNodeOption = (input, nodeId) => {
 	const node = input.nodes.find((candidate) => candidate.id === nodeId);
-	if (node === void 0) return;
+	if (node === void 0) return Option$2.none();
 	const meta = input.nodeMetadata.get(nodeId);
 	const prompt = meta?.prompt ?? "";
 	const criteria = meta?.criteria ? [...meta.criteria] : [];
 	const passedByNodeId = new Map(collectStoredResults(input).filter((result) => result.status === "passed").map((result) => [result.nodeId, result]));
 	const upstreamOutputs = node.needs.flatMap((needId) => {
 		const result = passedByNodeId.get(needId);
-		return result ? [{
+		return result === void 0 ? [] : [{
 			nodeId: needId,
 			output: result.output
-		}] : [];
+		}];
 	});
-	return {
+	return Option$2.some({
 		criteria,
 		nodeId,
 		prompt,
 		runId: input.runId,
 		upstreamOutputs
-	};
-}
-function recordNodeResult(input) {
+	});
+};
+const buildEnvelopeForNode = (input, nodeId) => Option$2.getOrUndefined(buildEnvelopeForNodeOption(input, nodeId));
+const recordNodeResult = (input) => {
 	input.store.record(input.runId, input.result.nodeId, {
 		criteria: [],
 		inputs: void 0,
 		result: input.result
 	});
-}
+};
 //#endregion
 export { buildEnvelopeForNode, collectStoredResults, recordNodeResult };

package/dist/runtime/workflow-execution.js

@@ -9,76 +9,74 @@ import { LocalScheduler } from "./local-scheduler.js";
 import { workflowRuntimeResult } from "./runtime-results.js";
 import { executePlannedNode, isCancelled, markNodeReady, recordSkippedNodeState } from "./node-execution.js";
 import { hydrateDependencyOutputs, hydrateScheduledDependencyStates } from "./scheduled-dependencies.js";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 //#region src/runtime/workflow-execution.ts
-function runPipelineWithContext(context, dbUrl) {
-	return Effect.scoped(Effect.gen(function* () {
-		const scheduler = buildPipelineScheduler(context, yield* acquireRunJournal(context.runId, dbUrl));
-		return finishRuntime(context, yield* Effect.tryPromise(() => scheduler.runWorkflow(context.plan, context)));
-	}));
-}
-function resumeRunWithContext(context, dbUrl) {
-	return Effect.scoped(Effect.gen(function* () {
-		const journal = yield* acquireRunJournal(context.runId, dbUrl);
-		yield* requireResumableRun(context.runId, journal);
-		const scheduler = buildPipelineScheduler(context, journal);
-		return finishRuntime(context, yield* Effect.tryPromise(() => scheduler.runWorkflow(context.plan, context)));
-	}));
-}
-function executeScheduledWorkflowTaskWithContext(context, nodeId, dependencyOutputs) {
+const executeScheduledWorkflowTaskWithContext = (context, nodeId, dependencyOutputs) => {
 	hydrateScheduledDependencyStates(context, nodeId);
 	hydrateDependencyOutputs(context, dependencyOutputs);
 	markNodeReady(context, nodeId);
 	return executePlannedNode(nodeId, context);
-}
-function requireResumableRun(runId, journal) {
+};
+const requireResumableRun = (runId, journal) => {
 	if (journal === void 0) return Effect.fail(/* @__PURE__ */ new Error(`Cannot resume run '${runId ?? "<unknown>"}': no durable store is configured (set momokaya.db.url).`));
 	if (journal.resumeCompleted().length === 0) return Effect.fail(/* @__PURE__ */ new Error(`Cannot resume run '${runId}': no persisted node results were found in the durable store.`));
 	return Effect.void;
-}
-function buildPipelineScheduler(context, journal) {
-	return new LocalScheduler({
-		buildResult: (outcome, nodes, failure) => workflowRuntimeResult(context, outcome, nodes, failure),
-		emitWorkflowPlanned: (nextContext) => emitWorkflowPlanned(nextContext),
-		emitWorkflowStarted: (nextContext) => emitWorkflowStarted(nextContext),
-		executeNode: (nodeId, nextContext) => Effect.runPromise(executePlannedNode(nodeId, nextContext)),
-		isCancelled: (nextContext) => isCancelled(nextContext),
-		markNodeReady: (nodeId, nextContext) => markNodeReady(nextContext, nodeId),
-		resolveJournal: () => journal,
-		runWorkflowHook: (event, failure, nextContext) => Effect.runPromise(dispatchHooksEffect(nextContext, event, failure)),
-		shouldContinueAfterNodeResult: (result, nextContext) => shouldContinueAfterNodeResult(result, nextContext),
-		skipNode: (nodeId, reason, nextContext) => recordSkippedNodeState(nextContext, nodeId, reason)
-	});
-}
-function shouldContinueAfterNodeResult(result, context) {
-	if (result.status !== "failed") return true;
-	return isRecoverableParallelFailure(context.plan.graph.node(result.nodeId), result.output, context);
-}
-function isRecoverableParallelFailure(node, output, context) {
-	if (!isParallelWithChildren(node, output)) return false;
-	return hasOnlyDrainMergeDependents(node, context);
-}
-function isParallelWithChildren(node, output) {
+};
+const parallelOutputHasChildren = (output) => Object.keys(parseJsonObject(parseJsonObject(output).children)).length > 0;
+const isParallelWithChildren = (output, node) => {
 	if (!node) return false;
 	return node.kind === "parallel" ? parallelOutputHasChildren(output) : false;
-}
-function hasOnlyDrainMergeDependents(node, context) {
-	if (node.dependents.length === 0) return false;
-	return node.dependents.every((dependentId) => isDrainMergeNode(context.plan.graph.node(dependentId)));
-}
-function parallelOutputHasChildren(output) {
-	return Object.keys(parseJsonObject(parseJsonObject(output).children)).length > 0;
-}
-function isDrainMergeNode(node) {
+};
+const isDrainMergeNode = (node) => {
 	if (!node) return false;
 	return node.kind === "builtin" ? node.builtin === "drain-merge" : false;
-}
-function dispatchHooksEffect(...args) {
-	return Effect.tryPromise(() => dispatchHooks(...args));
-}
-function finishRuntime(context, result) {
+};
+const hasOnlyDrainMergeDependents = (node, context) => {
+	if (node.dependents.length === 0) return false;
+	return node.dependents.every((dependentId) => isDrainMergeNode(context.plan.graph.node(dependentId)));
+};
+const isRecoverableParallelFailure = (output, context, node) => {
+	if (!isParallelWithChildren(output, node)) return false;
+	return hasOnlyDrainMergeDependents(node, context);
+};
+const shouldContinueAfterNodeResult = (result, context) => {
+	if (result.status !== "failed") return true;
+	const node = context.plan.graph.node(result.nodeId);
+	return isRecoverableParallelFailure(result.output, context, node);
+};
+const dispatchHooksEffect = (...args) => Effect.tryPromise(async () => await dispatchHooks(...args)).pipe(Effect.map(Option.fromNullishOr));
+const buildPipelineScheduler = (context, journal) => new LocalScheduler({
+	buildResult: (outcome, nodes, failure) => workflowRuntimeResult(context, outcome, nodes, failure),
+	emitWorkflowPlanned: (nextContext) => {
+		emitWorkflowPlanned(nextContext);
+	},
+	emitWorkflowStarted: (nextContext) => {
+		emitWorkflowStarted(nextContext);
+	},
+	executeNode: async (nodeId, nextContext) => await Effect.runPromise(executePlannedNode(nodeId, nextContext)),
+	isCancelled: (nextContext) => isCancelled(nextContext),
+	markNodeReady: (nodeId, nextContext) => {
+		markNodeReady(nextContext, nodeId);
+	},
+	resolveJournal: () => Option.fromUndefinedOr(journal),
+	runWorkflowHook: async (event, nextContext, failure) => await Effect.runPromise(dispatchHooksEffect(nextContext, event, failure)),
+	shouldContinueAfterNodeResult: (result, nextContext) => shouldContinueAfterNodeResult(result, nextContext),
+	skipNode: (nodeId, reason, nextContext) => {
+		recordSkippedNodeState(nextContext, nodeId, reason);
+	}
+});
+const finishRuntime = (context, result) => {
 	emitWorkflowFinish(context, result.outcome);
 	return result;
-}
+};
+const skipRunValidation = () => Effect.void;
+const runWorkflowWithContext = (context, dbUrl, validateRun = skipRunValidation) => Effect.scoped(Effect.gen(function* effectBody() {
+	const journal = yield* acquireRunJournal(Option.fromUndefinedOr(context.runId), dbUrl);
+	yield* validateRun(journal);
+	const scheduler = buildPipelineScheduler(context, Option.getOrUndefined(journal));
+	return finishRuntime(context, yield* Effect.tryPromise(async () => await scheduler.runWorkflow(context.plan, context)));
+}));
+const runPipelineWithContext = (context, dbUrl) => runWorkflowWithContext(context, Option.fromUndefinedOr(dbUrl));
+const resumeRunWithContext = (context, dbUrl) => runWorkflowWithContext(context, Option.fromUndefinedOr(dbUrl), (journal) => requireResumableRun(context.runId, Option.getOrUndefined(journal)));
 //#endregion
 export { executeScheduledWorkflowTaskWithContext, resumeRunWithContext, runPipelineWithContext };