@bratsos/workflow-engine-console 1.0.0-alpha.2

package/dist/chunk-RCVZ3AP4.js

@@ -0,0 +1,62 @@
+// src/node.ts
+function toNodeHandler(handler) {
+  return async function nodeHandler(request, response) {
+    try {
+      const fetchRequest = await toFetchRequest(request);
+      const fetchResponse = await handler(fetchRequest);
+      response.statusCode = fetchResponse.status;
+      fetchResponse.headers.forEach((value, key) => {
+        response.setHeader(key, value);
+      });
+      const body = fetchResponse.body ? Buffer.from(await fetchResponse.arrayBuffer()) : null;
+      response.end(body ?? void 0);
+    } catch (error) {
+      response.statusCode = 500;
+      response.setHeader("content-type", "application/json; charset=utf-8");
+      response.end(
+        JSON.stringify({
+          error: {
+            code: "internal_error",
+            message: error instanceof Error ? error.message : "Unexpected error."
+          }
+        })
+      );
+    }
+  };
+}
+async function toFetchRequest(request) {
+  const method = request.method ?? "GET";
+  const host = request.headers.host ?? "localhost";
+  const protocol = request.headers["x-forwarded-proto"] ?? "http";
+  const url = new URL(request.url ?? "/", `${protocol}://${host}`);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(request.headers)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) headers.append(key, entry);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody ? await readBody(request) : void 0;
+  return new Request(url, {
+    method,
+    headers,
+    body: body && body.length > 0 ? body : void 0
+  });
+}
+function readBody(request) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    request.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    request.on("end", () => resolve(Buffer.concat(chunks)));
+    request.on("error", reject);
+  });
+}
+
+export { toNodeHandler };
+//# sourceMappingURL=chunk-RCVZ3AP4.js.map
+//# sourceMappingURL=chunk-RCVZ3AP4.js.map

package/dist/chunk-RCVZ3AP4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node.ts"],"names":[],"mappings":"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","file":"chunk-RCVZ3AP4.js","sourcesContent":["import type { IncomingMessage, ServerResponse } from \"node:http\";\nimport type { WorkflowConsoleHandler } from \"./handler\";\n\n/**\n * Adapt the fetch handler to Node's `http` request/response pair.\n *\n * Only Express, Fastify and bare `node:http` need this. Next.js route\n * handlers, Hono, Cloudflare Workers, Deno and Bun all speak `Request` and\n * `Response` natively, so they mount the handler directly — see the README.\n */\nexport function toNodeHandler(\n  handler: WorkflowConsoleHandler,\n): (request: IncomingMessage, response: ServerResponse) => Promise<void> {\n  return async function nodeHandler(request, response) {\n    try {\n      const fetchRequest = await toFetchRequest(request);\n      const fetchResponse = await handler(fetchRequest);\n      response.statusCode = fetchResponse.status;\n      fetchResponse.headers.forEach((value, key) => {\n        response.setHeader(key, value);\n      });\n      const body = fetchResponse.body\n        ? Buffer.from(await fetchResponse.arrayBuffer())\n        : null;\n      response.end(body ?? undefined);\n    } catch (error) {\n      response.statusCode = 500;\n      response.setHeader(\"content-type\", \"application/json; charset=utf-8\");\n      response.end(\n        JSON.stringify({\n          error: {\n            code: \"internal_error\",\n            message:\n              error instanceof Error ? error.message : \"Unexpected error.\",\n          },\n        }),\n      );\n    }\n  };\n}\n\nasync function toFetchRequest(request: IncomingMessage): Promise<Request> {\n  const method = request.method ?? \"GET\";\n  // `req.url` is path-and-query only; the Host header supplies the origin.\n  // The origin is never used for routing — the handler derives its mount\n  // path from the pathname — so a missing Host just needs a placeholder.\n  const host = request.headers.host ?? \"localhost\";\n  const protocol =\n    (request.headers[\"x-forwarded-proto\"] as string | undefined) ?? \"http\";\n  const url = new URL(request.url ?? \"/\", `${protocol}://${host}`);\n\n  const headers = new Headers();\n  for (const [key, value] of Object.entries(request.headers)) {\n    if (value === undefined) continue;\n    if (Array.isArray(value)) {\n      for (const entry of value) headers.append(key, entry);\n    } else {\n      headers.set(key, value);\n    }\n  }\n\n  const hasBody = method !== \"GET\" && method !== \"HEAD\";\n  const body = hasBody ? await readBody(request) : undefined;\n\n  return new Request(url, {\n    method,\n    headers,\n    body: body && body.length > 0 ? body : undefined,\n  });\n}\n\nfunction readBody(request: IncomingMessage): Promise<Buffer> {\n  return new Promise((resolve, reject) => {\n    const chunks: Buffer[] = [];\n    request.on(\"data\", (chunk: Buffer | string) => {\n      chunks.push(typeof chunk === \"string\" ? Buffer.from(chunk) : chunk);\n    });\n    request.on(\"end\", () => resolve(Buffer.concat(chunks)));\n    request.on(\"error\", reject);\n  });\n}\n"]}

package/dist/chunk-THOZTVDT.js

