smithers-orchestrator 0.15.1 → 0.16.0

package/package.json

@@ -1,128 +1,62 @@
 {
   "name": "smithers-orchestrator",
-  "version": "0.15.1",
-  "description": "AI workflow orchestration with JSX",
-  "author": "William Cory",
-  "license": "MIT",
-  "module": "src/index.ts",
+  "version": "0.16.0",
+  "description": "Public Smithers facade and workflow authoring convenience package",
   "type": "module",
-  "bin": {
-    "smithers": "src/cli/index.ts"
-  },
+  "sideEffects": false,
   "exports": {
-    ".": "./src/index.ts",
-    "./gateway": "./src/gateway/index.ts",
-    "./jsx-runtime": "./src/jsx-runtime.ts",
-    "./jsx-dev-runtime": "./src/jsx-runtime.ts",
-    "./tools": "./src/tools/index.ts",
-    "./server": "./src/server/index.ts",
-    "./observability": "./src/observability/index.ts",
-    "./pi-plugin": "./src/pi-plugin/index.ts",
-    "./pi-extension": "./src/pi-plugin/extension.ts",
-    "./mdx-plugin": "./src/mdx-plugin.ts",
-    "./dom/renderer": "./src/dom/renderer.ts",
-    "./serve": "./src/server/serve.ts",
-    "./scorers": "./src/scorers/index.ts",
-    "./voice": "./src/voice/index.ts",
-    "./rag": "./src/rag/index.ts",
-    "./memory": "./src/memory/index.ts",
-    "./openapi": "./src/openapi/index.ts"
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./tools": {
+      "types": "./src/tools.d.ts",
+      "import": "./src/tools.js",
+      "default": "./src/tools.js"
+    },
+    "./*": {
+      "types": "./src/index.d.ts",
+      "import": "./src/*.js",
+      "default": "./src/*.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./src/index.d.ts",
+      "import": "./src/jsx-runtime.js",
+      "default": "./src/jsx-runtime.js"
+    }
   },
   "files": [
-    "src/",
-    "docs/",
-    "observability/",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/evmts/smithers.git"
-  },
-  "homepage": "https://github.com/evmts/smithers#readme",
-  "bugs": {
-    "url": "https://github.com/evmts/smithers/issues"
-  },
-  "keywords": [
-    "ai",
-    "agent",
-    "react",
-    "jsx",
-    "llm",
-    "claude",
-    "orchestration",
-    "workflow",
-    "bun"
+    "src/"
   ],
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "typecheck:examples": "tsc -p tsconfig.examples.json --noEmit",
-    "lint": "oxlint --react-plugin --node-plugin --import-plugin --ignore-path .gitignore src tests apps/cli/src",
-    "lint:fix": "oxlint --react-plugin --node-plugin --import-plugin --ignore-path .gitignore --fix src tests apps/cli/src",
-    "cli": "bun run src/cli/index.ts",
-    "test": "bash ./scripts/run-all-tests.sh",
-    "e2e": "playwright test",
-    "docs": "cd docs && bunx mintlify dev"
-  },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.36",
-    "@ai-sdk/openai": "^3.0.41",
-    "@effect/cluster": "^0.58.0",
-    "@effect/opentelemetry": "^0.61.0",
-    "@effect/platform": "^0.96.0",
-    "@effect/platform-bun": "^0.89.0",
-    "@effect/rpc": "^0.75.0",
-    "@effect/sql": "^0.51.0",
-    "@effect/sql-sqlite-bun": "^0.52.0",
-    "@effect/workflow": "^0.18.0",
-    "@mariozechner/pi-coding-agent": "0.63.1",
-    "@mariozechner/pi-tui": "0.63.1",
-    "@mdx-js/esbuild": "^3.1.1",
-    "@modelcontextprotocol/sdk": "^1.27.0",
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.213.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
-    "@opentelemetry/resources": "^2.6.0",
-    "@opentelemetry/sdk-logs": "^0.213.0",
-    "@opentelemetry/sdk-metrics": "^2.6.0",
-    "@opentelemetry/sdk-trace-base": "^2.6.0",
-    "@opentelemetry/sdk-trace-node": "^2.6.0",
-    "@opentelemetry/semantic-conventions": "^1.40.0",
-    "@opentui/core": "^0.1.92",
-    "@opentui/react": "^0.1.92",
-    "@sinclair/typebox": "0.34.49",
-    "@types/react-dom": "^19.2.3",
-    "@types/react-reconciler": "^0.28.9",
     "ai": "^6.0.69",
