@smithers-orchestrator/server 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/server",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "HTTP, WebSocket, gateway, cron, webhook, and metrics servers for Smithers",
   "type": "module",
   "sideEffects": false,
@@ -26,28 +26,28 @@
     "effect": "^3.21.1",
     "hono": "^4.12.14",
     "ws": "^8.20.0",
-    "@smithers-orchestrator/db": "0.17.0",
-    "@smithers-orchestrator/driver": "0.17.0",
-    "@smithers-orchestrator/devtools": "0.17.0",
-    "@smithers-orchestrator/errors": "0.17.0",
-    "@smithers-orchestrator/components": "0.17.0",
-    "@smithers-orchestrator/engine": "0.17.0",
-    "@smithers-orchestrator/gateway": "0.17.0",
-    "@smithers-orchestrator/observability": "0.17.0",
-    "@smithers-orchestrator/protocol": "0.17.0",
-    "@smithers-orchestrator/scheduler": "0.17.0",
-    "@smithers-orchestrator/time-travel": "0.17.0"
+    "@smithers-orchestrator/db": "0.19.0",
+    "@smithers-orchestrator/components": "0.19.0",
+    "@smithers-orchestrator/driver": "0.19.0",
+    "@smithers-orchestrator/devtools": "0.19.0",
+    "@smithers-orchestrator/engine": "0.19.0",
+    "@smithers-orchestrator/errors": "0.19.0",
+    "@smithers-orchestrator/observability": "0.19.0",
+    "@smithers-orchestrator/gateway": "0.19.0",
+    "@smithers-orchestrator/protocol": "0.19.0",
+    "@smithers-orchestrator/scheduler": "0.19.0",
+    "@smithers-orchestrator/time-travel": "0.19.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "react": "^19.2.5",
     "typescript": "~5.9.3",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/graph": "0.17.0"
+    "@smithers-orchestrator/graph": "0.19.0"
   },
   "scripts": {
     "test": "bun test tests",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "build": "tsup --dts-only"
+    "build": "rm -f src/index.d.ts && node ../../node_modules/tsup/dist/cli-default.js --dts-only"
   }
 }

package/src/GatewayOptions.ts

@@ -1,11 +1,13 @@
 import type { GatewayAuthConfig } from "./GatewayAuthConfig.js";
 import type { GatewayDefaults } from "./GatewayDefaults.js";
+import type { GatewayUiConfig } from "./GatewayUiConfig.js";
 
 export type GatewayOptions = {
   protocol?: number;
   features?: string[];
   heartbeatMs?: number;
   auth?: GatewayAuthConfig;
+  ui?: GatewayUiConfig;
   defaults?: GatewayDefaults;
   maxBodyBytes?: number;
   maxPayload?: number;

package/src/GatewayRegisterOptions.ts

@@ -0,0 +1,8 @@
+import type { GatewayWebhookConfig } from "./GatewayWebhookConfig.js";
+import type { GatewayUiConfig } from "./GatewayUiConfig.js";
+
+export type GatewayRegisterOptions = {
+  schedule?: string;
+  webhook?: GatewayWebhookConfig;
+  ui?: GatewayUiConfig;
+};

package/src/GatewayUiConfig.ts

@@ -0,0 +1,20 @@
+export type GatewayUiConfig = {
+  /**
+   * Browser entry module for the React app. Smithers bundles this with Bun and
+   * serves it from the Gateway origin.
+   */
+  entry: string;
+  /**
+   * URL path where the UI is mounted. Gateway-level UI defaults to `/`;
+   * workflow-level UI defaults to `/workflows/<workflowKey>`.
+   */
+  path?: string;
+  /**
+   * Document title for the generated HTML shell.
+   */
+  title?: string;
+  /**
+   * JSON-serializable boot data exposed to the browser.
+   */
+  props?: Record<string, unknown>;
+};

package/src/gateway.js

@@ -1,12 +1,15 @@
 // @smithers-type-exports-begin
 /** @typedef {import("./EventFrame.js").EventFrame} EventFrame */
 /** @typedef {import("./GatewayDefaults.js").GatewayDefaults} GatewayDefaults */
+/** @typedef {import("./GatewayRegisterOptions.js").GatewayRegisterOptions} GatewayRegisterOptions */
 /** @typedef {import("./GatewayTokenGrant.js").GatewayTokenGrant} GatewayTokenGrant */
+/** @typedef {import("./GatewayUiConfig.js").GatewayUiConfig} GatewayUiConfig */
 /** @typedef {import("./HelloResponse.js").HelloResponse} HelloResponse */
 // @smithers-type-exports-end
 
 import { createServer } from "node:http";
 import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import { resolve } from "node:path";
 import { CronExpressionParser } from "cron-parser";
 import { Effect, Metric } from "effect";
 import { WebSocketServer } from "ws";
@@ -36,6 +39,7 @@ import { writeRewindAuditRow } from "@smithers-orchestrator/time-travel/writeRew
 import { recoverInProgressRewindAudits } from "@smithers-orchestrator/time-travel/recoverInProgressRewindAudits";
 import { GATEWAY_EVENT_WINDOW_DEFAULT, SMITHERS_API_VERSION, getRequiredScopeForGatewayMethod, } from "@smithers-orchestrator/gateway/rpc";
 import { hasGatewayScope } from "@smithers-orchestrator/gateway/auth/scopes";
+import { createGatewayUiApp } from "./gatewayUi/createGatewayUiApp.js";
 /** @typedef {import("./GatewayWebhookRunConfig.js").GatewayWebhookRunConfig} GatewayWebhookRunConfig */
 /** @typedef {import("./GatewayWebhookSignalConfig.js").GatewayWebhookSignalConfig} GatewayWebhookSignalConfig */
 /** @typedef {import("./ConnectRequest.js").ConnectRequest} ConnectRequest */
@@ -90,6 +94,7 @@ import { hasGatewayScope } from "@smithers-orchestrator/gateway/auth/scopes";
  *   key: string;
  *   schedule?: string;
  *   webhook?: GatewayWebhookConfig;
+ *   ui?: ResolvedGatewayUiConfig | null;
  * }} RegisteredWorkflow
  */
 /**
@@ -100,6 +105,21 @@ import { hasGatewayScope } from "@smithers-orchestrator/gateway/auth/scopes";
  *   adapter: SmithersDb;
  * }} ResolvedRun
  */
+/**
+ * @typedef {{
+ *   entry: string;
+ *   path: string;
+ *   title?: string;
+ *   props?: Record<string, unknown>;
+ * }} ResolvedGatewayUiConfig
+ */
+/**
+ * @typedef {{
+ *   kind: "gateway" | "workflow";
+ *   workflowKey: string | null;
+ *   config: ResolvedGatewayUiConfig;
+ * }} GatewayUiMount
+ */
 
 const DEFAULT_PROTOCOL = 1;
 const DEFAULT_HEARTBEAT_MS = 15_000;
