@multiplier-labs/stepflow 0.3.1 → 0.3.3

package/.codekin/reports/security/2026-04-03_security-audit.md

@@ -0,0 +1,208 @@
+# Security Audit: stepflow
+
+**Date**: 2026-04-03T20:03:06.542Z
+**Repository**: /srv/repos/stepflow
+**Branch**: main
+**Workflow Run**: 54523493-771d-44b8-b39f-03f2d6caa49e
+**Session**: 53e402d9-8d47-49b4-9a27-03f2ae5ec912
+
+---
+
+I now have all the information needed to produce the report. Here is the security audit:
+
+---
+
+## Summary
+
+**Overall Risk Rating: Low**
+
+The Stepflow project is a TypeScript workflow orchestration library with a mature security posture. No critical or high vulnerabilities were identified. The codebase demonstrates intentional, defence-in-depth practices: parameterized queries, SSRF protection with DNS-rebinding prevention, HMAC-SHA256 webhook signing, and delegated authorization. Recent commits (`48e5f0a`, `d61858c`) show that prior SSRF and SQL-injection issues were already discovered and remediated.
+
+| Severity | Count |
+|----------|-------|
+| Critical | 0 |
+| High | 0 |
+| Medium | 2 |
+| Low | 3 |
+| Informational | 4 |
+
+---
+
+## Critical Findings
+
+None.
+
+---
+
+## High Findings
+
+None.
+
+---
+
+## Medium Findings
+
+### M1 — Missing Input Validation on `tableName` in `PostgresSchedulePersistence`
+
+**File:** `src/scheduler/postgres-persistence.ts:153`
+
+**Description:**  
+`PostgresSchedulePersistence` validates `schema` with a strict regex (`^[a-zA-Z_][a-zA-Z0-9_]{0,62}$`) but applies **no equivalent validation to `tableName`**. The raw `tableName` string is concatenated into `fullTableName` (`${this.schema}.${this.tableName}`) at line 235 and then passed to Kysely's `sql.table()` and `sql.ref()` at lines 257–296. While Kysely correctly double-quotes identifiers — preventing SQL injection — there is no upfront guard to reject nonsensical or adversarially crafted values.
+
+Contrast: `SQLiteSchedulePersistence` (`src/scheduler/sqlite-persistence.ts:61`) validates its `tableName` with `^[a-zA-Z_][a-zA-Z0-9_]*$` and the Postgres *storage* adapter (`src/storage/postgres.ts:228`) validates its schema similarly. The omission in `postgres-persistence.ts` is an inconsistency in the defensive pattern.
+
+**Impact:**  
+In the current implementation, `sql.table()` quoting prevents SQL injection. However, a consumer passing a malformed `tableName` (e.g. `"foo\x00bar"`, very long strings, or strings containing periods) will receive a confusing runtime database error rather than a clear upfront `Error`. If the Kysely dependency ever changes its quoting behaviour, this becomes a direct injection point.
+
+**Remediation:**  
+Add the same regex guard used for `schema` immediately after line 153:
+```typescript
+if (!/^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/.test(this.tableName)) {
+  throw new Error(`Invalid table name "${this.tableName}".`);
+}
+```
+
+---
+
+### M2 — Non-Cryptographic ID Generation Used for Workflow Run Identifiers
+
+**File:** `src/utils/id.ts:17`
+
+**Description:**  
+`generateId()` constructs identifiers using `Date.now()` and `Math.random()`:
+
+```typescript
+const randomPart = Math.random().toString(36).substring(2, 10);
+```
+
+`Math.random()` is not a CSPRNG. V8's implementation is seeded with a 64-bit value derived from the system clock at startup; an attacker with knowledge of the process start time can reconstruct the PRNG state and predict future IDs. These IDs are used as primary keys for workflow runs and steps (`src/core/orchestrator.ts`).
+
+**Impact:**  
+If run IDs are used for access-control purposes by a consumer (e.g. "share a link containing the run ID" patterns), predictable IDs enable enumeration and unauthorized access. The library itself does not enforce any access control on run IDs, so impact depends entirely on the consuming application's threat model.
+
+**Remediation:**  
+Replace `Math.random()` with `crypto.randomBytes` (Node) or `crypto.getRandomValues` (Web Crypto), both available in Node.js 18+:
+```typescript
+import { randomBytes } from 'node:crypto';
+const randomPart = randomBytes(6).toString('base64url');
+```
+
+---
+
+## Low Findings
+
+### L1 — Blanket Block of All IPv6 Literals in SSRF Protection
+
+**File:** `src/events/webhook.ts:493–496`
+
+**Description:**  
+The `isBlockedHost` function blocks **all** IPv6 address literals, not just private/reserved ones:
+
+```typescript
+// Block all IPv6 address literals (wrapped in brackets by URL parser)
+if (hostname.startsWith('[')) {
+  return true;
+}
+```
+
+This was added to prevent SSRF via `[::1]` and similar loopback bypasses (commit `48e5f0a`). While the intent is correct, the implementation also blocks legitimate public IPv6 targets such as `[2001:db8::1]`.
+
+**Impact:**  
+Consumers cannot register webhook endpoints using public IPv6 addresses. This is a functional limitation, not a security vulnerability. As global IPv6 adoption grows, this will become increasingly restrictive.
+
+**Remediation:**  
+Instead of blocking all bracket-wrapped addresses, parse the IPv6 address, expand it to full form, and check only against reserved ranges (loopback `::1`, ULA `fc00::/7`, link-local `fe80::/10`, documentation prefixes, etc.) using a library or the same range-check logic applied to IPv4.
+
+---
+
+### L2 — `allowInsecureUrls` Flag Lacks Production-Safety Warning
+
+**File:** `src/events/webhook.ts:64–67`
+
+**Description:**  
+The `allowInsecureUrls` option on `WebhookEventTransportConfig` relaxes the HTTPS requirement and bypasses URL scheme validation:
+
+```typescript
+/**
+ * Whether to allow non-HTTPS URLs (default: false).
+ * Set to true only in development environments.
+ */
+allowInsecureUrls?: boolean;
+```
+
+The comment mentions development use, but there is no runtime enforcement or warning when this flag is enabled in a context that looks like production (e.g. `NODE_ENV=production`).
+
+**Impact:**  
+A consumer who copies a development configuration to production silently downgrades all webhooks to plain HTTP, exposing payloads (which may contain workflow results and metadata) to network interception, and disabling part of the SSRF protection.
+
+**Remediation:**  
+Emit a logger warning at construction time when `allowInsecureUrls: true` is set, e.g.:
+```typescript
+if (this.allowInsecureUrls) {
+  this.logger.warn('allowInsecureUrls is enabled. Do not use this in production.');
+}
+```
+
+---
+
+### L3 — No Rate Limiting on Outbound Webhook Dispatch
+
+**File:** `src/events/webhook.ts:465–480`
+
+**Description:**  
+The webhook transport implements concurrency limiting (default 50 concurrent requests) and a queue, but no per-endpoint rate limiting or per-second emission cap. A burst of workflow events can cause hundreds of webhook deliveries in a short window.
+
+**Impact:**  
+Could trigger rate limiting or bans from external webhook receivers. Does not directly introduce an inbound attack surface (the library sends, not receives), but could cause unintended denial-of-service toward third-party services.
+
+**Remediation:**  
+Add an optional `rateLimit` configuration (e.g. `maxRequestsPerSecond`) per endpoint or globally, with token-bucket or leaky-bucket logic.
+
+---
+
+## Secrets & Credentials Exposure
+
+**Result: None found.**
+
+- `git grep` across all `*.ts`, `*.js`, `*.json`, `*.yaml`, `*.yml` files for `password`, `secret`, `api_key`, `token`, and `private_key` returned only:
+  - **`src/events/webhook.ts:22–23`** — `secret?: string` type definition for HMAC signing (no value)
+  - **`src/events/webhook.ts:116`** — JSDoc comment example: `secret: process.env.WEBHOOK_SECRET` (correctly references an environment variable, not a hardcoded value)
+  - **`src/planning/planner.ts`, `src/planning/types.ts`** — `tokensPerStep`, `tokens` — LLM token budget fields, not credentials
+  - **`dist/` build artefacts** — mirror of source, no embedded values
+
+- No `.env` files exist in the repository at any path.
+- `git log --all -p -- "*.env" "*.pem" "*.key"` returned no output — no credential files were ever committed to git history.
+
+---
+
+## Recommendations
+
+The following are ordered by risk impact:
+
+1. **[Medium — M1] Validate `tableName` in `PostgresSchedulePersistence`.**  
+   Add a regex guard (`^[a-zA-Z_][a-zA-Z0-9_]{0,62}$`) for `tableName` at `src/scheduler/postgres-persistence.ts:153`, matching the existing pattern in `sqlite-persistence.ts:61` and `storage/postgres.ts:228`. This closes the inconsistency and provides a clean failure mode.
+
+2. **[Medium — M2] Replace `Math.random()` with a CSPRNG in ID generation.**  
+   Replace `Math.random()` at `src/utils/id.ts:17` with `crypto.getRandomValues` or Node's `crypto.randomBytes`. The timestamp prefix can remain. This is low-effort and eliminates predictability of workflow run IDs if consumers use them for access decisions.
+
+3. **[Low — L2] Add a runtime warning for `allowInsecureUrls: true`.**  
+   Log a warning through the configured logger in `WebhookEventTransport`'s constructor when `allowInsecureUrls` is set. This is a single-line addition that prevents silent production misconfiguration.
+
+4. **[Low — L1] Narrow IPv6 blocking to reserved ranges only.**  
+   Replace the blanket `hostname.startsWith('[')` block in `isBlockedHost` (`webhook.ts:493`) with targeted checks for `[::1]`, `[fc00:...]`, `[fe80:...]`, and other RFC-reserved IPv6 prefixes, allowing legitimate public IPv6 webhook endpoints.
+
+5. **[Low — L3] Document or implement outbound webhook rate limiting.**  
+   Either add an optional `rateLimit` configuration to `WebhookEventTransport`, or explicitly document in JSDoc that consumers are responsible for choosing receivers that can handle burst traffic.
+
+6. **[Informational] Add explicit authorization enforcement documentation.**  
+   The Socket.IO transport (`src/events/socketio.ts`) requires consumers to provide an `authorize` callback. Add JSDoc `@throws` documentation and an example showing what happens when no `authorize` callback is supplied, to prevent consumers from accidentally running with open subscriptions.
+
+7. **[Informational] Consider documenting CORS requirements for Socket.IO consumers.**  
+   The library accepts an already-constructed `SocketIOServer` (`src/events/socketio.ts:45`) and does not configure CORS. Add a README section or JSDoc example showing the minimum recommended CORS configuration to avoid consumers defaulting to wildcard origins.
+
+8. **[Informational] Run `npm audit` in CI.**  
+   The production dependency surface is minimal (only `cron-parser` and `re2`), but automated vulnerability scanning should be enforced in the CI pipeline to catch transitive dependency CVEs early.
+
+---
+
+*Audit performed: 2026-04-03. Branch: `main` (HEAD `4d9838a`). No source files were modified during this audit.*