-    "bippy": "^0.5.32",
-    "cron-parser": "^5.5.0",
     "diff": "^5.2.0",
-    "drizzle-orm": "^0.45.1",
-    "drizzle-zod": "^0.8.3",
-    "effect": "^3.21.0",
-    "hono": "^4.12.8",
-    "incur": "^0.3.3",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "react-reconciler": "^0.31.0",
-    "picocolors": "^1.1.1",
-    "ws": "^8.18.0",
-    "zod": "^4.3.6"
-  },
-  "peerDependencies": {
-    "typescript": "~5.9.3"
+    "zod": "^4.3.6",
+    "@smithers-orchestrator/agents": "0.16.0",
+    "@smithers-orchestrator/driver": "0.16.0",
+    "@smithers-orchestrator/engine": "0.16.0",
+    "@smithers-orchestrator/errors": "0.16.0",
+    "@smithers-orchestrator/db": "0.16.0",
+    "@smithers-orchestrator/memory": "0.16.0",
+    "@smithers-orchestrator/graph": "0.16.0",
+    "@smithers-orchestrator/observability": "0.16.0",
+    "@smithers-orchestrator/openapi": "0.16.0",
+    "@smithers-orchestrator/components": "0.16.0",
+    "@smithers-orchestrator/react-reconciler": "0.16.0",
+    "@smithers-orchestrator/sandbox": "0.16.0",
+    "@smithers-orchestrator/scheduler": "0.16.0",
+    "@smithers-orchestrator/scorers": "0.16.0",
+    "@smithers-orchestrator/server": "0.16.0",
+    "@smithers-orchestrator/vcs": "0.16.0",
+    "@smithers-orchestrator/time-travel": "0.16.0"
   },
   "devDependencies": {
-    "@playwright/test": "^1.52.0",
-    "@tanstack/react-query": "^5.96.2",
     "@types/bun": "latest",
-    "@types/diff": "^5.2.0",
-    "@types/react": "^19.2.10",
-    "@types/ws": "^8.5.12",
-    "oxlint": "^1.59.0",
     "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build": "tsup --dts-only"
   }
-}
+}

package/src/CreateSmithersApi.ts

