@smithers-orchestrator/components 0.16.0

package/src/components/Poller.js

@@ -0,0 +1,69 @@
+import React from "react";
+import { SmithersContext } from "@smithers-orchestrator/react-reconciler/context";
+import { Task } from "./Task.js";
+import { Loop } from "./Ralph.js";
+/** @typedef {import("./PollerProps.ts").PollerProps} PollerProps */
+
+/**
+ * Compute the timeout for a given attempt based on the backoff strategy.
+ * This effectively controls the interval between polls by setting
+ * the task's timeoutMs, giving the agent/compute time proportional
+ * to the backoff delay.
+ */
+function computeTimeoutMs(attempt, baseMs, strategy) {
+    switch (strategy) {
+        case "linear":
+            return baseMs * (attempt + 1);
+        case "exponential":
+            return baseMs * Math.pow(2, attempt);
+        case "fixed":
+        default:
+            return baseMs;
+    }
+}
+/**
+ * @param {PollerProps} props
+ */
+export function Poller(props) {
+    if (props.skipIf)
+        return null;
+    const ctx = React.useContext(SmithersContext);
+    const prefix = props.id ?? "poll";
+    const maxAttempts = props.maxAttempts ?? 30;
+    const backoff = props.backoff ?? "fixed";
+    const baseInterval = props.intervalMs ?? 5000;
+    const onTimeout = props.onTimeout ?? "fail";
+    const iteration = ctx?.iterations?.[`${prefix}-loop`] ?? ctx?.iteration ?? 0;
+    const checkRow = ctx?.outputMaybe(props.checkOutput, {
+        nodeId: `${prefix}-check`,
+        iteration,
+    });
+    const until = checkRow?.satisfied === true;
+    // Determine if check is an agent or a compute function
+    const isAgent = typeof props.check === "object" &&
+        props.check !== null &&
+        "generate" in props.check;
+    // Build the check task
+    const prompt = props.children ??
+        "Check whether the condition is satisfied. Return an object with a satisfied boolean.";
+    const checkTask = isAgent
+        ? React.createElement(Task, {
+            id: `${prefix}-check`,
+            output: props.checkOutput,
+            timeoutMs: computeTimeoutMs(iteration, baseInterval, backoff),
+            agent: props.check,
+            children: prompt,
+        })
+        : React.createElement(Task, {
+            id: `${prefix}-check`,
+            output: props.checkOutput,
+            timeoutMs: computeTimeoutMs(iteration, baseInterval, backoff),
+            children: props.check,
+        });
+    return React.createElement(Loop, {
+        id: `${prefix}-loop`,
+        until,
+        maxIterations: maxAttempts,
+        onMaxReached: onTimeout === "fail" ? "fail" : "return-last",
+    }, checkTask);
+}

package/src/components/PollerProps.ts

@@ -0,0 +1,24 @@
+import type React from "react";
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type PollerProps = {
+	/** ID prefix for generated task/component ids. */
+	id?: string;
+	/** Agent or compute function that checks the condition. */
+	check: AgentLike | (() => unknown | Promise<unknown>);
+	/** Output schema for the check result. Must include `satisfied: boolean`. */
+	checkOutput: OutputTarget;
+	/** Maximum poll attempts. Default 30. */
+	maxAttempts?: number;
+	/** Backoff strategy between polls. Default "fixed". */
+	backoff?: "fixed" | "linear" | "exponential";
+	/** Base interval in milliseconds between polls. Default 5000. */
+	intervalMs?: number;
+	/** Behavior when maxAttempts is reached. Default "fail". */
+	onTimeout?: "fail" | "return-last";
+	/** Skip the entire component. */
+	skipIf?: boolean;
+	/** Prompt/condition description for the check agent. */
+	children?: React.ReactNode;
+};

package/src/components/Ralph.js

@@ -0,0 +1,17 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./RalphProps.ts").RalphProps} RalphProps */
+// @smithers-type-exports-end
+
+import React from "react";
+/** @typedef {import("./LoopProps.ts").LoopProps} LoopProps */
+
+/**
+ * @param {LoopProps} props
+ */
+export function Loop(props) {
+    if (props.skipIf)
+        return null;
+    return React.createElement("smithers:ralph", props, props.children);
+}
+/** @deprecated Use `Loop` instead. */
+export const Ralph = Loop;