@@ -0,0 +1,85 @@
+// src/errors.ts
+var ConsoleQueryTimeoutError = class extends Error {
+  constructor(query, timeoutMs, options) {
+    super(
+      `Console query "${query}" was cancelled after ${timeoutMs}ms by statement_timeout. Narrow the filter or raise statementTimeoutMs.`,
+      options
+    );
+    this.query = query;
+    this.timeoutMs = timeoutMs;
+    this.name = "ConsoleQueryTimeoutError";
+  }
+  code = "query_timeout";
+};
+var STATEMENT_TIMEOUT_SQLSTATE = "57014";
+function isStatementTimeout(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const candidate = error;
+  if (candidate.code === STATEMENT_TIMEOUT_SQLSTATE) return true;
+  if (candidate.meta?.code === STATEMENT_TIMEOUT_SQLSTATE) return true;
+  const messages = [candidate.message, candidate.meta?.message];
+  return messages.some(
+    (message) => typeof message === "string" && (message.includes(STATEMENT_TIMEOUT_SQLSTATE) || message.includes("canceling statement due to statement timeout"))
+  );
+}
+var ConsoleBadRequestError = class extends Error {
+  code = "bad_request";
+  constructor(message) {
+    super(message);
+    this.name = "ConsoleBadRequestError";
+  }
+};
+
+// src/read-port.ts
+var CONSOLE_STATUSES = [
+  "PENDING",
+  "RUNNING",
+  "SUSPENDED",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "SKIPPED"
+];
+function isConsoleStatus(value) {
+  return CONSOLE_STATUSES.includes(value);
+}
+var ALL_CAPABILITIES = {
+  runs: true,
+  steps: true,
+  annotations: true,
+  queue: true,
+  suspended: true,
+  deadLetters: true,
+  workers: true,
+  costs: true
+};
+var DEFAULT_RUN_LIMIT = 50;
+var MAX_LIMIT = 200;
+function clampLimit(requested, fallback = DEFAULT_RUN_LIMIT) {
+  if (requested === void 0 || !Number.isFinite(requested)) return fallback;
+  return Math.min(MAX_LIMIT, Math.max(1, Math.floor(requested)));
+}
+function encodeCursor(cursor) {
+  return Buffer.from(
+    `${cursor.createdAt.toISOString()}|${cursor.id}`,
+    "utf8"
+  ).toString("base64url");
+}
+function decodeCursor(raw) {
+  let decoded;
+  try {
+    decoded = Buffer.from(raw, "base64url").toString("utf8");
+  } catch {
+    return null;
+  }
+  const separator = decoded.indexOf("|");
+  if (separator <= 0) return null;
+  const createdAt = new Date(decoded.slice(0, separator));
+  const id = decoded.slice(separator + 1);
+  if (Number.isNaN(createdAt.getTime()) || id.length === 0) return null;
+  return { createdAt, id };
+}
+
+export { ALL_CAPABILITIES, CONSOLE_STATUSES, ConsoleBadRequestError, ConsoleQueryTimeoutError, DEFAULT_RUN_LIMIT, MAX_LIMIT, clampLimit, decodeCursor, encodeCursor, isConsoleStatus, isStatementTimeout };
+//# sourceMappingURL=chunk-THOZTVDT.js.map
+//# sourceMappingURL=chunk-THOZTVDT.js.map