@@ -0,0 +1,62 @@
+import type React from "react";
+import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+import type {
+	Sequence as BaseSequence,
+	Parallel as BaseParallel,
+	MergeQueue as BaseMergeQueue,
+	Branch as BaseBranch,
+	Loop as BaseLoop,
+	Ralph as BaseRalph,
+		ContinueAsNew as BaseContinueAsNew,
+		continueAsNew as baseContinueAsNew,
+		Worktree as BaseWorktree,
+		Timer as BaseTimer,
+} from "@smithers-orchestrator/components";
+import type { ApprovalProps } from "@smithers-orchestrator/components/components/ApprovalProps";
+import type { DepsSpec } from "@smithers-orchestrator/components/components/DepsSpec";
+import type { SandboxProps } from "@smithers-orchestrator/components/components/SandboxProps";
+import type { SignalProps } from "@smithers-orchestrator/components/components/SignalProps";
+import type { TaskProps } from "@smithers-orchestrator/components/components/TaskProps";
+import type { WorkflowProps } from "@smithers-orchestrator/components/components/WorkflowProps";
+import type { SmithersWorkflow } from "@smithers-orchestrator/components/SmithersWorkflow";
+import type { SmithersWorkflowOptions } from "@smithers-orchestrator/scheduler/SmithersWorkflowOptions";
+import type { SmithersCtx } from "@smithers-orchestrator/driver/SmithersCtx";
+import type { z } from "zod";
+
+/** Union of all Zod schema values registered in the schema, constrained to ZodObject. */
+type SchemaOutput<Schema> = Extract<Schema[keyof Schema], z.ZodObject<z.ZodRawShape>>;
+type RuntimeSchema<Schema> = Schema extends { input: infer Input }
+	? Omit<Schema, "input"> & {
+			input: Input extends z.ZodTypeAny ? z.infer<Input> : Input;
+		}
+	: Schema;
+
+export type CreateSmithersApi<Schema = unknown> = {
+	Workflow: (props: WorkflowProps) => React.ReactElement;
+	Approval: <Row>(props: ApprovalProps<Row, SchemaOutput<Schema>>) => React.ReactElement;
+	Task: <Row, D extends DepsSpec = {}>(
+		props: TaskProps<Row, SchemaOutput<Schema>, D>,
+	) => React.ReactElement;
+	Sequence: typeof BaseSequence;
+	Parallel: typeof BaseParallel;
+	MergeQueue: typeof BaseMergeQueue;
+	Branch: typeof BaseBranch;
+	Loop: typeof BaseLoop;
+	Ralph: typeof BaseRalph;
+	ContinueAsNew: typeof BaseContinueAsNew;
+	continueAsNew: typeof baseContinueAsNew;
+	Worktree: typeof BaseWorktree;
+	Sandbox: (props: SandboxProps) => React.ReactElement;
+	Signal: <SignalSchema extends z.ZodObject<z.ZodRawShape>>(
+		props: SignalProps<SignalSchema>,
+	) => React.ReactElement;
+	Timer: typeof BaseTimer;
+	useCtx: () => SmithersCtx<RuntimeSchema<Schema>>;
+	smithers: (
+		build: (ctx: SmithersCtx<RuntimeSchema<Schema>>) => React.ReactElement,
+		opts?: SmithersWorkflowOptions,
+	) => SmithersWorkflow<RuntimeSchema<Schema>>;
+	db: BunSQLiteDatabase<Record<string, unknown>>;
+	tables: { [K in keyof Schema]: unknown };
+	outputs: { [K in keyof Schema]: Schema[K] };
+};

package/src/CreateSmithersOptions.ts

@@ -0,0 +1,9 @@
+import type { SmithersAlertPolicy } from "@smithers-orchestrator/scheduler/SmithersWorkflowOptions";
+
+export type CreateSmithersOptions = {
+	readableName?: string;
+	description?: string;
+	alertPolicy?: SmithersAlertPolicy;
+	dbPath?: string;
+	journalMode?: string;
+};

package/src/create.js