package/.github/CODEOWNERS

@@ -0,0 +1,15 @@
+# Default owners for all files
+* @Multiplier-Labs/engineering
+
+# CI/CD and GitHub configuration — require admin review
+.github/ @Multiplier-Labs/admin
+package.json @Multiplier-Labs/admin
+package-lock.json @Multiplier-Labs/admin
+
+# Security-sensitive code
+src/events/webhook.ts @Multiplier-Labs/admin
+src/utils/id.ts @Multiplier-Labs/admin
+
+# Persistence layer
+src/storage/ @Multiplier-Labs/engineering
+src/scheduler/ @Multiplier-Labs/engineering

package/.github/dependabot.yml

@@ -0,0 +1,23 @@
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 10
+    reviewers:
+      - Multiplier-Labs/engineering
+    labels:
+      - dependencies
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    reviewers:
+      - Multiplier-Labs/admin
+    labels:
+      - ci

package/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20, 22]
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Audit dependencies
+        run: npm audit --audit-level=high
+
+      - name: Typecheck
+        run: npm run typecheck
+
+      - name: Build
+        run: npm run build
+
+      - name: Test
+        run: npm test

package/.github/workflows/publish.yml

@@ -1,4 +1,4 @@
-name: Publish to npm
+name: Publish to GitHub Packages
 
 on:
   release:
