@smithers-orchestrator/engine 0.18.0 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/engine",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Concrete Smithers workflow execution engine",
   "type": "module",
   "sideEffects": false,
@@ -33,20 +33,20 @@
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/agents": "0.18.0",
-    "@smithers-orchestrator/db": "0.18.0",
-    "@smithers-orchestrator/driver": "0.18.0",
-    "@smithers-orchestrator/errors": "0.18.0",
-    "@smithers-orchestrator/graph": "0.18.0",
-    "@smithers-orchestrator/memory": "0.18.0",
-    "@smithers-orchestrator/observability": "0.18.0",
-    "@smithers-orchestrator/scheduler": "0.18.0",
-    "@smithers-orchestrator/scorers": "0.18.0",
-    "@smithers-orchestrator/time-travel": "0.18.0",
-    "@smithers-orchestrator/components": "0.18.0",
-    "@smithers-orchestrator/react-reconciler": "0.18.0",
-    "@smithers-orchestrator/sandbox": "0.18.0",
-    "@smithers-orchestrator/vcs": "0.18.0"
+    "@smithers-orchestrator/agents": "0.20.0",
+    "@smithers-orchestrator/driver": "0.20.0",
+    "@smithers-orchestrator/components": "0.20.0",
+    "@smithers-orchestrator/db": "0.20.0",
+    "@smithers-orchestrator/graph": "0.20.0",
+    "@smithers-orchestrator/memory": "0.20.0",
+    "@smithers-orchestrator/errors": "0.20.0",
+    "@smithers-orchestrator/observability": "0.20.0",
+    "@smithers-orchestrator/react-reconciler": "0.20.0",
+    "@smithers-orchestrator/sandbox": "0.20.0",
+    "@smithers-orchestrator/scheduler": "0.20.0",
+    "@smithers-orchestrator/scorers": "0.20.0",
+    "@smithers-orchestrator/vcs": "0.20.0",
+    "@smithers-orchestrator/time-travel": "0.20.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/effect/builder.js

@@ -14,6 +14,9 @@ import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 /**
  * @typedef {import("effect").Schema.Schema<unknown, unknown, never>} AnySchema
  */
+/**
+ * @typedef {unknown | Promise<unknown> | import("effect").Effect.Effect<unknown, unknown, unknown>} AnyEffect
+ */
 /**
  * @typedef {{ needs?: Record<string, BuilderStepHandle>; request: (ctx: Record<string, unknown>) => { title: string; summary?: string | null; }; onDeny?: "fail" | "continue" | "skip"; }} ApprovalOptions
  */
@@ -24,6 +27,41 @@ import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 /** @typedef {import("./BuilderStepHandle.ts").BuilderStepHandle} BuilderStepHandle */
 /** @typedef {import("@smithers-orchestrator/scheduler/RetryPolicy").RetryPolicy} RetryPolicy */
 /** @typedef {import("./SmithersSqliteOptions.ts").SmithersSqliteOptions} SmithersSqliteOptions */