@@ -0,0 +1,384 @@
+// @smithers-type-exports-begin
+/**
+ * @template Schema
+ * @typedef {import("./CreateSmithersApi.ts").CreateSmithersApi<Schema>} CreateSmithersApi
+ */
+// @smithers-type-exports-end
+
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+import React from "react";
+import { createSmithersContext, SmithersContext as GlobalSmithersContext } from "@smithers-orchestrator/react-reconciler/context";
+import { Approval as BaseApproval, Workflow as BaseWorkflow, Task as BaseTask, Sequence as BaseSequence, Parallel as BaseParallel, MergeQueue as BaseMergeQueue, Branch as BaseBranch, Loop as BaseLoop, Ralph as BaseRalph, ContinueAsNew as BaseContinueAsNew, continueAsNew as baseContinueAsNew, Worktree as BaseWorktree, Sandbox as BaseSandbox, Signal as BaseSignal, Timer as BaseTimer, } from "@smithers-orchestrator/components";
+import { zodToTable } from "@smithers-orchestrator/db/zodToTable";
+import { zodToCreateTableSQL } from "@smithers-orchestrator/db/zodToCreateTableSQL";
+import { camelToSnake } from "@smithers-orchestrator/db/utils/camelToSnake";
+import { resolve } from "node:path";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+/** @typedef {import("@smithers-orchestrator/components").ApprovalProps<any, any>} ApprovalProps */
+/** @typedef {import("@smithers-orchestrator/components").SandboxProps} SandboxProps */
+/** @typedef {import("@smithers-orchestrator/components").SignalProps<any>} SignalProps */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertPolicy} SmithersAlertPolicy */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertPolicyDefaults} SmithersAlertPolicyDefaults */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertPolicyRule} SmithersAlertPolicyRule */
+/**
+ * @template Schema
+ * @typedef {import("@smithers-orchestrator/driver/SmithersCtx").SmithersCtx<Schema>} SmithersCtx
+ */
+/**
+ * @template Schema
+ * @typedef {import("@smithers-orchestrator/components/SmithersWorkflow").SmithersWorkflow<Schema>} SmithersWorkflow
+ */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersWorkflowOptions} SmithersWorkflowOptions */
+/** @typedef {import("@smithers-orchestrator/components").WorkflowProps} WorkflowProps */
+/** @typedef {import("./CreateSmithersOptions.ts").CreateSmithersOptions} CreateSmithersOptions */
+
+const hotCache = new Map();
+/**
+ * @param {Record<string, any>} schemas
+ * @param {string} dbPath
+ * @returns {string}
+ */
+function computeSchemaSig(schemas, dbPath) {
+    const parts = [dbPath];
+    for (const name of Object.keys(schemas).sort()) {
+        const tableName = camelToSnake(name);
+        const ddl = zodToCreateTableSQL(tableName, schemas[name]);
+        parts.push(`${name}:${ddl}`);
+    }
+    return parts.join("\n");
+}
+/**
+ * @param {Record<string, string>} [base]
+ * @param {Record<string, string>} [override]
+ * @returns {Record<string, string> | undefined}
+ */
+function mergeAlertLabels(base, override) {
+    if (!base && !override)
+        return undefined;
+    return {
+        ...base,
+        ...override,
+    };
+}
+/**
+ * @param {SmithersAlertPolicyDefaults} [base]
+ * @param {SmithersAlertPolicyDefaults} [override]
+ * @returns {SmithersAlertPolicyDefaults | undefined}
+ */
+function mergeAlertDefaults(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = {
+        ...base,
+        ...override,
+    };
+    const labels = mergeAlertLabels(base?.labels, override?.labels);
+    if (labels)
+        merged.labels = labels;
+    return merged;
+}
+/**
+ * @param {SmithersAlertPolicyRule} [base]
+ * @param {SmithersAlertPolicyRule} [override]
+ * @returns {SmithersAlertPolicyRule | undefined}
+ */
+function mergeAlertRule(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = {
+        ...base,
+        ...override,
+    };
+    const labels = mergeAlertLabels(base?.labels, override?.labels);
+    if (labels)
+        merged.labels = labels;
+    return merged;
+}
+/**
+ * @param {Record<string, SmithersAlertPolicyRule>} [base]
+ * @param {Record<string, SmithersAlertPolicyRule>} [override]
+ * @returns {Record<string, SmithersAlertPolicyRule> | undefined}
+ */
+function mergeAlertRules(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = {
+        ...base,
+    };
+    for (const [name, rule] of Object.entries(override ?? {})) {
+        merged[name] = mergeAlertRule(base?.[name], rule) ?? rule;
+    }
+    return merged;
+}
+/**
+ * @param {SmithersAlertPolicy} [base]
+ * @param {SmithersAlertPolicy} [override]
+ * @returns {SmithersAlertPolicy | undefined}
+ */
+function mergeAlertPolicies(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = {};
+    const defaults = mergeAlertDefaults(base?.defaults, override?.defaults);
+    const rules = mergeAlertRules(base?.rules, override?.rules);
+    const reactions = base?.reactions || override?.reactions
+        ? {
+            ...base?.reactions,
+            ...override?.reactions,
+        }
+        : undefined;
+    if (defaults)
+        merged.defaults = defaults;
+    if (rules)
+        merged.rules = rules;
+    if (reactions)
+        merged.reactions = reactions;
+    return merged;
+}
+/**
+ * Schema-driven API — users define only Zod schemas, the framework owns the entire storage layer.
+ *
+ * @template {Record<string, import("zod").ZodObject<any>>} Schemas
+ * @param {Schemas} schemas
+ * @param {CreateSmithersOptions} [opts]
+ * @returns {import("./CreateSmithersApi.ts").CreateSmithersApi<Schemas>}
+ *
+ * @example
+ * ```ts
+ * const { Workflow, Task, smithers, outputs } = createSmithers({
+ *   discover: discoverOutputSchema,
+ *   research: researchOutputSchema,
+ * });
+ *
+ * export default smithers((ctx) => (
+ *   <Workflow name="my-workflow">
+ *     <Task id="discover" output={outputs.discover} agent={myAgent}>...</Task>
+ *   </Workflow>
+ * ));
+ * ```
+ */
+export function createSmithers(schemas, opts) {
+    const dbPath = opts?.dbPath ?? "./smithers.db";
+    const absDbPath = resolve(process.cwd(), dbPath);
+    if (process.env.SMITHERS_HOT === "1") {
+        const sig = computeSchemaSig(schemas, absDbPath);
+        const cached = hotCache.get(absDbPath);
+        if (cached) {
+            if (cached.schemaSig !== sig) {
+                throw new SmithersError("SCHEMA_CHANGE_HOT", "[smithers hot] Schema change detected; restart required to apply schema changes.");
+            }
+            cached.setModuleAlertPolicy(opts?.alertPolicy);
+            return cached.api;
+        }
+        // Will cache after creating the API below
+    }
+    // 1. Generate Drizzle tables from Zod schemas
+    const tables = {};
+    const inputTable = schemas.input
+        ? zodToTable("input", schemas.input, { isInput: true })
+        : sqliteTable("input", {
+            runId: text("run_id").primaryKey(),
+            payload: text("payload", { mode: "json" }).$type(),
+        });
+    for (const [name, zodSchema] of Object.entries(schemas)) {
+        if (name === "input")
+            continue;
+        const tableName = camelToSnake(name);
+        tables[name] = zodToTable(tableName, zodSchema);
+    }
+    // 2. Create SQLite db
+    const sqlite = new Database(dbPath);
+    sqlite.run(`PRAGMA journal_mode = ${opts?.journalMode ?? "WAL"}`);
+    // 30s timeout: concurrent worktrees each spawn agent processes that all write
+    // to smithers.db simultaneously. 5s is too short and causes SQLITE_IOERR_VNODE
+    // on macOS when the VFS can't acquire the WAL shared-memory lock in time.
+    sqlite.run("PRAGMA busy_timeout = 30000");
+    // NORMAL is safe in WAL mode (no data loss on crash) and reduces fsync
+    // stalls that contribute to WAL checkpoint contention across processes.
+    sqlite.run("PRAGMA synchronous = NORMAL");
+    // Ensure no exclusive lock is held, allowing multiple readers/writers.
+    sqlite.run("PRAGMA locking_mode = NORMAL");
+    sqlite.run("PRAGMA foreign_keys = ON");
+    // Register a process-exit hook to explicitly close the Database.
+    // bun:sqlite's GC finalizer calls sqlite3_close() which fatally aborts if
+    // Drizzle's cached prepared statements haven't been finalized first.
+    // Calling close() ourselves lets sqlite3 finalize everything gracefully.
+    let dbClosed = false;
+    const closeDb = () => {
+        if (dbClosed)
+            return;
+        dbClosed = true;
+        try {
+            sqlite.close();
+        }
+        catch { }
+    };
+    process.on("exit", closeDb);
+    // 3. Auto-create tables using CREATE TABLE IF NOT EXISTS
+    if (schemas.input) {
+        const inputDdl = zodToCreateTableSQL("input", schemas.input, { isInput: true });
+        sqlite.run(inputDdl);
+    }
+    else {
+        sqlite.exec(`CREATE TABLE IF NOT EXISTS "input" (run_id TEXT PRIMARY KEY, payload TEXT)`);
+        try {
+            const cols = sqlite.query(`PRAGMA table_info("input")`).all();
+            const hasPayload = cols.some((col) => col?.name === "payload");
+            if (!hasPayload) {
+                sqlite.run(`ALTER TABLE "input" ADD COLUMN payload TEXT`);
+            }
+        }
+        catch {
+            // ignore - older SQLite or permission issues; input payload remains best-effort
+        }
+    }
+    for (const [name, zodSchema] of Object.entries(schemas)) {
+        if (name === "input")
+            continue;
+        const tableName = camelToSnake(name);
+        const ddl = zodToCreateTableSQL(tableName, zodSchema);
+        sqlite.run(ddl);
+    }
+    // 4. Create Drizzle instance with all tables in the schema
+    const drizzleSchema = { input: inputTable };
+    for (const [key, table] of Object.entries(tables)) {
+        drizzleSchema[key] = table;
+    }
+    const db = drizzle(sqlite, { schema: drizzleSchema });
+    // 5. Build schema registry for engine resolution of string output keys
+    const schemaRegistry = new Map();
+    for (const [name, zodSchema] of Object.entries(schemas)) {
+        if (name === "input")
+            continue;
+        schemaRegistry.set(name, { table: tables[name], zodSchema });
+    }
+    // 6. Build reverse lookup: ZodObject reference → schema key name
+    const zodToKeyName = new Map();
+    for (const [name, zodSchema] of Object.entries(schemas)) {
+        if (name === "input")
+            continue;
+        zodToKeyName.set(zodSchema, name);
+    }
+    // 7. Context + hooks
+    const { SmithersContext: RuntimeSmithersContext, useCtx, } = createSmithersContext();
+    const ctxRef = { current: null };
+    let moduleAlertPolicy = opts?.alertPolicy;
+    /**
+   * @param {WorkflowProps} props
+   */
+    function Workflow(props) {
+        return React.createElement(BaseWorkflow, props, props.children);
+    }
+    /**
+   * @template Row
+   * @param {ApprovalProps<Row>} props
+   */
+    function Approval(props) {
+        return React.createElement(BaseApproval, {
+            ...props,
+            smithersContext: RuntimeSmithersContext,
+        });
+    }
+    /**
+     * Task wrapper that resolves ZodObject output references against the
+     * schema registry by reference equality, injecting the outputSchema.
+     */
+    function Task(props) {
+        return React.createElement(BaseTask, {
+            ...props,
+            smithersContext: RuntimeSmithersContext,
+        });
+    }
+    /**
+   * @param {SandboxProps} props
+   */
+    function Sandbox(props) {
+        const workflow = props.workflow ??
+            {
+                db,
+                build: () => React.createElement(BaseWorkflow, { name: `sandbox:${props.id}` }, props.children),
+                opts: {},
+                schemaRegistry,
+                zodToKeyName,
+            };
+        return React.createElement(BaseSandbox, {
+            ...props,
+            workflow,
+            smithersContext: RuntimeSmithersContext,
+        });
+    }
+    /**
+   * @template SignalSchema
+   * @param {SignalProps<SignalSchema>} props
+   */
+    function Signal(props) {
+        return React.createElement(BaseSignal, {
+            ...props,
+            smithersContext: RuntimeSmithersContext,
+        });
+    }
+    /**
+   * @param {(ctx: SmithersCtx<Schemas>) => React.ReactElement} build
+   * @param {SmithersWorkflowOptions} [smithersOpts]
+   * @returns {SmithersWorkflow<Schemas>}
+   */
+    function boundSmithers(build, smithersOpts) {
+        const workflowOpts = {
+            ...smithersOpts,
+        };
+        const alertPolicy = mergeAlertPolicies(moduleAlertPolicy, smithersOpts?.alertPolicy);
+        if (alertPolicy)
+            workflowOpts.alertPolicy = alertPolicy;
+        return {
+            readableName: opts?.readableName,
+            description: opts?.description,
+            db,
+            build: (ctx) => {
+                ctxRef.current = ctx;
+                return React.createElement(RuntimeSmithersContext.Provider, { value: ctxRef.current }, React.createElement(GlobalSmithersContext.Provider, { value: ctxRef.current }, build(ctx)));
+            },
+            opts: workflowOpts,
+            schemaRegistry,
+            zodToKeyName,
+        };
+    }
+    /**
+   * @param {SmithersAlertPolicy} [alertPolicy]
+   */
+    const setModuleAlertPolicy = (alertPolicy) => {
+        moduleAlertPolicy = alertPolicy;
+    };
+    const api = {
+        Workflow,
+        Approval,
+        Task,
+        Sequence: BaseSequence,
+        Parallel: BaseParallel,
+        MergeQueue: BaseMergeQueue,
+        Branch: BaseBranch,
+        Loop: BaseLoop,
+        Ralph: BaseRalph,
+        ContinueAsNew: BaseContinueAsNew,
+        continueAsNew: baseContinueAsNew,
+        Worktree: BaseWorktree,
+        Sandbox,
+        Signal,
+        Timer: BaseTimer,
+        useCtx,
+        smithers: boundSmithers,
+        db,
+        tables: tables,
+        outputs: schemas,
+    };
+    if (process.env.SMITHERS_HOT === "1") {
+        const sig = computeSchemaSig(schemas, absDbPath);
+        hotCache.set(absDbPath, {
+            api: api,
+            schemaSig: sig,
+            setModuleAlertPolicy,
+        });
+    }
+    return api;
+}