package/src/components/RalphProps.ts

@@ -0,0 +1,4 @@
+import type { LoopProps } from "./LoopProps.ts";
+
+/** @deprecated Use `LoopProps` instead. */
+export type RalphProps = LoopProps;

package/src/components/ReviewLoop.js

@@ -0,0 +1,51 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./ReviewLoopProps.ts").ReviewLoopProps} ReviewLoopProps */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Loop } from "./Ralph.js";
+import { Sequence } from "./Sequence.js";
+import { Task } from "./Task.js";
+/**
+ * Produce -> review -> fix -> repeat until approved.
+ *
+ * Composes Loop, Sequence, and Task to create a standard
+ * review-loop pattern. The producer receives the reviewer's
+ * feedback on subsequent iterations.
+ * @param {ReviewLoopProps} props
+ */
+export function ReviewLoop(props) {
+    if (props.skipIf)
+        return null;
+    const { id, producer, reviewer, produceOutput, reviewOutput, maxIterations = 5, onMaxReached = "return-last", children, } = props;
+    const prefix = id ?? "review-loop";
+    const produceId = `${prefix}-produce`;
+    const reviewId = `${prefix}-review`;
+    // The Loop's `until` condition is always false here — at render time
+    // the runtime re-renders and re-evaluates. The composite defers the
+    // `until` condition to the host element which reads `reviewOutput`
+    // for the `approved` field.
+    //
+    // We pass `until={false}` because the condition is evaluated by the
+    // runtime reading the review output's `approved` field each frame.
+    // The Loop primitive re-renders the tree, and the runtime checks
+    // the review output to decide whether to continue.
+    const reviewerAgents = Array.isArray(reviewer) ? reviewer : [reviewer];
+    return React.createElement(Loop, {
+        id: prefix,
+        until: false,
+        maxIterations,
+        onMaxReached,
+    }, React.createElement(Sequence, null, React.createElement(Task, {
+        id: produceId,
+        output: produceOutput,
+        agent: producer,
+        children,
+    }), React.createElement(Task, {
+        id: reviewId,
+        output: reviewOutput,
+        agent: reviewerAgents.length === 1 ? reviewerAgents[0] : reviewerAgents,
+        needs: { produced: produceId },
+        children: `Review the produced work and decide whether to approve.`,
+    })));
+}

package/src/components/ReviewLoopProps.ts

@@ -0,0 +1,23 @@
+import type React from "react";
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type ReviewLoopProps = {
+	id?: string;
+	/** Agent that produces or fixes the work each iteration. */
+	producer: AgentLike;
+	/** Agent (or agents) that reviews the produced work. */
+	reviewer: AgentLike | AgentLike[];
+	/** Output schema for the produced work. */
+	produceOutput: OutputTarget;
+	/** Output schema for the review result. Must include an `approved: boolean` field. */
+	reviewOutput: OutputTarget;
+	/** Maximum number of review cycles before stopping. @default 5 */
+	maxIterations?: number;
+	/** Behavior when maxIterations is reached. @default "return-last" */
+	onMaxReached?: "return-last" | "fail";
+	/** Skip the entire review loop. */
+	skipIf?: boolean;
+	/** Initial prompt for the producer (string or ReactNode). */
+	children: string | React.ReactNode;
+};

package/src/components/Runbook.js