@@ -117,6 +137,115 @@ export const GATEWAY_FRAME_ID_MAX_LENGTH = 128;
 export const GATEWAY_RPC_INPUT_MAX_BYTES = GATEWAY_RPC_MAX_PAYLOAD_BYTES;
 export const GATEWAY_RPC_INPUT_MAX_DEPTH = GATEWAY_RPC_MAX_DEPTH;
 const GATEWAY_METHOD_NAME_PATTERN = /^[a-z][a-zA-Z0-9]*(?:\.[a-z][a-zA-Z0-9]*)*$/;
+const GATEWAY_UI_ASSET_PREFIX = "__smithers_ui";
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+function safeJsonScript(value) {
+    return JSON.stringify(value).replaceAll("<", "\\u003c");
+}
+
+/**
+ * @param {string | undefined} rawPath
+ * @param {string} fallbackPath
+ * @returns {string}
+ */
+function normalizeUiMountPath(rawPath, fallbackPath) {
+    const candidate = (rawPath && rawPath.trim()) || fallbackPath;
+    const withSlash = candidate.startsWith("/") ? candidate : `/${candidate}`;
+    const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+    if (!/^\/[A-Za-z0-9/_:.-]*$/.test(withoutTrailing)) {
+        throw new SmithersError("INVALID_INPUT", `Gateway UI path is invalid: ${candidate}`);
+    }
+    return withoutTrailing;
+}
+
+/**
+ * @param {string} mountPath
+ * @param {string} suffix
+ * @returns {string}
+ */
+function joinUiPath(mountPath, suffix) {
+    if (mountPath === "/") {
+        return `/${suffix.replace(/^\/+/, "")}`;
+    }
+    return `${mountPath}/${suffix.replace(/^\/+/, "")}`;
+}
+
+/**
+ * @param {GatewayUiConfig | undefined} ui
+ * @param {string} fallbackPath
+ * @returns {ResolvedGatewayUiConfig | null}
+ */
+function resolveGatewayUiConfig(ui, fallbackPath) {
+    if (!ui) {
+        return null;
+    }
+    if (typeof ui.entry !== "string" || !ui.entry.trim()) {
+        throw new SmithersError("INVALID_INPUT", "Gateway UI config requires a non-empty entry path.");
+    }
+    return {
+        entry: resolve(process.cwd(), ui.entry),
+        path: normalizeUiMountPath(ui.path, fallbackPath),
+        ...(typeof ui.title === "string" ? { title: ui.title } : {}),
+        ...(ui.props && typeof ui.props === "object" && !Array.isArray(ui.props)
+            ? { props: ui.props }
+            : {}),
+    };
+}
+
+/**
+ * @param {import("node:http").IncomingHttpHeaders} headers
+ * @returns {Headers}
+ */
+function nodeHeadersToFetchHeaders(headers) {
+    const out = new Headers();
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                out.append(key, entry);
+            }
+            continue;
+        }
+        out.set(key, value);
+    }
+    return out;
+}
+
+/**
+ * @param {ServerResponse} res
+ * @param {Response} response
+ * @param {boolean} headOnly
+ */
+async function writeFetchResponse(res, response, headOnly = false) {
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+    });
+    if (headOnly) {
+        res.end();
+        return;
+    }
+    const body = Buffer.from(await response.arrayBuffer());
+    res.end(body);
+}
 /**
  * @template T
  * @param {string | null | undefined} value
@@ -1054,6 +1183,8 @@ export class Gateway {
     headersTimeout;
     requestTimeout;
     auth;
+    ui;
+    uiApp;
     defaults;
     workflows = new Map();
     connections = new Set();
@@ -1066,6 +1197,7 @@ export class Gateway {
     devtoolsSubscriberCounts = new Map();
     /** Flagged subscriber IDs that should force a snapshot on their next emit. */
     devtoolsInvalidateFlags = new Set();
+    uiAssetCache = new Map();
     server = null;
     wsServer = null;
     schedulerTimer = null;
@@ -1097,8 +1229,193 @@ export class Gateway {
             ? DEFAULT_REQUEST_TIMEOUT
             : Math.floor(assertPositiveFiniteInteger("requestTimeout", Number(options.requestTimeout)));
         this.auth = options.auth;
+        this.ui = resolveGatewayUiConfig(options.ui, "/");
+        this.uiApp = createGatewayUiApp({
+            resolveMatch: (pathname) => this.resolveUiMatch(pathname),
+            renderIndex: (match) => this.renderUiIndex(match),
+            renderAsset: (match) => this.renderUiAsset(match),
+        });
         this.defaults = options.defaults;
     }