@@ -9,14 +9,14 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: read
+      packages: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
 
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
           node-version: '20'
           registry-url: 'https://registry.npmjs.org'
-          scope: '@multiplier-labs'
 
       - name: Install dependencies
         run: npm ci
@@ -24,7 +24,13 @@ jobs:
       - name: Build
         run: npm run build
 
+      - name: Typecheck
+        run: npm run typecheck
+
+      - name: Test
+        run: npm test
+
       - name: Publish
-        run: npm publish --access public
+        run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/security.yml

@@ -0,0 +1,29 @@
+name: Security
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '0 8 * * 1' # Weekly on Monday at 08:00 UTC
+
+permissions:
+  contents: read
+
+jobs:
+  audit:
+    name: Dependency Audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: '20'
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run npm audit
+        run: npm audit --audit-level=moderate

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- CI workflow for automated build, typecheck, and test on pull requests
+- Security scanning workflow with weekly `npm audit` checks
+- Dependabot configuration for automated dependency and GitHub Actions updates
+- `CODEOWNERS` file requiring designated reviewers for security-sensitive paths
+- `SECURITY.md` with vulnerability reporting instructions and disclosure policy
+- Branch protection documentation in README
+
+### Changed
+- Pinned GitHub Actions in `publish.yml` to full commit SHAs to prevent supply-chain attacks via tag hijacking
+
+## [0.2.6] - 2026-04-03
+
+### Added
+- Initial public release
+- Durable workflow execution engine with step orchestration
+- SQLite and PostgreSQL storage backends
+- In-memory storage for testing
+- Cron-based scheduling with SQLite and PostgreSQL persistence
+- Workflow completion triggers
+- Socket.IO and webhook event transports with HMAC-SHA256 signing
+- SSRF protection for webhook URLs with DNS-rebinding prevention
+- Concurrency control with priority queues
+- Rule-based planning system for dynamic workflow generation
+- Full TypeScript support with type inference