@@ -0,0 +1,91 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./RunbookProps.ts").RunbookProps} RunbookProps */
+/** @typedef {import("./RunbookStep.ts").RunbookStep} RunbookStep */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Sequence } from "./Sequence.js";
+import { Task } from "./Task.js";
+import { Approval } from "./Approval.js";
+/**
+ * <Runbook> — Sequential steps with risk classification.
+ *
+ * Safe steps auto-execute. Risky and critical steps require human approval first.
+ * Composes: Sequence of [Approval? → Task] per step, chained via `needs`.
+ * @param {RunbookProps} props
+ */
+export function Runbook(props) {
+    if (props.skipIf)
+        return null;
+    const prefix = props.id ?? "runbook";
+    const onDeny = props.onDeny ?? "fail";
+    const children = [];
+    let previousStepId;
+    for (let i = 0; i < props.steps.length; i++) {
+        const step = props.steps[i];
+        const stepId = `${prefix}-${step.id}`;
+        const agent = step.agent ?? props.defaultAgent;
+        const output = step.output ?? props.stepOutput;
+        const label = step.label ?? step.id;
+        // Build needs: each step depends on the previous step's completion
+        const needs = previousStepId
+            ? { previousStep: previousStepId }
+            : undefined;
+        if (step.risk === "safe") {
+            // Safe: plain Task, auto-executes
+            children.push(React.createElement(Task, {
+                key: stepId,
+                id: stepId,
+                output,
+                agent,
+                needs,
+                label: `[safe] ${label}`,
+                children: step.command ?? `Execute step: ${label}`,
+            }));
+            previousStepId = stepId;
+        }
+        else {
+            // Risky or critical: Approval gate then Task
+            const approvalId = `${stepId}-approval`;
+            const isCritical = step.risk === "critical";
+            const approvalTitle = props.approvalRequest?.title ??
+                `Approve ${isCritical ? "CRITICAL" : "risky"} step: ${label}`;
+            const approvalSummary = props.approvalRequest?.summary ??
+                (isCritical
+                    ? `CRITICAL step requires elevated approval. Command: ${step.command ?? label}`
+                    : `Risky step requires approval before execution. Command: ${step.command ?? label}`);
+            const approvalMeta = {
+                stepId: step.id,
+                risk: step.risk,
+                ...props.approvalRequest?.metadata,
+            };
+            if (isCritical) {
+                approvalMeta.elevated = true;
+            }
+            children.push(React.createElement(Approval, {
+                key: approvalId,
+                id: approvalId,
+                output: `${approvalId}-decision`,
+                request: {
+                    title: approvalTitle,
+                    summary: approvalSummary,
+                    metadata: approvalMeta,
+                },
+                onDeny: onDeny === "skip" ? "skip" : "fail",
+                needs,
+                label: `Approve: ${label}`,
+            }));
+            children.push(React.createElement(Task, {
+                key: stepId,
+                id: stepId,
+                output,
+                agent,
+                needs: { approval: approvalId },
+                label: `[${step.risk}] ${label}`,
+                children: step.command ?? `Execute step: ${label}`,
+            }));
+            previousStepId = stepId;
+        }
+    }
+    return React.createElement(Sequence, null, ...children);
+}

package/src/components/RunbookProps.ts

@@ -0,0 +1,19 @@
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { ApprovalRequest } from "./ApprovalRequest.ts";
+import type { RunbookStep } from "./RunbookStep.ts";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type RunbookProps = {
+	id?: string;
+	/** Ordered steps to execute. */
+	steps: RunbookStep[];
+	/** Default agent for steps that don't specify one. */
+	defaultAgent?: AgentLike;
+	/** Default output schema for step results. */
+	stepOutput: OutputTarget;
+	/** Template for approval requests on risky/critical steps. */
+	approvalRequest?: Partial<ApprovalRequest>;
+	/** Behavior when a risky/critical step is denied: "fail" (default) or "skip". */
+	onDeny?: "fail" | "skip";
+	skipIf?: boolean;
+};

package/src/components/RunbookStep.ts

@@ -0,0 +1,17 @@
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type RunbookStep = {
+	/** Unique step identifier. */
+	id: string;
+	/** Agent for this step (falls back to `defaultAgent`). */
+	agent?: AgentLike;
+	/** Shell command or instruction for the step. */
+	command?: string;
+	/** Risk classification: safe auto-executes, risky/critical require approval. */
+	risk: "safe" | "risky" | "critical";
+	/** Human-readable label for the step. */
+	label?: string;
+	/** Per-step output schema override. */
+	output?: OutputTarget;
+};

package/src/components/Saga.js