+    /**
+   * @returns {GatewayUiMount[]}
+   */
+    getUiMounts() {
+        const mounts = [];
+        if (this.ui) {
+            mounts.push({ kind: "gateway", workflowKey: null, config: this.ui });
+        }
+        for (const [workflowKey, entry] of this.workflows.entries()) {
+            if (entry.ui) {
+                mounts.push({ kind: "workflow", workflowKey, config: entry.ui });
+            }
+        }
+        return mounts.sort((left, right) => right.config.path.length - left.config.path.length);
+    }
+    /**
+   * @param {string} pathname
+   * @returns {GatewayUiMount | null}
+   */
+    findUiMount(pathname) {
+        for (const mount of this.getUiMounts()) {
+            const mountPath = mount.config.path;
+            if (mountPath === "/" || pathname === mountPath || pathname.startsWith(`${mountPath}/`)) {
+                return mount;
+            }
+        }
+        return null;
+    }
+    /**
+   * @param {string} pathname
+   */
+    resolveUiMatch(pathname) {
+        const mount = this.findUiMount(pathname);
+        if (!mount) {
+            return null;
+        }
+        const assetBase = joinUiPath(mount.config.path, `${GATEWAY_UI_ASSET_PREFIX}/`);
+        const assetPath = pathname.startsWith(assetBase)
+            ? pathname.slice(assetBase.length)
+            : null;
+        return {
+            pathname,
+            mountPath: mount.config.path,
+            assetPath,
+            config: mount,
+        };
+    }
+    /**
+   * @param {GatewayUiMount} mount
+   */
+    uiBootConfig(mount) {
+        return {
+            apiVersion: SMITHERS_API_VERSION,
+            kind: mount.kind,
+            workflowKey: mount.workflowKey,
+            mountPath: mount.config.path,
+            rpcPath: "/v1/rpc",
+            wsPath: "/",
+            assetBasePath: joinUiPath(mount.config.path, `${GATEWAY_UI_ASSET_PREFIX}/`),
+            props: mount.config.props ?? {},
+        };
+    }
+    /**
+   * @param {{ config: GatewayUiMount }} match
+   */
+    renderUiIndex(match) {
+        const mount = match.config;
+        const title = mount.config.title ?? (mount.workflowKey ? `${mount.workflowKey} | Smithers` : "Smithers");
+        const boot = this.uiBootConfig(mount);
+        const assetSrc = joinUiPath(mount.config.path, `${GATEWAY_UI_ASSET_PREFIX}/client.js`);
+        return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${escapeHtml(title)}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script>globalThis.__SMITHERS_GATEWAY_UI__=${safeJsonScript(boot)};</script>
+    <script type="module" src="${escapeHtml(assetSrc)}"></script>
+  </body>
+</html>`;
+    }
+    /**
+   * @param {{ config: GatewayUiMount; assetPath: string | null }} match
+   */
+    async renderUiAsset(match) {
+        if (match.assetPath !== "client.js") {
+            return null;
+        }
+        const body = await this.bundleUiEntry(match.config.config);
+        return {
+            body,
+            contentType: "text/javascript; charset=utf-8",
+        };
+    }
+    /**
+   * @param {ResolvedGatewayUiConfig} config
+   * @returns {Promise<string>}
+   */
+    async bundleUiEntry(config) {
+        const cached = this.uiAssetCache.get(config.entry);
+        if (cached) {
+            return cached;
+        }
+        if (typeof Bun === "undefined" || typeof Bun.build !== "function") {
+            throw new SmithersError("INVALID_INPUT", "Gateway UI bundling requires Bun.build.");
+        }
+        const result = await Bun.build({
+            entrypoints: [config.entry],
+            root: process.cwd(),
+            target: "browser",
+            format: "esm",
+            sourcemap: "inline",
+            minify: false,
+            jsx: {
+                runtime: "automatic",
+                importSource: "react",
+            },
+        });
+        if (!result.success) {
+            const message = result.logs?.map((entry) => entry.message).filter(Boolean).join("\n")
+                || `Failed to build Gateway UI entry ${config.entry}`;
+            throw new SmithersError("INVALID_INPUT", message);
+        }
+        const output = result.outputs.find((entry) => entry.path.endsWith(".js")) ?? result.outputs[0];
+        const body = await output.text();
+        this.uiAssetCache.set(config.entry, body);
+        return body;
+    }
+    /**
+   * @param {IncomingMessage} req
+   * @param {ServerResponse} res
+   */
+    async handleUiHttp(req, res) {
+        if ((req.method ?? "GET") !== "GET" && (req.method ?? "GET") !== "HEAD") {
+            return false;
+        }
+        const host = headerValue(req, "host") ?? "127.0.0.1";
+        const request = new Request(`http://${host}${req.url ?? "/"}`, {
+            method: "GET",
+            headers: nodeHeadersToFetchHeaders(req.headers),
+        });
+        const response = await this.uiApp.fetch(request);
+        if (response.status === 404 && response.headers.get("x-smithers-ui-miss") === "1") {
+            return false;
+        }
+        await writeFetchResponse(res, response, (req.method ?? "GET") === "HEAD");
+        return true;
+    }
+    /**
+   * @param {string} key
+   * @param {RegisteredWorkflow} entry
+   */
+    workflowSummary(key, entry) {
+        return {
+            key,
+            ...(entry.workflow.readableName ? { readableName: entry.workflow.readableName } : {}),
+            ...(entry.workflow.description ? { description: entry.workflow.description } : {}),
+            hasUi: Boolean(entry.ui),
+            uiPath: entry.ui?.path ?? null,
+        };
+    }
+    /**
+   * @param {boolean | undefined} hasUi
+   */
+    listWorkflowSummaries(hasUi) {
+        const rows = [];
+        for (const [key, entry] of this.workflows.entries()) {
+            const summary = this.workflowSummary(key, entry);
+            if (hasUi !== undefined && summary.hasUi !== hasUi) {
+                continue;
+            }
+            rows.push(summary);
+        }
+        rows.sort((left, right) => left.key.localeCompare(right.key));
+        return rows;
+    }
     authModeLabel() {
         return gatewayAuthMode(this.auth);
     }