+/**
+ * @typedef {{
+ *   output: AnySchema;
+ *   needs?: Record<string, BuilderStepHandle>;
+ *   run?: (ctx: BuilderStepContext) => AnyEffect;
+ *   retry?: unknown;
+ *   retryPolicy?: RetryPolicy;
+ *   timeout?: unknown;
+ *   skipIf?: (ctx: BuilderStepContext) => boolean;
+ *   cache?: import("@smithers-orchestrator/scheduler/CachePolicy").CachePolicy;
+ * }} StepOptions
+ */
+/**
+ * @typedef {{
+ *   step: (id: string, options: StepOptions) => BuilderStepHandle;
+ *   approval: (id: string, options: ApprovalOptions) => BuilderStepHandle;
+ *   sequence: (...nodes: BuilderNode[]) => BuilderNode;
+ *   parallel: (...nodesOrOptions: [...BuilderNode[], { maxConcurrency?: number }] | BuilderNode[]) => BuilderNode;
+ *   loop: (options: { id?: string; children: BuilderNode; until: (outputs: Record<string, unknown>) => boolean; maxIterations?: number; onMaxReached?: "fail" | "return-last"; }) => BuilderNode;
+ *   match: (source: BuilderStepHandle, options: { when: (value: unknown) => boolean; then: () => BuilderNode; else?: () => BuilderNode; }) => BuilderNode;
+ *   component: (instanceId: string, definition: ComponentDefinition, params?: Record<string, unknown>) => BuilderNode;
+ * }} BuilderApi
+ */
+/**
+ * @typedef {{ execute: (input: unknown, opts?: Omit<Parameters<typeof runWorkflow>[1], "input">) => import("effect").Effect.Effect<unknown, unknown, unknown> }} BuiltSmithersWorkflow
+ */
+/**
+ * @typedef {{ build: (buildGraph: ($: BuilderApi) => BuilderNode) => BuiltSmithersWorkflow }} WorkflowDefinitionBuilder
+ */
+/**
+ * @typedef {{ kind: "component-definition"; name: string; buildWithPrefix: (prefix: string, params?: Record<string, unknown>) => BuilderNode }} ComponentDefinition
+ */
+/**
+ * @typedef {{ build: (buildGraph: ($: BuilderApi, params?: Record<string, unknown>) => BuilderNode) => ComponentDefinition }} ComponentDefinitionBuilder
+ */
 
 const SmithersSqlite = Context.GenericTag("smithers/effect/sqlite");
 class ApprovalDecision extends Schema.Class("ApprovalDecision")({
@@ -751,25 +789,262 @@ function normalizeExecutionError(result) {
     }
     return new SmithersError("WORKFLOW_EXECUTION_FAILED", `Workflow execution ended with status "${result.status}"`, { status: result.status });
 }
+/**
+ * @typedef {{ _tag: "WorkflowGraph"; expr: unknown; pipe: (...fns: Array<(g: any) => any>) => any }} WorkflowGraph
+ */
+
+/**
+ * @param {unknown} value
+ * @returns {value is WorkflowGraph}
+ */
+function isWorkflowGraph(value) {
+    return Boolean(value) && typeof value === "object" && /** @type {any} */ (value)._tag === "WorkflowGraph";
+}
+
+/**
+ * @param {unknown} expr
+ * @returns {WorkflowGraph}
+ */
+function makeGraph(expr) {
+    /** @type {WorkflowGraph} */
+    const graph = /** @type {any} */ ({ _tag: "WorkflowGraph", expr });
+    graph.pipe = function pipe(...fns) {
+        return fns.reduce((acc, fn) => fn(acc), graph);
+    };
+    return graph;
+}
+
+/**
+ * Build the graph constructors shared by Smithers.workflow and Smithers.fragment.
+ */
+function makeFactory() {
+    return {
+        /**
+         * @param {string} id
+         * @param {StepOptions} options
+         */
+        step: (id, options) => makeGraph({ _tag: "Step", id, options }),
+        /**
+         * @param {string} id
+         * @param {ApprovalOptions} options
+         */
+        approval: (id, options) => makeGraph({ _tag: "Approval", id, options }),
+        /**
+         * @param {WorkflowGraph[]} children
+         */
+        sequence: (...children) => makeGraph({ _tag: "Sequence", children }),
+        parallel: (...args) => {
+            let maxConcurrency;
+            const items = [...args];
+            const last = items[items.length - 1];
+            if (last &&
+                typeof last === "object" &&
+                !Array.isArray(last) &&
+                !isWorkflowGraph(last) &&
+                "maxConcurrency" in last) {
+                maxConcurrency = Number(last.maxConcurrency);
+                items.pop();
+            }
+            return makeGraph({ _tag: "Parallel", children: items, maxConcurrency });
+        },
+        match: (source, options) => makeGraph({
+            _tag: "Match",
+            source,
+            when: options.when,
+            then: options.then,
+            else: options.else,
+        }),
+        branch: (options) => makeGraph({
+            _tag: "Branch",
+            condition: options.condition,
+            needs: options.needs,
+            then: options.then,
+            else: options.else,
+        }),
+        loop: (options) => makeGraph({
+            _tag: "Loop",
+            id: options.id,
+            child: options.children,
+            until: options.until,
+            maxIterations: options.maxIterations,
+            onMaxReached: options.onMaxReached,
+        }),
+        worktree: (options) => makeGraph({
+            _tag: "Worktree",
+            id: options.id,
+            path: options.path,
+            branch: options.branch,
+            skipIf: options.skipIf,
+            needs: options.needs,
+            child: options.children,
+        }),
+        scope: (instanceId, child) => makeGraph({
+            _tag: "Scope",
+            instanceId,
+            child,
+        }),
+    };
+}
+
+/**
+ * @param {string} prefix
+ * @param {string | undefined} id
+ */
+function applyPrefixId(prefix, id) {
+    if (!id) return id;
+    return prefix ? `${prefix}.${id}` : id;
+}
+
+/**
+ * @param {Record<string, WorkflowGraph> | undefined} needs
+ * @param {string} prefix
+ * @param {Map<string, Map<WorkflowGraph, BuilderNode>>} memo
+ */
+function compileNeeds(needs, prefix, memo) {
+    if (!needs) return undefined;
+    const out = {};
+    for (const [key, dep] of Object.entries(needs)) {
+        out[key] = compileGraph(dep, prefix, memo);
+    }
+    return out;
+}
+
+/**
+ * Walk a graph expression tree and produce a BuilderNode tree at the active prefix.
+ * Memoizes per (prefix, graph) so a value referenced as both a child and a needs source
+ * compiles to a single handle, while reuse under different scopes produces distinct handles.
+ *
+ * @param {WorkflowGraph} graph
+ * @param {string} [prefix]
+ * @param {Map<string, Map<WorkflowGraph, BuilderNode>>} [memo]
+ * @returns {BuilderNode}
+ */
+function compileGraph(graph, prefix = "", memo = new Map()) {
+    let perPrefix = memo.get(prefix);
+    if (!perPrefix) {
+        perPrefix = new Map();
+        memo.set(prefix, perPrefix);
+    }
+    const cached = perPrefix.get(graph);
+    if (cached) return cached;
+
+    const builder = createBuilder(prefix);
+    const expr = /** @type {any} */ (graph.expr);
+    let node;
+
+    switch (expr._tag) {
+        case "Step": {
+            const compiledOptions = {
+                ...expr.options,
+                needs: compileNeeds(expr.options.needs, prefix, memo) ?? {},
+            };
+            node = builder.step(expr.id, compiledOptions);
+            break;
+        }
+        case "Approval": {
+            const compiledOptions = {
+                ...expr.options,
+                needs: compileNeeds(expr.options.needs, prefix, memo) ?? {},
+            };
+            node = builder.approval(expr.id, compiledOptions);
+            break;
+        }
+        case "Sequence": {
+            node = {
+                kind: "sequence",
+                children: expr.children.map((c) => compileGraph(c, prefix, memo)),
+            };
+            break;
+        }
+        case "Parallel": {
+            node = {
+                kind: "parallel",
+                children: expr.children.map((c) => compileGraph(c, prefix, memo)),
+                maxConcurrency: expr.maxConcurrency,
+            };
+            break;
+        }
+        case "Match": {
+            node = {
+                kind: "match",
+                source: compileGraph(expr.source, prefix, memo),
+                when: expr.when,
+                then: compileGraph(expr.then, prefix, memo),
+                else: expr.else ? compileGraph(expr.else, prefix, memo) : undefined,
+            };
+            break;
+        }
+        case "Branch": {
+            node = {
+                kind: "branch",
+                condition: expr.condition,
+                needs: compileNeeds(expr.needs, prefix, memo),
+                then: compileGraph(expr.then, prefix, memo),
+                else: expr.else ? compileGraph(expr.else, prefix, memo) : undefined,
+            };
+            break;
+        }
+        case "Loop": {
+            node = {
+                kind: "loop",
+                id: applyPrefixId(prefix, expr.id),
+                children: compileGraph(expr.child, prefix, memo),
+                until: expr.until,
+                maxIterations: expr.maxIterations,
+                onMaxReached: expr.onMaxReached,
+            };
+            break;
+        }
+        case "Worktree": {
+            node = {
+                kind: "worktree",
+                id: applyPrefixId(prefix, expr.id),
+                path: expr.path,
+                branch: expr.branch,
+                skipIf: expr.skipIf,
+                needs: compileNeeds(expr.needs, prefix, memo),
+                children: compileGraph(expr.child, prefix, memo),
+            };
+            break;
+        }
+        case "Scope": {
+            const nextPrefix = prefix ? `${prefix}.${expr.instanceId}` : expr.instanceId;
+            node = compileGraph(expr.child, nextPrefix, memo);
+            break;
+        }
+        default:
+            throw new SmithersError("UNKNOWN_GRAPH_EXPR", `Unknown graph expression _tag: "${expr._tag}"`);
+    }
+
+    perPrefix.set(graph, node);
+    return node;
+}
+
 /**
  * @param {{ name: string; input: AnySchema }} options
  */
-function _createWorkflow(options) {
+export function workflow(options) {
+    const factory = makeFactory();
     return {
+        ...factory,
         /**
-     * @param {($: BuilderApi) => BuilderNode} buildGraph
-     * @returns {BuiltSmithersWorkflow}
-     */
-        build(buildGraph) {
-            const root = buildGraph(createBuilder());
+         * Finalize the workflow definition. Compiles the graph expression tree to a
+         * BuilderNode tree, allocates step handles with active prefixes, and returns
+         * a runnable workflow.
+         *
+         * @param {WorkflowGraph} graph
+         */
+        from(graph) {
+            const root = compileGraph(graph);
             annotateLoops(root);
             const handles = collectHandles(root);
             assertUniqueHandleIds(handles);
             return {
+                node: root,
                 /**
-         * @param {unknown} input
-         * @param {Omit<Parameters<typeof runWorkflow>[1], "input">} [opts]
-         */
+                 * @param {unknown} input
+                 * @param {Omit<Parameters<typeof runWorkflow>[1], "input">} [opts]
+                 */
                 execute(input, opts) {
                     return Effect.gen(function* () {
                         const env = yield* Effect.context();
@@ -777,12 +1052,12 @@ function _createWorkflow(options) {
                         const decodedInput = decodeSchema(options.input, input);
                         const encodedInput = JSON.parse(JSON.stringify(encodeSchema(options.input, decodedInput) ?? {}));
                         return yield* Effect.acquireUseRelease(Effect.sync(() => createBuilderDb(sqliteConfig.filename, handles)), (runtime) => Effect.promise(async () => {
-                            const workflow = {
+                            const wf = {
                                 db: runtime.db,
-                                build: (ctx) => React.createElement(Workflow, { name: options.name }, renderNode(ctx && root ? root : root, ctx, decodedInput, env)),
+                                build: (ctx) => React.createElement(Workflow, { name: options.name }, renderNode(root, ctx, decodedInput, env)),
                                 opts: {},
                             };
-                            const result = await Effect.runPromise(runWorkflow(workflow, {
+                            const result = await Effect.runPromise(runWorkflow(wf, {
                                 ...opts,
                                 input: encodedInput,
                             }));
@@ -801,37 +1076,28 @@ function _createWorkflow(options) {
         },
     };
 }
+
 /**
- * @param {{ name: string; params?: Record<string, unknown> }} options
+ * Build a graph fragment whose steps live across workflows. Same constructors as
+ * a workflow handle, minus `from` — fragments are values, not workflows. They compile
+ * when mounted into a real workflow via `G.scope(instanceId, fragment)`.
+ *
+ * @param {AnySchema} _inputSchema
  */
-function _createComponent(options) {
-    return {
-        /**
-     * @param {($: BuilderApi, params: Record<string, unknown>) => BuilderNode} buildGraph
-     * @returns {ComponentDefinition}
-     */
-        build(buildGraph) {
-            return {
-                kind: "component-definition",
-                name: options.name,
-                /**
-         * @param {string} prefix
-         * @param {Record<string, unknown>} params
-         */
-                buildWithPrefix(prefix, params) {
-                    return buildGraph(createBuilder(prefix), params);
-                },
-            };
-        },
-    };
+export function fragment(_inputSchema) {
+    return makeFactory();
 }
+
 /**
  * @param {SmithersSqliteOptions} options
  */
 function sqlite(options) {
     return Layer.succeed(SmithersSqlite, options);
 }
-/** @type {{ sqlite: typeof sqlite }} */
+
+/** @type {{ sqlite: typeof sqlite; workflow: typeof workflow; fragment: typeof fragment }} */
 export const Smithers = {
     sqlite,
+    workflow,
+    fragment,
 };

package/src/index.d.ts

@@ -1220,10 +1220,95 @@ type WorktreeNode = {
     children: BuilderNode$1;
 };
 type BuilderNode$1 = BuilderStepHandle$1 | SequenceNode | ParallelNode | LoopNode | MatchNode | BranchNode | WorktreeNode;
-
-/** @type {{ sqlite: typeof sqlite }} */
+type StepOptions = {
+    output: AnySchema$1;
+    needs?: Record<string, BuilderStepHandle$1>;
+    run?: (ctx: BuilderStepContext$1) => AnyEffect;
+    retry?: unknown;
+    retryPolicy?: RetryPolicy$1;
+    timeout?: unknown;
+    skipIf?: (ctx: BuilderStepContext$1) => boolean;
+    cache?: CachePolicy;
+};
+type ComponentDefinition = {
+    kind: "component-definition";
+    name: string;
+    buildWithPrefix: (prefix: string, params?: Record<string, unknown>) => BuilderNode$1;
+};
+type BuilderApi = {
+    step: (id: string, options: StepOptions) => BuilderStepHandle$1;
+    approval: (id: string, options: ApprovalOptions$1) => BuilderStepHandle$1;
+    sequence: (...nodes: BuilderNode$1[]) => BuilderNode$1;
+    parallel: (...nodesOrOptions: Array<BuilderNode$1 | {
+        maxConcurrency?: number;
+    }>) => BuilderNode$1;
+    loop: (options: {
+        id?: string;
+        children: BuilderNode$1;
+        until: (outputs: Record<string, unknown>) => boolean;
+        maxIterations?: number;
+        onMaxReached?: "fail" | "return-last";
+    }) => BuilderNode$1;
+    match: (source: BuilderStepHandle$1, options: {
+        when: (value: unknown) => boolean;
+        then: () => BuilderNode$1;
+        else?: () => BuilderNode$1;
+    }) => BuilderNode$1;
+    component: (instanceId: string, definition: ComponentDefinition, params?: Record<string, unknown>) => BuilderNode$1;
+};
+type BuiltSmithersWorkflow = {
+    execute: (input: unknown, opts?: Omit<Parameters<typeof runWorkflow>[1], "input">) => Effect.Effect<unknown, unknown, unknown>;
+};
+type WorkflowGraph<I = unknown, A = unknown> = {
+    readonly _tag: "WorkflowGraph";
+    readonly expr: unknown;
+    pipe<B = A>(...fns: Array<(g: WorkflowGraph<I, any>) => WorkflowGraph<I, any>>): WorkflowGraph<I, B>;
+};
+type GraphFactory = {
+    step: (id: string, options: StepOptions$1) => WorkflowGraph;
+    approval: (id: string, options: ApprovalOptions$1) => WorkflowGraph;
+    sequence: (...children: WorkflowGraph[]) => WorkflowGraph;
+    parallel: (...nodesOrOptions: Array<WorkflowGraph | { maxConcurrency?: number }>) => WorkflowGraph;
+    match: (source: WorkflowGraph, options: {
+        when: (value: unknown) => boolean;
+        then: WorkflowGraph;
+        else?: WorkflowGraph;
+    }) => WorkflowGraph;
+    branch: (options: {
+        condition: (ctx: Record<string, unknown>) => boolean;
+        needs?: Record<string, WorkflowGraph>;
+        then: WorkflowGraph;
+        else?: WorkflowGraph;
+    }) => WorkflowGraph;
+    loop: (options: {
+        id?: string;
+        children: WorkflowGraph;
+        until: (outputs: Record<string, unknown>) => boolean;
+        maxIterations?: number;
+        onMaxReached?: "fail" | "return-last";
+    }) => WorkflowGraph;
+    worktree: (options: {
+        id?: string;
+        path: string;
+        branch?: string;
+        skipIf?: (ctx: Record<string, unknown>) => boolean;
+        needs?: Record<string, WorkflowGraph>;
+        children: WorkflowGraph;
+    }) => WorkflowGraph;
+    scope: (instanceId: string, child: WorkflowGraph) => WorkflowGraph;
+};
+type WorkflowHandle = GraphFactory & {
+    from(graph: WorkflowGraph): BuiltSmithersWorkflow & { node: BuilderNode$1 };
+};
+declare function workflow(options: {
+    name: string;
+    input: AnySchema$1;
+}): WorkflowHandle;
+declare function fragment(_inputSchema: AnySchema$1): GraphFactory;
 declare const Smithers: {
     sqlite: typeof sqlite;
+    workflow: typeof workflow;
+    fragment: typeof fragment;
 };
 type AnySchema = effect.Schema.Schema<unknown, unknown, never>;
 type ApprovalOptions = {
@@ -1234,6 +1319,9 @@ type ApprovalOptions = {
     };
     onDeny?: "fail" | "continue" | "skip";
 };
+type BuiltSmithersWorkflow$1 = BuiltSmithersWorkflow;
+type BuilderApi$1 = BuilderApi;
+type StepOptions$1 = StepOptions;
 type BuilderNode = BuilderNode$1;
 type BuilderStepContext = Record<string, unknown> & {
     input: unknown;
@@ -1594,4 +1682,4 @@ type SmithersWorkflow = any;
 
 type ChildWorkflowDefinition = ChildWorkflowDefinition$1;
 
-export { type AlertHumanRequestOptions, AlertRuntime, type AlertRuntimeServices, type AnySchema, type ApprovalOptions, type ApprovalPayload, ApprovalPayloadSchema, type ApprovalResult, ApprovalResultSchema, type BridgeManagedTaskKind, type BuilderNode, type BuilderStepContext, type BuilderStepHandle, type CancelPayload, CancelPayloadSchema, type CancelResult, CancelResultSchema, type ChildWorkflowDefinition, type ChildWorkflowExecuteOptions, CodeplaneSandboxExecutorLive, type ComputeTaskBridgeToolConfig, type ContinuationRequest, type CorrelatedSmithersEvent, type CorrelationContext, type DiffBundle, DockerSandboxExecutorLive, EventBus, type ExecuteTaskActivityOptions, type FilePatch, type GetRunPayload, GetRunPayloadSchema, type GetRunResult, GetRunResultSchema, HUMAN_REQUEST_KINDS, HUMAN_REQUEST_STATUSES, type HijackState, type HotReloadEvent, HotWorkflowController, type HumanRequestKind, type HumanRequestSchemaValidation, type HumanRequestStatus, type JsonSchema, type LegacyExecuteTaskFn, type ListRunsPayload, ListRunsPayloadSchema, type OverlayOptions, type PlanNode, type RalphMeta, type RalphState, type RalphStateMap, type ReadonlyTaskStateMap, RetriableTaskFailure, type RetryPolicy, type RetryWaitMap, type RunResult$2 as RunResult, RunStatusSchema, type RunSummary, RunSummarySchema, type SQLiteTable, SandboxHttpRunner, type ScheduleResult, type ScheduleSnapshot, type SignalPayload, SignalPayloadSchema, type SignalResult, SignalResultSchema, type SignalRunOptions, Smithers, type SmithersAlertPolicy, type SmithersEvent, SmithersRpcGroup, type SmithersSqliteOptions, SqlMessageStorage, type StaticTaskBridgeToolConfig, type TaskActivityContext, type TaskActivityRetryOptions, type TaskBridgeToolConfig, type TaskRecord, TaskResult, type TaskState, type TaskStateMap, TaskWorkerEntity, WatchTree, type WatchTreeOptions, WorkerDispatchKind, WorkerTask$1 as WorkerTask, WorkerTaskKind, type WorkflowPatchDecisionRecord, type WorkflowPatchDecisions, type WorkflowVersioningRuntime, type WorkflowVersioningRuntimeOptions, type XmlNode, type _TaskActivityContext, applyDiffBundle, approve, approveNode, awaitApprovalDurableDeferred, awaitWaitForEventDurableDeferred, bridgeApprovalResolve, bridgeSignalResolve, bridgeWaitForEventResolve, buildHumanRequestId, buildOverlay, buildPlanTree, canExecuteBridgeManagedComputeTask, canExecuteBridgeManagedStaticTask, cancel, cancelPendingTimersBridge, cleanupGenerations, computeDiffBundle, computeDiffBundleBetweenRefs, createSchedulerWakeQueue, createWorkflowVersioningRuntime, denyNode, dispatchWorkerTask, ensureSqlMessageStorage, ensureSqlMessageStorageEffect, executeChildWorkflow, executeComputeTaskBridge, executeStaticTaskBridge, executeTaskActivity, executeTaskBridge, executeTaskBridgeEffect, getDefinedToolMetadata, getHumanTaskPrompt, getRun, getSqlMessageStorage, getWorkflowMakeBridgeRuntime, getWorkflowPatchDecisions, getWorkflowVersioningRuntime, isBridgeManagedTimerTask, isBridgeManagedWaitForEventTask, isHumanRequestPastTimeout, isHumanTaskMeta, isPidAlive, isRunHeartbeatFresh, isTaskResultFailure, jsonSchemaToZod, listRuns, makeAbortError, makeApprovalDurableDeferred, makeDurableDeferredBridgeExecutionId, makeTaskActivity, makeTaskBridgeKey, makeWaitForEventDurableDeferred, makeWorkerTask, parseAttemptMetaJson, parseRuntimeOwnerPid, renderFrame, resolveDeferredTaskStateBridge, resolveOverlayEntry, resolveSchema, runWorkflow, runWorkflowWithMakeBridge, scheduleTasks, signal, signalRun, subscribeTaskWorkerDispatches, usePatched, validateHumanRequestValue, wireAbortSignal, withWorkflowMakeBridgeRuntime, withWorkflowVersioningRuntime };
+export { type AlertHumanRequestOptions, AlertRuntime, type AlertRuntimeServices, type AnySchema, type ApprovalOptions, type ApprovalPayload, ApprovalPayloadSchema, type ApprovalResult, ApprovalResultSchema, type BridgeManagedTaskKind, type BuilderApi$1 as BuilderApi, type BuilderNode, type BuilderStepContext, type BuilderStepHandle, type BuiltSmithersWorkflow$1 as BuiltSmithersWorkflow, type CancelPayload, CancelPayloadSchema, type CancelResult, CancelResultSchema, type ChildWorkflowDefinition, type ChildWorkflowExecuteOptions, CodeplaneSandboxExecutorLive, type ComputeTaskBridgeToolConfig, type ContinuationRequest, type CorrelatedSmithersEvent, type CorrelationContext, type DiffBundle, DockerSandboxExecutorLive, EventBus, type ExecuteTaskActivityOptions, type FilePatch, type GetRunPayload, GetRunPayloadSchema, type GetRunResult, GetRunResultSchema, type GraphFactory, HUMAN_REQUEST_KINDS, HUMAN_REQUEST_STATUSES, type HijackState, type HotReloadEvent, HotWorkflowController, type HumanRequestKind, type HumanRequestSchemaValidation, type HumanRequestStatus, type JsonSchema, type LegacyExecuteTaskFn, type ListRunsPayload, ListRunsPayloadSchema, type OverlayOptions, type PlanNode, type RalphMeta, type RalphState, type RalphStateMap, type ReadonlyTaskStateMap, RetriableTaskFailure, type RetryPolicy, type RetryWaitMap, type RunResult$2 as RunResult, RunStatusSchema, type RunSummary, RunSummarySchema, type SQLiteTable, SandboxHttpRunner, type ScheduleResult, type ScheduleSnapshot, type SignalPayload, SignalPayloadSchema, type SignalResult, SignalResultSchema, type SignalRunOptions, Smithers, type SmithersAlertPolicy, type SmithersEvent, SmithersRpcGroup, type SmithersSqliteOptions, SqlMessageStorage, type StaticTaskBridgeToolConfig, type StepOptions$1 as StepOptions, type TaskActivityContext, type TaskActivityRetryOptions, type TaskBridgeToolConfig, type TaskRecord, TaskResult, type TaskState, type TaskStateMap, TaskWorkerEntity, WatchTree, type WatchTreeOptions, WorkerDispatchKind, WorkerTask$1 as WorkerTask, WorkerTaskKind, type WorkflowGraph, type WorkflowHandle, type WorkflowPatchDecisionRecord, type WorkflowPatchDecisions, type WorkflowVersioningRuntime, type WorkflowVersioningRuntimeOptions, type XmlNode, type _TaskActivityContext, applyDiffBundle, approve, approveNode, awaitApprovalDurableDeferred, awaitWaitForEventDurableDeferred, bridgeApprovalResolve, bridgeSignalResolve, bridgeWaitForEventResolve, buildHumanRequestId, buildOverlay, buildPlanTree, canExecuteBridgeManagedComputeTask, canExecuteBridgeManagedStaticTask, cancel, cancelPendingTimersBridge, cleanupGenerations, computeDiffBundle, computeDiffBundleBetweenRefs, createSchedulerWakeQueue, createWorkflowVersioningRuntime, denyNode, dispatchWorkerTask, ensureSqlMessageStorage, ensureSqlMessageStorageEffect, executeChildWorkflow, executeComputeTaskBridge, executeStaticTaskBridge, executeTaskActivity, executeTaskBridge, executeTaskBridgeEffect, fragment, getDefinedToolMetadata, getHumanTaskPrompt, getRun, getSqlMessageStorage, getWorkflowMakeBridgeRuntime, getWorkflowPatchDecisions, getWorkflowVersioningRuntime, isBridgeManagedTimerTask, isBridgeManagedWaitForEventTask, isHumanRequestPastTimeout, isHumanTaskMeta, isPidAlive, isRunHeartbeatFresh, isTaskResultFailure, jsonSchemaToZod, listRuns, makeAbortError, makeApprovalDurableDeferred, makeDurableDeferredBridgeExecutionId, makeTaskActivity, makeTaskBridgeKey, makeWaitForEventDurableDeferred, makeWorkerTask, parseAttemptMetaJson, parseRuntimeOwnerPid, renderFrame, resolveDeferredTaskStateBridge, resolveOverlayEntry, resolveSchema, runWorkflow, runWorkflowWithMakeBridge, scheduleTasks, signal, signalRun, subscribeTaskWorkerDispatches, usePatched, validateHumanRequestValue, wireAbortSignal, withWorkflowMakeBridgeRuntime, withWorkflowVersioningRuntime, workflow };