@smithers-orchestrator/react-reconciler 0.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 William Cory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@smithers-orchestrator/react-reconciler",
+  "version": "0.16.0",
+  "description": "Custom React reconciler that renders Smithers host trees",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./context": {
+      "types": "./src/index.d.ts",
+      "import": "./src/context.js",
+      "default": "./src/context.js"
+    },
+    "./devtools": {
+      "types": "./src/index.d.ts",
+      "import": "./src/devtools/index.js",
+      "default": "./src/devtools/index.js"
+    },
+    "./devtools/preload": {
+      "import": "./src/devtools/preload.js",
+      "default": "./src/devtools/preload.js"
+    },
+    "./driver": {
+      "types": "./src/index.d.ts",
+      "import": "./src/driver.js",
+      "default": "./src/driver.js"
+    },
+    "./jsx-runtime": {
+      "types": "./src/index.d.ts",
+      "import": "./src/jsx-runtime.js",
+      "default": "./src/jsx-runtime.js"
+    },
+    "./*": {
+      "types": "./src/index.d.ts",
+      "import": "./src/*.js",
+      "default": "./src/*.js"
+    }
+  },
+  "files": [
+    "src/"
+  ],
+  "dependencies": {
+    "react": "^18.3.0 || ^19.0.0",
+    "react-reconciler": "^0.31.0",
+    "bippy": "^0.5.32",
+    "@smithers-orchestrator/devtools": "0.16.0",
+    "@smithers-orchestrator/errors": "0.16.0",
+    "@smithers-orchestrator/driver": "0.16.0",
+    "@smithers-orchestrator/graph": "0.16.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "build": "rm -f src/index.d.ts && tsup --dts-only",
+    "test": "bun test tests",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/HostContainer.ts

@@ -0,0 +1,5 @@
+import type { HostNode } from "@smithers-orchestrator/graph/types";
+
+export type HostContainer = {
+	root: HostNode | null;
+};

package/src/OutputSnapshot.ts

@@ -0,0 +1 @@
+export type { OutputSnapshot } from "@smithers-orchestrator/driver/OutputSnapshot";

package/src/SmithersCtxOptions.ts

@@ -0,0 +1 @@
+export type { SmithersCtxOptions } from "@smithers-orchestrator/driver/SmithersCtx";

package/src/SmithersRendererOptions.ts

@@ -0,0 +1,5 @@
+import type { ExtractGraph } from "@smithers-orchestrator/graph/types";
+
+export type SmithersRendererOptions = {
+	extractGraph?: ExtractGraph;
+};

package/src/context.js

@@ -0,0 +1,32 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./OutputSnapshot.ts").OutputSnapshot} OutputSnapshot */
+/** @typedef {import("./SmithersCtxOptions.ts").SmithersCtxOptions} SmithersCtxOptions */
+// @smithers-type-exports-end
+
+import React from "react";
+import { SmithersCtx } from "@smithers-orchestrator/driver/SmithersCtx";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+export { SmithersCtx } from "@smithers-orchestrator/driver/SmithersCtx";
+/** @type {React.Context<SmithersCtx<any> | null>} */
+export const SmithersContext = React.createContext(null);
+SmithersContext.displayName = "SmithersContext";
+/**
+ * @template Schema
+ * @returns {{ SmithersContext: React.Context<SmithersCtx<Schema> | null>, useCtx: () => SmithersCtx<Schema> }}
+ */
+export function createSmithersContext() {
+    /** @type {React.Context<SmithersCtx<Schema> | null>} */
+    const Context = React.createContext(null);
+    Context.displayName = "SmithersContext";
+    /**
+   * @returns {SmithersCtx<Schema>}
+   */
+    function useCtx() {
+        const ctx = React.useContext(Context);
+        if (!ctx) {
+            throw new SmithersError("CONTEXT_OUTSIDE_WORKFLOW", "useCtx() must be called inside a <Workflow> created by createSmithers()");
+        }
+        return ctx;
+    }
+    return { SmithersContext: Context, useCtx };
+}

package/src/core-peer.js

@@ -0,0 +1,33 @@
+
+/** @typedef {import("@smithers-orchestrator/graph/types").ExtractGraph} ExtractGraph */
+const GRAPH_SPECIFIER = "@smithers-orchestrator/graph";
+const LOCAL_GRAPH_SPECIFIER = "../../graph/src/index.js";
+/**
+ * @param {string} specifier
+ * @returns {Promise<CoreModule | null>}
+ */
+async function importCoreModule(specifier) {
+    try {
+        return (await import(specifier));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @returns {Promise<ExtractGraph>}
+ */
+export async function resolveExtractGraph() {
+    const modules = [
+        await importCoreModule(GRAPH_SPECIFIER),
+        await importCoreModule(LOCAL_GRAPH_SPECIFIER),
+    ];
+    for (const mod of modules) {
+        const fn = mod?.extractGraph;
+        if (typeof fn === "function") {
+            return fn;
+        }
+    }
+    throw new Error("Unable to load extractGraph from @smithers-orchestrator/graph. " +
+        "Install @smithers-orchestrator/graph and ensure it exports extractGraph.");
+}

package/src/core-types.js

@@ -0,0 +1 @@
+export * from "@smithers-orchestrator/graph";

package/src/devtools/SmithersDevTools.js

@@ -0,0 +1,360 @@
+// @smithers-type-exports-begin
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsEventBus} DevToolsEventBus */
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsEventHandler} DevToolsEventHandler */
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsSnapshot} DevToolsSnapshot */
+/** @typedef {import("@smithers-orchestrator/devtools").RunExecutionState} RunExecutionState */
+/** @typedef {import("@smithers-orchestrator/devtools").SmithersNodeType} SmithersNodeType */
+/** @typedef {import("@smithers-orchestrator/devtools").TaskExecutionState} TaskExecutionState */
+// @smithers-type-exports-end
+
+import { instrument, secure, installRDTHook, traverseFiber, getDisplayName, isHostFiber, getFiberId, setFiberId, } from "bippy";
+import { SmithersDevToolsCore, printTree, } from "@smithers-orchestrator/devtools";
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsNode} DevToolsNode */
+/** @typedef {import("@smithers-orchestrator/devtools").SmithersDevToolsCore} SmithersDevToolsCoreType */
+/** @typedef {import("@smithers-orchestrator/devtools").SmithersDevToolsOptions} SmithersDevToolsOptions */
+/** @typedef {import("bippy").Fiber} Fiber */
+/** @typedef {import("bippy").FiberRoot} FiberRoot */
+
+// ---------------------------------------------------------------------------
+// React host tag mapping
+// ---------------------------------------------------------------------------
+const HOST_TAG_MAP = {
+    "smithers:workflow": "workflow",
+    "smithers:task": "task",
+    "smithers:sequence": "sequence",
+    "smithers:parallel": "parallel",
+    "smithers:merge-queue": "merge-queue",
+    "smithers:branch": "branch",
+    "smithers:ralph": "loop",
+    "smithers:worktree": "worktree",
+    "smithers:approval": "approval",
+    "smithers:timer": "timer",
+    "smithers:subflow": "subflow",
+    "smithers:wait-for-event": "wait-for-event",
+    "smithers:saga": "saga",
+    "smithers:try-catch-finally": "try-catch",
+};
+/**
+ * @param {Fiber} fiber
+ * @returns {SmithersNodeType | null}
+ */
+function resolveNodeType(fiber) {
+    // Only match host fibers (smithers:* tags).
+    // Composite fibers (Task, Workflow, etc.) are pass-throughs that always
+    // create a host fiber underneath, so matching both would double-count.
+    if (isHostFiber(fiber)) {
+        const tag = fiber.type;
+        return HOST_TAG_MAP[tag] ?? null;
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Fiber to DevToolsNode
+// ---------------------------------------------------------------------------
+/**
+ * @param {Fiber} fiber
+ * @returns {Record<string, unknown>}
+ */
+function extractSerializableProps(fiber) {
+    const raw = fiber.memoizedProps;
+    if (!raw || typeof raw !== "object")
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (key.startsWith("__"))
+            continue;
+        if (key === "children")
+            continue;
+        if (typeof value === "function") {
+            out[key] = "[Function]";
+            continue;
+        }
+        if (typeof value === "object" && value !== null) {
+            // Agent objects, Zod schemas, Drizzle tables: record a stable label only.
+            if ("modelId" in value || "model" in value) {
+                out[key] = `[Agent: ${value.modelId ?? value.model ?? "unknown"}]`;
+                continue;
+            }
+            if ("shape" in value) {
+                out[key] = "[ZodSchema]";
+                continue;
+            }
+            out[key] = "[Object]";
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * @param {Fiber} fiber
+ * @returns {DevToolsNode["task"] | undefined}
+ */
+function extractTaskInfo(fiber) {
+    const raw = fiber.memoizedProps;
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const nodeId = raw.id;
+    if (typeof nodeId !== "string")
+        return undefined;
+    const kind = raw.__smithersKind === "agent"
+        ? "agent"
+        : raw.__smithersKind === "compute"
+            ? "compute"
+            : "static";
+    const agent = raw.agent;
+    let agentName;
+    if (agent) {
+        if (Array.isArray(agent)) {
+            agentName = agent
+                .map((a) => a?.modelId ?? a?.model ?? "?")
+                .join(" → ");
+        }
+        else {
+            agentName = agent.modelId ?? agent.model ?? "agent";
+        }
+    }
+    return {
+        nodeId,
+        kind,
+        agent: agentName,
+        label: raw.label,
+        outputTableName: typeof raw.output === "string" ? raw.output : undefined,
+        iteration: raw.iteration,
+    };
+}
+/**
+ * @param {Fiber} fiber
+ * @param {number} depth
+ * @returns {DevToolsNode | null}
+ */
+function fiberToNode(fiber, depth) {
+    const nodeType = resolveNodeType(fiber);
+    if (!nodeType)
+        return null;
+    const id = getFiberId(fiber) ?? setFiberId(fiber);
+    const children = [];
+    let child = fiber.child;
+    while (child) {
+        const childNode = fiberToNode(child, depth + 1);
+        if (childNode) {
+            children.push(childNode);
+        }
+        else {
+            // Recurse through non-Smithers fibers to find nested Smithers nodes.
+            let grandchild = child.child;
+            while (grandchild) {
+                const gc = fiberToNode(grandchild, depth + 1);
+                if (gc)
+                    children.push(gc);
+                grandchild = grandchild.sibling;
+            }
+        }
+        child = child.sibling;
+    }
+    return {
+        id,
+        type: nodeType,
+        name: getDisplayName(fiber) ?? fiber.type ?? "unknown",
+        props: extractSerializableProps(fiber),
+        task: nodeType === "task" ? extractTaskInfo(fiber) : undefined,
+        children,
+        depth,
+    };
+}
+// ---------------------------------------------------------------------------
+// Walk fiber root to find Smithers root
+// ---------------------------------------------------------------------------
+/**
+ * @param {FiberRoot | null | undefined} fiberRoot
+ * @returns {Fiber | null}
+ */
+function findSmithersRoot(fiberRoot) {
+    const current = fiberRoot?.current;
+    if (!current)
+        return null;
+    let result = null;
+    traverseFiber(current, (fiber) => {
+        const nodeType = resolveNodeType(fiber);
+        if (nodeType === "workflow") {
+            result = fiber;
+            return true;
+        }
+        return false;
+    });
+    return result;
+}
+// ---------------------------------------------------------------------------
+// React adapter
+// ---------------------------------------------------------------------------
+export class SmithersDevTools {
+    /** @type {SmithersDevToolsOptions} */
+    options;
+    /** @type {SmithersDevToolsCoreType} */
+    core;
+    _active = false;
+    _cleanup = null;
+    /**
+   * @param {SmithersDevToolsOptions} [options]
+   */
+    constructor(options = {}) {
+        this.options = options;
+        this.core = new SmithersDevToolsCore(options);
+    }
+    /**
+     * Start instrumenting. Installs the React DevTools global hook (if not
+     * already present) and begins listening for fiber commits.
+     *
+     * For best results, call this before `SmithersRenderer` is first imported.
+     * If the renderer is already loaded, it will still work as long as the
+     * renderer called `injectIntoDevTools` (which it does by default).
+     */
+    start() {
+        if (this._active)
+            return this;
+        this._active = true;
+        // Avoid reinstalling the hook after renderers have already injected
+        // themselves, otherwise we lose their registrations.
+        if (!("__REACT_DEVTOOLS_GLOBAL_HOOK__" in globalThis)) {
+            installRDTHook();
+        }
+        const self = this;
+        const verbose = this.options.verbose ?? false;
+        const hookHost = globalThis;
+        const hook = hookHost.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+        const previousRootHandler = hook?.onCommitFiberRoot;
+        const previousUnmountHandler = hook?.onCommitFiberUnmount;
+        instrument(secure({
+            /**
+     * @param {number} rendererID
+     * @param {FiberRoot} root
+     * @returns {void}
+     */
+            onCommitFiberRoot(rendererID, root) {
+                const smithersRoot = findSmithersRoot(root);
+                const tree = smithersRoot ? fiberToNode(smithersRoot, 0) : null;
+                const snapshot = self.core.captureSnapshot(tree);
+                if (verbose && tree) {
+                    console.log("\n🔍 [smithers-devtools] Commit detected:\n" +
+                        printTree(tree) +
+                        `   ${snapshot.nodeCount} nodes, ${snapshot.taskCount} tasks\n`);
+                }
+                self.core.emitCommit(snapshot);
+            },
+            /**
+     * @param {number} _rendererID
+     * @param {Fiber} fiber
+     * @returns {void}
+     */
+            onCommitFiberUnmount(_rendererID, fiber) {
+                const nodeType = resolveNodeType(fiber);
+                if (nodeType && verbose) {
+                    const name = getDisplayName(fiber) ?? fiber.type;
+                    console.log(`🗑️  [smithers-devtools] Unmounted: ${nodeType} (${name})`);
+                }
+                self.core.emitUnmount();
+            },
+        }));
+        const installedRootHandler = hook?.onCommitFiberRoot;
+        const installedUnmountHandler = hook?.onCommitFiberUnmount;
+        this._cleanup = () => {
+            if (!hook)
+                return;
+            if (hook.onCommitFiberRoot === installedRootHandler) {
+                if (previousRootHandler) {
+                    hook.onCommitFiberRoot = previousRootHandler;
+                }
+                else {
+                    delete hook.onCommitFiberRoot;
+                }
+            }
+            if (hook.onCommitFiberUnmount === installedUnmountHandler) {
+                if (previousUnmountHandler) {
+                    hook.onCommitFiberUnmount = previousUnmountHandler;
+                }
+                else {
+                    delete hook.onCommitFiberUnmount;
+                }
+            }
+        };
+        return this;
+    }
+    /** Stop instrumenting and clean up. */
+    stop() {
+        this._cleanup?.();
+        this._cleanup = null;
+        this._active = false;
+        this.core.detachEventBuses();
+    }
+    /**
+     * Attach to a Smithers EventBus to track task execution state.
+     * Listens for SmithersEvent emissions and builds up a run state model.
+     * @param {DevToolsEventBus} bus
+     * @returns {this}
+     */
+    attachEventBus(bus) {
+        this.core.attachEventBus(bus);
+        return this;
+    }
+    /**
+     * Get execution state for a specific run.
+     * @param {string} runId
+     * @returns {RunExecutionState | undefined}
+     */
+    getRun(runId) {
+        return this.core.getRun(runId);
+    }
+    /**
+     * Get all tracked runs.
+     * @returns {Map<string, RunExecutionState>}
+     */
+    get runs() {
+        return this.core.runs;
+    }
+    /**
+     * Get task execution state by nodeId within a run. Searches all iterations.
+     * @param {string} runId
+     * @param {string} nodeId
+     * @param {number} [iteration]
+     * @returns {TaskExecutionState | undefined}
+     */
+    getTaskState(runId, nodeId, iteration) {
+        return this.core.getTaskState(runId, nodeId, iteration);
+    }
+    /**
+     * Get the last captured snapshot.
+     * @returns {DevToolsSnapshot | null}
+     */
+    get snapshot() {
+        return this.core.snapshot;
+    }
+    /**
+     * Get the current tree (shorthand).
+     * @returns {DevToolsNode | null}
+     */
+    get tree() {
+        return this.core.tree;
+    }
+    /**
+     * Pretty-print the current tree to a string.
+     * @returns {string}
+     */
+    printTree() {
+        return this.core.printTree();
+    }
+    /**
+     * Find a node by task nodeId.
+     * @param {string} nodeId
+     * @returns {DevToolsNode | null}
+     */
+    findTask(nodeId) {
+        return this.core.findTask(nodeId);
+    }
+    /**
+     * List all tasks in the current tree.
+     * @returns {DevToolsNode[]}
+     */
+    listTasks() {
+        return this.core.listTasks();
+    }
+}

package/src/devtools/index.js

@@ -0,0 +1,12 @@
+// @smithers-type-exports-begin
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsEventBus} DevToolsEventBus */
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsEventHandler} DevToolsEventHandler */
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsNode} DevToolsNode */
+/** @typedef {import("@smithers-orchestrator/devtools").DevToolsSnapshot} DevToolsSnapshot */
+/** @typedef {import("@smithers-orchestrator/devtools").RunExecutionState} RunExecutionState */
+/** @typedef {import("@smithers-orchestrator/devtools").SmithersDevToolsOptions} SmithersDevToolsOptions */
+/** @typedef {import("@smithers-orchestrator/devtools").SmithersNodeType} SmithersNodeType */
+/** @typedef {import("@smithers-orchestrator/devtools").TaskExecutionState} TaskExecutionState */
+// @smithers-type-exports-end
+
+export { SmithersDevTools } from "./SmithersDevTools.js";

package/src/devtools/preload.js

@@ -0,0 +1,11 @@
+/**
+ * Preload script that installs the React DevTools global hook before
+ * any React code runs. Use this as a Bun preload:
+ *
+ *   bun --preload ./src/devtools/preload.js run myworkflow.tsx
+ *
+ * Or in bunfig.toml:
+ *   preload = ["./src/devtools/preload.js"]
+ */
+import { installRDTHook } from "bippy";
+installRDTHook();

package/src/dom/renderer.js

@@ -0,0 +1 @@
+export * from "../reconciler.js";

package/src/driver.js

@@ -0,0 +1,19 @@
+import { WorkflowDriver, } from "@smithers-orchestrator/driver";
+import { SmithersRenderer } from "./reconciler.js";
+
+/**
+ * @template [Schema=unknown]
+ * @extends {WorkflowDriver<Schema>}
+ */
+export class ReactWorkflowDriver extends WorkflowDriver {
+    /**
+   * @param {import("@smithers-orchestrator/driver").WorkflowDriverOptions<Schema>} options
+   */
+    constructor(options) {
+        const renderer = options.renderer ?? new SmithersRenderer();
+        super({
+            ...options,
+            renderer,
+        });
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,87 @@
+import * as _smithers_orchestrator_graph_types from '@smithers-orchestrator/graph/types';
+import { ExtractGraph as ExtractGraph$1, HostNode as HostNode$1 } from '@smithers-orchestrator/graph/types';
+import * as React$1 from 'react';
+import React__default from 'react';
+import { WorkflowDriver } from '@smithers-orchestrator/driver';
+import { SmithersCtx } from '@smithers-orchestrator/driver/SmithersCtx';
+export { SmithersCtx } from '@smithers-orchestrator/driver/SmithersCtx';
+
+type SmithersRendererOptions$1 = {
+    extractGraph?: ExtractGraph$1;
+};
+
+type HostContainer$1 = {
+    root: HostNode$1 | null;
+};
+
+declare class SmithersRenderer {
+    /**
+   * @param {SmithersRendererOptions} [options]
+   */
+    constructor(options?: SmithersRendererOptions);
+    /** @type {HostContainer} */
+    container: HostContainer;
+    /** @type {unknown} */
+    root: unknown;
+    /** @type {ExtractGraph | undefined} */
+    extractGraph: ExtractGraph | undefined;
+    /**
+   * @param {React.ReactElement} element
+   * @param {ExtractOptions} [opts]
+   * @returns {Promise<WorkflowGraph>}
+   */
+    render(element: React.ReactElement, opts?: ExtractOptions): Promise<WorkflowGraph>;
+    /**
+   * @returns {HostNode | null}
+   */
+    getRoot(): HostNode | null;
+}
+type ExtractGraph = _smithers_orchestrator_graph_types.ExtractGraph;
+type ExtractOptions = _smithers_orchestrator_graph_types.ExtractOptions;
+type HostContainer = HostContainer$1;
+type MutableHostElement = _smithers_orchestrator_graph_types.HostElement & {
+    props: Record<string, string>;
+    rawProps: Record<string, unknown>;
+    children: HostNode[];
+};
+type HostNode = _smithers_orchestrator_graph_types.HostNode;
+type MutableHostText = _smithers_orchestrator_graph_types.HostText & {
+    text: string;
+};
+type React = React$1.default;
+type SmithersRendererOptions = SmithersRendererOptions$1;
+type WorkflowGraph = _smithers_orchestrator_graph_types.WorkflowGraph;
+/**
+ * Minimal local shape for a react-reconciler instance. `@types/react-reconciler`
+ * is not installed here, so we describe only the methods we call.
+ */
+type ReconcilerInstance = {
+    createContainer: (rootContainer: unknown, tag: number, hydrationCallbacks: unknown, isStrictMode: boolean, concurrentUpdatesByDefaultOverride: unknown, identifierPrefix: string, onUncaughtError: unknown, onCaughtError: unknown, onRecoverableError: unknown, transitionCallbacks: unknown) => unknown;
+    updateContainerSync: (element: unknown, container: unknown, parentComponent: unknown, callback: () => void) => void;
+    flushSyncWork: () => void;
+    injectIntoDevTools: (devtools: unknown) => void;
+    defaultOnUncaughtError: unknown;
+    defaultOnCaughtError: unknown;
+    defaultOnRecoverableError: unknown;
+};
+
+/**
+ * @template [Schema=unknown]
+ * @extends {WorkflowDriver<Schema>}
+ */
+declare class ReactWorkflowDriver<Schema = unknown> extends WorkflowDriver<Schema> {
+}
+
+/**
+ * @template Schema
+ * @returns {{ SmithersContext: React.Context<SmithersCtx<Schema> | null>, useCtx: () => SmithersCtx<Schema> }}
+ */
+declare function createSmithersContext<Schema>(): {
+    SmithersContext: React__default.Context<SmithersCtx<Schema> | null>;
+    useCtx: () => SmithersCtx<Schema>;
+};
+
+/** @type {React.Context<SmithersCtx<any> | null>} */
+declare const SmithersContext: React__default.Context<SmithersCtx<any> | null>;
+
+export { type ExtractGraph, type ExtractOptions, type HostContainer, type HostNode, type MutableHostElement, type MutableHostText, type React, ReactWorkflowDriver, type ReconcilerInstance, SmithersContext, SmithersRenderer, type SmithersRendererOptions, type WorkflowGraph, createSmithersContext };

package/src/index.js

@@ -0,0 +1,3 @@
+export * from "./reconciler.js";
+export { ReactWorkflowDriver } from "./driver.js";
+export { SmithersContext, SmithersCtx, createSmithersContext } from "./context.js";

package/src/jsx-runtime.js

@@ -0,0 +1,3 @@
+/** @typedef {import("react").ReactElement} JSX.Element */
+export { jsx, jsxs, Fragment } from "react/jsx-runtime";
+export { jsxDEV } from "react/jsx-dev-runtime";

package/src/reconciler.js

@@ -0,0 +1,387 @@
+import Reconciler from "react-reconciler";
+import { installRDTHook } from "bippy";
+import { resolveExtractGraph } from "./core-peer.js";
+/** @typedef {import("@smithers-orchestrator/graph/types").ExtractGraph} ExtractGraph */
+/** @typedef {import("@smithers-orchestrator/graph/types").ExtractOptions} ExtractOptions */
+/** @typedef {import("./HostContainer.ts").HostContainer} HostContainer */
+/** @typedef {import("@smithers-orchestrator/graph/types").HostElement & { props: Record<string, string>; rawProps: Record<string, unknown>; children: HostNode[] }} MutableHostElement */
+/** @typedef {import("@smithers-orchestrator/graph/types").HostNode} HostNode */
+/** @typedef {import("@smithers-orchestrator/graph/types").HostText & { text: string }} MutableHostText */
+/** @typedef {import("react").default} React */
+/** @typedef {import("./SmithersRendererOptions.ts").SmithersRendererOptions} SmithersRendererOptions */
+/** @typedef {import("@smithers-orchestrator/graph/types").WorkflowGraph} WorkflowGraph */
+/**
+ * Minimal local shape for a react-reconciler instance. `@types/react-reconciler`
+ * is not installed here, so we describe only the methods we call.
+ * @typedef {{
+ *   createContainer: (
+ *     rootContainer: unknown,
+ *     tag: number,
+ *     hydrationCallbacks: unknown,
+ *     isStrictMode: boolean,
+ *     concurrentUpdatesByDefaultOverride: unknown,
+ *     identifierPrefix: string,
+ *     onUncaughtError: unknown,
+ *     onCaughtError: unknown,
+ *     onRecoverableError: unknown,
+ *     transitionCallbacks: unknown,
+ *   ) => unknown;
+ *   updateContainerSync: (element: unknown, container: unknown, parentComponent: unknown, callback: () => void) => void;
+ *   flushSyncWork: () => void;
+ *   injectIntoDevTools: (devtools: unknown) => void;
+ *   defaultOnUncaughtError: unknown;
+ *   defaultOnCaughtError: unknown;
+ *   defaultOnRecoverableError: unknown;
+ * }} ReconcilerInstance */
+
+/**
+ * @param {string} type
+ * @param {Record<string, unknown>} props
+ * @returns {MutableHostElement}
+ */
+function createElement(type, props) {
+    const { children: _children, ...rest } = props || {};
+    const stringProps = {};
+    for (const [key, value] of Object.entries(rest)) {
+        if (value === undefined || typeof value === "function")
+            continue;
+        if (key.startsWith("__"))
+            continue;
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            stringProps[key] = String(value);
+        }
+    }
+    return {
+        kind: "element",
+        tag: type,
+        props: stringProps,
+        rawProps: props ?? {},
+        children: [],
+    };
+}
+let currentUpdatePriority = 1;
+const hostConfig = {
+    supportsMutation: true,
+    supportsPersistence: false,
+    supportsHydration: false,
+    isPrimaryRenderer: true,
+    supportsMicrotasks: true,
+    /**
+   * @returns {Record<string, unknown>}
+   */
+    getRootHostContext() {
+        return {};
+    },
+    /**
+   * @returns {Record<string, unknown>}
+   */
+    getChildHostContext() {
+        return {};
+    },
+    /**
+   * @param {unknown} instance
+   * @returns {unknown}
+   */
+    getPublicInstance(instance) {
+        return instance;
+    },
+    /**
+   * @param {string} type
+   * @param {Record<string, unknown>} props
+   * @returns {MutableHostElement}
+   */
+    createInstance(type, props) {
+        return createElement(type, props);
+    },
+    /**
+   * @param {string} text
+   * @returns {MutableHostText}
+   */
+    createTextInstance(text) {
+        return { kind: "text", text };
+    },
+    /**
+   * @param {MutableHostElement} parent
+   * @param {HostNode} child
+   * @returns {void}
+   */
+    appendInitialChild(parent, child) {
+        parent.children.push(child);
+    },
+    /**
+   * @param {MutableHostElement} parent
+   * @param {HostNode} child
+   * @returns {void}
+   */
+    appendChild(parent, child) {
+        parent.children.push(child);
+    },
+    /**
+   * @param {HostContainer} container
+   * @param {HostNode} child
+   * @returns {void}
+   */
+    appendChildToContainer(container, child) {
+        container.root = child;
+    },
+    /**
+   * @param {MutableHostElement} parent
+   * @param {HostNode} child
+   * @returns {void}
+   */
+    removeChild(parent, child) {
+        const idx = parent.children.indexOf(child);
+        if (idx >= 0)
+            parent.children.splice(idx, 1);
+    },
+    /**
+   * @param {HostContainer} container
+   * @returns {void}
+   */
+    removeChildFromContainer(container) {
+        container.root = null;
+    },
+    /**
+   * @param {MutableHostElement} parent
+   * @param {HostNode} child
+   * @param {HostNode} beforeChild
+   * @returns {void}
+   */
+    insertBefore(parent, child, beforeChild) {
+        const idx = parent.children.indexOf(beforeChild);
+        if (idx >= 0)
+            parent.children.splice(idx, 0, child);
+        else
+            parent.children.push(child);
+    },
+    /**
+   * @param {HostContainer} container
+   * @param {HostNode} child
+   * @param {HostNode} _beforeChild
+   * @returns {void}
+   */
+    insertInContainerBefore(container, child, _beforeChild) {
+        container.root = child;
+    },
+    /**
+   * @param {MutableHostElement} _instance
+   * @param {string} _type
+   * @param {unknown} oldProps
+   * @param {unknown} newProps
+   * @returns {unknown}
+   */
+    prepareUpdate(_instance, _type, oldProps, newProps) {
+        if (oldProps === newProps)
+            return null;
+        return newProps;
+    },
+    /**
+   * @param {MutableHostElement} instance
+   * @param {unknown[]} args
+   * @returns {void}
+   */
+    commitUpdate(instance, ...args) {
+        let nextProps = null;
+        const first = args[0];
+        const second = args[1];
+        if (typeof second === "string" && first && typeof first === "object") {
+            nextProps = first;
+        }
+        else if (typeof first === "string") {
+            const maybeNewProps = args[2];
+            if (maybeNewProps && typeof maybeNewProps === "object") {
+                nextProps = maybeNewProps;
+            }
+        }
+        else if (first && typeof first === "object") {
+            nextProps = first;
+        }
+        if (!nextProps)
+            return;
+        const next = createElement(instance.tag, nextProps);
+        instance.props = next.props;
+        instance.rawProps = next.rawProps;
+    },
+    /**
+   * @param {MutableHostText} textInstance
+   * @param {string} _oldText
+   * @param {string} newText
+   * @returns {void}
+   */
+    commitTextUpdate(textInstance, _oldText, newText) {
+        textInstance.text = newText;
+    },
+    /**
+   * @returns {boolean}
+   */
+    finalizeInitialChildren() {
+        return false;
+    },
+    /**
+   * @returns {null}
+   */
+    prepareForCommit() {
+        return null;
+    },
+    /**
+   * @returns {void}
+   */
+    resetAfterCommit() { },
+    /**
+   * @returns {boolean}
+   */
+    shouldSetTextContent() {
+        return false;
+    },
+    /**
+   * @param {HostContainer} container
+   * @returns {void}
+   */
+    clearContainer(container) {
+        container.root = null;
+    },
+    /**
+   * @returns {number}
+   */
+    getCurrentEventPriority() {
+        return 1;
+    },
+    /**
+   * @returns {boolean}
+   */
+    shouldAttemptEagerTransition() {
+        return false;
+    },
+    /**
+   * @returns {boolean}
+   */
+    maySuspendCommit() {
+        return false;
+    },
+    /**
+   * @returns {void}
+   */
+    preloadInstance() { },
+    /**
+   * @returns {void}
+   */
+    startSuspendingCommit() { },
+    /**
+   * @returns {void}
+   */
+    suspendInstance() { },
+    /**
+   * @returns {null}
+   */
+    waitForCommitToBeReady() {
+        return null;
+    },
+    /**
+   * @returns {void}
+   */
+    resetFormInstance() { },
+    /**
+   * @returns {void}
+   */
+    detachDeletedInstance() { },
+    /**
+   * @param {"error" | "warn" | "info" | "log"} type
+   * @param {unknown[]} args
+   * @returns {() => void}
+   */
+    bindToConsole(type, args) {
+        return () => {
+            const fn = console[type] ?? console.log;
+            fn(...args);
+        };
+    },
+    /**
+   * @returns {number}
+   */
+    getCurrentUpdatePriority() {
+        return currentUpdatePriority;
+    },
+    /**
+   * @param {number} priority
+   * @returns {void}
+   */
+    setCurrentUpdatePriority(priority) {
+        currentUpdatePriority = priority;
+    },
+    /**
+   * @returns {number}
+   */
+    resolveUpdatePriority() {
+        return currentUpdatePriority;
+    },
+    /**
+   * @param {(...args: unknown[]) => void} fn
+   * @param {number} [delay]
+   * @returns {ReturnType<typeof setTimeout>}
+   */
+    scheduleTimeout(fn, delay) {
+        return setTimeout(fn, delay ?? 0);
+    },
+    /**
+   * @param {() => void} fn
+   * @returns {void}
+   */
+    scheduleMicrotask(fn) {
+        queueMicrotask(fn);
+    },
+    /**
+   * @param {ReturnType<typeof setTimeout>} id
+   * @returns {void}
+   */
+    cancelTimeout(id) {
+        clearTimeout(id);
+    },
+    noTimeout: -1,
+};
+/** @type {ReconcilerInstance} */
+const reconciler = /** @type {ReconcilerInstance} */ (Reconciler(hostConfig));
+const hookHost = globalThis;
+if (!hookHost.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
+    installRDTHook();
+}
+reconciler.injectIntoDevTools({
+    bundleType: typeof process !== "undefined" && process.env.NODE_ENV === "production" ? 0 : 1,
+    version: "0.0.0",
+    rendererPackageName: "@smithers-orchestrator/core-react",
+    findFiberByHostInstance: () => null,
+});
+export class SmithersRenderer {
+    /** @type {HostContainer} */
+    container;
+    /** @type {unknown} */
+    root;
+    /** @type {ExtractGraph | undefined} */
+    extractGraph;
+    /**
+   * @param {SmithersRendererOptions} [options]
+   */
+    constructor(options = {}) {
+        this.extractGraph = options.extractGraph;
+        this.container = { root: null };
+        this.root = reconciler.createContainer(this.container, 0, null, false, null, "", reconciler.defaultOnUncaughtError, reconciler.defaultOnCaughtError, reconciler.defaultOnRecoverableError, null);
+    }
+    /**
+   * @param {React.ReactElement} element
+   * @param {ExtractOptions} [opts]
+   * @returns {Promise<WorkflowGraph>}
+   */
+    async render(element, opts) {
+        reconciler.updateContainerSync(element, this.root, null, () => { });
+        reconciler.flushSyncWork();
+        const extractGraph = this.extractGraph ?? (await resolveExtractGraph());
+        return extractGraph(this.container.root, opts);
+    }
+    /**
+   * @returns {HostNode | null}
+   */
+    getRoot() {
+        return this.container.root;
+    }
+}