@oisincoveney/pipeline 3.15.0 → 3.15.1

package/dist/commands/bench-command.js

@@ -2,7 +2,7 @@ import { buildEvalReport, renderEvalReport } from "../bench/eval-report.js";
 import { Context, Effect, Layer } from "effect";
 import { readFileSync } from "node:fs";
 //#region src/commands/bench-command.ts
-var BenchCommandService = class extends Context.Tag("BenchCommandService")() {};
+var BenchCommandService = class extends Context.Service()("BenchCommandService") {};
 const BenchCommandServiceLive = Layer.succeed(BenchCommandService, {
 	readResults: (path) => Effect.try(() => JSON.parse(readFileSync(path, "utf8"))),
 	writeReport: (report) => Effect.try(() => process.stdout.write(`${report}\n`))

package/dist/commands/pipeline-command.js

@@ -12,7 +12,7 @@ const BUILTIN_PIPE_COMMANDS = new Set([
 	"runner-command",
 	"ticket"
 ]);
-var EntrypointCommandService = class extends Context.Tag("EntrypointCommandService")() {};
+var EntrypointCommandService = class extends Context.Service()("EntrypointCommandService") {};
 const createEntrypointCommandServiceLive = (runEntrypoint) => Layer.succeed(EntrypointCommandService, { runEntrypoint: (entrypoint, task, opts) => Effect.tryPromise({
 	catch: (error) => error,
 	try: () => runEntrypoint(entrypoint, task, opts)

package/dist/commands/runner-command-command.js

@@ -3,7 +3,7 @@ import { runRunnerFinalize } from "../runner-command/finalize.js";
 import { runRunnerLifecycle } from "../runner-command/lifecycle.js";
 import { Context, Effect, Layer } from "effect";
 //#region src/commands/runner-command-command.ts
-var RunnerCommandService = class extends Context.Tag("RunnerCommandService")() {};
+var RunnerCommandService = class extends Context.Service()("RunnerCommandService") {};
 const RunnerCommandServiceLive = Layer.succeed(RunnerCommandService, {
 	finalize: (options) => Effect.tryPromise({
 		catch: (error) => error,

package/dist/config/schemas.d.ts

@@ -99,10 +99,10 @@ declare const workflowNodeBaseSchema: z.ZodObject<{
   models: z.ZodOptional<z.ZodArray<z.ZodString>>;
   needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
   reasoning_effort: z.ZodOptional<z.ZodEnum<{
-    none: "none";
-    low: "low";
-    medium: "medium";
     high: "high";
+    medium: "medium";
+    low: "low";
+    none: "none";
     xhigh: "xhigh";
   }>>;
   retries: z.ZodOptional<z.ZodObject<{
@@ -233,8 +233,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        deny: "deny";
         "trusted-only": "trusted-only";
+        deny: "deny";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -262,8 +262,8 @@ declare const configSchema: z.ZodObject<{
       global: "global";
     }>>;
     mode: z.ZodEnum<{
-      local: "local";
       hosted: "hosted";
+      local: "local";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -307,10 +307,10 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>;
     output: z.ZodOptional<z.ZodObject<{
       format: z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>;
       repair: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -320,10 +320,10 @@ declare const configSchema: z.ZodObject<{
       schema_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     reasoning_effort: z.ZodOptional<z.ZodEnum<{
-      none: "none";
-      low: "low";
-      medium: "medium";
       high: "high";
+      medium: "medium";
+      low: "low";
+      none: "none";
       xhigh: "xhigh";
     }>>;
     rules: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -386,10 +386,10 @@ declare const configSchema: z.ZodObject<{
         disabled: "disabled";
       }>>>;
       output_formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>>>;
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
@@ -408,10 +408,10 @@ declare const configSchema: z.ZodObject<{
     host_models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     model: z.ZodOptional<z.ZodString>;
     reasoning_effort: z.ZodOptional<z.ZodEnum<{
-      none: "none";
-      low: "low";
-      medium: "medium";
       high: "high";
+      medium: "medium";
+      low: "low";
+      none: "none";
       xhigh: "xhigh";
     }>>;
     type: z.ZodEnum<{
@@ -497,10 +497,10 @@ declare const configSchema: z.ZodObject<{
         models: z.ZodArray<z.ZodString>;
         profile: z.ZodString;
         reasoning_effort: z.ZodOptional<z.ZodEnum<{
-          none: "none";
-          low: "low";
-          medium: "medium";
           high: "high";
+          medium: "medium";
+          low: "low";
+          none: "none";
           xhigh: "xhigh";
         }>>;
       }, z.core.$strict>>>;
@@ -510,8 +510,8 @@ declare const configSchema: z.ZodObject<{
   schedules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     baseline: z.ZodEnum<{
-      execute: "execute";
       quick: "quick";
+      execute: "execute";
     }>;
     max_parallel_nodes: z.ZodOptional<z.ZodNumber>;
     node_catalog: z.ZodOptional<z.ZodString>;

package/dist/loop/argo-poll.js

@@ -104,18 +104,18 @@ function pollLoop(state) {
 		workflowReadApi: state.workflowReadApi
 	}).pipe(Effect.flatMap((phase) => {
 		if (isTerminal(phase)) return Effect.succeed(phase);
-		return Effect.sleep(Duration.millis(state.pollIntervalMs)).pipe(Effect.zipRight(pollLoop({
+		return Effect.sleep(Duration.millis(state.pollIntervalMs)).pipe(Effect.andThen(pollLoop({
 			...state,
 			errorCount: 0
 		})));
-	}), Effect.catchAll((error) => handlePollError(state, error)));
+	}), Effect.catch((error) => handlePollError(state, error)));
 }
 function handlePollError(state, error) {
 	const nextErrorCount = state.errorCount + 1;
 	state.onTransientError?.(error, nextErrorCount);
 	if (nextErrorCount > state.maxRetries) return Effect.fail(error);
 	const delay = Duration.millis(RETRY_BASE_DELAY_MS * 2 ** (nextErrorCount - 1));
-	return Effect.sleep(delay).pipe(Effect.zipRight(pollLoop({
+	return Effect.sleep(delay).pipe(Effect.andThen(pollLoop({
 		...state,
 		errorCount: nextErrorCount
 	})));

package/dist/loop/merge.js

@@ -49,7 +49,7 @@ function enableAutoMerge(pr, gh) {
 	return gh.text(args).pipe(Effect.map(() => ({
 		_tag: "pending",
 		pr: pr.number
-	})), Effect.catchAll((error) => Effect.succeed(toBlocked(pr, error))));
+	})), Effect.catch((error) => Effect.succeed(toBlocked(pr, error))));
 }
 /**
 * Admin-merge through branch protection using the bypass token. The token is
@@ -71,7 +71,7 @@ function adminMerge(pr, token, gh) {
 	return gh.text(args, { secretEnv: { GH_TOKEN: token.reveal() } }).pipe(Effect.map(() => ({
 		_tag: "merged",
 		pr: pr.number
-	})), Effect.catchAll((error) => Effect.succeed(toBlocked(pr, error))));
+	})), Effect.catch((error) => Effect.succeed(toBlocked(pr, error))));
 }
 function toBlocked(pr, error) {
 	const message = error instanceof Error ? error.message : String(error);

package/dist/mcp/gateway.js

@@ -188,7 +188,7 @@ function checkGatewayRequiredTools(gateway) {
 			name: "gateway-required-tools",
 			passed: false
 		};
-	}).pipe(Effect.catchAll((error) => Effect.succeed({
+	}).pipe(Effect.catch((error) => Effect.succeed({
 		detail: error instanceof Error ? error.message : String(error),
 		name: "gateway-required-tools",
 		passed: false
@@ -317,7 +317,7 @@ function checkThv(cwd) {
 			name: "toolhive",
 			passed: true
 		};
-	}).pipe(Effect.catchAll((error) => Effect.succeed({
+	}).pipe(Effect.catch((error) => Effect.succeed({
 		detail: error.message || "not available",
 		name: "toolhive",
 		passed: false
@@ -342,7 +342,7 @@ function checkGatewayHealth(gateway) {
 			name: "gateway-health",
 			passed
 		};
-	}).pipe(Effect.catchAll((error) => Effect.succeed({
+	}).pipe(Effect.catch((error) => Effect.succeed({
 		detail: error instanceof Error ? error.message : String(error),
 		name: "gateway-health",
 		passed: false

package/dist/moka-submit.d.ts

@@ -6,13 +6,13 @@ import { z } from "zod";
 //#region src/moka-submit.d.ts
 declare const mokaSubmitDirectHooksSchema: z.ZodRecord<z.ZodEnum<{
   "workflow.start": "workflow.start";
+  "node.finish": "node.finish";
+  "node.start": "node.start";
   "workflow.success": "workflow.success";
   "workflow.failure": "workflow.failure";
   "workflow.complete": "workflow.complete";
-  "node.start": "node.start";
   "node.success": "node.success";
   "node.error": "node.error";
-  "node.finish": "node.finish";
   "gate.failure": "gate.failure";
 }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
   failure: z.ZodDefault<z.ZodEnum<{
@@ -99,13 +99,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -170,8 +170,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodOptional<z.ZodString>;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
   schedulePath: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodOptional<z.ZodString>;
@@ -220,13 +220,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{

package/dist/pipeline-runtime.js

@@ -28,6 +28,7 @@ import { NodeStateTracker } from "./runtime/node-state-tracker.js";
 import { configUsesOpencode, leaseOpencodeRuntime } from "./runtime/opencode-runtime.js";
 import { executeParallelNode } from "./runtime/parallel-node/parallel-node.js";
 import "./runtime/parallel-node/index.js";
+import { remediateFailedNode } from "./runtime/remediation/remediation.js";
 import { decideNodeRetry, nodeRetryPolicy } from "./runtime/retry.js";
 import { Effect } from "effect";
 //#region src/pipeline-runtime.ts
@@ -192,6 +193,18 @@ function executePlannedNode(nodeId, context) {
 function dispatchHooksEffect(...args) {
 	return Effect.tryPromise(() => dispatchHooks(...args));
 }
+const runtimeRemediationDependencies = {
+	executeNode: executeReadyNode,
+	isCancelled,
+	snapshotChangedFiles: snapshotChangedFilesEffect
+};
+function executeReadyNode(node, context) {
+	recordNodeEvent(context, node.id, {
+		at: now(),
+		type: "READY"
+	});
+	return executeNode(node, context);
+}
 function plannedNodeById(context, nodeId) {
 	return context.plan.graph.node(nodeId) ?? findPlannedNode(context.plan.topologicalOrder, nodeId);
 }
@@ -418,7 +431,7 @@ function runSingleNodeAttempt(node, context, retryPolicy, state, attempt) {
 	});
 }
 function nodeAttemptCycleOrError(node, context, attempt, last) {
-	return Effect.catchAll(executeNodeAttemptCycle(node, context, attempt, last), (error) => Effect.succeed({ error }));
+	return Effect.catch(executeNodeAttemptCycle(node, context, attempt, last), (error) => Effect.succeed({ error }));
 }
 function continueAfterAttemptCycle(node, context, retryPolicy, state, attempt, cycle) {
 	if (cycle.result) {
@@ -433,6 +446,7 @@ function continueAfterRetryCandidate(node, context, retryPolicy, retry, attempt)
 		const remediation = yield* remediateFailedNode({
 			attempt,
 			context,
+			dependencies: runtimeRemediationDependencies,
 			node,
 			retry
 		});
@@ -441,10 +455,25 @@ function continueAfterRetryCandidate(node, context, retryPolicy, retry, attempt)
 			emitRemediationPass(context, node.id, passed);
 			return passed;
 		}
-		if (remediationRequestsRetry(remediation)) return "retry";
+		if (remediationRequestsRetry(remediation)) {
+			recordRemediationRetryingNodeEvent(context, node.id, attempt, retry);
+			return "retry";
+		}
 		return yield* scheduleNodeRetry(node, context, retryPolicy, retry, attempt);
 	});
 }
+function recordRemediationRetryingNodeEvent(context, nodeId, attempt, retry) {
+	recordRetryingNodeEvent(context, nodeId, attempt, retry, {
+		attempt,
+		delayMs: 0,
+		evidence: retry.evidence,
+		exhausted: false,
+		gate: retry.gate,
+		reason: retry.reason,
+		retryReason: retry.retryReason,
+		scheduled: true
+	});
+}
 function remediationPassedResult(remediation) {
 	if (!remediation) return null;
 	return remediation.result ?? null;
@@ -562,242 +591,13 @@ function emitRuntimeRetry(context, nodeId, retry, reason) {
 		type: retry.scheduled ? "runtime.retry.scheduled" : "runtime.retry.exhausted"
 	});
 }
-function remediateFailedNode(input) {
-	return Effect.gen(function* () {
-		const selfRemediation = yield* remediateWritableNodeFailure(input);
-		if (selfRemediation) return { result: selfRemediation };
-		if (yield* remediateCoverageFailure(input)) return { retryNode: true };
-		if (yield* remediateUpstreamImplementationFailure(input)) return { retryNode: true };
-		return null;
-	});
-}
-function remediateWritableNodeFailure(input) {
-	return Effect.gen(function* () {
-		if (!canSelfRemediateWritableNode(input)) return null;
-		const beforeSnapshot = yield* snapshotChangedFilesEffect(input.context.worktreePath);
-		const beforeOutput = input.context.nodeStateStore.getOutput(input.node.id);
-		const result = yield* executeSelfRemediation(input);
-		if (result.status !== "passed") return null;
-		const changed = diffChangedFiles(beforeSnapshot, yield* snapshotChangedFilesEffect(input.context.worktreePath), input.context.worktreePath);
-		if (remediationChangedNothing(changed.files.size, result, beforeOutput)) return null;
-		input.context.nodeStateStore.setSnapshot(input.node.id, changed);
-		input.context.nodeStateStore.recordOutput(input.node.id, result.output);
-		return {
-			attempts: input.attempt + 1,
-			evidence: result.evidence,
-			exitCode: result.exitCode,
-			nodeId: input.node.id,
-			output: result.output,
-			status: "passed"
-		};
-	});
-}
-function canSelfRemediateWritableNode(input) {
-	if (input.retry.retryReason !== "gate_failure") return false;
-	if (isRemediationNode(input.node)) return false;
-	return nodeCanWrite(input.context, input.node);
-}
-function remediationChangedNothing(changedFileCount, result, beforeOutput) {
-	if (changedFileCount !== 0) return false;
-	return result.output === beforeOutput;
-}
-function executeSelfRemediation(input) {
-	return Effect.gen(function* () {
-		const node = {
-			...input.node,
-			artifacts: void 0,
-			dependents: [],
-			id: `${input.node.id}:remediate:${input.retry.gate}:${input.attempt}`,
-			needs: [],
-			retries: void 0
-		};
-		const originalTask = input.context.task;
-		input.context.task = nodeRemediationTask({
-			node: input.node,
-			originalTask,
-			retry: input.retry
-		});
-		return yield* Effect.ensuring(executeNode(node, input.context), Effect.sync(() => {
-			input.context.task = originalTask;
-		}));
-	});
-}
-function remediateCoverageFailure(input) {
-	if (input.retry.retryReason !== "gate_failure" || !hasSchedulingRole(input.context, input.node, "coverage")) return Effect.succeed(false);
-	return remediatePassedImplementationAncestors(input);
-}
-function remediateUpstreamImplementationFailure(input) {
-	if (isRemediationNode(input.node) || nodeCanWrite(input.context, input.node) || hasSchedulingRole(input.context, input.node, "coverage")) return Effect.succeed(false);
-	return remediatePassedImplementationAncestors(input);
-}
-function remediatePassedImplementationAncestors(input) {
-	return Effect.gen(function* () {
-		const implementationNodes = upstreamImplementationNodes(input.context, input.node);
-		if (implementationNodes.length === 0) return false;
-		let remediated = false;
-		for (const implementationNode of implementationNodes) if (yield* remediateImplementationAncestor(input, implementationNode)) remediated = true;
-		return remediated;
-	});
-}
-function remediateImplementationAncestor(input, implementationNode) {
-	return Effect.gen(function* () {
-		if (isCancelled(input.context)) return false;
-		const beforeSnapshot = yield* snapshotChangedFilesEffect(input.context.worktreePath);
-		const beforeOutput = input.context.nodeStateStore.getOutput(implementationNode.id);
-		const result = yield* executeImplementationRemediation({
-			attempt: input.attempt,
-			context: input.context,
-			coverageNode: input.node,
-			implementationNode,
-			retry: input.retry
-		});
-		if (result.status !== "passed") return false;
-		return yield* recordImplementationRemediationEffect({
-			beforeOutput,
-			beforeSnapshot,
-			context: input.context,
-			implementationNode,
-			result
-		});
-	});
-}
-function recordImplementationRemediationEffect(input) {
-	return Effect.gen(function* () {
-		if (diffChangedFiles(input.beforeSnapshot, yield* snapshotChangedFilesEffect(input.context.worktreePath), input.context.worktreePath).files.size === 0 && input.result.output === input.beforeOutput) return false;
-		input.context.nodeStateStore.recordOutput(input.implementationNode.id, input.result.output);
-		return true;
-	});
-}
-function executeImplementationRemediation(input) {
-	return Effect.gen(function* () {
-		const node = {
-			...input.implementationNode,
-			artifacts: void 0,
-			dependents: [],
-			gates: void 0,
-			id: `${input.implementationNode.id}:remediate:${input.coverageNode.id}:${input.attempt}`,
-			needs: [],
-			retries: void 0
-		};
-		const originalTask = input.context.task;
-		input.context.task = remediationTask({
-			coverageNode: input.coverageNode,
-			originalTask,
-			retry: input.retry
-		});
-		return yield* Effect.ensuring(executeNode(node, input.context), Effect.sync(() => {
-			input.context.task = originalTask;
-		}));
-	});
-}
-function remediationTask(input) {
-	return [
-		"Remediate a pipeline coverage failure.",
-		"",
-		"Original task:",
-		input.originalTask,
-		"",
-		"Coverage node:",
-		input.coverageNode.id,
-		"",
-		"Failed gate:",
-		input.retry.gate,
-		"",
-		"Failure reason:",
-		input.retry.reason,
-		"",
-		"Coverage failure feedback:",
-		...input.retry.evidence.map((item) => `- ${item}`),
-		"",
-		"Update the implementation so the coverage node can pass on its next run."
-	].join("\n");
-}
-function nodeCanWrite(context, node) {
-	const profileId = node.profile;
-	if (!profileId) return false;
-	return profileCanWrite(context.config.profiles[profileId]);
-}
-function profileCanWrite(profile) {
-	if (!profile) return false;
-	return hasWorkspaceWriteMode(profile) ? true : hasWriteTool(profile.tools ?? []);
-}
-function hasWorkspaceWriteMode(profile) {
-	return profile.filesystem?.mode === "workspace-write";
-}
-function hasWriteTool(tools) {
-	return tools.some(isWriteTool);
-}
-function isWriteTool(tool) {
-	return tool === "edit" ? true : tool === "write";
-}
-function isRemediationNode(node) {
-	return node.id.includes(":remediate:");
-}
-function nodeRemediationTask(input) {
-	return [
-		"Remediate a pipeline node gate failure.",
-		"",
-		"Original task:",
-		input.originalTask,
-		"",
-		"Node:",
-		input.node.id,
-		"",
-		"Failed gate:",
-		input.retry.gate,
-		"",
-		"Failure reason:",
-		input.retry.reason,
-		"",
-		"Gate failure feedback:",
-		...input.retry.evidence.map((item) => `- ${item}`),
-		"",
-		"Update the node output and files so this gate can pass."
-	].join("\n");
-}
-function upstreamImplementationNodes(context, node) {
-	const visited = /* @__PURE__ */ new Set();
-	const ordered = [];
-	const visit = (candidateId) => visitImplementationNode(context, visited, ordered, candidateId, visit);
-	for (const need of node.needs) visit(need);
-	return ordered;
-}
-function visitImplementationNode(context, visited, ordered, nodeId, visit) {
-	if (visited.has(nodeId)) return;
-	visited.add(nodeId);
-	const candidate = context.plan.graph.node(nodeId);
-	if (!candidate) return;
-	visitImplementationDependencies(candidate, visit);
-	appendImplementationNode(context, ordered, candidate);
-}
-function visitImplementationDependencies(candidate, visit) {
-	for (const need of candidate.needs) visit(need);
-}
-function appendImplementationNode(context, ordered, candidate) {
-	if (!nodeStatePassed(context, candidate.id)) return;
-	pushIfImplementation(context, ordered, candidate);
-	for (const child of candidate.children ?? []) appendPassedImplementationChild(context, ordered, child);
-}
-function appendPassedImplementationChild(context, ordered, child) {
-	pushIfImplementation(context, ordered, child);
-	for (const grandchild of child.children ?? []) appendPassedImplementationChild(context, ordered, grandchild);
-}
-function pushIfImplementation(context, ordered, node) {
-	if (hasSchedulingRole(context, node, "implementation")) ordered.push(node);
-}
-function nodeStatePassed(context, nodeId) {
-	return context.nodeStateStore.getNodeState(nodeId)?.status === "passed";
-}
-function hasSchedulingRole(context, node, role) {
-	return node.profile ? context.config.profiles[node.profile]?.scheduling_roles?.includes(role) ?? false : false;
-}
 function waitForRetryDelay(delayMs, signal) {
 	if (delayMs <= 0 || signal?.aborted) return Effect.void;
 	return Effect.race(Effect.sleep(delayMs), waitForAbort(signal));
 }
 function waitForAbort(signal) {
 	if (!signal) return Effect.never;
-	return Effect.async((resume) => {
+	return Effect.callback((resume) => {
 		const onAbort = () => resume(Effect.void);
 		signal.addEventListener("abort", onAbort, { once: true });
 		return Effect.sync(() => signal.removeEventListener("abort", onAbort));