@@ -0,0 +1,77 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./SagaProps.ts").SagaProps} SagaProps */
+/** @typedef {import("./SagaStepDef.ts").SagaStepDef} SagaStepDef */
+// @smithers-type-exports-end
+
+import React from "react";
+import { forceContinueOnFail } from "./control-flow-utils.js";
+/** @typedef {import("./SagaStepProps.ts").SagaStepProps} SagaStepProps */
+
+/**
+ * @param {SagaStepProps} _props
+ * @returns {React.ReactElement | null}
+ */
+function SagaStep(_props) {
+    // SagaStep is a declarative marker — the Saga component reads its props
+    // directly from the children array. It does not render on its own.
+    return null;
+}
+/**
+ * Forward steps with registered compensations executed in reverse on failure/cancel.
+ *
+ * Use the `steps` prop for an array-driven API, or nest `<Saga.Step>` children
+ * for a declarative JSX style.
+ *
+ * Renders to `<smithers:saga>`.
+ * @param {SagaProps} props
+ */
+export function Saga(props) {
+    if (props.skipIf)
+        return null;
+    const { steps, children, onFailure = "compensate", id, ...rest } = props;
+    // Collect steps from either the `steps` prop or Saga.Step children.
+    let resolvedSteps = [];
+    if (steps && steps.length > 0) {
+        resolvedSteps = steps;
+    }
+    else if (children) {
+        // Walk children to extract Saga.Step elements.
+        const childArr = React.Children.toArray(children);
+        for (const child of childArr) {
+            if (React.isValidElement(child) &&
+                (child.type === SagaStep || child.type.__isSagaStep)) {
+                const stepProps = child.props;
+                resolvedSteps.push({
+                    id: stepProps.id,
+                    action: stepProps.children,
+                    compensation: stepProps.compensation,
+                });
+            }
+        }
+    }
+    // Build the host element props with step metadata.
+    const sagaProps = {
+        ...rest,
+        id,
+        onFailure,
+        __sagaSteps: resolvedSteps.map((s) => ({
+            id: s.id,
+            label: s.label,
+        })),
+    };
+    const actionChildren = resolvedSteps.map((step) => React.cloneElement(forceContinueOnFail(step.action), {
+        key: `saga-action-${step.id}`,
+    }));
+    const compensationChildren = resolvedSteps.map((step) => React.cloneElement(step.compensation, {
+        key: `saga-compensation-${step.id}`,
+    }));
+    // Store compensation elements on the host props for the engine.
+    sagaProps.__sagaCompensations = resolvedSteps.reduce((acc, step) => {
+        acc[step.id] = step.compensation;
+        return acc;
+    }, {});
+    return React.createElement("smithers:saga", sagaProps, React.createElement("smithers:saga-actions", null, ...actionChildren), React.createElement("smithers:saga-compensations", null, ...compensationChildren));
+}
+// Mark SagaStep for identification.
+SagaStep.__isSagaStep = true;
+Saga.Step = SagaStep;

package/src/components/SagaProps.ts

@@ -0,0 +1,10 @@
+import type React from "react";
+import type { SagaStepDef } from "./SagaStepDef.ts";
+
+export type SagaProps = {
+	id?: string;
+	steps?: SagaStepDef[];
+	onFailure?: "compensate" | "compensate-and-fail" | "fail";
+	skipIf?: boolean;
+	children?: React.ReactNode;
+};

package/src/components/SagaStepDef.ts

@@ -0,0 +1,8 @@
+import type React from "react";
+
+export type SagaStepDef = {
+	id: string;
+	action: React.ReactElement;
+	compensation: React.ReactElement;
+	label?: string;
+};

package/src/components/SagaStepProps.ts

@@ -0,0 +1,7 @@
+import type React from "react";
+
+export type SagaStepProps = {
+	id: string;
+	compensation: React.ReactElement;
+	children: React.ReactElement;
+};

package/src/components/Sandbox.js