package/README.md

@@ -403,6 +403,30 @@ See the [API Reference](docs/stepflow-api-reference.md#planning-system) for full
 
 For the complete API reference including all classes, interfaces, and configuration options, see [docs/stepflow-api-reference.md](docs/stepflow-api-reference.md).
 
+## Security
+
+This project takes security seriously. The repository enforces:
+
+- **Branch protection** on `main` with required PR reviews and status checks
+- **CODEOWNERS** requiring designated reviewer approval for security-sensitive paths
+- **Pinned GitHub Actions** to full commit SHAs to prevent supply-chain attacks
+- **Automated dependency scanning** via Dependabot with weekly update PRs
+- **npm audit** in CI on every pull request and weekly scheduled runs
+- **Secret scanning** and **push protection** to prevent credential leaks
+
+For vulnerability reporting, see [SECURITY.md](SECURITY.md).
+
+## Contributing
+
+1. Fork the repository and create a feature branch from `main`
+2. Ensure your changes pass all checks: `npm run typecheck && npm run build && npm test`
+3. Open a pull request — CI will run automatically
+4. A CODEOWNERS reviewer will be assigned based on the files changed
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a history of notable changes.
+
 ## License
 
 MIT

package/SECURITY.md

@@ -0,0 +1,40 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 0.2.x   | Yes                |
+| < 0.2   | No                 |
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability in Stepflow, please report it responsibly.
+
+**Do not open a public GitHub issue for security vulnerabilities.**
+
+Instead, please email **security@multiplier-labs.com** with:
+
+- A description of the vulnerability
+- Steps to reproduce the issue
+- The potential impact
+- Any suggested remediation (optional)
+
+We will acknowledge receipt within **48 hours** and aim to provide an initial assessment within **5 business days**.
+
+## Disclosure Policy
+
+- We follow coordinated disclosure. Please allow us reasonable time to address the issue before public disclosure.
+- Once a fix is released, we will publish a security advisory via GitHub Security Advisories.
+- Contributors who report valid vulnerabilities will be credited in the advisory (unless they prefer anonymity).
+
+## Security Practices
+
+This project follows these security practices:
+
+- **Signed commits** are encouraged for all contributors
+- **Branch protection** is enforced on `main` with required reviews and status checks
+- **Dependency scanning** via Dependabot with automated PRs for security updates
+- **npm audit** runs in CI on every pull request
+- **Secret scanning** and **push protection** are enabled on the repository
+- **CODEOWNERS** requires review from designated maintainers for security-sensitive code paths

package/dist/{chunk-FQCT3I2A.js → chunk-4VOKMGP6.js}

@@ -2,7 +2,7 @@ import {
   generateId,
   loadPostgresDeps,
   sanitizeErrorForStorage
-} from "./chunk-GXY66V7Q.js";
+} from "./chunk-ML35PIHX.js";
 
 // src/storage/memory.ts
 var MemoryStorageAdapter = class {
@@ -84,9 +84,7 @@ var MemoryStorageAdapter = class {
   }
   /** Retrieve all step records for a workflow run, ordered by start time ascending. */
   async getStepsForRun(runId) {
-    return Array.from(this.steps.values()).filter((s) => s.runId === runId).sort(
-      (a, b) => (a.startedAt?.getTime() ?? 0) - (b.startedAt?.getTime() ?? 0)
-    );
+    return Array.from(this.steps.values()).filter((s) => s.runId === runId).sort((a, b) => (a.startedAt?.getTime() ?? 0) - (b.startedAt?.getTime() ?? 0));
   }
   // ============================================================================
   // Event Operations
@@ -101,9 +99,7 @@ var MemoryStorageAdapter = class {
   }
   /** Retrieve events for a workflow run with optional filtering and pagination. */
   async getEventsForRun(runId, options = {}) {
-    let items = Array.from(this.events.values()).filter(
-      (e) => e.runId === runId
-    );
+    let items = Array.from(this.events.values()).filter((e) => e.runId === runId);
     if (options.stepKey) {
       items = items.filter((e) => e.stepKey === options.stepKey);
     }
@@ -173,6 +169,7 @@ CREATE TABLE IF NOT EXISTS workflow_runs (
   input_json TEXT NOT NULL,
   metadata_json TEXT NOT NULL,
   context_json TEXT NOT NULL,
+  completed_steps_json TEXT,
   error_json TEXT,
   created_at TEXT NOT NULL,
   started_at TEXT,
@@ -243,8 +240,8 @@ var SQLiteStorageAdapter = class {
   prepareStatements() {
     this.stmts = {
       insertRun: this.db.prepare(`
-        INSERT INTO workflow_runs (id, kind, status, parent_run_id, input_json, metadata_json, context_json, error_json, created_at, started_at, finished_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO workflow_runs (id, kind, status, parent_run_id, input_json, metadata_json, context_json, completed_steps_json, error_json, created_at, started_at, finished_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `),
       getRun: this.db.prepare(`
         SELECT * FROM workflow_runs WHERE id = ?
@@ -253,6 +250,7 @@ var SQLiteStorageAdapter = class {
         UPDATE workflow_runs
         SET status = COALESCE(?, status),
             context_json = COALESCE(?, context_json),
+            completed_steps_json = COALESCE(?, completed_steps_json),
             error_json = COALESCE(?, error_json),
             started_at = COALESCE(?, started_at),
             finished_at = COALESCE(?, finished_at)
@@ -344,6 +342,7 @@ var SQLiteStorageAdapter = class {
       JSON.stringify(run.input),
       JSON.stringify(run.metadata),
       JSON.stringify(run.context),
+      run.completedSteps ? JSON.stringify(run.completedSteps) : null,
       run.error ? JSON.stringify(sanitizeErrorForStorage(run.error)) : null,
       createdAt.toISOString(),
       run.startedAt?.toISOString() ?? null,
@@ -363,6 +362,7 @@ var SQLiteStorageAdapter = class {
     this.stmts.updateRun.run(
       updates.status ?? null,
       updates.context ? JSON.stringify(updates.context) : null,
+      updates.completedSteps ? JSON.stringify(updates.completedSteps) : null,
       updates.error ? JSON.stringify(sanitizeErrorForStorage(updates.error)) : null,
       updates.startedAt?.toISOString() ?? null,
       updates.finishedAt?.toISOString() ?? null,
@@ -550,6 +550,7 @@ var SQLiteStorageAdapter = class {
       input: JSON.parse(row.input_json),
       metadata: JSON.parse(row.metadata_json),
       context: JSON.parse(row.context_json),
+      completedSteps: row.completed_steps_json ? JSON.parse(row.completed_steps_json) : void 0,
       error: row.error_json ? JSON.parse(row.error_json) : void 0,
       createdAt: new Date(row.created_at),
       startedAt: row.started_at ? new Date(row.started_at) : void 0,
@@ -663,9 +664,7 @@ var PostgresStorageAdapter = class {
       this.pool = this.config.pool;
       this.ownsPool = false;
     } else if (this.config.connectionString) {
-      this.pool = new pgModule.Pool({
-        connectionString: this.config.connectionString
-      });
+      this.pool = new pgModule.Pool({ connectionString: this.config.connectionString });
       this.ownsPool = true;
     } else if (this.config.poolConfig) {
       this.pool = new pgModule.Pool(this.config.poolConfig);
@@ -700,9 +699,7 @@ var PostgresStorageAdapter = class {
    */
   async createTables() {
     if (this.schema !== "public") {
-      await sql`CREATE SCHEMA IF NOT EXISTS ${sql.ref(this.schema)}`.execute(
-        this.db
-      );
+      await sql`CREATE SCHEMA IF NOT EXISTS ${sql.ref(this.schema)}`.execute(this.db);
     }
     await sql`
       CREATE TABLE IF NOT EXISTS ${sql.table(`${this.schema}.runs`)} (
@@ -890,9 +887,7 @@ var PostgresStorageAdapter = class {
       updateData.output_json = JSON.stringify(updates.output);
     }
     if (updates.error !== void 0) {
-      updateData.error_json = JSON.stringify(
-        sanitizeErrorForStorage(updates.error)
-      );
+      updateData.error_json = JSON.stringify(sanitizeErrorForStorage(updates.error));
     }
     if (updates.startedAt !== void 0) {
       updateData.started_at = updates.startedAt;
@@ -987,9 +982,7 @@ var PostgresStorageAdapter = class {
       updateData.result_json = JSON.stringify(updates.result);
     }
     if (updates.error !== void 0) {
-      updateData.error_json = JSON.stringify(
-        sanitizeErrorForStorage(updates.error)
-      );
+      updateData.error_json = JSON.stringify(sanitizeErrorForStorage(updates.error));
     }
     if (updates.finishedAt !== void 0) {
       updateData.finished_at = updates.finishedAt;
@@ -1362,18 +1355,11 @@ var PostgresTransactionAdapter = class {
   async updateRun(runId, updates) {
     const updateData = {};
     if (updates.status !== void 0) updateData.status = updates.status;
-    if (updates.context !== void 0)
-      updateData.context_json = JSON.stringify(updates.context);
-    if ("output" in updates && updates.output !== void 0)
-      updateData.output_json = JSON.stringify(updates.output);
-    if (updates.error !== void 0)
-      updateData.error_json = JSON.stringify(
-        sanitizeErrorForStorage(updates.error)
-      );
-    if (updates.startedAt !== void 0)
-      updateData.started_at = updates.startedAt;
-    if (updates.finishedAt !== void 0)
-      updateData.finished_at = updates.finishedAt;
+    if (updates.context !== void 0) updateData.context_json = JSON.stringify(updates.context);
+    if ("output" in updates && updates.output !== void 0) updateData.output_json = JSON.stringify(updates.output);
+    if (updates.error !== void 0) updateData.error_json = JSON.stringify(sanitizeErrorForStorage(updates.error));
+    if (updates.startedAt !== void 0) updateData.started_at = updates.startedAt;
+    if (updates.finishedAt !== void 0) updateData.finished_at = updates.finishedAt;
     if (Object.keys(updateData).length > 0) {
       await this.qb.updateTable("runs").set(updateData).where("id", "=", runId).execute();
     }
@@ -1424,14 +1410,9 @@ var PostgresTransactionAdapter = class {
     const updateData = {};
     if (updates.status !== void 0) updateData.status = updates.status;
     if (updates.attempt !== void 0) updateData.attempt = updates.attempt;
-    if (updates.result !== void 0)
-      updateData.result_json = JSON.stringify(updates.result);
-    if (updates.error !== void 0)
-      updateData.error_json = JSON.stringify(
-        sanitizeErrorForStorage(updates.error)
-      );
-    if (updates.finishedAt !== void 0)
-      updateData.finished_at = updates.finishedAt;
+    if (updates.result !== void 0) updateData.result_json = JSON.stringify(updates.result);
+    if (updates.error !== void 0) updateData.error_json = JSON.stringify(sanitizeErrorForStorage(updates.error));
+    if (updates.finishedAt !== void 0) updateData.finished_at = updates.finishedAt;
     if (Object.keys(updateData).length > 0) {
       await this.qb.updateTable("workflow_run_steps").set(updateData).where("id", "=", stepId).execute();
     }
@@ -1509,4 +1490,4 @@ export {
   SQLiteStorageAdapter,
   PostgresStorageAdapter
 };
-//# sourceMappingURL=chunk-FQCT3I2A.js.map
+//# sourceMappingURL=chunk-4VOKMGP6.js.map