package/dist/chunk-THOZTVDT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/read-port.ts"],"names":[],"mappings":"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","file":"chunk-THOZTVDT.js","sourcesContent":["/**\n * A console query was cancelled by `statement_timeout` (Postgres `57014`).\n *\n * Thrown rather than swallowed so the handler can answer with an honest\n * \"that query was too expensive\" instead of holding the request open. The\n * UI renders it as an inline banner and leaves the filter bar interactive,\n * so the operator can narrow the filter and retry — a page that keeps\n * working is worth more than a spinner that never resolves.\n */\nexport class ConsoleQueryTimeoutError extends Error {\n  readonly code = \"query_timeout\" as const;\n  constructor(\n    readonly query: string,\n    readonly timeoutMs: number,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      `Console query \"${query}\" was cancelled after ${timeoutMs}ms by statement_timeout. Narrow the filter or raise statementTimeoutMs.`,\n      options,\n    );\n    this.name = \"ConsoleQueryTimeoutError\";\n  }\n}\n\n/** Postgres `query_canceled`. */\nconst STATEMENT_TIMEOUT_SQLSTATE = \"57014\";\n\n/**\n * Recognise a cancelled statement through whatever wrapper the driver put\n * around it. Prisma surfaces the SQLSTATE on `meta.code` for\n * `PrismaClientKnownRequestError` P2010, node-postgres puts it on `code`,\n * and a raw error may only carry the message.\n */\nexport function isStatementTimeout(error: unknown): boolean {\n  if (typeof error !== \"object\" || error === null) return false;\n  const candidate = error as {\n    code?: unknown;\n    meta?: { code?: unknown; message?: unknown };\n    message?: unknown;\n  };\n  if (candidate.code === STATEMENT_TIMEOUT_SQLSTATE) return true;\n  if (candidate.meta?.code === STATEMENT_TIMEOUT_SQLSTATE) return true;\n  const messages = [candidate.message, candidate.meta?.message];\n  return messages.some(\n    (message) =>\n      typeof message === \"string\" &&\n      (message.includes(STATEMENT_TIMEOUT_SQLSTATE) ||\n        message.includes(\"canceling statement due to statement timeout\")),\n  );\n}\n\n/** The request asked for something the console cannot serve. */\nexport class ConsoleBadRequestError extends Error {\n  readonly code = \"bad_request\" as const;\n  constructor(message: string) {\n    super(message);\n    this.name = \"ConsoleBadRequestError\";\n  }\n}\n","/**\n * The console's read contract.\n *\n * Everything the console can show is expressed here, and nothing else in\n * the package reaches for a database. An implementation is handed the\n * connection its caller already has — a Prisma client, or the transaction\n * client the caller opened — and never opens one of its own. That is the\n * property the whole design exists to preserve: a consumer running the\n * kernel inside one transaction per tenant, under row-level security, gets\n * the console's reads inside that same transaction, evaluated against the\n * same policies, with authentication already decided upstream. A reader\n * that dialled the database itself would be a second session and therefore\n * a second security context, and no amount of configuration recovers the\n * tenant scoping once that happens.\n *\n * The interface is declared here rather than added to the engine's\n * `PersistenceCore` on purpose — see the note in the package README. It is\n * a small, optional surface; making it a required part of the persistence\n * port would break every third-party adapter for a feature that is\n * explicitly optional.\n */\n\n/** Run/stage/job lifecycle states, mirroring the engine's `Status` enum. */\nexport type ConsoleStatus =\n  | \"PENDING\"\n  | \"RUNNING\"\n  | \"SUSPENDED\"\n  | \"COMPLETED\"\n  | \"FAILED\"\n  | \"CANCELLED\"\n  | \"SKIPPED\";\n\nexport const CONSOLE_STATUSES: readonly ConsoleStatus[] = [\n  \"PENDING\",\n  \"RUNNING\",\n  \"SUSPENDED\",\n  \"COMPLETED\",\n  \"FAILED\",\n  \"CANCELLED\",\n  \"SKIPPED\",\n] as const;\n\nexport function isConsoleStatus(value: string): value is ConsoleStatus {\n  return (CONSOLE_STATUSES as readonly string[]).includes(value);\n}\n\n/** One row of the runs list. Deliberately excludes `input`/`output`/`config`: a list page must not carry payloads. */\nexport interface RunSummary {\n  id: string;\n  createdAt: Date;\n  updatedAt: Date;\n  workflowId: string;\n  workflowName: string;\n  workflowType: string;\n  status: ConsoleStatus;\n  startedAt: Date | null;\n  completedAt: Date | null;\n  duration: number | null;\n  totalCost: number;\n  totalTokens: number;\n  priority: number;\n  definitionVersion: string | null;\n  redriveCount: number;\n}\n\nexport interface StageSummary {\n  id: string;\n  workflowRunId: string;\n  stageId: string;\n  stageName: string;\n  stageNumber: number;\n  executionGroup: number;\n  attempt: number;\n  status: ConsoleStatus;\n  startedAt: Date | null;\n  completedAt: Date | null;\n  duration: number | null;\n  nextPollAt: Date | null;\n  pollInterval: number | null;\n  maxWaitUntil: Date | null;\n  errorMessage: string | null;\n}\n\n/** A durable-step ledger entry. `status` is a free-form string in the schema, so it stays one here. */\nexport interface StepSummary {\n  id: string;\n  stageRecordId: string;\n  stepId: string;\n  seq: number;\n  kind: string;\n  status: string;\n  attempt: number;\n  leaseExpiresAt: Date | null;\n  deadlineAt: Date | null;\n  /** Deterministic name of the external effect a `run` step creates; null for other kinds. */\n  externalKey: string | null;\n  error: string | null;\n  createdAt: Date;\n  updatedAt: Date;\n}\n\nexport interface AnnotationSummary {\n  id: string;\n  createdAt: Date;\n  workflowRunId: string;\n  workflowStageRecordId: string | null;\n  attempt: number;\n  scope: string;\n  scopeId: string | null;\n  actorKind: string | null;\n  actorId: string | null;\n  key: string;\n  value: unknown;\n}\n\nexport interface LogEntry {\n  id: string;\n  createdAt: Date;\n  workflowRunId: string | null;\n  workflowStageId: string | null;\n  level: string;\n  message: string;\n}\n\n/**\n * One retained outbox row, read as a run's event timeline. The engine marks\n * events published rather than deleting them, and `(workflowRunId, sequence)`\n * is unique, so a run timeline is an index range scan.\n */\nexport interface RunEvent {\n  id: string;\n  workflowRunId: string;\n  sequence: number;\n  eventType: string;\n  occurredAt: Date;\n  publishedAt: Date | null;\n  retryCount: number;\n  dlqAt: Date | null;\n}\n\nexport interface RunDetail {\n  run: RunSummary & {\n    input: unknown;\n    output: unknown;\n    config: unknown;\n    metadata: unknown;\n  };\n  stages: StageSummary[];\n  steps: StepSummary[];\n  annotations: AnnotationSummary[];\n  logs: LogEntry[];\n  events: RunEvent[];\n  /** True when a list was cut off by its limit, so the UI can say so instead of implying completeness. */\n  truncated: {\n    steps: boolean;\n    annotations: boolean;\n    logs: boolean;\n    events: boolean;\n  };\n}\n\nexport interface RunListFilters {\n  status?: ConsoleStatus[];\n  workflowId?: string;\n  workflowType?: string;\n  createdAfter?: Date;\n  createdBefore?: Date;\n  definitionVersion?: string;\n}\n\nexport interface RunListQuery {\n  filters?: RunListFilters;\n  /** Opaque cursor from a previous page's `nextCursor`. Keyset, not offset. */\n  cursor?: string;\n  limit?: number;\n}\n\nexport interface RunListPage {\n  runs: RunSummary[];\n  nextCursor: string | null;\n}\n\nexport interface QueueHealth {\n  countsByStatus: Record<ConsoleStatus, number>;\n  /** Enqueue time of the oldest job still waiting to be picked up. */\n  oldestPendingAt: Date | null;\n  /** `lockedAt` of the longest-held lease among running jobs — a lease older than your reaper's threshold is a stuck worker. */\n  oldestLeaseAt: Date | null;\n  /** Suspended jobs whose `nextPollAt` is already in the past. */\n  overduePolls: number;\n}\n\n/**\n * A worker, derived from the leases it holds. The engine has no worker\n * registry table; `touchJob` refreshes `job_queue.lockedAt`, so the newest\n * lease a worker holds is the best available heartbeat, and a worker with\n * no running job is invisible here by construction.\n */\nexport interface WorkerInstance {\n  workerId: string;\n  runningJobs: number;\n  oldestLockedAt: Date | null;\n  /** Most recent `touchJob`; the console renders `now - lastSeenAt` as heartbeat age. */\n  lastSeenAt: Date | null;\n}\n\nexport interface SuspendedStage {\n  id: string;\n  workflowRunId: string;\n  workflowId: string;\n  stageId: string;\n  stageName: string;\n  attempt: number;\n  nextPollAt: Date | null;\n  pollInterval: number | null;\n  maxWaitUntil: Date | null;\n}\n\nexport interface DeadLetter {\n  id: string;\n  workflowRunId: string;\n  sequence: number;\n  eventType: string;\n  retryCount: number;\n  occurredAt: Date;\n  dlqAt: Date | null;\n}\n\nexport interface CostBucket {\n  /** A workflow id, or an ISO date (`YYYY-MM-DD`) when bucketing by day. */\n  key: string;\n  runs: number;\n  cost: number;\n  tokens: number;\n}\n\nexport interface CostQuery {\n  by: \"workflow\" | \"day\";\n  from?: Date;\n  to?: Date;\n}\n\n/**\n * What a given reader can actually serve, so the UI hides what is not there\n * rather than rendering an empty page. Adapters that predate a view, or\n * schemas whose migrations lag, report `false` and the tab disappears.\n */\nexport interface ConsoleCapabilities {\n  runs: boolean;\n  steps: boolean;\n  annotations: boolean;\n  queue: boolean;\n  suspended: boolean;\n  deadLetters: boolean;\n  workers: boolean;\n  costs: boolean;\n}\n\nexport const ALL_CAPABILITIES: ConsoleCapabilities = {\n  runs: true,\n  steps: true,\n  annotations: true,\n  queue: true,\n  suspended: true,\n  deadLetters: true,\n  workers: true,\n  costs: true,\n};\n\nexport interface RunDetailOptions {\n  stepLimit?: number;\n  annotationLimit?: number;\n  logLimit?: number;\n  eventLimit?: number;\n}\n\nexport interface ConsoleReadPort {\n  readonly capabilities: ConsoleCapabilities;\n\n  listRuns(query: RunListQuery): Promise<RunListPage>;\n  getRunDetail(\n    runId: string,\n    options?: RunDetailOptions,\n  ): Promise<RunDetail | null>;\n  /** Incremental tail of one run's timeline. `afterSequence` of 0 returns from the start. */\n  listRunEvents(\n    runId: string,\n    afterSequence: number,\n    limit?: number,\n  ): Promise<RunEvent[]>;\n  getQueueHealth(): Promise<QueueHealth>;\n  listSuspendedStages(limit?: number): Promise<SuspendedStage[]>;\n  listDeadLetters(limit?: number): Promise<DeadLetter[]>;\n  listWorkers(): Promise<WorkerInstance[]>;\n  getCosts(query: CostQuery): Promise<CostBucket[]>;\n}\n\n/** Default page size for the runs list. */\nexport const DEFAULT_RUN_LIMIT = 50;\n/** Hard ceiling on any page size, whatever the request asks for. */\nexport const MAX_LIMIT = 200;\n\nexport function clampLimit(\n  requested: number | undefined,\n  fallback = DEFAULT_RUN_LIMIT,\n): number {\n  if (requested === undefined || !Number.isFinite(requested)) return fallback;\n  return Math.min(MAX_LIMIT, Math.max(1, Math.floor(requested)));\n}\n\n/**\n * Keyset cursors are `(createdAt, id)` — the exact tuple the composite\n * indexes carry — encoded as opaque text so callers cannot turn one into an\n * offset. Offset pagination is what makes page 400 a sequential scan.\n */\nexport interface RunCursor {\n  createdAt: Date;\n  id: string;\n}\n\nexport function encodeCursor(cursor: RunCursor): string {\n  return Buffer.from(\n    `${cursor.createdAt.toISOString()}|${cursor.id}`,\n    \"utf8\",\n  ).toString(\"base64url\");\n}\n\nexport function decodeCursor(raw: string): RunCursor | null {\n  let decoded: string;\n  try {\n    decoded = Buffer.from(raw, \"base64url\").toString(\"utf8\");\n  } catch {\n    return null;\n  }\n  const separator = decoded.indexOf(\"|\");\n  if (separator <= 0) return null;\n  const createdAt = new Date(decoded.slice(0, separator));\n  const id = decoded.slice(separator + 1);\n  if (Number.isNaN(createdAt.getTime()) || id.length === 0) return null;\n  return { createdAt, id };\n}\n"]}