@@ -0,0 +1,48 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./SandboxRuntime.ts").SandboxRuntime} SandboxRuntime */
+/** @typedef {import("./SandboxVolumeMount.ts").SandboxVolumeMount} SandboxVolumeMount */
+/** @typedef {import("./SandboxWorkspaceSpec.ts").SandboxWorkspaceSpec} SandboxWorkspaceSpec */
+// @smithers-type-exports-end
+
+import React from "react";
+/** @typedef {import("./SandboxProps.ts").SandboxProps} SandboxProps */
+
+/**
+ * @param {SandboxProps} props
+ */
+export function Sandbox(props) {
+    if (props.skipIf)
+        return null;
+    return React.createElement("smithers:sandbox", {
+        id: props.id,
+        key: props.key,
+        output: props.output,
+        runtime: props.runtime ?? "bubblewrap",
+        allowNetwork: props.allowNetwork,
+        reviewDiffs: props.reviewDiffs,
+        autoAcceptDiffs: props.autoAcceptDiffs,
+        image: props.image,
+        env: props.env,
+        ports: props.ports,
+        volumes: props.volumes,
+        memoryLimit: props.memoryLimit,
+        cpuLimit: props.cpuLimit,
+        command: props.command,
+        workspace: props.workspace,
+        timeoutMs: props.timeoutMs,
+        heartbeatTimeoutMs: props.heartbeatTimeoutMs,
+        heartbeatTimeout: props.heartbeatTimeout,
+        retries: props.retries,
+        retryPolicy: props.retryPolicy,
+        continueOnFail: props.continueOnFail,
+        cache: props.cache,
+        dependsOn: props.dependsOn,
+        needs: props.needs,
+        label: props.label ?? props.id,
+        meta: props.meta,
+        __smithersSandboxWorkflow: props.workflow,
+        __smithersSandboxInput: props.input,
+        __smithersSandboxRuntime: props.runtime ?? "bubblewrap",
+        __smithersSandboxChildren: props.children,
+    });
+}

package/src/components/SandboxProps.ts

@@ -0,0 +1,46 @@
+import type React from "react";
+import type { CachePolicy } from "@smithers-orchestrator/scheduler/CachePolicy";
+import type { RetryPolicy } from "@smithers-orchestrator/scheduler/RetryPolicy";
+import type { SmithersWorkflow } from "../SmithersWorkflow.ts";
+import type { OutputTarget } from "./OutputTarget.ts";
+import type { SandboxRuntime } from "./SandboxRuntime.ts";
+import type { SandboxVolumeMount } from "./SandboxVolumeMount.ts";
+import type { SandboxWorkspaceSpec } from "./SandboxWorkspaceSpec.ts";
+
+export type SandboxProps = {
+	id: string;
+	/** Child workflow definition. If omitted, createSmithers-bound Sandbox wrappers may provide one. */
+	workflow?: SmithersWorkflow<unknown>;
+	/** Input passed to the child workflow. */
+	input?: unknown;
+	output: OutputTarget;
+	runtime?: SandboxRuntime;
+	allowNetwork?: boolean;
+	reviewDiffs?: boolean;
+	autoAcceptDiffs?: boolean;
+	image?: string;
+	env?: Record<string, string>;
+	ports?: Array<{
+		host: number;
+		container: number;
+	}>;
+	volumes?: SandboxVolumeMount[];
+	memoryLimit?: string;
+	cpuLimit?: string;
+	command?: string;
+	workspace?: SandboxWorkspaceSpec;
+	skipIf?: boolean;
+	timeoutMs?: number;
+	heartbeatTimeoutMs?: number;
+	heartbeatTimeout?: number;
+	retries?: number;
+	retryPolicy?: RetryPolicy;
+	continueOnFail?: boolean;
+	cache?: CachePolicy;
+	dependsOn?: string[];
+	needs?: Record<string, string>;
+	label?: string;
+	meta?: Record<string, unknown>;
+	key?: string;
+	children?: React.ReactNode;
+};

package/src/components/SandboxRuntime.ts

@@ -0,0 +1 @@
+export type SandboxRuntime = "bubblewrap" | "docker" | "codeplane";

package/src/components/SandboxVolumeMount.ts

@@ -0,0 +1,5 @@
+export type SandboxVolumeMount = {
+	host: string;
+	container: string;
+	readonly?: boolean;
+};

package/src/components/SandboxWorkspaceSpec.ts

@@ -0,0 +1,6 @@
+export type SandboxWorkspaceSpec = {
+	name: string;
+	snapshotId?: string;
+	idleTimeoutSecs?: number;
+	persistence?: "ephemeral" | "sticky";
+};

package/src/components/ScanFixVerify.js