@@ -1770,16 +2087,18 @@ export class Gateway {
     /**
    * @param {string} key
    * @param {SmithersWorkflow} workflow
-   * @param {{ schedule?: string; webhook?: GatewayWebhookConfig }} [options]
+   * @param {GatewayRegisterOptions} [options]
    * @returns {this}
    */
     register(key, workflow, options) {
         ensureSmithersTables(workflow.db);
+        const ui = resolveGatewayUiConfig(options?.ui, `/workflows/${encodeURIComponent(key)}`);
         this.workflows.set(key, {
             key,
             workflow,
             schedule: options?.schedule,
             webhook: options?.webhook,
+            ui,
         });
         // Startup recovery: any audit row left in `in_progress` from a prior
         // crash is flipped to `partial` and the associated run is flagged as
@@ -1795,7 +2114,7 @@ export class Gateway {
         return this;
     }
     /**
-   * @param {{ port?: number; host?: string }} [options]
+   * @param {{ port?: number; host?: string; path?: string }} [options]
    */
     async listen(options = {}) {
         if (this.server) {
@@ -1832,6 +2151,9 @@ export class Gateway {
             if ((req.method ?? "GET") === "POST" && (req.url ?? "/") === "/rpc") {
                 return this.handleHttpRpc(req, res);
             }
+            if (await this.handleUiHttp(req, res)) {
+                return;
+            }
             return sendJson(res, 404, { error: { code: "NOT_FOUND", message: "Route not found" } });
         });
         server.headersTimeout = this.headersTimeout;
@@ -1863,6 +2185,10 @@ export class Gateway {
             });
         });
         await new Promise((resolve) => {
+            if (options.path !== undefined) {
+                server.listen(options.path, () => resolve());
+                return;
+            }
             if (options.host === undefined) {
                 server.listen(options.port ?? 7331, () => resolve());
                 return;
@@ -2698,6 +3024,7 @@ export class Gateway {
                     const request = parseApprovalRequest(parseJson(approval.requestJson), node?.label ?? approval.nodeId);
                     approvals.push({
                         runId: approval.runId,
+                        workflowKey: entry.key,
                         nodeId: approval.nodeId,
                         iteration: approval.iteration ?? 0,
                         requestTitle: request.title ?? node?.label ?? approval.nodeId,
@@ -2945,6 +3272,12 @@ export class Gateway {
                 const status = asString(params.status) ?? asString(filter.status);
                 return responseOk(frame.id, await this.listRunsAcrossWorkflows(limit, status));
             }
+            case "workflows.list":
+            case "listWorkflows": {
+                const filter = asObject(params.filter) ?? {};
+                const hasUi = asBoolean(params.hasUi) ?? asBoolean(filter.hasUi);
+                return responseOk(frame.id, this.listWorkflowSummaries(hasUi));
+            }
             case "runs.create":
             case "launchRun": {
                 const workflowKey = asString(params.workflow);
@@ -3548,7 +3881,23 @@ export class Gateway {
                 return responseOk(frame.id, diffRawSnapshots(leftSnapshot, rightSnapshot));
             }
             case "approvals.list":
-                return responseOk(frame.id, await this.listPendingApprovals());
+            case "listApprovals": {
+                const filter = asObject(params.filter) ?? {};
+                const runId = asString(params.runId) ?? asString(filter.runId);
+                const workflow = asString(params.workflow) ?? asString(filter.workflow);
+                const limit = asOptionalPositiveInt(params.limit ?? filter.limit, "limit");
+                let approvals = await this.listPendingApprovals();
+                if (runId) {
+                    approvals = approvals.filter((approval) => approval.runId === runId);
+                }
+                if (workflow) {
+                    approvals = approvals.filter((approval) => approval.workflowKey === workflow);
+                }
+                if (limit !== undefined) {
+                    approvals = approvals.slice(0, limit);
+                }
+                return responseOk(frame.id, approvals);
+            }
             case "approvals.decide":
             case "submitApproval": {
                 const runId = asString(params.runId);

package/src/gatewayUi/createGatewayUiApp.js

@@ -0,0 +1,47 @@
+import { Hono } from "hono";
+
+/**
+ * @typedef {{
+ *   pathname: string;
+ *   mountPath: string;
+ *   assetPath: string | null;
+ *   config: Record<string, unknown>;
+ * }} GatewayUiMatch
+ */
+
+/**
+ * @param {{
+ *   resolveMatch: (pathname: string) => GatewayUiMatch | null;
+ *   renderIndex: (match: GatewayUiMatch) => string;
+ *   renderAsset: (match: GatewayUiMatch) => Promise<{ body: string; contentType: string } | null>;
+ * }} options
+ */
+export function createGatewayUiApp(options) {
+    const app = new Hono();
+    app.get("*", async (c) => {
+        const url = new URL(c.req.url);
+        const match = options.resolveMatch(url.pathname);
+        if (!match) {
+            return new Response("Not Found", {
+                status: 404,
+                headers: { "x-smithers-ui-miss": "1" },
+            });
+        }
+        if (match.assetPath) {
+            const asset = await options.renderAsset(match);
+            if (!asset) {
+                return c.text("Not Found", 404);
+            }
+            return c.body(asset.body, 200, {
+                "Content-Type": asset.contentType,
+                "Cache-Control": "no-store",
+                "X-Content-Type-Options": "nosniff",
+            });
+        }
+        return c.html(options.renderIndex(match), 200, {
+            "Cache-Control": "no-store",
+            "X-Content-Type-Options": "nosniff",
+        });
+    });
+    return app;
+}

package/src/index.d.ts

@@ -1,22 +1,22 @@
-import * as _smithers_db_adapter_RunRow from '@smithers-orchestrator/db/adapter/RunRow';
+import * as _smithers_orchestrator_db_adapter_RunRow from '@smithers-orchestrator/db/adapter/RunRow';
 import * as node_http from 'node:http';
-import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1 } from 'node:http';
-import * as _smithers_observability_SmithersEvent from '@smithers-orchestrator/observability/SmithersEvent';
-import * as _smithers_components_SmithersWorkflow from '@smithers-orchestrator/components/SmithersWorkflow';
+import * as _smithers_orchestrator_observability_SmithersEvent from '@smithers-orchestrator/observability/SmithersEvent';
+import * as _smithers_orchestrator_components_SmithersWorkflow from '@smithers-orchestrator/components/SmithersWorkflow';
 import { SmithersWorkflow as SmithersWorkflow$1 } from '@smithers-orchestrator/components/SmithersWorkflow';
+import * as hono from 'hono';
+import { Hono } from 'hono';
+import * as hono_types from 'hono/types';
 import { Effect } from 'effect';
-import * as _smithers_db_adapter from '@smithers-orchestrator/db/adapter';
+import * as _smithers_orchestrator_db_adapter from '@smithers-orchestrator/db/adapter';
 import { SmithersDb as SmithersDb$4 } from '@smithers-orchestrator/db/adapter';
-import * as hono_types from 'hono/types';
-import { Hono } from 'hono';
 import * as effect_Fiber from 'effect/Fiber';
-import * as _smithers_protocol_errors from '@smithers-orchestrator/protocol/errors';
-import * as _smithers_devtools_snapshotSerializer from '@smithers-orchestrator/devtools/snapshotSerializer';
-import * as _smithers_protocol_devtools from '@smithers-orchestrator/protocol/devtools';
-import * as _smithers_engine_effect_DiffBundle from '@smithers-orchestrator/engine/effect/DiffBundle';
+import * as _smithers_orchestrator_protocol_errors from '@smithers-orchestrator/protocol/errors';
+import * as _smithers_orchestrator_devtools_snapshotSerializer from '@smithers-orchestrator/devtools/snapshotSerializer';
+import * as _smithers_orchestrator_protocol_devtools from '@smithers-orchestrator/protocol/devtools';
+import * as _smithers_orchestrator_engine_effect_DiffBundle from '@smithers-orchestrator/engine/effect/DiffBundle';
 import { DiffBundle } from '@smithers-orchestrator/engine/effect/DiffBundle';
 import { selectOutputRow } from '@smithers-orchestrator/db/output';
-import * as _smithers_time_travel_jumpToFrame from '@smithers-orchestrator/time-travel/jumpToFrame';
+import * as _smithers_orchestrator_time_travel_jumpToFrame from '@smithers-orchestrator/time-travel/jumpToFrame';
 export { JumpToFrameError } from '@smithers-orchestrator/time-travel/jumpToFrame';
 
 type ServerOptions$1 = {
@@ -26,16 +26,33 @@ type ServerOptions$1 = {
     maxBodyBytes?: number;
     rootDir?: string;
     allowNetwork?: boolean;
+    /**
+     * Maximum time (in milliseconds) allowed for the HTTP parser to receive the
+     * complete headers of a single request. Helps mitigate slowloris attacks.
+     * @default 30000
+     */
+    headersTimeout?: number;
+    /**
+     * Maximum time (in milliseconds) allowed for a single request to be received
+     * and parsed, including the body. Helps mitigate slowloris attacks.
+     * @default 60000
+     */
+    requestTimeout?: number;
 };
 
 type ResponseFrame$1 = {
     type: "res";
     id: string;
     ok: boolean;
+    apiVersion?: "v1";
     payload?: unknown;
     error?: {
+        version?: "v1";
         code: string;
         message: string;
+        requiredScope?: string;
+        refresh?: string;
+        details?: unknown;
     };
 };
 
@@ -70,6 +87,10 @@ type GatewayTokenGrant$1 = {
     role: string;
     scopes: string[];
     userId?: string;
+    tokenId?: string;
+    issuedAtMs?: number;
+    expiresAtMs?: number;
+    revokedAtMs?: number;
 };
 
 type GatewayAuthConfig$1 = {
@@ -98,15 +119,54 @@ type GatewayDefaults$1 = {
     cliAgentTools?: "all" | "explicit-only";
 };
 
+type GatewayUiConfig$1 = {
+    /**
+     * Browser entry module for the React app. Smithers bundles this with Bun and
+     * serves it from the Gateway origin.
+     */
+    entry: string;
+    /**
+     * URL path where the UI is mounted. Gateway-level UI defaults to `/`;
+     * workflow-level UI defaults to `/workflows/<workflowKey>`.
+     */
+    path?: string;
+    /**
+     * Document title for the generated HTML shell.
+     */
+    title?: string;
+    /**
+     * JSON-serializable boot data exposed to the browser.
+     */
+    props?: Record<string, unknown>;
+};
+
 type GatewayOptions$1 = {
     protocol?: number;
     features?: string[];
     heartbeatMs?: number;
     auth?: GatewayAuthConfig$1;
+    ui?: GatewayUiConfig$1;
     defaults?: GatewayDefaults$1;
     maxBodyBytes?: number;
     maxPayload?: number;
     maxConnections?: number;
+    /**
+     * Per-run replay window for Gateway run event streams.
+     * @default 10000
+     */
+    eventWindowSize?: number;
+    /**
+     * Maximum time (in milliseconds) allowed for the HTTP parser to receive the
+     * complete headers of a single request. Helps mitigate slowloris attacks.
+     * @default 30000
+     */
+    headersTimeout?: number;
+    /**
+     * Maximum time (in milliseconds) allowed for a single request to be received
+     * and parsed, including the body. Helps mitigate slowloris attacks.
+     * @default 60000
+     */
+    requestTimeout?: number;
 };
 
 type ConnectRequest$1 = {
@@ -144,12 +204,19 @@ type HelloResponse$1 = {
     };
 };
 
+type GatewayRegisterOptions$1 = {
+    schedule?: string;
+    webhook?: GatewayWebhookConfig$1;
+    ui?: GatewayUiConfig$1;
+};
+
 type EventFrame$1 = {
     type: "event";
     event: string;
     payload?: unknown;
     seq: number;
     stateVersion: number;
+    apiVersion?: "v1";
 };
 
 /**
@@ -175,7 +242,7 @@ declare function assertGatewayInputDepthWithinBounds(value: unknown, maxDepth?:
 /**
  * @param {string | undefined} code
  */
-declare function statusForRpcError(code: string | undefined): 401 | 403 | 404 | 400 | 409 | 413 | 429 | 501 | 500;
+declare function statusForRpcError(code: string | undefined): 400 | 401 | 403 | 404 | 409 | 429 | 413 | 501 | 500;
 declare const GATEWAY_RPC_MAX_PAYLOAD_BYTES: 1048576;
 declare const GATEWAY_RPC_MAX_DEPTH: 32;
 declare const GATEWAY_RPC_MAX_ARRAY_LENGTH: 256;
@@ -195,7 +262,12 @@ declare class Gateway {
     maxBodyBytes: number;
     maxPayload: number;
     maxConnections: number;
+    eventWindowSize: number;
+    headersTimeout: number;
+    requestTimeout: number;
     auth: GatewayAuthConfig$1 | undefined;
+    ui: ResolvedGatewayUiConfig | null;
+    uiApp: hono.Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
     defaults: GatewayDefaults$1 | undefined;
     workflows: Map<any, any>;
     connections: Set<any>;
@@ -203,15 +275,95 @@ declare class Gateway {
     activeRuns: Map<any, any>;
     inflightRuns: Map<any, any>;
     devtoolsSubscribers: Map<any, any>;
+    runEventWindows: Map<any, any>;
     /** Absolute active subscriber count per runId (gauge source of truth). */
     devtoolsSubscriberCounts: Map<any, any>;
     /** Flagged subscriber IDs that should force a snapshot on their next emit. */
     devtoolsInvalidateFlags: Set<any>;
+    uiAssetCache: Map<any, any>;
     server: null;
     wsServer: null;
     schedulerTimer: null;
     stateVersion: number;
     startedAtMs: number;
+    /**
+   * @returns {GatewayUiMount[]}
+   */
+    getUiMounts(): GatewayUiMount[];
+    /**
+   * @param {string} pathname
+   * @returns {GatewayUiMount | null}
+   */
+    findUiMount(pathname: string): GatewayUiMount | null;
+    /**
+   * @param {string} pathname
+   */
+    resolveUiMatch(pathname: string): {
+        pathname: string;
+        mountPath: string;
+        assetPath: string | null;
+        config: GatewayUiMount;
+    } | null;
+    /**
+   * @param {GatewayUiMount} mount
+   */
+    uiBootConfig(mount: GatewayUiMount): {
+        apiVersion: "v1";
+        kind: "workflow" | "gateway";
+        workflowKey: string | null;
+        mountPath: string;
+        rpcPath: string;
+        wsPath: string;
+        assetBasePath: string;
+        props: Record<string, unknown>;
+    };
+    /**
+   * @param {{ config: GatewayUiMount }} match
+   */
+    renderUiIndex(match: {
+        config: GatewayUiMount;
+    }): string;
+    /**
+   * @param {{ config: GatewayUiMount; assetPath: string | null }} match
+   */
+    renderUiAsset(match: {
+        config: GatewayUiMount;
+        assetPath: string | null;
+    }): Promise<{
+        body: string;
+        contentType: string;
+    } | null>;
+    /**
+   * @param {ResolvedGatewayUiConfig} config
+   * @returns {Promise<string>}
+   */
+    bundleUiEntry(config: ResolvedGatewayUiConfig): Promise<string>;
+    /**
+   * @param {IncomingMessage} req
+   * @param {ServerResponse} res
+   */
+    handleUiHttp(req: IncomingMessage, res: ServerResponse$1): Promise<boolean>;
+    /**
+   * @param {string} key
+   * @param {RegisteredWorkflow} entry
+   */
+    workflowSummary(key: string, entry: RegisteredWorkflow): {
+        hasUi: boolean;
+        uiPath: string | null;
+        description?: string | undefined;
+        readableName?: string | undefined;
+        key: string;
+    };
+    /**
+   * @param {boolean | undefined} hasUi
+   */
+    listWorkflowSummaries(hasUi: boolean | undefined): {
+        hasUi: boolean;
+        uiPath: string | null;
+        description?: string | undefined;
+        readableName?: string | undefined;
+        key: string;
+    }[];
     authModeLabel(): string;
     /**
    * @param {string} [runId]
@@ -269,6 +421,61 @@ declare class Gateway {
    */
     cleanupDevToolsSubscribers(connection: ConnectionState): void;
     /**
+   * @param {string} runId
+   * @returns {{ nextSeq: number; window: Array<Record<string, unknown>> }}
+   */
+    getRunEventWindow(runId: string): {
+        nextSeq: number;
+        window: Array<Record<string, unknown>>;
+    };
+    /**
+   * @param {string} event
+   * @param {unknown} payload
+   * @param {number} stateVersion
+   * @returns {Record<string, unknown> | null}
+   */
+    appendRunEventWindow(event: string, payload: unknown, stateVersion: number): Record<string, unknown> | null;
+    /**
+   * @param {string} runId
+   * @returns {number}
+   */
+    getRunEventCurrentSeq(runId: string): number;
+    /**
+   * @param {ConnectionState} connection
+   * @param {string} streamId
+   * @param {string} runId
+   * @returns {() => void}
+   */
+    registerRunEventSubscriber(connection: ConnectionState, streamId: string, runId: string): () => void;
+    /**
+   * @param {ConnectionState} connection
+   * @param {string} streamId
+   */
+    unregisterRunEventSubscriber(connection: ConnectionState, streamId: string): void;
+    /**
+   * @param {ConnectionState} connection
+   */
+    cleanupRunEventSubscribers(connection: ConnectionState): void;
+    /**
+   * @param {ConnectionState} connection
+   * @param {string} streamId
+   * @param {Record<string, unknown>} frame
+   */
+    sendRunEventStreamFrame(connection: ConnectionState, streamId: string, frame: Record<string, unknown>): void;
+    /**
+   * @param {ConnectionState} connection
+   * @param {string} streamId
+   * @param {string} runId
+   * @param {number} fromSeq
+   * @param {number} toSeq
+   * @param {unknown} snapshot
+   */
+    sendRunGapResync(connection: ConnectionState, streamId: string, runId: string, fromSeq: number, toSeq: number, snapshot: unknown): void;
+    /**
+   * @param {string} runId
+   */
+    buildRunSnapshot(runId: string): Promise<any>;
+    /**
    * @param {GatewayTransport} transport
    * @param {string} frameType
    * @param {GatewayMetricLabels} [labels]
@@ -307,7 +514,7 @@ declare class Gateway {
    * @param {number} status
    * @param {ResponseFrame} response
    */
-    sendHttpRpcResponse(res: ServerResponse, status: number, response: ResponseFrame): void;
+    sendHttpRpcResponse(res: ServerResponse$1, status: number, response: ResponseFrame): void;
     /**
    * @param {SmithersDb} adapter
    * @param {string} runId
@@ -327,23 +534,21 @@ declare class Gateway {
    * @param {ServerResponse} res
    * @param {string} workflowKey
    */
-    handleWebhook(req: IncomingMessage, res: ServerResponse, workflowKey: string): Promise<void>;
+    handleWebhook(req: IncomingMessage, res: ServerResponse$1, workflowKey: string): Promise<void>;
     /**
    * @param {string} key
    * @param {SmithersWorkflow} workflow
-   * @param {{ schedule?: string; webhook?: GatewayWebhookConfig }} [options]
+   * @param {GatewayRegisterOptions} [options]
    * @returns {this}
    */
-    register(key: string, workflow: SmithersWorkflow, options?: {
-        schedule?: string;
-        webhook?: GatewayWebhookConfig;
-    }): this;
+    register(key: string, workflow: SmithersWorkflow, options?: GatewayRegisterOptions): this;
     /**
-   * @param {{ port?: number; host?: string }} [options]
+   * @param {{ port?: number; host?: string; path?: string }} [options]
    */
     listen(options?: {
         port?: number;
         host?: string;
+        path?: string;
     }): Promise<node_http.Server<typeof node_http.IncomingMessage, typeof node_http.ServerResponse>>;
     close(): Promise<void>;
     startScheduler(): void;
@@ -419,8 +624,9 @@ declare class Gateway {
     /**
    * @param {IncomingMessage} req
    * @param {ServerResponse} res
+   * @param {string} [forcedMethod]
    */
-    handleHttpRpc(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    handleHttpRpc(req: IncomingMessage, res: ServerResponse$1, forcedMethod?: string): Promise<void>;
     /**
    * @param {ConnectionState} connection
    * @param {ResponseFrame} frame
@@ -441,6 +647,7 @@ declare class Gateway {
         runs: any[];
         approvals: {
             runId: any;
+            workflowKey: any;
             nodeId: any;
             iteration: any;
             requestTitle: any;
@@ -465,6 +672,7 @@ declare class Gateway {
     listRunsAcrossWorkflows(limit?: number, status?: string): Promise<any[]>;
     listPendingApprovals(): Promise<{
         runId: any;
+        workflowKey: any;
         nodeId: any;
         iteration: any;
         requestTitle: any;
@@ -511,7 +719,9 @@ declare class Gateway {
 }
 type EventFrame = EventFrame$1;
 type GatewayDefaults = GatewayDefaults$1;
+type GatewayRegisterOptions = GatewayRegisterOptions$1;
 type GatewayTokenGrant = GatewayTokenGrant$1;
+type GatewayUiConfig = GatewayUiConfig$1;
 type HelloResponse = HelloResponse$1;
 type GatewayWebhookRunConfig = GatewayWebhookRunConfig$1;
 type GatewayWebhookSignalConfig = GatewayWebhookSignalConfig$1;
@@ -522,9 +732,9 @@ type GatewayWebhookConfig = GatewayWebhookConfig$1;
 type IncomingMessage = node_http.IncomingMessage;
 type RequestFrame = RequestFrame$1;
 type ResponseFrame = ResponseFrame$1;
-type ServerResponse = node_http.ServerResponse;
-type SmithersWorkflow = _smithers_components_SmithersWorkflow.SmithersWorkflow<unknown>;
-type SmithersEvent$1 = _smithers_observability_SmithersEvent.SmithersEvent;
+type ServerResponse$1 = node_http.ServerResponse;
+type SmithersWorkflow = _smithers_orchestrator_components_SmithersWorkflow.SmithersWorkflow<unknown>;
+type SmithersEvent$1 = _smithers_orchestrator_observability_SmithersEvent.SmithersEvent;
 type GatewayMetricLabels = Record<string, string | number | null | undefined>;
 type GatewayTransport = "ws" | "http";
 type GatewayRequestContext = {
@@ -532,6 +742,7 @@ type GatewayRequestContext = {
     role?: string;
     scopes?: string[];
     userId?: string | null;
+    tokenId?: string | null;
     origin?: string;
     transport?: GatewayTransport;
 };
@@ -550,6 +761,7 @@ type RunStartAuthContext = {
     role: string;
     scopes: string[];
     userId?: string | null;
+    tokenId?: string | null;
     connectionId?: string;
 };
 type RegisteredWorkflow = {
@@ -558,6 +770,7 @@ type RegisteredWorkflow = {
     key: string;
     schedule?: string;
     webhook?: GatewayWebhookConfig;
+    ui?: ResolvedGatewayUiConfig | null;
 };
 type ResolvedRun = {
     runId: string;
@@ -565,6 +778,17 @@ type ResolvedRun = {
     workflow: SmithersWorkflow;
     adapter: SmithersDb$4;
 };
+type ResolvedGatewayUiConfig = {
+    entry: string;
+    path: string;
+    title?: string;
+    props?: Record<string, unknown>;
+};
+type GatewayUiMount = {
+    kind: "gateway" | "workflow";
+    workflowKey: string | null;
+    config: ResolvedGatewayUiConfig;
+};
 
 type ServeOptions$1 = {
     workflow: SmithersWorkflow$1<unknown>;
@@ -614,7 +838,7 @@ declare class NodeOutputRouteError extends Error {
     /** @type {NodeOutputErrorCode} */
     code: NodeOutputErrorCode;
 }
-type NodeOutputErrorCode = _smithers_protocol_errors.NodeOutputErrorCode;
+type NodeOutputErrorCode = _smithers_orchestrator_protocol_errors.NodeOutputErrorCode;
 
 /**
  * @returns {DevToolsNode}
@@ -701,11 +925,11 @@ declare class DevToolsRouteError extends Error {
     hint: string | undefined;
 }
 declare const DEVTOOLS_EMPTY_ROOT_ID: 0;
-type SmithersDb$3 = _smithers_db_adapter.SmithersDb;
-type DevToolsNode = _smithers_protocol_devtools.DevToolsNode;
-type DevToolsSnapshot = _smithers_protocol_devtools.DevToolsSnapshot;
-type DevToolsNodeType = _smithers_protocol_devtools.DevToolsNodeType;
-type SnapshotSerializerWarning$1 = _smithers_devtools_snapshotSerializer.SnapshotSerializerWarning;
+type SmithersDb$3 = _smithers_orchestrator_db_adapter.SmithersDb;
+type DevToolsNode = _smithers_orchestrator_protocol_devtools.DevToolsNode;
+type DevToolsSnapshot = _smithers_orchestrator_protocol_devtools.DevToolsSnapshot;
+type DevToolsNodeType = _smithers_orchestrator_protocol_devtools.DevToolsNodeType;
+type SnapshotSerializerWarning$1 = _smithers_orchestrator_devtools_snapshotSerializer.SnapshotSerializerWarning;
 
 type DiffSummary$1 = {
     filesChanged: number;
@@ -752,7 +976,7 @@ type GetNodeDiffRouteResult$1 = {
  * }} opts
  * @returns {Promise<GetNodeDiffRouteResult>}
  */
-declare function getNodeDiffRoute({ runId: rawRunId, nodeId: rawNodeId, iteration: rawIteration, resolveRun, emitEffect, computeDiffBundleImpl, computeDiffBundleBetweenRefsImpl, getCurrentPointerImpl, resolveCommitPointerImpl, restorePointerImpl, nowMs, stat, }: {
+declare function getNodeDiffRoute({ runId: rawRunId, nodeId: rawNodeId, iteration: rawIteration, resolveRun, emitEffect, computeDiffBundleImpl, computeDiffBundleBetweenRefsImpl, getCurrentPointerImpl: _getCurrentPointerImpl, resolveCommitPointerImpl, restorePointerImpl: _restorePointerImpl, nowMs, stat, }: {
     runId: unknown;
     nodeId: unknown;
     iteration: unknown;
@@ -760,8 +984,8 @@ declare function getNodeDiffRoute({ runId: rawRunId, nodeId: rawNodeId, iteratio
         adapter: SmithersDb$2;
     } | null>;
     emitEffect?: (effect: Effect.Effect<void>) => Promise<unknown>;
-    computeDiffBundleImpl?: (baseRef: string, cwd: string, seq?: number) => Promise<_smithers_engine_effect_DiffBundle.DiffBundle>;
-    computeDiffBundleBetweenRefsImpl?: (baseRef: string, targetRef: string, cwd: string, seq?: number) => Promise<_smithers_engine_effect_DiffBundle.DiffBundle>;
+    computeDiffBundleImpl?: (baseRef: string, cwd: string, seq?: number) => Promise<_smithers_orchestrator_engine_effect_DiffBundle.DiffBundle>;
+    computeDiffBundleBetweenRefsImpl?: (baseRef: string, targetRef: string, cwd: string, seq?: number) => Promise<_smithers_orchestrator_engine_effect_DiffBundle.DiffBundle>;
     getCurrentPointerImpl?: (cwd: string) => Promise<string | null>;
     resolveCommitPointerImpl?: (pointer: string, cwd: string) => Promise<string | null>;
     restorePointerImpl?: (pointer: string, cwd: string) => Promise<{
@@ -771,8 +995,8 @@ declare function getNodeDiffRoute({ runId: rawRunId, nodeId: rawNodeId, iteratio
     nowMs?: () => number;
     stat?: boolean;
 }): Promise<GetNodeDiffRouteResult>;
-type SmithersDb$2 = _smithers_db_adapter.SmithersDb;
-type AttemptRow = _smithers_db_adapter.AttemptRow;
+type SmithersDb$2 = _smithers_orchestrator_db_adapter.SmithersDb;
+type AttemptRow = _smithers_orchestrator_db_adapter.AttemptRow;
 type GetNodeDiffRouteResult = GetNodeDiffRouteResult$1;
 type DiffSummary = DiffSummary$1;
 
@@ -832,8 +1056,8 @@ declare function getNodeOutputRoute(params: {
     nodeId: unknown;
     iteration: unknown;
     resolveRun: (runId: string) => Promise<{
-        workflow: _smithers_components_SmithersWorkflow.SmithersWorkflow<unknown>;
-        adapter: _smithers_db_adapter.SmithersDb;
+        workflow: _smithers_orchestrator_components_SmithersWorkflow.SmithersWorkflow<unknown>;
+        adapter: _smithers_orchestrator_db_adapter.SmithersDb;
     } | null>;
     selectOutputRowImpl?: typeof selectOutputRow;
     emitEffect?: (effect: Effect.Effect<void>) => Promise<unknown>;
@@ -883,9 +1107,9 @@ declare function jumpToFrameRoute(input: {
     onLog?: (level: "info" | "warn" | "error", message: string, fields?: Record<string, unknown>) => Promise<void> | void;
 }): Promise<JumpResult>;
 
-type SmithersDb$1 = _smithers_db_adapter.SmithersDb;
-type SmithersEvent = _smithers_observability_SmithersEvent.SmithersEvent;
-type JumpResult = _smithers_time_travel_jumpToFrame.JumpResult;
+type SmithersDb$1 = _smithers_orchestrator_db_adapter.SmithersDb;
+type SmithersEvent = _smithers_orchestrator_observability_SmithersEvent.SmithersEvent;
+type JumpResult = _smithers_orchestrator_time_travel_jumpToFrame.JumpResult;
 
 /**
  * @param {{
@@ -934,20 +1158,21 @@ declare function streamDevToolsRoute(input: {
 declare const DEVTOOLS_REBASELINE_INTERVAL: 50;
 declare const DEVTOOLS_BACKPRESSURE_LIMIT: 1000;
 declare const DEVTOOLS_POLL_INTERVAL_MS: 25;
-type SmithersDb = _smithers_db_adapter.SmithersDb;
-type DevToolsEvent = _smithers_protocol_devtools.DevToolsEvent;
-type SnapshotSerializerWarning = _smithers_devtools_snapshotSerializer.SnapshotSerializerWarning;
+type SmithersDb = _smithers_orchestrator_db_adapter.SmithersDb;
+type DevToolsEvent = _smithers_orchestrator_protocol_devtools.DevToolsEvent;
+type SnapshotSerializerWarning = _smithers_orchestrator_devtools_snapshotSerializer.SnapshotSerializerWarning;
 
 /**
  * @param {ServerOptions} [opts]
  */
-declare function startServerEffect(opts?: ServerOptions): Effect.Effect<node_http.Server<typeof IncomingMessage$1, typeof ServerResponse$1>, never, never>;
+declare function startServerEffect(opts?: ServerOptions): Effect.Effect<node_http.Server<typeof node_http.IncomingMessage, typeof node_http.ServerResponse>, never, never>;
 /**
  * @param {ServerOptions} [opts]
  */
-declare function startServer(opts?: ServerOptions): node_http.Server<typeof IncomingMessage$1, typeof ServerResponse$1>;
+declare function startServer(opts?: ServerOptions): node_http.Server<typeof node_http.IncomingMessage, typeof node_http.ServerResponse>;
 
-type RunRow = _smithers_db_adapter_RunRow.RunRow;
+type RunRow = _smithers_orchestrator_db_adapter_RunRow.RunRow;
+type ServerResponse = node_http.ServerResponse;
 type ServerOptions = ServerOptions$1;
 
-export { type AttemptRow, type ConnectRequest, type ConnectionState, DEVTOOLS_BACKPRESSURE_LIMIT, DEVTOOLS_EMPTY_ROOT_ID, DEVTOOLS_MAX_FRAME_NO, DEVTOOLS_POLL_INTERVAL_MS, DEVTOOLS_REBASELINE_INTERVAL, DEVTOOLS_RUN_ID_PATTERN, DEVTOOLS_TREE_MAX_DEPTH, type DevToolsEvent, type DevToolsNode, type DevToolsNodeType, DevToolsRouteError, type DiffSummary, type EventFrame, GATEWAY_FRAME_ID_MAX_LENGTH, GATEWAY_METHOD_NAME_MAX_LENGTH, GATEWAY_RPC_INPUT_MAX_BYTES, GATEWAY_RPC_INPUT_MAX_DEPTH, GATEWAY_RPC_MAX_ARRAY_LENGTH, GATEWAY_RPC_MAX_DEPTH, GATEWAY_RPC_MAX_PAYLOAD_BYTES, GATEWAY_RPC_MAX_STRING_LENGTH, Gateway, type GatewayAuthConfig, type GatewayDefaults, type GatewayMetricLabels, type GatewayOptions, type GatewayRequestContext, type GatewayTokenGrant, type GatewayTransport, type GatewayWebhookConfig, type GatewayWebhookRunConfig, type GatewayWebhookSignalConfig, type GetNodeDiffRouteResult, type HelloResponse, ITERATION_MAX, type IncomingMessage, type JumpResult, NODE_ID_PATTERN, NODE_OUTPUT_MAX_BYTES, NODE_OUTPUT_WARN_BYTES, type NodeOutputErrorCode, type NodeOutputResponse, NodeOutputRouteError, RUN_ID_PATTERN, type RegisteredWorkflow, type RequestFrame, type ResolvedRun, type ResponseFrame, type RunRow, type RunStartAuthContext, type ServeOptions, type ServerOptions, type ServerResponse, type SmithersWorkflow, assertGatewayInputDepthWithinBounds, createServeApp, emptyDevToolsRoot, getDevToolsSnapshotRoute, getGatewayInputDepth, getNodeDiffRoute, getNodeOutputRoute, jumpToFrameRoute, parseGatewayRequestFrame, parseXmlToDevToolsRoot, runFork, runPromise, runSync, snapshotFromFrameRow, startServer, startServerEffect, statusForRpcError, streamDevToolsRoute, summarizeBundle, validateFrameNoInput, validateFromSeqInput, validateGatewayMethodName, validateRequestedFrameNo, validateRunId };
+export { type AttemptRow, type ConnectRequest, type ConnectionState, DEVTOOLS_BACKPRESSURE_LIMIT, DEVTOOLS_EMPTY_ROOT_ID, DEVTOOLS_MAX_FRAME_NO, DEVTOOLS_POLL_INTERVAL_MS, DEVTOOLS_REBASELINE_INTERVAL, DEVTOOLS_RUN_ID_PATTERN, DEVTOOLS_TREE_MAX_DEPTH, type DevToolsEvent, type DevToolsNode, type DevToolsNodeType, DevToolsRouteError, type DiffSummary, type EventFrame, GATEWAY_FRAME_ID_MAX_LENGTH, GATEWAY_METHOD_NAME_MAX_LENGTH, GATEWAY_RPC_INPUT_MAX_BYTES, GATEWAY_RPC_INPUT_MAX_DEPTH, GATEWAY_RPC_MAX_ARRAY_LENGTH, GATEWAY_RPC_MAX_DEPTH, GATEWAY_RPC_MAX_PAYLOAD_BYTES, GATEWAY_RPC_MAX_STRING_LENGTH, Gateway, type GatewayAuthConfig, type GatewayDefaults, type GatewayMetricLabels, type GatewayOptions, type GatewayRegisterOptions, type GatewayRequestContext, type GatewayTokenGrant, type GatewayTransport, type GatewayUiConfig, type GatewayUiMount, type GatewayWebhookConfig, type GatewayWebhookRunConfig, type GatewayWebhookSignalConfig, type GetNodeDiffRouteResult, type HelloResponse, ITERATION_MAX, type IncomingMessage, type JumpResult, NODE_ID_PATTERN, NODE_OUTPUT_MAX_BYTES, NODE_OUTPUT_WARN_BYTES, type NodeOutputErrorCode, type NodeOutputResponse, NodeOutputRouteError, RUN_ID_PATTERN, type RegisteredWorkflow, type RequestFrame, type ResolvedGatewayUiConfig, type ResolvedRun, type ResponseFrame, type RunRow, type RunStartAuthContext, type ServeOptions, type ServerOptions, type ServerResponse, type SmithersWorkflow, assertGatewayInputDepthWithinBounds, createServeApp, emptyDevToolsRoot, getDevToolsSnapshotRoute, getGatewayInputDepth, getNodeDiffRoute, getNodeOutputRoute, jumpToFrameRoute, parseGatewayRequestFrame, parseXmlToDevToolsRoot, runFork, runPromise, runSync, snapshotFromFrameRow, startServer, startServerEffect, statusForRpcError, streamDevToolsRoute, summarizeBundle, validateFrameNoInput, validateFromSeqInput, validateGatewayMethodName, validateRequestedFrameNo, validateRunId };