package/dist/cli.d.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { C as ConsoleKernel } from './actions-DOP8plrl.js';
+import { C as ConsoleReadPort } from './read-port-CRmaGAKb.js';
+
+/**
+ * What a `--config` module must default-export, or export as `console`:
+ * either the object or a zero-argument function returning it.
+ *
+ * Building it is the consumer's job precisely because they know how their
+ * client is constructed — which role it connects as, which `SET LOCAL`
+ * calls their RLS policies expect, whether it is a transaction client.
+ */
+interface ConsoleDevConfig {
+    reader: ConsoleReadPort;
+    kernel?: ConsoleKernel;
+    /** Called once when the server shuts down, to close whatever the module opened. */
+    dispose?: () => void | Promise<void>;
+}
+interface CliOptions {
+    configPath?: string;
+    port: number;
+    host: string;
+    actions: boolean;
+    allowDirectConnection: boolean;
+    databaseUrl?: string;
+    pollIntervalMs: number;
+    help: boolean;
+}
+declare function parseArgs(argv: string[]): CliOptions;
+declare function assertLoopback(host: string): void;
+declare function main(argv: string[]): Promise<number>;
+
+export { type ConsoleDevConfig, assertLoopback, main, parseArgs };

package/dist/cli.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+import { createWorkflowConsole } from './chunk-4RL6UAMS.js';
+import { toNodeHandler } from './chunk-RCVZ3AP4.js';
+import './chunk-THOZTVDT.js';
+import { createServer } from 'http';
+import { pathToFileURL } from 'url';
+
+var HELP = `workflow-console \u2014 serve the workflow engine console locally
+
+  A DEVELOPMENT TOOL. It binds to loopback (127.0.0.1) and refuses any other
+  interface: it ships no authentication, so anything that can reach it can
+  read every run in the database.
+
+Usage
+  workflow-console --config ./console.config.mjs [options]
+  workflow-console --database-url postgres://... --allow-direct-connection
+
+Options
+  --config <path>            Module that builds the reader the way your own
+                             application does. Default-export (or export as
+                             \`console\`) an object { reader, kernel?, dispose? },
+                             or a function returning one. This is the path that
+                             preserves row-level security, because your code
+                             constructs the client.
+  --database-url <url>       Connect directly with Prisma instead. Requires
+                             --allow-direct-connection.
+  --allow-direct-connection  Acknowledge that a direct connection is a second
+                             session and therefore a second security context:
+                             row-level security scoped to your application's
+                             session will NOT apply, and this connection sees
+                             whatever its role can see, across all tenants.
+  --port <n>                 Default 7799.
+  --host <addr>              Default 127.0.0.1. Only loopback is accepted.
+  --actions                  Enable cancel / rerun / replay. Off by default;
+                             needs a kernel from the --config module.
+  --poll <ms>                UI poll interval. Default 5000.
+  --help                     This text.
+`;
+function parseArgs(argv) {
+  const options = {
+    port: 7799,
+    host: "127.0.0.1",
+    actions: false,
+    allowDirectConnection: false,
+    pollIntervalMs: 5e3,
+    help: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = () => {
+      const value = argv[index + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new Error(`${arg} needs a value.`);
+      }
+      index += 1;
+      return value;
+    };
+    switch (arg) {
+      case "--config":
+        options.configPath = next();
+        break;
+      case "--database-url":
+        options.databaseUrl = next();
+        break;
+      case "--allow-direct-connection":
+        options.allowDirectConnection = true;
+        break;
+      case "--port": {
+        const port = Number(next());
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+          throw new Error("--port must be an integer between 1 and 65535.");
+        }
+        options.port = port;
+        break;
+      }
+      case "--host":
+        options.host = next();
+        break;
+      case "--actions":
+        options.actions = true;
+        break;
+      case "--poll": {
+        const poll = Number(next());
+        if (!Number.isFinite(poll) || poll < 0) {
+          throw new Error("--poll must be a non-negative number.");
+        }
+        options.pollIntervalMs = poll;
+        break;
+      }
+      case "--help":
+      case "-h":
+        options.help = true;
+        break;
+      default:
+        throw new Error(`Unknown argument "${arg}". Try --help.`);
+    }
+  }
+  return options;
+}
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+function assertLoopback(host) {
+  if (!LOOPBACK.has(host)) {
+    throw new Error(
+      `--host ${host} is refused. This console ships no authentication, so it binds to loopback only. Put the mounted handler in your application if you need it reachable.`
+    );
+  }
+}
+async function loadConfigModule(path) {
+  const url = pathToFileURL(
+    path.startsWith("/") ? path : `${process.cwd()}/${path}`
+  ).href;
+  const module = await import(url);
+  const candidate = module.default ?? module.console;
+  const resolved = typeof candidate === "function" ? await candidate() : candidate;
+  if (typeof resolved !== "object" || resolved === null || !("reader" in resolved)) {
+    throw new Error(
+      `${path} must export { reader, kernel?, dispose? } as its default export (or as \`console\`), or a function returning it.`
+    );
+  }
+  return resolved;
+}
+async function connectDirectly(databaseUrl) {
+  const { createPrismaConsoleReadPort } = await import('./prisma-read-port-GPAHJEVC.js');
+  const prismaSpecifier = "@prisma/client";
+  const prismaModule = await import(prismaSpecifier).catch(() => {
+    throw new Error(
+      "--database-url needs @prisma/client installed in this project."
+    );
+  });
+  const PrismaClient = prismaModule.PrismaClient;
+  if (!PrismaClient) {
+    throw new Error("@prisma/client did not export PrismaClient.");
+  }
+  const client = new PrismaClient({
+    datasources: { db: { url: databaseUrl } }
+  });
+  return {
+    reader: createPrismaConsoleReadPort(
+      client
+    ),
+    dispose: () => client.$disconnect()
+  };
+}
+async function main(argv) {
+  let options;
+  try {
+    options = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 2;
+  }
+  if (options.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  try {
+    assertLoopback(options.host);
+    let config;
+    if (options.configPath) {
+      config = await loadConfigModule(options.configPath);
+    } else {
+      const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;
+      if (!databaseUrl) {
+        process.stderr.write(
+          "Nothing to connect to. Pass --config <path> (preferred: your code builds the client, so row-level security still applies) or --database-url with --allow-direct-connection.\n"
+        );
+        return 2;
+      }
+      if (!options.allowDirectConnection) {
+        process.stderr.write(
+          "Refusing to open a database connection of my own.\n\nA direct connection is a second session and therefore a second security context: row-level security scoped to your application's session will not apply, and this console would read whatever its role can read, across every tenant.\n\nEither pass --config <path> to a module that builds the reader the way your own code does, or re-run with --allow-direct-connection to accept that.\n"
+        );
+        return 2;
+      }
+      config = await connectDirectly(databaseUrl);
+    }
+    if (options.actions && !config.kernel) {
+      process.stderr.write(
+        "--actions needs a kernel. Export one from your --config module; writes go through kernel commands, not SQL.\n"
+      );
+      await config.dispose?.();
+      return 2;
+    }
+    const handler = createWorkflowConsole({
+      reader: config.reader,
+      kernel: config.kernel,
+      actions: options.actions,
+      pollIntervalMs: options.pollIntervalMs,
+      // Local, single-operator, already behind loopback: there is no
+      // principal to distinguish, so everything the console offers is
+      // allowed. The mounted handler defaults the other way, to deny.
+      authorize: () => true
+    });
+    const server = createServer(toNodeHandler(handler));
+    await new Promise((resolve) => {
+      server.listen(options.port, options.host, resolve);
+    });
+    process.stdout.write(
+      `Workflow console on http://${options.host}:${options.port}/
+  ${options.actions ? "actions enabled" : "read-only"}, polling every ${options.pollIntervalMs}ms
+  Development tool: loopback only, no authentication. Do not expose it.
+`
+    );
+    const shutdown = () => {
+      server.close(() => {
+        void Promise.resolve(config.dispose?.()).then(() => process.exit(0));
+      });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    return 0;
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const code = await main(process.argv.slice(2));
+  if (code !== 0) process.exit(code);
+}
+
+export { assertLoopback, main, parseArgs };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts"],"names":[],"mappings":"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","file":"cli.js","sourcesContent":["#!/usr/bin/env node\n/**\n * `workflow-console` — serve the console locally, with no host application.\n *\n * The mounted handler assumes the consumer has a web app to mount into. A\n * worker-only repository has none, and that is a real gap rather than an\n * edge case. This command closes it with the *same* handler plus a server:\n * there is no second implementation of anything here.\n *\n * It is a development tool and binds to loopback only. The interesting\n * decision is where the database access comes from. The whole point of the\n * mounted design is that the console runs on the connection the consumer\n * already has, inside their transaction, under their row-level security —\n * so the default path here asks the consumer for a module that builds the\n * reader exactly the way their own code does. Falling back to a connection\n * string of our own would quietly discard that property, so it is not the\n * default: it requires an explicit acknowledgement.\n */\nimport { createServer } from \"node:http\";\nimport { pathToFileURL } from \"node:url\";\nimport type { ConsoleKernel } from \"./actions\";\nimport { createWorkflowConsole } from \"./handler\";\nimport { toNodeHandler } from \"./node\";\nimport type { ConsoleReadPort } from \"./read-port\";\n\n/**\n * What a `--config` module must default-export, or export as `console`:\n * either the object or a zero-argument function returning it.\n *\n * Building it is the consumer's job precisely because they know how their\n * client is constructed — which role it connects as, which `SET LOCAL`\n * calls their RLS policies expect, whether it is a transaction client.\n */\nexport interface ConsoleDevConfig {\n  reader: ConsoleReadPort;\n  kernel?: ConsoleKernel;\n  /** Called once when the server shuts down, to close whatever the module opened. */\n  dispose?: () => void | Promise<void>;\n}\n\ninterface CliOptions {\n  configPath?: string;\n  port: number;\n  host: string;\n  actions: boolean;\n  allowDirectConnection: boolean;\n  databaseUrl?: string;\n  pollIntervalMs: number;\n  help: boolean;\n}\n\nconst HELP = `workflow-console — serve the workflow engine console locally\n\n  A DEVELOPMENT TOOL. It binds to loopback (127.0.0.1) and refuses any other\n  interface: it ships no authentication, so anything that can reach it can\n  read every run in the database.\n\nUsage\n  workflow-console --config ./console.config.mjs [options]\n  workflow-console --database-url postgres://... --allow-direct-connection\n\nOptions\n  --config <path>            Module that builds the reader the way your own\n                             application does. Default-export (or export as\n                             \\`console\\`) an object { reader, kernel?, dispose? },\n                             or a function returning one. This is the path that\n                             preserves row-level security, because your code\n                             constructs the client.\n  --database-url <url>       Connect directly with Prisma instead. Requires\n                             --allow-direct-connection.\n  --allow-direct-connection  Acknowledge that a direct connection is a second\n                             session and therefore a second security context:\n                             row-level security scoped to your application's\n                             session will NOT apply, and this connection sees\n                             whatever its role can see, across all tenants.\n  --port <n>                 Default 7799.\n  --host <addr>              Default 127.0.0.1. Only loopback is accepted.\n  --actions                  Enable cancel / rerun / replay. Off by default;\n                             needs a kernel from the --config module.\n  --poll <ms>                UI poll interval. Default 5000.\n  --help                     This text.\n`;\n\nexport function parseArgs(argv: string[]): CliOptions {\n  const options: CliOptions = {\n    port: 7799,\n    host: \"127.0.0.1\",\n    actions: false,\n    allowDirectConnection: false,\n    pollIntervalMs: 5000,\n    help: false,\n  };\n\n  for (let index = 0; index < argv.length; index += 1) {\n    const arg = argv[index];\n    const next = (): string => {\n      const value = argv[index + 1];\n      if (value === undefined || value.startsWith(\"--\")) {\n        throw new Error(`${arg} needs a value.`);\n      }\n      index += 1;\n      return value;\n    };\n    switch (arg) {\n      case \"--config\":\n        options.configPath = next();\n        break;\n      case \"--database-url\":\n        options.databaseUrl = next();\n        break;\n      case \"--allow-direct-connection\":\n        options.allowDirectConnection = true;\n        break;\n      case \"--port\": {\n        const port = Number(next());\n        if (!Number.isInteger(port) || port < 1 || port > 65535) {\n          throw new Error(\"--port must be an integer between 1 and 65535.\");\n        }\n        options.port = port;\n        break;\n      }\n      case \"--host\":\n        options.host = next();\n        break;\n      case \"--actions\":\n        options.actions = true;\n        break;\n      case \"--poll\": {\n        const poll = Number(next());\n        if (!Number.isFinite(poll) || poll < 0) {\n          throw new Error(\"--poll must be a non-negative number.\");\n        }\n        options.pollIntervalMs = poll;\n        break;\n      }\n      case \"--help\":\n      case \"-h\":\n        options.help = true;\n        break;\n      default:\n        throw new Error(`Unknown argument \"${arg}\". Try --help.`);\n    }\n  }\n  return options;\n}\n\n/** Loopback only. A dev console with no auth must not be reachable off-box. */\nconst LOOPBACK = new Set([\"127.0.0.1\", \"localhost\", \"::1\", \"[::1]\"]);\n\nexport function assertLoopback(host: string): void {\n  if (!LOOPBACK.has(host)) {\n    throw new Error(\n      `--host ${host} is refused. This console ships no authentication, so it binds to loopback only. Put the mounted handler in your application if you need it reachable.`,\n    );\n  }\n}\n\nasync function loadConfigModule(path: string): Promise<ConsoleDevConfig> {\n  const url = pathToFileURL(\n    path.startsWith(\"/\") ? path : `${process.cwd()}/${path}`,\n  ).href;\n  const module: Record<string, unknown> = await import(url);\n  const candidate = module.default ?? module.console;\n  const resolved =\n    typeof candidate === \"function\"\n      ? await (\n          candidate as () => ConsoleDevConfig | Promise<ConsoleDevConfig>\n        )()\n      : candidate;\n  if (\n    typeof resolved !== \"object\" ||\n    resolved === null ||\n    !(\"reader\" in resolved)\n  ) {\n    throw new Error(\n      `${path} must export { reader, kernel?, dispose? } as its default export (or as \\`console\\`), or a function returning it.`,\n    );\n  }\n  return resolved as ConsoleDevConfig;\n}\n\n/**\n * The escape hatch: our own Prisma client from a connection string.\n *\n * Deliberately behind an explicit flag. `@prisma/client` is imported\n * dynamically so the package does not depend on it for the mounted path,\n * which is the path that matters.\n */\nasync function connectDirectly(databaseUrl: string): Promise<ConsoleDevConfig> {\n  const { createPrismaConsoleReadPort } = await import(\"./prisma-read-port\");\n  // Loaded through a variable specifier so TypeScript does not try to\n  // resolve `@prisma/client` at build time: this package does not depend on\n  // it, and this is the one path that touches it.\n  const prismaSpecifier = \"@prisma/client\";\n  const prismaModule: Record<string, unknown> = await import(\n    prismaSpecifier\n  ).catch(() => {\n    throw new Error(\n      \"--database-url needs @prisma/client installed in this project.\",\n    );\n  });\n  const PrismaClient = prismaModule.PrismaClient as\n    | (new (\n        args: unknown,\n      ) => {\n        $disconnect(): Promise<void>;\n      })\n    | undefined;\n  if (!PrismaClient) {\n    throw new Error(\"@prisma/client did not export PrismaClient.\");\n  }\n  const client = new PrismaClient({\n    datasources: { db: { url: databaseUrl } },\n  });\n  return {\n    reader: createPrismaConsoleReadPort(\n      client as unknown as Parameters<typeof createPrismaConsoleReadPort>[0],\n    ),\n    dispose: () => client.$disconnect(),\n  };\n}\n\nexport async function main(argv: string[]): Promise<number> {\n  let options: CliOptions;\n  try {\n    options = parseArgs(argv);\n  } catch (error) {\n    process.stderr.write(\n      `${error instanceof Error ? error.message : String(error)}\\n`,\n    );\n    return 2;\n  }\n\n  if (options.help) {\n    process.stdout.write(HELP);\n    return 0;\n  }\n\n  try {\n    assertLoopback(options.host);\n\n    let config: ConsoleDevConfig;\n    if (options.configPath) {\n      config = await loadConfigModule(options.configPath);\n    } else {\n      const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;\n      if (!databaseUrl) {\n        process.stderr.write(\n          \"Nothing to connect to. Pass --config <path> (preferred: your code builds the client, so row-level security still applies) or --database-url with --allow-direct-connection.\\n\",\n        );\n        return 2;\n      }\n      if (!options.allowDirectConnection) {\n        process.stderr.write(\n          \"Refusing to open a database connection of my own.\\n\\n\" +\n            \"A direct connection is a second session and therefore a second security context: row-level security scoped to your application's session will not apply, and this console would read whatever its role can read, across every tenant.\\n\\n\" +\n            \"Either pass --config <path> to a module that builds the reader the way your own code does, or re-run with --allow-direct-connection to accept that.\\n\",\n        );\n        return 2;\n      }\n      config = await connectDirectly(databaseUrl);\n    }\n\n    if (options.actions && !config.kernel) {\n      process.stderr.write(\n        \"--actions needs a kernel. Export one from your --config module; writes go through kernel commands, not SQL.\\n\",\n      );\n      await config.dispose?.();\n      return 2;\n    }\n\n    const handler = createWorkflowConsole({\n      reader: config.reader,\n      kernel: config.kernel,\n      actions: options.actions,\n      pollIntervalMs: options.pollIntervalMs,\n      // Local, single-operator, already behind loopback: there is no\n      // principal to distinguish, so everything the console offers is\n      // allowed. The mounted handler defaults the other way, to deny.\n      authorize: () => true,\n    });\n\n    const server = createServer(toNodeHandler(handler));\n    await new Promise<void>((resolve) => {\n      server.listen(options.port, options.host, resolve);\n    });\n\n    process.stdout.write(\n      `Workflow console on http://${options.host}:${options.port}/\\n` +\n        `  ${options.actions ? \"actions enabled\" : \"read-only\"}, polling every ${options.pollIntervalMs}ms\\n` +\n        \"  Development tool: loopback only, no authentication. Do not expose it.\\n\",\n    );\n\n    const shutdown = () => {\n      server.close(() => {\n        void Promise.resolve(config.dispose?.()).then(() => process.exit(0));\n      });\n    };\n    process.on(\"SIGINT\", shutdown);\n    process.on(\"SIGTERM\", shutdown);\n\n    return 0;\n  } catch (error) {\n    process.stderr.write(\n      `${error instanceof Error ? error.message : String(error)}\\n`,\n    );\n    return 1;\n  }\n}\n\n// Only run when invoked as a program, so the exported pieces stay testable.\nif (\n  process.argv[1] &&\n  import.meta.url === pathToFileURL(process.argv[1]).href\n) {\n  const code = await main(process.argv.slice(2));\n  if (code !== 0) process.exit(code);\n}\n"]}

package/dist/handler-Cq2cVh7p.d.ts

@@ -0,0 +1,47 @@
+import { d as ConsoleAuthorizeContext, C as ConsoleKernel, c as ConsoleActionEvent } from './actions-DOP8plrl.js';
+import { C as ConsoleReadPort } from './read-port-CRmaGAKb.js';
+
+interface WorkflowConsoleOptions {
+    /** Reads run on this. It is constructed from the caller's client or transaction; the console never opens one. */
+    reader: ConsoleReadPort;
+    /**
+     * Per-request authorisation. Omit it and every action is denied — a
+     * console that shipped with a permissive default would be a way to leak
+     * a tenant's runs by forgetting one line of configuration.
+     *
+     * It runs *after* the host's authentication. Assume "is this request
+     * authenticated?" is already decided; answer only "may this principal do
+     * this?". A throw denies, so a bug in the callback fails closed.
+     */
+    authorize?: (context: ConsoleAuthorizeContext) => boolean | Promise<boolean>;
+    /** Required only when `actions` is true. */
+    kernel?: ConsoleKernel;
+    /** Write actions are off unless this is true. Read-only is the default. */
+    actions?: boolean;
+    /**
+     * Mount path, if the handler cannot work it out. It normally can: the
+     * SPA routes on the fragment, so the only paths the server ever sees are
+     * the mount root itself, `<root>/api/...` and `<root>/assets/...`.
+     */
+    basePath?: string;
+    /** UI poll interval in ms. Default 5000; the surveyed consoles sit between 1s and 5s and a shared console should be at the slow end. */
+    pollIntervalMs?: number;
+    /** Fix the poll interval and hide the picker. */
+    forcePollInterval?: boolean;
+    /** Supply a CSP nonce for the injected config script, for hosts running a strict policy. */
+    cspNonce?: (request: Request) => string | undefined;
+    /** Called after every allowed write. The audit trail hosts would otherwise have to build themselves. */
+    onAction?: (event: ConsoleActionEvent) => void | Promise<void>;
+}
+type WorkflowConsoleHandler = (request: Request) => Promise<Response>;
+/**
+ * Build a fetch handler serving the console's JSON API and its prebuilt UI.
+ *
+ * It opens no connection: every read goes through `reader`, which the caller
+ * built over the client or transaction they already had, so the console runs
+ * in the caller's security context and inherits their row-level security
+ * rather than working around it.
+ */
+declare function createWorkflowConsole(options: WorkflowConsoleOptions): WorkflowConsoleHandler;
+
+export { type WorkflowConsoleHandler as W, type WorkflowConsoleOptions as a, createWorkflowConsole as c };

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+export { a as CONSOLE_ACTIONS, b as ConsoleAction, c as ConsoleActionEvent, d as ConsoleAuthorizeContext, C as ConsoleKernel, W as WRITE_ACTIONS, i as isWriteAction } from './actions-DOP8plrl.js';
+export { W as WorkflowConsoleHandler, a as WorkflowConsoleOptions, c as createWorkflowConsole } from './handler-Cq2cVh7p.js';
+import { C as ConsoleReadPort, a as ConsoleCapabilities, R as RunListQuery, b as RunListPage, c as RunDetailOptions, d as RunDetail, e as RunEvent, Q as QueueHealth, S as SuspendedStage, D as DeadLetter, W as WorkerInstance, f as CostQuery, g as CostBucket } from './read-port-CRmaGAKb.js';
+export { A as ALL_CAPABILITIES, h as AnnotationSummary, i as CONSOLE_STATUSES, j as ConsoleStatus, k as DEFAULT_RUN_LIMIT, L as LogEntry, M as MAX_LIMIT, l as RunCursor, m as RunListFilters, n as RunSummary, o as StageSummary, p as StepSummary, q as clampLimit, r as decodeCursor, s as encodeCursor, t as isConsoleStatus } from './read-port-CRmaGAKb.js';
+
+/**
+ * A console query was cancelled by `statement_timeout` (Postgres `57014`).
+ *
+ * Thrown rather than swallowed so the handler can answer with an honest
+ * "that query was too expensive" instead of holding the request open. The
+ * UI renders it as an inline banner and leaves the filter bar interactive,
+ * so the operator can narrow the filter and retry — a page that keeps
+ * working is worth more than a spinner that never resolves.
+ */
+declare class ConsoleQueryTimeoutError extends Error {
+    readonly query: string;
+    readonly timeoutMs: number;
+    readonly code: "query_timeout";
+    constructor(query: string, timeoutMs: number, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Recognise a cancelled statement through whatever wrapper the driver put
+ * around it. Prisma surfaces the SQLSTATE on `meta.code` for
+ * `PrismaClientKnownRequestError` P2010, node-postgres puts it on `code`,
+ * and a raw error may only carry the message.
+ */
+declare function isStatementTimeout(error: unknown): boolean;
+/** The request asked for something the console cannot serve. */
+declare class ConsoleBadRequestError extends Error {
+    readonly code: "bad_request";
+    constructor(message: string);
+}
+
+/**
+ * Minimal structural client contract.
+ *
+ * This avoids a hard dependency on `@prisma/client` or the engine's internals,
+ * letting callers pass either their root PrismaClient or an existing interactive
+ * transaction client.
+ */
+interface ConsolePrismaClient {
+    $queryRawUnsafe<T = unknown>(query: string, ...values: unknown[]): Promise<T>;
+    $executeRawUnsafe?(query: string, ...values: unknown[]): Promise<number>;
+    $transaction?<T>(fn: (tx: ConsolePrismaClient) => Promise<T>): Promise<T>;
+}
+interface PrismaConsoleReadPortOptions {
+    statusEnumName?: string;
+    statementTimeoutMs?: number;
+    now?: () => Date;
+}
+declare class PrismaConsoleReadPort implements ConsoleReadPort {
+    readonly capabilities: ConsoleCapabilities;
+    private readonly prisma;
+    private readonly statusEnumName;
+    private readonly statementTimeoutMs;
+    private readonly now;
+    constructor(prisma: ConsolePrismaClient, options?: PrismaConsoleReadPortOptions);
+    /** One `SELECT` against whichever client the surrounding `read` gave us. */
+    private select;
+    /**
+     * Runs one console read, whatever number of statements it takes, and
+     * translates a cancelled statement into `ConsoleQueryTimeoutError`.
+     *
+     * The callback receives the client to issue statements on, and every read
+     * that needs more than one statement issues all of them here, inside a
+     * single transaction — a run-detail page is six queries, and giving each
+     * its own interactive transaction would take six connections out of the
+     * consumer's pool to render one page. One transaction also means the six
+     * results are a coherent snapshot rather than six moments.
+     *
+     * The transaction is opened only when we were handed a root client. When
+     * `$transaction` is absent we are already inside the caller's transaction
+     * — the row-level-security case this package exists for — and we neither
+     * open another nor touch `statement_timeout`: `SET LOCAL` there would
+     * silently re-time the remainder of a transaction the console did not
+     * open and does not get to reconfigure. Timeouts in that case are the
+     * caller's to set, and a cancellation is still reported honestly because
+     * the catch below does not care who set the limit.
+     */
+    private read;
+    /** Convenience for the reads that are a single statement. */
+    private query;
+    listRuns(query: RunListQuery): Promise<RunListPage>;
+    getRunDetail(runId: string, options?: RunDetailOptions): Promise<RunDetail | null>;
+    listRunEvents(runId: string, afterSequence: number, limit?: number): Promise<RunEvent[]>;
+    getQueueHealth(): Promise<QueueHealth>;
+    listSuspendedStages(limit?: number): Promise<SuspendedStage[]>;
+    listDeadLetters(limit?: number): Promise<DeadLetter[]>;
+    listWorkers(): Promise<WorkerInstance[]>;
+    getCosts(query: CostQuery): Promise<CostBucket[]>;
+}
+declare function createPrismaConsoleReadPort(prisma: ConsolePrismaClient, options?: PrismaConsoleReadPortOptions): ConsoleReadPort;
+
+export { ConsoleBadRequestError, ConsoleCapabilities, type ConsolePrismaClient, ConsoleQueryTimeoutError, ConsoleReadPort, CostBucket, CostQuery, DeadLetter, PrismaConsoleReadPort, type PrismaConsoleReadPortOptions, QueueHealth, RunDetail, RunDetailOptions, RunEvent, RunListPage, RunListQuery, SuspendedStage, WorkerInstance, createPrismaConsoleReadPort, isStatementTimeout };