@@ -0,0 +1,60 @@
+import React from "react";
+import { Task } from "./Task.js";
+import { Sequence } from "./Sequence.js";
+import { Parallel } from "./Parallel.js";
+import { Loop } from "./Ralph.js";
+/** @typedef {import("./ScanFixVerifyProps.ts").ScanFixVerifyProps} ScanFixVerifyProps */
+
+/**
+ * @param {ScanFixVerifyProps} props
+ */
+export function ScanFixVerify(props) {
+    if (props.skipIf)
+        return null;
+    const prefix = props.id ?? "sfv";
+    const maxRetries = props.maxRetries ?? 3;
+    const fixers = Array.isArray(props.fixer) ? props.fixer : [props.fixer];
+    // The scan task finds problems
+    const scanTask = React.createElement(Task, {
+        id: `${prefix}-scan`,
+        output: props.scanOutput,
+        agent: props.scanner,
+        children: props.children ?? "Scan for problems and return an issues array.",
+    });
+    // Parallel fix tasks — one per issue slot. At render time we don't know
+    // how many issues there are, so we create a single fix task that the agent
+    // will apply to all discovered issues. The Parallel wrapper allows the
+    // runtime to fan out when the scan output becomes available.
+    const fixTask = React.createElement(Task, {
+        id: `${prefix}-fix`,
+        output: props.fixOutput,
+        agent: fixers[0],
+        dependsOn: [`${prefix}-scan`],
+        children: "Fix all issues identified by the scan. Address each problem found.",
+    });
+    const fixParallel = React.createElement(Parallel, { id: `${prefix}-fixes`, maxConcurrency: props.maxConcurrency }, fixTask);
+    // Verify that all fixes were applied correctly
+    const verifyTask = React.createElement(Task, {
+        id: `${prefix}-verify`,
+        output: props.verifyOutput,
+        agent: props.verifier,
+        dependsOn: [`${prefix}-fix`],
+        children: "Verify that all fixes were applied correctly. Return whether all issues are resolved.",
+    });
+    // The inner loop: scan → fix → verify, repeating until verification passes
+    const innerSequence = React.createElement(Sequence, null, scanTask, fixParallel, verifyTask);
+    const loop = React.createElement(Loop, {
+        id: `${prefix}-loop`,
+        until: false, // Re-evaluated at render time via reactive context
+        maxIterations: maxRetries,
+        onMaxReached: "return-last",
+    }, innerSequence);
+    // Final report task after the loop completes
+    const reportTask = React.createElement(Task, {
+        id: `${prefix}-report`,
+        output: props.reportOutput,
+        dependsOn: [`${prefix}-verify`],
+        children: "Produce a final summary report of all scan-fix-verify cycles, including what was found, what was fixed, and the final verification status.",
+    });
+    return React.createElement(Sequence, null, loop, reportTask);
+}

package/src/components/ScanFixVerifyProps.ts

@@ -0,0 +1,30 @@
+import type React from "react";
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type ScanFixVerifyProps = {
+	/** ID prefix for generated task/component ids. */
+	id?: string;
+	/** Agent that scans for problems. */
+	scanner: AgentLike;
+	/** Agent (or agents) that fixes problems. When an array is provided, agents are cycled across issues. */
+	fixer: AgentLike | AgentLike[];
+	/** Agent that verifies the fixes were applied correctly. */
+	verifier: AgentLike;
+	/** Output schema for scan results. Should include `issues: Array`. */
+	scanOutput: OutputTarget;
+	/** Output schema for each individual fix. */
+	fixOutput: OutputTarget;
+	/** Output schema for verification results. */
+	verifyOutput: OutputTarget;
+	/** Output schema for the final summary report. */
+	reportOutput: OutputTarget;
+	/** Maximum number of parallel fix tasks. */
+	maxConcurrency?: number;
+	/** Maximum scan-fix-verify cycles before stopping. Default 3. */
+	maxRetries?: number;
+	/** Skip the entire component. */
+	skipIf?: boolean;
+	/** Prompt/context describing what to scan for. */
+	children?: React.ReactNode;
+};

package/src/components/Sequence.js

@@ -0,0 +1,11 @@
+import React from "react";
+/** @typedef {import("./SequenceProps.ts").SequenceProps} SequenceProps */
+
+/**
+ * @param {SequenceProps} props
+ */
+export function Sequence(props) {
+    if (props.skipIf)
+        return null;
+    return React.createElement("smithers:sequence", props, props.children);
+}

package/src/components/SequenceProps.ts

@@ -0,0 +1,6 @@
+import type React from "react";
+
+export type SequenceProps = {
+	skipIf?: boolean;
+	children?: React.ReactNode;
+};