@smithers-orchestrator/components 0.16.0

package/src/components/Task.js

@@ -0,0 +1,319 @@
+// @smithers-type-exports-begin
+/**
+ * @template D
+ * @typedef {import("./InferDeps.ts").InferDeps<D>} InferDeps
+ */
+/** @typedef {import("./OutputTarget.ts").OutputTarget} OutputTarget */
+// @smithers-type-exports-end
+
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { markdownComponents } from "../markdownComponents.js";
+import { zodSchemaToJsonExample } from "../zod-to-example.js";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { SmithersContext } from "@smithers-orchestrator/react-reconciler/context";
+import { AspectContext } from "../aspects/AspectContext.js";
+import { ClaudeCodeAgent } from "@smithers-orchestrator/agents/ClaudeCodeAgent";
+import { GeminiAgent } from "@smithers-orchestrator/agents/GeminiAgent";
+import { PiAgent } from "@smithers-orchestrator/agents/PiAgent";
+/** @typedef {import("@smithers-orchestrator/agents/AgentLike").AgentLike} AgentLike */
+/** @typedef {import("./DepsSpec.ts").DepsSpec} DepsSpec */
+/**
+ * @template Row, Output, D
+ * @typedef {import("./TaskProps.ts").TaskProps<Row, Output, D>} TaskProps
+ */
+
+/**
+ * Render a prompt React node to plain markdown text.
+ *
+ * If the prompt is a React element (e.g. a compiled MDX component), we inject
+ * `markdownComponents` via the standard MDX `components` prop so that
+ * renderToStaticMarkup outputs clean markdown instead of HTML.
+ * No HTML tag stripping or entity decoding needed.
+ * @param {unknown} prompt
+ * @returns {string}
+ */
+export function renderPromptToText(prompt) {
+    if (prompt == null)
+        return "";
+    if (typeof prompt === "string")
+        return prompt;
+    if (typeof prompt === "number")
+        return String(prompt);
+    try {
+        let element;
+        if (React.isValidElement(prompt)) {
+            // Inject markdown components into the element so MDX components
+            // render fragments instead of HTML tags.
+            element = React.cloneElement(prompt, {
+                components: markdownComponents,
+            });
+        }
+        else {
+            element = React.createElement(React.Fragment, null, prompt);
+        }
+        return renderToStaticMarkup(element)
+            .replace(/\n{3,}/g, "\n\n")
+            .trim();
+    }
+    catch (err) {
+        const result = String(prompt ?? "");
+        if (result === "[object Object]") {
+            throw new SmithersError("MDX_PRELOAD_INACTIVE", `MDX prompt could not be rendered — the prompt resolved to [object Object] instead of a React component.\n\n` +
+                `This usually means the MDX preload is not active. Common causes:\n` +
+                `  • bunfig.toml uses [run] preload instead of top-level preload (the [run] section doesn't apply to dynamic imports)\n` +
+                `  • bunfig.toml is not in the current working directory\n` +
+                `  • mdxPlugin() is not registered in the preload script\n` +
+                `  • The MDX file is imported without a default import (use: import MyPrompt from "./prompt.mdx")\n\n` +
+                `Original error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return result;
+    }
+}
+/**
+ * @param {unknown} value
+ * @returns {value is import("zod").ZodObject<import("zod").ZodRawShape>}
+ */
+function isZodObject(value) {
+    return Boolean(value && typeof value === "object" && "shape" in value);
+}
+/**
+ * @param {DepsSpec | undefined} deps
+ * @param {Record<string, string> | undefined} needs
+ * @returns {string[] | undefined}
+ */
+function deriveDepNodeIds(deps, needs) {
+    if (!deps)
+        return undefined;
+    const ids = new Set();
+    for (const key of Object.keys(deps)) {
+        const nodeId = needs?.[key] ?? key;
+        if (nodeId)
+            ids.add(nodeId);
+    }
+    return ids.size > 0 ? [...ids] : undefined;
+}
+/**
+ * @param {string[] | undefined} dependsOn
+ * @param {string[] | undefined} depNodeIds
+ * @returns {string[] | undefined}
+ */
+function mergeDependsOn(dependsOn, depNodeIds) {
+    const merged = new Set();
+    for (const id of dependsOn ?? [])
+        merged.add(id);
+    for (const id of depNodeIds ?? [])
+        merged.add(id);
+    return merged.size > 0 ? [...merged] : undefined;
+}
+/**
+ * @param {any} ctx
+ * @param {DepsSpec | undefined} deps
+ * @param {Record<string, string> | undefined} needs
+ * @param {string} [taskId]
+ * @returns {Record<string, unknown> | null}
+ */
+function resolveDeps(ctx, deps, needs, taskId) {
+    if (!deps)
+        return Object.create(null);
+    const keys = Object.keys(deps);
+    if (keys.length === 0)
+        return Object.create(null);
+    const resolved = Object.create(null);
+    for (const key of keys) {
+        const target = deps[key];
+        const nodeId = needs?.[key] ?? key;
+        const value = ctx.outputMaybe(target, { nodeId });
+        if (value === undefined)
+            return null;
+        resolved[key] = value;
+    }
+    return resolved;
+}
+/**
+ * Validate that all deps are satisfied. Throws a descriptive SmithersError
+ * naming which dep is missing and which task needs it.
+ * @param {{ outputMaybe: (target: unknown, opts: { nodeId: string }) => unknown }} ctx
+ * @param {DepsSpec} deps
+ * @param {Record<string, string> | undefined} needs
+ * @param {string} [taskId]
+ * @returns {void}
+ */
+function validateDeps(ctx, deps, needs, taskId) {
+    for (const key of Object.keys(deps)) {
+        const target = deps[key];
+        const nodeId = needs?.[key] ?? key;
+        const value = ctx.outputMaybe(target, { nodeId });
+        if (value === undefined) {
+            throw new SmithersError("DEP_NOT_SATISFIED", `Task "${taskId}" dependency "${key}" (resolved from node "${nodeId}") is not satisfied. ` +
+                `The upstream task must complete and produce output before this task can run.`, { taskId, depKey: key, resolvedNodeId: nodeId });
+        }
+    }
+}
+/**
+ * @param {AgentLike} agent
+ * @param {string[] | undefined} allowTools
+ * @returns {AgentLike}
+ */
+function applyCliToolAllowlist(agent, allowTools) {
+    if (!allowTools) {
+        return agent;
+    }
+    if (agent instanceof ClaudeCodeAgent) {
+        const opts = { ...agent.opts };
+        if (allowTools.length === 0) {
+            return new ClaudeCodeAgent({
+                ...opts,
+                allowedTools: [],
+                tools: "",
+            });
+        }
+        return new ClaudeCodeAgent({
+            ...opts,
+            allowedTools: [...allowTools],
+        });
+    }
+    if (agent instanceof PiAgent) {
+        const opts = { ...agent.opts };
+        if (allowTools.length === 0) {
+            return new PiAgent({
+                ...opts,
+                tools: [],
+                noTools: true,
+            });
+        }
+        return new PiAgent({
+            ...opts,
+            tools: [...allowTools],
+            noTools: false,
+        });
+    }
+    if (agent instanceof GeminiAgent) {
+        const opts = { ...agent.opts };
+        return new GeminiAgent({
+            ...opts,
+            allowedTools: [...allowTools],
+        });
+    }
+    return agent;
+}
+/**
+ * @param {unknown} ctx
+ * @param {string[] | undefined} allowTools
+ * @returns {string[] | undefined}
+ */
+function resolveCliToolAllowlist(ctx, allowTools) {
+    if (allowTools !== undefined) {
+        return allowTools;
+    }
+    const cliAgentToolsDefault = ctx && typeof ctx === "object"
+        ? ctx.__smithersRuntime?.cliAgentToolsDefault
+        : undefined;
+    return cliAgentToolsDefault === "explicit-only" ? [] : undefined;
+}
+/**
+ * @template Row, Output, D
+ * @param {TaskProps<Row, Output, D>} props
+ * @returns {React.ReactElement | null}
+ */
+export function Task(props) {
+    const { children, agent, fallbackAgent, deps, ...rest } = props;
+    const taskContext = props.smithersContext ?? SmithersContext;
+    const ctx = React.useContext(taskContext);
+    const aspectCtx = React.useContext(AspectContext);
+    const depNodeIds = deriveDepNodeIds(deps, rest.needs);
+    if (deps && !ctx) {
+        throw new SmithersError("CONTEXT_OUTSIDE_WORKFLOW", "Task deps require a workflow context. Build the workflow with createSmithers().");
+    }
+    const resolvedDeps = deps ? resolveDeps(ctx, deps, rest.needs, rest.id) : undefined;
+    if (deps && resolvedDeps == null) {
+        // Deps not yet available — component defers until upstream tasks complete.
+        // This is normal reactive behavior; the task will re-render once deps are ready.
+        return null;
+    }
+    // Build aspect metadata to attach to the task element so the engine can
+    // enforce budgets and tracking at execution time.
+    const aspectMeta = aspectCtx ? buildAspectMeta(aspectCtx) : undefined;
+    const agentChain = Array.isArray(agent)
+        ? fallbackAgent
+            ? [...agent, fallbackAgent]
+            : agent
+        : agent && fallbackAgent
+            ? [agent, fallbackAgent]
+            : agent;
+    const effectiveAllowTools = resolveCliToolAllowlist(ctx, rest.allowTools);
+    const restrictedAgentChain = Array.isArray(agentChain)
+        ? agentChain.map((entry) => applyCliToolAllowlist(entry, effectiveAllowTools))
+        : agentChain
+            ? applyCliToolAllowlist(agentChain, effectiveAllowTools)
+            : agentChain;
+    const nextDependsOn = mergeDependsOn(rest.dependsOn, depNodeIds);
+    const childValue = typeof children === "function" && (agent || deps)
+        ? children(resolvedDeps ?? Object.create(null))
+        : children;
+    if (agent) {
+        // Auto-inject `schema` prop into React element children when output is a ZodObject
+        let childElement = childValue;
+        const schemaForInjection = props.outputSchema ??
+            (isZodObject(props.output) ? props.output : undefined);
+        if (React.isValidElement(childValue) && schemaForInjection) {
+            childElement = React.cloneElement(childValue, {
+                schema: zodSchemaToJsonExample(schemaForInjection),
+            });
+        }
+        const prompt = renderPromptToText(childElement);
+        return React.createElement("smithers:task", {
+            ...rest,
+            dependsOn: nextDependsOn,
+            waitAsync: rest.async === true,
+            agent: restrictedAgentChain,
+            __smithersKind: "agent",
+            ...aspectMeta,
+        }, prompt);
+    }
+    if (typeof children === "function" && !deps) {
+        const nextProps = {
+            ...rest,
+            dependsOn: nextDependsOn,
+            waitAsync: rest.async === true,
+            __smithersKind: "compute",
+            __smithersComputeFn: children,
+            ...aspectMeta,
+        };
+        return React.createElement("smithers:task", nextProps, null);
+    }
+    const nextProps = {
+        ...rest,
+        dependsOn: nextDependsOn,
+        waitAsync: rest.async === true,
+        __smithersKind: "static",
+        __smithersPayload: childValue,
+        __payload: childValue,
+        ...aspectMeta,
+    };
+    return React.createElement("smithers:task", nextProps, null);
+}
+/**
+ * Build the __aspects metadata object from the current AspectContext.
+ * This is attached to the smithers:task element props so the engine
+ * can read budgets and tracking config at execution time.
+ * @param {{
+ *     tokenBudget?: unknown;
+ *     latencySlo?: unknown;
+ *     costBudget?: unknown;
+ *     tracking?: unknown;
+ *     accumulator?: unknown;
+ * }} aspectCtx
+ * @returns {{ __aspects: Record<string, unknown> }}
+ */
+function buildAspectMeta(aspectCtx) {
+    return {
+        __aspects: {
+            tokenBudget: aspectCtx.tokenBudget,
+            latencySlo: aspectCtx.latencySlo,
+            costBudget: aspectCtx.costBudget,
+            tracking: aspectCtx.tracking,
+            accumulator: aspectCtx.accumulator,
+        },
+    };
+}

package/src/components/TaskProps.ts

@@ -0,0 +1,57 @@
+import type React from "react";
+import type { z } from "zod";
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { SmithersCtx } from "@smithers-orchestrator/driver";
+import type { CachePolicy } from "@smithers-orchestrator/scheduler/CachePolicy";
+import type { RetryPolicy } from "@smithers-orchestrator/scheduler/RetryPolicy";
+import type { ScorersMap } from "@smithers-orchestrator/scorers/types";
+import type { TaskMemoryConfig } from "@smithers-orchestrator/memory/types";
+import type { OutputTarget } from "./OutputTarget.ts";
+import type { DepsSpec } from "./DepsSpec.ts";
+import type { InferDeps } from "./InferDeps.ts";
+
+export type TaskProps<Row, Output extends OutputTarget = OutputTarget, D extends DepsSpec = {}> = {
+	key?: string;
+	id: string;
+	/** Where to store the task's result. Pass a Zod schema from `outputs` (recommended), a Drizzle table, or a string key. */
+	output: Output;
+	/**
+	 * Optional Zod schema describing the expected agent output shape.
+	 * When `output` is already a ZodObject this is inferred automatically.
+	 * Used for validation and to inject schema examples into MDX prompts.
+	 */
+	outputSchema?: z.ZodObject<z.ZodRawShape>;
+	/** Agent or array of agents [primary, fallback1, fallback2, ...]. Tries in order on retries. */
+	agent?: AgentLike | AgentLike[];
+	/** Convenience alias for a single retry fallback without exposing array syntax in JSX. */
+	fallbackAgent?: AgentLike;
+	/** Explicit dependency on other task node IDs. The task will not run until all listed tasks complete. */
+	dependsOn?: string[];
+	/** Named dependencies on other tasks. Keys become context keys, values are task node IDs. */
+	needs?: Record<string, string>;
+	/** Render-time typed dependencies. Keys resolve from task ids of the same name, or from matching `needs` entries. */
+	deps?: D;
+	skipIf?: boolean;
+	needsApproval?: boolean;
+	/** When paired with `needsApproval`, do not block unrelated downstream flow while the approval is pending. */
+	async?: boolean;
+	timeoutMs?: number;
+	heartbeatTimeoutMs?: number;
+	heartbeatTimeout?: number;
+	/** Disable retries entirely. Equivalent to retries={0}. */
+	noRetry?: boolean;
+	retries?: number;
+	retryPolicy?: RetryPolicy;
+	continueOnFail?: boolean;
+	cache?: CachePolicy;
+	/** Optional scorers to evaluate this task's output after completion. */
+	scorers?: ScorersMap;
+	/** Optional cross-run memory configuration. */
+	memory?: TaskMemoryConfig;
+	allowTools?: string[];
+	label?: string;
+	meta?: Record<string, unknown>;
+	/** @internal Used by createSmithers() to bind tasks to the correct workflow context. */
+	smithersContext?: React.Context<SmithersCtx<unknown> | null>;
+	children?: string | Row | (() => Row | Promise<Row>) | React.ReactNode | ((deps: InferDeps<D>) => Row | React.ReactNode);
+};

package/src/components/Timer.js

@@ -0,0 +1,42 @@
+import React from "react";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+/** @typedef {import("./TimerProps.ts").TimerProps} TimerProps */
+
+/**
+ * @param {TimerProps} props
+ */
+export function Timer(props) {
+    if (props.skipIf)
+        return null;
+    const hasDuration = typeof props.duration === "string" && props.duration.trim().length > 0;
+    const hasUntil = props.until !== undefined && props.until !== null && String(props.until).trim().length > 0;
+    if ((hasDuration ? 1 : 0) + (hasUntil ? 1 : 0) !== 1) {
+        throw new SmithersError("INVALID_INPUT", `<Timer id="${props.id}"> requires exactly one of "duration" or "until".`);
+    }
+    if (props.every !== undefined) {
+        throw new SmithersError("INVALID_INPUT", `<Timer id="${props.id}"> does not support "every" yet. Recurring timers ship in phase 2.`);
+    }
+    const untilIso = props.until instanceof Date
+        ? props.until.toISOString()
+        : typeof props.until === "string"
+            ? props.until
+            : undefined;
+    const timerMeta = {
+        timer: true,
+        ...(hasDuration ? { duration: props.duration } : {}),
+        ...(hasUntil ? { until: untilIso } : {}),
+        ...props.meta,
+    };
+    return React.createElement("smithers:timer", {
+        id: props.id,
+        key: props.key,
+        duration: props.duration,
+        until: untilIso,
+        dependsOn: props.dependsOn,
+        needs: props.needs,
+        label: props.label ?? `timer:${props.id}`,
+        meta: Object.keys(timerMeta).length > 0 ? timerMeta : undefined,
+        __smithersTimerDuration: props.duration,
+        __smithersTimerUntil: untilIso,
+    });
+}

package/src/components/TimerProps.ts

@@ -0,0 +1,21 @@
+export type TimerProps = {
+	id: string;
+	/**
+	 * Relative duration (examples: "500ms", "1s", "30m", "1h", "7d").
+	 */
+	duration?: string;
+	/**
+	 * Absolute fire time (ISO timestamp or Date).
+	 */
+	until?: string | Date;
+	/**
+	 * Recurring timer syntax is reserved for phase 2 and is not supported yet.
+	 */
+	every?: string;
+	skipIf?: boolean;
+	dependsOn?: string[];
+	needs?: Record<string, string>;
+	label?: string;
+	meta?: Record<string, unknown>;
+	key?: string;
+};

package/src/components/TryCatchFinally.js

@@ -0,0 +1,35 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./TryCatchFinallyProps.ts").TryCatchFinallyProps} TryCatchFinallyProps */
+// @smithers-type-exports-end
+
+import React from "react";
+import { forceContinueOnFail } from "./control-flow-utils.js";
+/**
+ * Workflow-scoped error boundary. Catch specific error types, run recovery
+ * handlers, and ensure cleanup always runs.
+ *
+ * - The `try` block is the main workflow content.
+ * - If any task in `try` fails with a matching error, the `catch` block mounts.
+ * - The `finally` block always runs after try (success) or catch (failure).
+ *
+ * Renders to `<smithers:try-catch-finally>`.
+ * @param {TryCatchFinallyProps} props
+ */
+export function TryCatchFinally(props) {
+    if (props.skipIf)
+        return null;
+    const { id, catch: catchHandler, catchErrors, finally: finallyHandler } = props;
+    const tryBlock = forceContinueOnFail(props.try);
+    const catchBlock = catchHandler && typeof catchHandler !== "function" ? catchHandler : null;
+    const hostProps = {
+        id,
+        __tcfCatchErrors: catchErrors,
+        __tcfCatchHandler: catchHandler,
+        __tcfFinallyHandler: finallyHandler,
+    };
+    return React.createElement("smithers:try-catch-finally", hostProps, React.createElement("smithers:tcf-try", null, tryBlock), catchBlock
+        ? React.createElement("smithers:tcf-catch", null, catchBlock)
+        : null, finallyHandler
+        ? React.createElement("smithers:tcf-finally", null, finallyHandler)
+        : null);
+}

package/src/components/TryCatchFinallyProps.ts

@@ -0,0 +1,12 @@
+import type React from "react";
+import type { SmithersErrorCode } from "@smithers-orchestrator/errors/SmithersErrorCode";
+import type { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+
+export type TryCatchFinallyProps = {
+	id?: string;
+	try: React.ReactElement;
+	catch?: React.ReactElement | ((error: SmithersError) => React.ReactElement);
+	catchErrors?: SmithersErrorCode[];
+	finally?: React.ReactElement;
+	skipIf?: boolean;
+};

package/src/components/WaitForEvent.js

@@ -0,0 +1,37 @@
+import React from "react";
+import { getTaskRuntime } from "@smithers-orchestrator/driver/task-runtime";
+import { SmithersDb } from "@smithers-orchestrator/db/adapter";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+/** @typedef {import("./WaitForEventProps.ts").WaitForEventProps} WaitForEventProps */
+
+/**
+ * @param {WaitForEventProps} props
+ */
+export function WaitForEvent(props) {
+    if (props.skipIf)
+        return null;
+    const eventMeta = {
+        event: props.event,
+        ...(props.correlationId ? { correlationId: props.correlationId } : {}),
+        ...(props.onTimeout ? { onTimeout: props.onTimeout } : {}),
+        ...props.meta,
+    };
+    return React.createElement("smithers:wait-for-event", {
+        id: props.id,
+        key: props.key,
+        event: props.event,
+        correlationId: props.correlationId,
+        output: props.output,
+        outputSchema: props.outputSchema,
+        timeoutMs: props.timeoutMs,
+        onTimeout: props.onTimeout ?? "fail",
+        waitAsync: props.async === true,
+        dependsOn: props.dependsOn,
+        needs: props.needs,
+        label: props.label ?? `wait:${props.event}`,
+        meta: Object.keys(eventMeta).length > 0 ? eventMeta : undefined,
+        __smithersEventName: props.event,
+        __smithersCorrelationId: props.correlationId,
+        __smithersOnTimeout: props.onTimeout ?? "fail",
+    });
+}

package/src/components/WaitForEventProps.ts

@@ -0,0 +1,28 @@
+import type { z } from "zod";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type WaitForEventProps = {
+	id: string;
+	/** Event name/type to wait for. */
+	event: string;
+	/** Correlation key to match the right event instance. */
+	correlationId?: string;
+	/** Where to store the event payload. */
+	output: OutputTarget;
+	/** Zod schema for the event payload. */
+	outputSchema?: z.ZodObject<z.ZodRawShape>;
+	/** Max wait time in ms before timing out. */
+	timeoutMs?: number;
+	/** Behavior on timeout: fail (default), skip the node, or continue with null. */
+	onTimeout?: "fail" | "skip" | "continue";
+	/** Do not block unrelated downstream flow while waiting for the event. */
+	async?: boolean;
+	skipIf?: boolean;
+	/** Explicit dependency on other task node IDs. */
+	dependsOn?: string[];
+	/** Named dependencies on other tasks. Keys become context keys, values are task node IDs. */
+	needs?: Record<string, string>;
+	label?: string;
+	meta?: Record<string, unknown>;
+	key?: string;
+};

package/src/components/Workflow.js

@@ -0,0 +1,10 @@
+import React from "react";
+/** @typedef {import("./WorkflowProps.ts").WorkflowProps} WorkflowProps */
+
+/**
+ * @param {WorkflowProps} props
+ * @returns {React.DOMElement<WorkflowProps, Element>}
+ */
+export function Workflow(props) {
+    return React.createElement("smithers:workflow", props, props.children);
+}

package/src/components/WorkflowProps.ts

@@ -0,0 +1,7 @@
+import type React from "react";
+
+export type WorkflowProps = {
+	name: string;
+	cache?: boolean;
+	children?: React.ReactNode;
+};

package/src/components/Worktree.js

@@ -0,0 +1,17 @@
+import React from "react";
+import { WORKTREE_EMPTY_PATH_ERROR } from "@smithers-orchestrator/graph/constants";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+/** @typedef {import("./WorktreeProps.ts").WorktreeProps} WorktreeProps */
+
+/**
+ * @param {WorktreeProps} props
+ */
+export function Worktree(props) {
+    if (typeof props.path !== "string" || props.path.trim() === "") {
+        throw new SmithersError("WORKTREE_EMPTY_PATH", WORKTREE_EMPTY_PATH_ERROR);
+    }
+    if (props.skipIf)
+        return null;
+    const next = { id: props.id, path: props.path, branch: props.branch, baseBranch: props.baseBranch };
+    return React.createElement("smithers:worktree", next, props.children);
+}

package/src/components/WorktreeProps.ts

@@ -0,0 +1,11 @@
+import type React from "react";
+
+export type WorktreeProps = {
+	id?: string;
+	path: string;
+	branch?: string;
+	/** Base branch for syncing worktrees (default: "main"). */
+	baseBranch?: string;
+	skipIf?: boolean;
+	children?: React.ReactNode;
+};

package/src/components/control-flow-utils.js

@@ -0,0 +1,37 @@
+import React from "react";
+/**
+ * @param {unknown} node
+ * @returns {unknown}
+ */
+function mapChildren(node) {
+    if (Array.isArray(node)) {
+        return node.map((child) => forceContinueOnFail(child));
+    }
+    if (React.isValidElement(node)) {
+        return forceContinueOnFail(node);
+    }
+    return node;
+}
+/**
+ * Failure-boundary components need inner tasks to fail "softly" so the
+ * scheduler can decide whether to run catch/finally or compensations.
+ * @param {React.ReactNode} node
+ * @returns {React.ReactNode}
+ */
+export function forceContinueOnFail(node) {
+    if (!React.isValidElement(node)) {
+        return node;
+    }
+    const props = (node.props ?? {});
+    const nextProps = {};
+    if ("output" in props) {
+        nextProps.continueOnFail = true;
+    }
+    if ("children" in props) {
+        nextProps.children = mapChildren(props.children);
+    }
+    if (Object.keys(nextProps).length === 0) {
+        return node;
+    }
+    return React.cloneElement(node, nextProps);
+}