@multiplier-labs/stepflow 0.3.1 → 0.3.3

package/src/utils/errors.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from 'vitest';
 import {
   WorkflowEngineError,
   WorkflowNotFoundError,
@@ -8,145 +8,143 @@ import {
   StepTimeoutError,
   WorkflowCanceledError,
   WorkflowTimeoutError,
-} from "./errors";
+} from './errors';
 
-describe("WorkflowEngineError", () => {
-  it("should store code, message, and details", () => {
-    const err = new WorkflowEngineError("TEST_CODE", "test message", {
-      key: "val",
-    });
+describe('WorkflowEngineError', () => {
+  it('should store code, message, and details', () => {
+    const err = new WorkflowEngineError('TEST_CODE', 'test message', { key: 'val' });
 
-    expect(err.code).toBe("TEST_CODE");
-    expect(err.message).toBe("test message");
-    expect(err.details).toEqual({ key: "val" });
-    expect(err.name).toBe("WorkflowEngineError");
+    expect(err.code).toBe('TEST_CODE');
+    expect(err.message).toBe('test message');
+    expect(err.details).toEqual({ key: 'val' });
+    expect(err.name).toBe('WorkflowEngineError');
     expect(err).toBeInstanceOf(Error);
   });
 
-  it("should convert to record", () => {
-    const err = new WorkflowEngineError("CODE", "msg", { x: 1 });
+  it('should convert to record', () => {
+    const err = new WorkflowEngineError('CODE', 'msg', { x: 1 });
     const record = err.toRecord();
 
-    expect(record.code).toBe("CODE");
-    expect(record.message).toBe("msg");
+    expect(record.code).toBe('CODE');
+    expect(record.message).toBe('msg');
     expect(record.details).toEqual({ x: 1 });
-    expect(record.stack).toBeDefined();
+    expect(record.stack).toBeUndefined();
   });
 
-  describe("fromError", () => {
-    it("should convert WorkflowEngineError to record", () => {
-      const err = new WorkflowEngineError("MY_CODE", "my msg");
+  describe('fromError', () => {
+    it('should convert WorkflowEngineError to record', () => {
+      const err = new WorkflowEngineError('MY_CODE', 'my msg');
       const record = WorkflowEngineError.fromError(err);
 
-      expect(record.code).toBe("MY_CODE");
-      expect(record.message).toBe("my msg");
+      expect(record.code).toBe('MY_CODE');
+      expect(record.message).toBe('my msg');
     });
 
-    it("should convert regular Error to record with default code", () => {
-      const err = new Error("regular error");
+    it('should convert regular Error to record with default code', () => {
+      const err = new Error('regular error');
       const record = WorkflowEngineError.fromError(err);
 
-      expect(record.code).toBe("UNKNOWN_ERROR");
-      expect(record.message).toBe("regular error");
-      expect(record.stack).toBeDefined();
+      expect(record.code).toBe('UNKNOWN_ERROR');
+      expect(record.message).toBe('regular error');
+      expect(record.stack).toBeUndefined();
     });
 
-    it("should convert regular Error with custom code", () => {
-      const err = new Error("oops");
-      const record = WorkflowEngineError.fromError(err, "CUSTOM_CODE");
+    it('should convert regular Error with custom code', () => {
+      const err = new Error('oops');
+      const record = WorkflowEngineError.fromError(err, 'CUSTOM_CODE');
 
-      expect(record.code).toBe("CUSTOM_CODE");
+      expect(record.code).toBe('CUSTOM_CODE');
     });
 
-    it("should convert non-Error value to record", () => {
-      const record = WorkflowEngineError.fromError("string error");
+    it('should convert non-Error value to record', () => {
+      const record = WorkflowEngineError.fromError('string error');
 
-      expect(record.code).toBe("UNKNOWN_ERROR");
-      expect(record.message).toBe("string error");
+      expect(record.code).toBe('UNKNOWN_ERROR');
+      expect(record.message).toBe('string error');
       expect(record.stack).toBeUndefined();
     });
 
-    it("should convert number to record", () => {
+    it('should convert number to record', () => {
       const record = WorkflowEngineError.fromError(42);
 
-      expect(record.message).toBe("42");
+      expect(record.message).toBe('42');
     });
   });
 });
 
-describe("WorkflowNotFoundError", () => {
-  it("should have correct code and message", () => {
-    const err = new WorkflowNotFoundError("my.workflow");
+describe('WorkflowNotFoundError', () => {
+  it('should have correct code and message', () => {
+    const err = new WorkflowNotFoundError('my.workflow');
 
-    expect(err.code).toBe("WORKFLOW_NOT_FOUND");
+    expect(err.code).toBe('WORKFLOW_NOT_FOUND');
     expect(err.message).toBe('Workflow "my.workflow" is not registered');
-    expect(err.name).toBe("WorkflowNotFoundError");
-    expect(err.details).toEqual({ kind: "my.workflow" });
+    expect(err.name).toBe('WorkflowNotFoundError');
+    expect(err.details).toEqual({ kind: 'my.workflow' });
   });
 });
 
-describe("WorkflowAlreadyRegisteredError", () => {
-  it("should have correct code and message", () => {
-    const err = new WorkflowAlreadyRegisteredError("dup.workflow");
+describe('WorkflowAlreadyRegisteredError', () => {
+  it('should have correct code and message', () => {
+    const err = new WorkflowAlreadyRegisteredError('dup.workflow');
 
-    expect(err.code).toBe("WORKFLOW_ALREADY_REGISTERED");
-    expect(err.message).toContain("dup.workflow");
-    expect(err.name).toBe("WorkflowAlreadyRegisteredError");
+    expect(err.code).toBe('WORKFLOW_ALREADY_REGISTERED');
+    expect(err.message).toContain('dup.workflow');
+    expect(err.name).toBe('WorkflowAlreadyRegisteredError');
   });
 });
 
-describe("RunNotFoundError", () => {
-  it("should have correct code and message", () => {
-    const err = new RunNotFoundError("run-123");
+describe('RunNotFoundError', () => {
+  it('should have correct code and message', () => {
+    const err = new RunNotFoundError('run-123');
 
-    expect(err.code).toBe("RUN_NOT_FOUND");
-    expect(err.message).toContain("run-123");
-    expect(err.name).toBe("RunNotFoundError");
+    expect(err.code).toBe('RUN_NOT_FOUND');
+    expect(err.message).toContain('run-123');
+    expect(err.name).toBe('RunNotFoundError');
   });
 });
 
-describe("StepError", () => {
-  it("should store step key, attempt, and cause", () => {
-    const cause = new Error("root cause");
-    const err = new StepError("step1", "step failed", 3, cause);
+describe('StepError', () => {
+  it('should store step key, attempt, and cause', () => {
+    const cause = new Error('root cause');
+    const err = new StepError('step1', 'step failed', 3, cause);
 
-    expect(err.code).toBe("STEP_ERROR");
-    expect(err.stepKey).toBe("step1");
+    expect(err.code).toBe('STEP_ERROR');
+    expect(err.stepKey).toBe('step1');
     expect(err.attempt).toBe(3);
     expect(err.cause).toBe(cause);
-    expect(err.name).toBe("StepError");
+    expect(err.name).toBe('StepError');
   });
 });
 
-describe("StepTimeoutError", () => {
-  it("should store step key and timeout", () => {
-    const err = new StepTimeoutError("slow_step", 5000);
+describe('StepTimeoutError', () => {
+  it('should store step key and timeout', () => {
+    const err = new StepTimeoutError('slow_step', 5000);
 
-    expect(err.code).toBe("STEP_TIMEOUT");
-    expect(err.stepKey).toBe("slow_step");
+    expect(err.code).toBe('STEP_TIMEOUT');
+    expect(err.stepKey).toBe('slow_step');
     expect(err.timeoutMs).toBe(5000);
-    expect(err.message).toContain("5000ms");
-    expect(err.name).toBe("StepTimeoutError");
+    expect(err.message).toContain('5000ms');
+    expect(err.name).toBe('StepTimeoutError');
   });
 });
 
-describe("WorkflowCanceledError", () => {
-  it("should have correct code and message", () => {
-    const err = new WorkflowCanceledError("run-456");
+describe('WorkflowCanceledError', () => {
+  it('should have correct code and message', () => {
+    const err = new WorkflowCanceledError('run-456');
 
-    expect(err.code).toBe("WORKFLOW_CANCELED");
-    expect(err.message).toContain("run-456");
-    expect(err.name).toBe("WorkflowCanceledError");
+    expect(err.code).toBe('WORKFLOW_CANCELED');
+    expect(err.message).toContain('run-456');
+    expect(err.name).toBe('WorkflowCanceledError');
   });
 });
 
-describe("WorkflowTimeoutError", () => {
-  it("should store timeout value", () => {
-    const err = new WorkflowTimeoutError("run-789", 30000);
+describe('WorkflowTimeoutError', () => {
+  it('should store timeout value', () => {
+    const err = new WorkflowTimeoutError('run-789', 30000);
 
-    expect(err.code).toBe("WORKFLOW_TIMEOUT");
+    expect(err.code).toBe('WORKFLOW_TIMEOUT');
     expect(err.timeoutMs).toBe(30000);
-    expect(err.message).toContain("30000ms");
-    expect(err.name).toBe("WorkflowTimeoutError");
+    expect(err.message).toContain('30000ms');
+    expect(err.name).toBe('WorkflowTimeoutError');
   });
 });

package/src/utils/errors.ts

@@ -2,7 +2,7 @@
  * Custom error classes for the workflow engine.
  */
 
-import type { WorkflowError } from "../core/types";
+import type { WorkflowError } from '../core/types';
 
 /**
  * Base error class for workflow-related errors.
@@ -11,13 +11,9 @@ export class WorkflowEngineError extends Error {
   readonly code: string;
   readonly details?: Record<string, unknown>;
 
-  constructor(
-    code: string,
-    message: string,
-    details?: Record<string, unknown>,
-  ) {
+  constructor(code: string, message: string, details?: Record<string, unknown>) {
     super(message);
-    this.name = "WorkflowEngineError";
+    this.name = 'WorkflowEngineError';
     this.code = code;
     this.details = details;
   }
@@ -29,7 +25,6 @@ export class WorkflowEngineError extends Error {
     return {
       code: this.code,
       message: this.message,
-      stack: this.stack,
       details: this.details,
     };
   }
@@ -37,10 +32,7 @@ export class WorkflowEngineError extends Error {
   /**
    * Create a WorkflowError record from any error.
    */
-  static fromError(
-    error: unknown,
-    defaultCode = "UNKNOWN_ERROR",
-  ): WorkflowError {
+  static fromError(error: unknown, defaultCode = 'UNKNOWN_ERROR'): WorkflowError {
     if (error instanceof WorkflowEngineError) {
       return error.toRecord();
     }
@@ -49,7 +41,6 @@ export class WorkflowEngineError extends Error {
       return {
         code: defaultCode,
         message: error.message,
-        stack: error.stack,
       };
     }
 
@@ -65,10 +56,8 @@ export class WorkflowEngineError extends Error {
  */
 export class WorkflowNotFoundError extends WorkflowEngineError {
   constructor(kind: string) {
-    super("WORKFLOW_NOT_FOUND", `Workflow "${kind}" is not registered`, {
-      kind,
-    });
-    this.name = "WorkflowNotFoundError";
+    super('WORKFLOW_NOT_FOUND', `Workflow "${kind}" is not registered`, { kind });
+    this.name = 'WorkflowNotFoundError';
   }
 }
 
@@ -77,12 +66,8 @@ export class WorkflowNotFoundError extends WorkflowEngineError {
  */
 export class WorkflowAlreadyRegisteredError extends WorkflowEngineError {
   constructor(kind: string) {
-    super(
-      "WORKFLOW_ALREADY_REGISTERED",
-      `Workflow "${kind}" is already registered`,
-      { kind },
-    );
-    this.name = "WorkflowAlreadyRegisteredError";
+    super('WORKFLOW_ALREADY_REGISTERED', `Workflow "${kind}" is already registered`, { kind });
+    this.name = 'WorkflowAlreadyRegisteredError';
   }
 }
 
@@ -91,8 +76,8 @@ export class WorkflowAlreadyRegisteredError extends WorkflowEngineError {
  */
 export class RunNotFoundError extends WorkflowEngineError {
   constructor(runId: string) {
-    super("RUN_NOT_FOUND", `Run "${runId}" not found`, { runId });
-    this.name = "RunNotFoundError";
+    super('RUN_NOT_FOUND', `Run "${runId}" not found`, { runId });
+    this.name = 'RunNotFoundError';
   }
 }
 
@@ -104,14 +89,9 @@ export class StepError extends WorkflowEngineError {
   readonly attempt: number;
   readonly cause?: Error;
 
-  constructor(
-    stepKey: string,
-    message: string,
-    attempt: number,
-    cause?: Error,
-  ) {
-    super("STEP_ERROR", message, { stepKey, attempt });
-    this.name = "StepError";
+  constructor(stepKey: string, message: string, attempt: number, cause?: Error) {
+    super('STEP_ERROR', message, { stepKey, attempt });
+    this.name = 'StepError';
     this.stepKey = stepKey;
     this.attempt = attempt;
     this.cause = cause;
@@ -126,11 +106,11 @@ export class StepTimeoutError extends WorkflowEngineError {
   readonly timeoutMs: number;
 
   constructor(stepKey: string, timeoutMs: number) {
-    super("STEP_TIMEOUT", `Step "${stepKey}" timed out after ${timeoutMs}ms`, {
+    super('STEP_TIMEOUT', `Step "${stepKey}" timed out after ${timeoutMs}ms`, {
       stepKey,
       timeoutMs,
     });
-    this.name = "StepTimeoutError";
+    this.name = 'StepTimeoutError';
     this.stepKey = stepKey;
     this.timeoutMs = timeoutMs;
   }
@@ -141,10 +121,8 @@ export class StepTimeoutError extends WorkflowEngineError {
  */
 export class WorkflowCanceledError extends WorkflowEngineError {
   constructor(runId: string) {
-    super("WORKFLOW_CANCELED", `Workflow run "${runId}" was canceled`, {
-      runId,
-    });
-    this.name = "WorkflowCanceledError";
+    super('WORKFLOW_CANCELED', `Workflow run "${runId}" was canceled`, { runId });
+    this.name = 'WorkflowCanceledError';
   }
 }
 
@@ -156,15 +134,11 @@ export class WaitForRunTimeoutError extends WorkflowEngineError {
   readonly timeoutMs: number;
 
   constructor(runId: string, timeoutMs: number) {
-    super(
-      "WAIT_FOR_RUN_TIMEOUT",
-      `Timeout waiting for run ${runId} after ${timeoutMs}ms`,
-      {
-        runId,
-        timeoutMs,
-      },
-    );
-    this.name = "WaitForRunTimeoutError";
+    super('WAIT_FOR_RUN_TIMEOUT', `Timeout waiting for run ${runId} after ${timeoutMs}ms`, {
+      runId,
+      timeoutMs,
+    });
+    this.name = 'WaitForRunTimeoutError';
     this.runId = runId;
     this.timeoutMs = timeoutMs;
   }
@@ -177,15 +151,11 @@ export class WorkflowTimeoutError extends WorkflowEngineError {
   readonly timeoutMs: number;
 
   constructor(runId: string, timeoutMs: number) {
-    super(
-      "WORKFLOW_TIMEOUT",
-      `Workflow run "${runId}" timed out after ${timeoutMs}ms`,
-      {
-        runId,
-        timeoutMs,
-      },
-    );
-    this.name = "WorkflowTimeoutError";
+    super('WORKFLOW_TIMEOUT', `Workflow run "${runId}" timed out after ${timeoutMs}ms`, {
+      runId,
+      timeoutMs,
+    });
+    this.name = 'WorkflowTimeoutError';
     this.timeoutMs = timeoutMs;
   }
 }

package/src/utils/id.ts

@@ -1,7 +1,8 @@
 /**
  * ID generation utilities for the workflow engine.
  */
-import { randomBytes } from "node:crypto";
+
+import { randomBytes } from 'node:crypto';
 
 /**
  * Generate a unique ID for database records.
@@ -10,12 +11,11 @@ import { randomBytes } from "node:crypto";
  * - Rough time-ordering (useful for debugging)
  * - High collision resistance
  * - URL-safe characters
- * - Cryptographically secure random component
  *
  * @returns A unique identifier string (approx 16 characters)
  */
 export function generateId(): string {
   const timestamp = Date.now().toString(36);
-  const randomPart = randomBytes(6).toString("base64url");
+  const randomPart = randomBytes(6).toString('base64url');
   return `${timestamp}${randomPart}`;
 }

package/src/utils/index.ts

@@ -2,7 +2,7 @@
  * Utilities module exports.
  */
 
-export * from "./id";
-export * from "./errors";
-export * from "./logger";
-export * from "./retry";
+export * from './id';
+export * from './errors';
+export * from './logger';
+export * from './retry';

package/src/utils/logger.test.ts

@@ -1,77 +1,71 @@
-import { describe, it, expect, vi } from "vitest";
-import { ConsoleLogger, SilentLogger, createScopedLogger } from "./logger";
+import { describe, it, expect, vi } from 'vitest';
+import { ConsoleLogger, SilentLogger, createScopedLogger } from './logger';
 
-describe("ConsoleLogger", () => {
-  it("should log debug messages with prefix", () => {
-    const spy = vi.spyOn(console, "debug").mockImplementation(() => {});
-    const logger = new ConsoleLogger("[test]", "debug");
+describe('ConsoleLogger', () => {
+  it('should log debug messages with prefix', () => {
+    const spy = vi.spyOn(console, 'debug').mockImplementation(() => {});
+    const logger = new ConsoleLogger('[test]', 'debug');
 
-    logger.debug("hello", { extra: true });
+    logger.debug('hello', { extra: true });
 
-    expect(spy).toHaveBeenCalledWith("[test] [DEBUG]", "hello", {
-      extra: true,
-    });
+    expect(spy).toHaveBeenCalledWith('[test] [DEBUG]', 'hello', { extra: true });
     spy.mockRestore();
   });
 
-  it("should log info messages with prefix", () => {
-    const spy = vi.spyOn(console, "info").mockImplementation(() => {});
-    const logger = new ConsoleLogger("[test]");
+  it('should log info messages with prefix', () => {
+    const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
+    const logger = new ConsoleLogger('[test]');
 
-    logger.info("info msg");
+    logger.info('info msg');
 
-    expect(spy).toHaveBeenCalledWith("[test] [INFO]", "info msg");
+    expect(spy).toHaveBeenCalledWith('[test] [INFO]', 'info msg');
     spy.mockRestore();
   });
 
-  it("should log warn messages with prefix", () => {
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const logger = new ConsoleLogger("[test]");
+  it('should log warn messages with prefix', () => {
+    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const logger = new ConsoleLogger('[test]');
 
-    logger.warn("warning");
+    logger.warn('warning');
 
-    expect(spy).toHaveBeenCalledWith("[test] [WARN]", "warning");
+    expect(spy).toHaveBeenCalledWith('[test] [WARN]', 'warning');
     spy.mockRestore();
   });
 
-  it("should log error messages with prefix", () => {
-    const spy = vi.spyOn(console, "error").mockImplementation(() => {});
-    const logger = new ConsoleLogger("[test]");
+  it('should log error messages with prefix', () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const logger = new ConsoleLogger('[test]');
 
-    logger.error("error msg", new Error("boom"));
+    logger.error('error msg', new Error('boom'));
 
-    expect(spy).toHaveBeenCalledWith(
-      "[test] [ERROR]",
-      "error msg",
-      expect.any(Error),
-    );
+    expect(spy).toHaveBeenCalledWith('[test] [ERROR]', 'error msg', expect.any(Error));
     spy.mockRestore();
   });
 
-  it("should use default prefix when none provided", () => {
-    const spy = vi.spyOn(console, "info").mockImplementation(() => {});
+  it('should use default prefix when none provided', () => {
+    const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
     const logger = new ConsoleLogger();
 
-    logger.info("test");
+    logger.info('test');
 
-    expect(spy).toHaveBeenCalledWith("[workflow] [INFO]", "test");
+    expect(spy).toHaveBeenCalledWith('[workflow] [INFO]', 'test');
     spy.mockRestore();
   });
 });
 
-describe("SilentLogger", () => {
-  it("should not throw on any log level", () => {
+describe('SilentLogger', () => {
+  it('should not throw on any log level', () => {
     const logger = new SilentLogger();
 
-    expect(() => logger.debug("test")).not.toThrow();
-    expect(() => logger.info("test")).not.toThrow();
-    expect(() => logger.warn("test")).not.toThrow();
-    expect(() => logger.error("test")).not.toThrow();
+    expect(() => logger.debug('test')).not.toThrow();
+    expect(() => logger.info('test')).not.toThrow();
+    expect(() => logger.warn('test')).not.toThrow();
+    expect(() => logger.error('test')).not.toThrow();
   });
 });
 
-describe("createScopedLogger", () => {
-  it("should prefix messages with run ID", () => {
+describe('createScopedLogger', () => {
+  it('should prefix messages with run ID', () => {
     const calls: string[] = [];
     const baseLogger = {
       debug: (msg: string) => calls.push(`debug:${msg}`),
@@ -80,22 +74,22 @@ describe("createScopedLogger", () => {
       error: (msg: string) => calls.push(`error:${msg}`),
     };
 
-    const scoped = createScopedLogger(baseLogger, "run-123");
+    const scoped = createScopedLogger(baseLogger, 'run-123');
 
-    scoped.debug("d");
-    scoped.info("i");
-    scoped.warn("w");
-    scoped.error("e");
+    scoped.debug('d');
+    scoped.info('i');
+    scoped.warn('w');
+    scoped.error('e');
 
     expect(calls).toEqual([
-      "debug:[run:run-123] d",
-      "info:[run:run-123] i",
-      "warn:[run:run-123] w",
-      "error:[run:run-123] e",
+      'debug:[run:run-123] d',
+      'info:[run:run-123] i',
+      'warn:[run:run-123] w',
+      'error:[run:run-123] e',
     ]);
   });
 
-  it("should include step key when provided", () => {
+  it('should include step key when provided', () => {
     const calls: string[] = [];
     const baseLogger = {
       debug: (msg: string) => calls.push(msg),
@@ -104,13 +98,13 @@ describe("createScopedLogger", () => {
       error: (msg: string) => calls.push(msg),
     };
 
-    const scoped = createScopedLogger(baseLogger, "run-1", "step-a");
-    scoped.info("hello");
+    const scoped = createScopedLogger(baseLogger, 'run-1', 'step-a');
+    scoped.info('hello');
 
-    expect(calls[0]).toBe("[run:run-1][step:step-a] hello");
+    expect(calls[0]).toBe('[run:run-1][step:step-a] hello');
   });
 
-  it("should forward extra arguments", () => {
+  it('should forward extra arguments', () => {
     const captured: unknown[][] = [];
     const baseLogger = {
       debug: (...args: unknown[]) => captured.push(args),
@@ -119,9 +113,9 @@ describe("createScopedLogger", () => {
       error: (...args: unknown[]) => captured.push(args),
     };
 
-    const scoped = createScopedLogger(baseLogger, "r1");
-    scoped.info("msg", { data: 1 }, 42);
+    const scoped = createScopedLogger(baseLogger, 'r1');
+    scoped.info('msg', { data: 1 }, 42);
 
-    expect(captured[0]).toEqual(["[run:r1] msg", { data: 1 }, 42]);
+    expect(captured[0]).toEqual(['[run:r1] msg', { data: 1 }, 42]);
   });
 });

package/src/utils/logger.ts

@@ -2,10 +2,10 @@
  * Logger utilities for the workflow engine.
  */
 
-import type { Logger, WorkflowError } from "../core/types";
+import type { Logger, WorkflowError } from '../core/types';
 
 /** Log level for ConsoleLogger. Levels are ordered: debug < info < warn < error. */
-export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 
 const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
   debug: 0,
@@ -23,7 +23,7 @@ export class ConsoleLogger implements Logger {
   private prefix: string;
   private minLevel: number;
 
-  constructor(prefix = "[workflow]", level: LogLevel = "info") {
+  constructor(prefix = '[workflow]', level: LogLevel = 'info') {
     this.prefix = prefix;
     this.minLevel = LOG_LEVEL_PRIORITY[level];
   }
@@ -79,7 +79,7 @@ export function sanitizeErrorForStorage(error: WorkflowError): WorkflowError {
 export function createScopedLogger(
   logger: Logger,
   runId: string,
-  stepKey?: string,
+  stepKey?: string
 ): Logger {
   const prefix = stepKey ? `[run:${runId}][step:${stepKey}]` : `[run:${runId}]`;