@smithers-orchestrator/driver 0.16.0

package/src/child-process.js

@@ -0,0 +1,222 @@
+import { spawn } from "node:child_process";
+import { Effect, Metric } from "effect";
+import { ignoreSyncError } from "./interop.js";
+import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { toolOutputTruncatedTotal } from "@smithers-orchestrator/observability/metrics";
+import { logDebug, logWarning } from "@smithers-orchestrator/observability/logging";
+/** @typedef {import("./SpawnCaptureOptions.ts").SpawnCaptureOptions} SpawnCaptureOptions */
+/** @typedef {import("./SpawnCaptureResult.ts").SpawnCaptureResult} SpawnCaptureResult */
+
+/**
+ * @param {string} text
+ * @param {number} maxBytes
+ * @returns {string}
+ */
+function truncateToBytes(text, maxBytes) {
+    const buf = Buffer.from(text, "utf8");
+    if (buf.length <= maxBytes)
+        return text;
+    return buf.subarray(0, maxBytes).toString("utf8");
+}
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {SpawnCaptureOptions} options
+ * @returns {Effect.Effect<SpawnCaptureResult, SmithersError>}
+ */
+export function spawnCaptureEffect(command, args, options) {
+    const { cwd, env, input, signal, timeoutMs, idleTimeoutMs, maxOutputBytes = 200_000, detached = false, onStdout, onStderr, } = options;
+    const errorDetails = {
+        command,
+        args,
+        cwd,
+        timeoutMs,
+        idleTimeoutMs,
+    };
+    const logAnnotations = {
+        command,
+        args: args.join(" "),
+        cwd,
+        timeoutMs: timeoutMs ?? null,
+        idleTimeoutMs: idleTimeoutMs ?? null,
+    };
+    const span = `process:${command}`;
+    return (Effect.async((resume) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        logDebug("spawning child process", logAnnotations, span);
+        const child = spawn(command, args, {
+            cwd,
+            env,
+            detached,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        /**
+     * @param {string} reason
+     * @param {"PROCESS_ABORTED" | "PROCESS_TIMEOUT" | "PROCESS_IDLE_TIMEOUT"} code
+     */
+        const kill = (reason, code) => {
+            logWarning("child process interrupted", {
+                ...logAnnotations,
+                reason,
+                errorCode: code,
+            }, span);
+            try {
+                if (detached && child.pid) {
+                    process.kill(-child.pid, "SIGKILL");
+                }
+                else {
+                    child.kill("SIGKILL");
+                }
+            }
+            catch {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (!settled) {
+                settled = true;
+                resume(Effect.fail(new SmithersError(code, reason, errorDetails)));
+            }
+        };
+        let totalTimer;
+        let idleTimer;
+        const resetIdle = () => {
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            if (idleTimeoutMs) {
+                idleTimer = setTimeout(() => {
+                    kill(`CLI idle timed out after ${idleTimeoutMs}ms`, "PROCESS_IDLE_TIMEOUT");
+                }, idleTimeoutMs);
+            }
+        };
+        if (timeoutMs) {
+            totalTimer = setTimeout(() => {
+                kill(`CLI timed out after ${timeoutMs}ms`, "PROCESS_TIMEOUT");
+            }, timeoutMs);
+        }
+        resetIdle();
+        /**
+     * @param {SpawnCaptureResult} result
+     */
+        const finalize = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (totalTimer)
+                clearTimeout(totalTimer);
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            logDebug("child process completed", {
+                ...logAnnotations,
+                exitCode: result.exitCode,
+                stderrBytes: Buffer.byteLength(result.stderr, "utf8"),
+                stdoutBytes: Buffer.byteLength(result.stdout, "utf8"),
+            }, span);
+            let truncationCount = 0;
+            if (stdoutTruncated)
+                truncationCount++;
+            if (stderrTruncated)
+                truncationCount++;
+            resume(Effect.succeed({ result, truncationCount }));
+        };
+        if (signal) {
+            if (signal.aborted) {
+                kill("CLI aborted", "PROCESS_ABORTED");
+            }
+            else {
+                signal.addEventListener("abort", () => kill("CLI aborted", "PROCESS_ABORTED"), {
+                    once: true,
+                });
+            }
+        }
+        child.stdout?.on("data", (chunk) => {
+            resetIdle();
+            const text = chunk.toString("utf8");
+            const nextStdout = stdout + text;
+            if (!stdoutTruncated && Buffer.byteLength(nextStdout, "utf8") > maxOutputBytes) {
+                stdoutTruncated = true;
+                logWarning("child process stdout truncated", {
+                    ...logAnnotations,
+                    maxOutputBytes,
+                    stream: "stdout",
+                }, span);
+            }
+            stdout = truncateToBytes(nextStdout, maxOutputBytes);
+            onStdout?.(text);
+        });
+        child.stderr?.on("data", (chunk) => {
+            resetIdle();
+            const text = chunk.toString("utf8");
+            const nextStderr = stderr + text;
+            if (!stderrTruncated && Buffer.byteLength(nextStderr, "utf8") > maxOutputBytes) {
+                stderrTruncated = true;
+                logWarning("child process stderr truncated", {
+                    ...logAnnotations,
+                    maxOutputBytes,
+                    stream: "stderr",
+                }, span);
+            }
+            stderr = truncateToBytes(nextStderr, maxOutputBytes);
+            onStderr?.(text);
+        });
+        child.on("error", (error) => {
+            if (totalTimer)
+                clearTimeout(totalTimer);
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            if (!settled) {
+                settled = true;
+                const smithersError = toSmithersError(error, `spawn ${command}`, {
+                    code: "PROCESS_SPAWN_FAILED",
+                    details: errorDetails,
+                });
+                logWarning("failed to spawn child process", {
+                    ...logAnnotations,
+                    error: smithersError.message,
+                }, span);
+                resume(Effect.fail(smithersError));
+            }
+        });
+        child.on("close", (code) => {
+            finalize({ stdout, stderr, exitCode: code ?? null });
+        });
+        if (input) {
+            child.stdin?.write(input);
+        }
+        child.stdin?.end();
+        return Effect.gen(function* () {
+            if (totalTimer)
+                clearTimeout(totalTimer);
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            if (!settled) {
+                yield* Effect.try({
+                    try: () => {
+                        if (detached && child.pid) {
+                            process.kill(-child.pid, "SIGKILL");
+                        }
+                        else {
+                            child.kill("SIGKILL");
+                        }
+                    },
+                    catch: (cause) => toSmithersError(cause, "kill process group", {
+                        code: "PROCESS_ABORTED",
+                        details: errorDetails,
+                    }),
+                }).pipe(Effect.catchAll(() => ignoreSyncError("kill fallback", () => child.kill("SIGKILL"))));
+            }
+        });
+    })).pipe(Effect.tap(({ truncationCount }) => truncationCount > 0
+        ? Metric.incrementBy(toolOutputTruncatedTotal, truncationCount)
+        : Effect.void), Effect.map(({ result }) => result), Effect.annotateLogs({
+        ...logAnnotations,
+    }), Effect.withLogSpan(span));
+}

package/src/defaultTaskExecutor.js

@@ -0,0 +1,28 @@
+import { withAbort } from "./withAbort.js";
+/** @typedef {import("@smithers-orchestrator/graph").TaskDescriptor} TaskDescriptor */
+/** @typedef {import("./workflow-types.ts").TaskExecutorContext} TaskExecutorContext */
+
+/**
+ * @param {TaskDescriptor} task
+ * @param {TaskExecutorContext} context
+ * @returns {Promise<unknown>}
+ */
+export async function defaultTaskExecutor(task, context) {
+    if (typeof task.computeFn === "function") {
+        return withAbort(Promise.resolve().then(() => task.computeFn()), context.signal);
+    }
+    if ("staticPayload" in task && task.staticPayload !== undefined) {
+        return task.staticPayload;
+    }
+    const agent = Array.isArray(task.agent) ? task.agent[0] : task.agent;
+    if (agent && typeof agent === "object") {
+        const target = agent;
+        for (const method of ["execute", "run", "call"]) {
+            const fn = target[method];
+            if (typeof fn === "function") {
+                return withAbort(Promise.resolve().then(() => fn(task, context)), context.signal);
+            }
+        }
+    }
+    return task.prompt ?? null;
+}

package/src/filterRowsByNodeId.js

@@ -0,0 +1,19 @@
+/**
+ * @param {readonly any[]} rows
+ * @param {string} lookupNodeId
+ * @param {Set<string>} currentScopes
+ * @returns {any[]}
+ */
+export function filterRowsByNodeId(rows, lookupNodeId, currentScopes) {
+    const exact = rows.filter((row) => row.nodeId === lookupNodeId);
+    if (exact.length > 0 || lookupNodeId.includes("@@"))
+        return exact;
+    const sortedScopes = [...currentScopes].sort((a, b) => b.length - a.length);
+    for (const scope of sortedScopes) {
+        const scopedId = lookupNodeId + scope;
+        const matched = rows.filter((row) => row.nodeId === scopedId);
+        if (matched.length > 0)
+            return matched;
+    }
+    return [];
+}

package/src/ignoreSyncError.js

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+/**
+ * @param {string} _label
+ * @param {() => void} fn
+ * @returns {Effect.Effect<void>}
+ */
+export function ignoreSyncError(_label, fn) {
+    return Effect.sync(() => {
+        try {
+            fn();
+        }
+        catch {
+            // Best-effort cleanup intentionally swallows failures.
+        }
+    });
+}

package/src/index.d.ts

@@ -0,0 +1,411 @@
+import * as _smithers_graph_types from '@smithers-orchestrator/graph/types';
+import { WorkflowGraph as WorkflowGraph$1, TaskDescriptor as TaskDescriptor$1 } from '@smithers-orchestrator/graph/types';
+import { SmithersEvent } from '@smithers-orchestrator/observability/SmithersEvent';
+import * as _smithers_scheduler from '@smithers-orchestrator/scheduler';
+import { WaitReason as WaitReason$1, EngineDecision as EngineDecision$1 } from '@smithers-orchestrator/scheduler';
+import { z } from 'zod';
+import { SmithersWorkflowOptions } from '@smithers-orchestrator/scheduler/SmithersWorkflowOptions';
+import { SchemaRegistryEntry } from '@smithers-orchestrator/db/SchemaRegistryEntry';
+import * as _smithers_graph from '@smithers-orchestrator/graph';
+import { ExtractOptions, WorkflowGraph } from '@smithers-orchestrator/graph';
+
+type TaskCompletedEvent = {
+    nodeId: string;
+    iteration: number;
+    output: unknown;
+};
+
+type TaskFailedEvent = {
+    nodeId: string;
+    iteration: number;
+    error: unknown;
+};
+
+type WorkflowSession$2 = {
+    submitGraph(graph: WorkflowGraph$1): unknown;
+    taskCompleted(event: TaskCompletedEvent): unknown;
+    taskFailed(event: TaskFailedEvent): unknown;
+    getNextDecision?(): unknown;
+    cancelRequested?(): unknown;
+};
+
+type WorkflowRuntime$2 = {
+    runPromise<A>(effect: unknown): Promise<A>;
+};
+
+type RunAuthContext$2 = {
+    triggeredBy: string;
+    scopes: string[];
+    role: string;
+    createdAt: string;
+};
+
+type HotReloadOptions$1 = {
+    /** Root directory to watch for changes (default: auto-detect from workflow entry) */
+    rootDir?: string;
+    /** Directory for generation overlays (default: .smithers/hmr/<runId>) */
+    outDir?: string;
+    /** Max overlay generations to keep (default: 3) */
+    maxGenerations?: number;
+    /** Whether to cancel tasks that become unmounted after hot reload (default: false) */
+    cancelUnmounted?: boolean;
+    /** Debounce interval in ms for file change events (default: 100) */
+    debounceMs?: number;
+};
+type RunOptions$2 = {
+    runId?: string;
+    parentRunId?: string | null;
+    input: Record<string, unknown>;
+    maxConcurrency?: number;
+    onProgress?: (e: SmithersEvent) => void;
+    signal?: AbortSignal;
+    resume?: boolean;
+    force?: boolean;
+    workflowPath?: string;
+    rootDir?: string;
+    logDir?: string | null;
+    allowNetwork?: boolean;
+    maxOutputBytes?: number;
+    toolTimeoutMs?: number;
+    hot?: boolean | HotReloadOptions$1;
+    auth?: RunAuthContext$2 | null;
+    config?: Record<string, unknown>;
+    cliAgentToolsDefault?: "all" | "explicit-only";
+    resumeClaim?: {
+        claimOwnerId: string;
+        claimHeartbeatAtMs: number;
+        restoreRuntimeOwnerId?: string | null;
+        restoreHeartbeatAtMs?: number | null;
+    };
+};
+
+type RunStatus$1 = "running" | "waiting-approval" | "waiting-event" | "waiting-timer" | "finished" | "continued" | "failed" | "cancelled";
+
+type RunResult$2 = {
+    readonly runId: string;
+    readonly status: RunStatus$1;
+    readonly output?: unknown;
+    readonly error?: unknown;
+    readonly nextRunId?: string;
+};
+
+type ContinueAsNewHandler$1 = (transition: unknown, context: {
+    runId: string;
+    options: RunOptions$2;
+}) => Promise<RunResult$2> | RunResult$2;
+
+type CreateWorkflowSessionOptions = {
+    db?: unknown;
+    runId: string;
+    rootDir?: string;
+    workflowPath?: string | null;
+    options: RunOptions$2;
+};
+
+type CreateWorkflowSession$1 = (opts: CreateWorkflowSessionOptions) => unknown;
+
+type SchedulerWaitHandler$1 = (durationMs: number, context: {
+    runId: string;
+    tasks: readonly TaskDescriptor$1[];
+}) => Promise<void> | void;
+
+type TaskExecutorContext = {
+    runId: string;
+    options: RunOptions$2;
+    signal?: AbortSignal;
+};
+
+type TaskExecutor$1 = (task: TaskDescriptor$1, context: TaskExecutorContext) => Promise<unknown> | unknown;
+
+type WaitHandler$1 = (reason: WaitReason$1, context: {
+    runId: string;
+    options: RunOptions$2;
+}) => Promise<EngineDecision$1 | RunResult$2> | EngineDecision$1 | RunResult$2;
+
+type InferRow<TTable> = TTable extends {
+    $inferSelect: infer R;
+} ? R : never;
+type InferOutputEntry$1<T> = T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: unknown;
+} ? InferRow<T> : never;
+type FallbackTableName<Schema> = [keyof Schema & string] extends [never] ? string : never;
+type OutputAccessor$2<Schema, TRow = unknown> = {
+    (table: FallbackTableName<Schema>): Array<TRow>;
+    <K extends keyof Schema & string>(table: K): Array<InferOutputEntry$1<Schema[K]>>;
+} & {
+    [K in keyof Schema & string]: Array<InferOutputEntry$1<Schema[K]>>;
+};
+
+type SmithersRuntimeConfig$1 = {
+    cliAgentToolsDefault?: "all" | "explicit-only";
+};
+
+type OutputSnapshot$2<TFallback = unknown> = {
+    [tableName: string]: Array<TFallback>;
+};
+
+type SmithersCtxOptions$2 = {
+    runId: string;
+    iteration: number;
+    iterations?: Record<string, number>;
+    input: unknown;
+    auth?: RunAuthContext$2 | null;
+    outputs: OutputSnapshot$2;
+    zodToKeyName?: Map<any, string>;
+    runtimeConfig?: SmithersRuntimeConfig$1;
+};
+
+type SafeParser$1 = {
+    safeParse(value: unknown): {
+        success: true;
+        data: unknown;
+    } | {
+        success: false;
+        error?: unknown;
+    };
+};
+
+type OutputKey$2 = {
+    nodeId: string;
+    iteration?: number;
+};
+
+/**
+ * @template {unknown} [Schema=unknown]
+ */
+declare class SmithersCtx<Schema extends unknown = unknown> {
+    /**
+     * @param {SmithersCtxOptions} opts
+     */
+    constructor(opts: SmithersCtxOptions$1);
+    /** @type {string} */
+    runId: string;
+    /** @type {number} */
+    iteration: number;
+    /** @type {Record<string, number> | undefined} */
+    iterations: Record<string, number> | undefined;
+    /** @type {Schema extends { input: infer T } ? T : unknown} */
+    input: Schema extends {
+        input: infer T;
+    } ? T : unknown;
+    /** @type {RunAuthContext | null} */
+    auth: RunAuthContext$1 | null;
+    /** @type {SmithersRuntimeConfig | null | undefined} */
+    __smithersRuntime: SmithersRuntimeConfig | null | undefined;
+    /** @type {OutputAccessor<Schema>} */
+    outputs: OutputAccessor$1<Schema>;
+    /** @type {import("./OutputSnapshot.ts").OutputSnapshot} */
+    _outputs: OutputSnapshot$2;
+    /** @type {Map<unknown, string> | undefined} */
+    _zodToKeyName: Map<unknown, string> | undefined;
+    /** @type {Set<string>} */
+    _currentScopes: Set<string>;
+    /**
+     * @param {TableRef} table
+     * @param {OutputKey} key
+     * @returns {OutputRow}
+     */
+    output(table: TableRef, key: OutputKey$1): OutputRow;
+    /**
+     * @param {TableRef} table
+     * @param {OutputKey} key
+     * @returns {OutputRow | undefined}
+     */
+    outputMaybe(table: TableRef, key: OutputKey$1): OutputRow | undefined;
+    /**
+     * @param {TableRef} table
+     * @param {string} nodeId
+     * @returns {OutputRow | undefined}
+     */
+    latest(table: TableRef, nodeId: string): OutputRow | undefined;
+    /**
+     * @param {unknown} value
+     * @param {SafeParser} schema
+     * @returns {unknown[]}
+     */
+    latestArray(value: unknown, schema: SafeParser): unknown[];
+    /**
+     * @param {TableRef} table
+     * @param {string} nodeId
+     * @returns {number}
+     */
+    iterationCount(table: TableRef, nodeId: string): number;
+    /**
+     * @param {TableRef} table
+     * @returns {string}
+     */
+    resolveTableName(table: TableRef): string;
+    /**
+     * @param {TableRef} table
+     * @param {OutputKey} key
+     * @returns {OutputRow | undefined}
+     */
+    resolveRow(table: TableRef, key: OutputKey$1): OutputRow | undefined;
+}
+type OutputKey$1 = OutputKey$2;
+type SafeParser = SafeParser$1;
+type SmithersCtxOptions$1 = SmithersCtxOptions$2;
+type RunAuthContext$1 = RunAuthContext$2;
+type SmithersRuntimeConfig = SmithersRuntimeConfig$1;
+type TableRef = unknown;
+type OutputRow = Record<string, unknown> & {
+    iteration?: number;
+    nodeId?: string;
+};
+type OutputAccessor$1<Schema> = OutputAccessor$2<Schema>;
+
+type WorkflowElement = {
+    type: unknown;
+    props: unknown;
+    key: string | number | null;
+};
+
+type WorkflowSmithersCtx<Schema = unknown> = SmithersCtx<Schema>;
+type WorkflowDefinition$1<Schema = unknown> = {
+    readableName?: string;
+    description?: string;
+    db?: unknown;
+    build: (ctx: WorkflowSmithersCtx<Schema>) => WorkflowElement;
+    opts: SmithersWorkflowOptions;
+    schemaRegistry?: Map<string, SchemaRegistryEntry>;
+    zodToKeyName?: Map<z.ZodObject<z.ZodRawShape>, string>;
+};
+
+type WorkflowGraphRenderer$1 = {
+    render(element: WorkflowElement, opts?: ExtractOptions): Promise<WorkflowGraph> | WorkflowGraph;
+};
+
+type WorkflowDriverOptions$1<Schema = unknown> = {
+    workflow: WorkflowDefinition$1<Schema>;
+    runtime: WorkflowRuntime$2;
+    renderer: WorkflowGraphRenderer$1;
+    session?: WorkflowSession$2;
+    createSession?: CreateWorkflowSession$1;
+    db?: unknown;
+    runId?: string;
+    rootDir?: string;
+    workflowPath?: string | null;
+    executeTask?: TaskExecutor$1;
+    onSchedulerWait?: SchedulerWaitHandler$1;
+    onWait?: WaitHandler$1;
+    continueAsNew?: ContinueAsNewHandler$1;
+};
+
+/**
+ * @template {unknown} [Schema=unknown]
+ */
+declare class WorkflowDriver<Schema extends unknown = unknown> {
+    /**
+     * @param {import("./WorkflowDriverOptions.ts").WorkflowDriverOptions<Schema>} options
+     */
+    constructor(options: WorkflowDriverOptions$1<Schema>);
+    /** @type {import("./WorkflowDefinition.ts").WorkflowDefinition<Schema>} */
+    workflow: WorkflowDefinition$1<Schema>;
+    /** @type {WorkflowRuntime} */
+    runtime: WorkflowRuntime$1;
+    /** @type {unknown} */
+    db: unknown;
+    /** @type {string | undefined} */
+    configuredRunId: string | undefined;
+    /** @type {string | undefined} */
+    rootDir: string | undefined;
+    /** @type {string | null | undefined} */
+    workflowPath: string | null | undefined;
+    /** @type {TaskExecutor} */
+    executeTask: TaskExecutor;
+    /** @type {SchedulerWaitHandler | undefined} */
+    onSchedulerWait: SchedulerWaitHandler | undefined;
+    /** @type {WaitHandler | undefined} */
+    onWait: WaitHandler | undefined;
+    /** @type {ContinueAsNewHandler | undefined} */
+    continueAsNewHandler: ContinueAsNewHandler | undefined;
+    /** @type {CreateWorkflowSession | undefined} */
+    createSession: CreateWorkflowSession | undefined;
+    /** @type {WorkflowGraphRenderer} */
+    renderer: WorkflowGraphRenderer;
+    /** @type {WorkflowSession | undefined} */
+    session: WorkflowSession$1 | undefined;
+    /** @type {string} */
+    activeRunId: string;
+    /** @type {RunOptions | undefined} */
+    activeOptions: RunOptions$1 | undefined;
+    /** @type {import("@smithers-orchestrator/graph").WorkflowGraph | undefined} */
+    lastGraph: _smithers_graph.WorkflowGraph | undefined;
+    /** @type {Map<string, string>} */
+    outputTablesByNodeId: Map<string, string>;
+    /** @type {OutputSnapshot} */
+    baseOutputs: OutputSnapshot$1;
+    /**
+   * @param {RunOptions} options
+   * @returns {Promise<RunResult>}
+   */
+    run(options: RunOptions$1): Promise<RunResult$1>;
+    /**
+   * @param {string} runId
+   * @param {RunOptions} options
+   * @returns {Promise<WorkflowSession>}
+   */
+    initializeSession(runId: string, options: RunOptions$1): Promise<WorkflowSession$1>;
+    /**
+   * @param {RenderContext} context
+   * @returns {Promise<EngineDecision>}
+   */
+    renderAndSubmit(context: RenderContext): Promise<EngineDecision>;
+    /**
+   * @param {readonly TaskDescriptor[]} tasks
+   * @returns {Promise<EngineDecision | RunResult>}
+   */
+    executeTasks(tasks: readonly TaskDescriptor[]): Promise<EngineDecision | RunResult$1>;
+    /**
+   * @param {WaitReason} reason
+   * @returns {Promise<EngineDecision | RunResult>}
+   */
+    handleWait(reason: WaitReason): Promise<EngineDecision | RunResult$1>;
+    /**
+   * @param {unknown} transition
+   * @returns {Promise<RunResult>}
+   */
+    continueAsNew(transition: unknown): Promise<RunResult$1>;
+    /**
+   * @returns {Promise<RunResult>}
+   */
+    cancelRun(): Promise<RunResult$1>;
+    /**
+   * @template A
+   * @param {unknown} effect
+   * @returns {Promise<A>}
+   */
+    runEffect<A>(effect: unknown): Promise<A>;
+}
+type CreateWorkflowSession = CreateWorkflowSession$1;
+type OutputSnapshot$1 = OutputSnapshot$2;
+type WorkflowSession$1 = WorkflowSession$2;
+type WorkflowRuntime$1 = WorkflowRuntime$2;
+type WorkflowGraphRenderer = WorkflowGraphRenderer$1;
+type TaskExecutor = TaskExecutor$1;
+type SchedulerWaitHandler = SchedulerWaitHandler$1;
+type WaitHandler = WaitHandler$1;
+type ContinueAsNewHandler = ContinueAsNewHandler$1;
+type RunOptions$1 = RunOptions$2;
+type RunResult$1 = _smithers_scheduler.RunResult;
+type EngineDecision = _smithers_scheduler.EngineDecision;
+type RenderContext = _smithers_scheduler.RenderContext;
+type WaitReason = _smithers_scheduler.WaitReason;
+type TaskDescriptor = _smithers_graph_types.TaskDescriptor;
+
+type HotReloadOptions = HotReloadOptions$1;
+type OutputAccessor<Schema = any> = OutputAccessor$2<Schema>;
+type InferOutputEntry<T> = InferOutputEntry$1<T>;
+type OutputKey = OutputKey$2;
+type OutputSnapshot = OutputSnapshot$2;
+type RunAuthContext = RunAuthContext$2;
+type RunOptions = RunOptions$2;
+type RunResult = RunResult$2;
+type RunStatus = RunStatus$1;
+type SmithersCtxOptions = SmithersCtxOptions$2;
+type WorkflowDefinition<Schema = unknown> = WorkflowDefinition$1<Schema>;
+type WorkflowDriverOptions<Schema = unknown> = WorkflowDriverOptions$1<Schema>;
+type WorkflowRuntime = WorkflowRuntime$2;
+type WorkflowSession = WorkflowSession$2;
+
+export { type HotReloadOptions, type InferOutputEntry, type OutputAccessor, type OutputKey, type OutputSnapshot, type RunAuthContext, type RunOptions, type RunResult, type RunStatus, SmithersCtx, type SmithersCtxOptions, type WorkflowDefinition, WorkflowDriver, type WorkflowDriverOptions, type WorkflowRuntime, type WorkflowSession };