package/src/dom/renderer.js

@@ -0,0 +1 @@
+export * from "@smithers-orchestrator/react-reconciler/dom/renderer";

package/src/examples-entry.js

@@ -0,0 +1,29 @@
+// @smithers-type-exports-begin
+/** @typedef {import("@smithers-orchestrator/agents/AgentLike").AgentLike} AgentLike */
+/** @typedef {import("@smithers-orchestrator/components").ApprovalDecision} ApprovalDecision */
+/** @typedef {import("@smithers-orchestrator/components").ApprovalProps} ApprovalProps */
+/** @typedef {import("@smithers-orchestrator/components").ApprovalRequest} ApprovalRequest */
+/**
+ * @template Schema
+ * @typedef {import("./CreateSmithersApi.ts").CreateSmithersApi<Schema>} CreateSmithersApi
+ */
+/** @typedef {import("@smithers-orchestrator/components").DepsSpec} DepsSpec */
+/** @typedef {import("@smithers-orchestrator/components").InferDeps} InferDeps */
+/** @typedef {import("@smithers-orchestrator/components").OutputTarget} OutputTarget */
+/** @typedef {import("@smithers-orchestrator/driver/SmithersCtx").SmithersCtx} SmithersCtx */
+/** @typedef {import("@smithers-orchestrator/errors/SmithersError").SmithersError} SmithersError */
+/**
+ * @template Schema
+ * @typedef {import("@smithers-orchestrator/components/SmithersWorkflow").SmithersWorkflow<Schema>} SmithersWorkflow
+ */
+/** @typedef {import("@smithers-orchestrator/components").TaskProps} TaskProps */
+/** @typedef {import("@smithers-orchestrator/components").WaitForEventProps} WaitForEventProps */
+// @smithers-type-exports-end
+
+export { Approval, approvalDecisionSchema, Workflow, Task, Sequence, Parallel, MergeQueue, Branch, Loop, Ralph, Worktree, } from "@smithers-orchestrator/components";
+export { Timer } from "@smithers-orchestrator/components";
+export { ClaudeCodeAgent } from "@smithers-orchestrator/agents/ClaudeCodeAgent";
+export { KimiAgent } from "@smithers-orchestrator/agents/KimiAgent";
+export { PiAgent } from "@smithers-orchestrator/agents/PiAgent";
+export { createSmithers } from "./create.js";
+export { runWorkflow, renderFrame } from "@smithers-orchestrator/engine";