@sonamu-kit/tasks 0.1.3 → 0.3.0

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@sonamu-kit/tasks",
-  "version": "0.1.3",
-  "type": "module",
+  "version": "0.3.0",
   "description": "Sonamu Task - Simple & Distributed Task Queue",
+  "author": "CartaNova <dev@cartanova.ai>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cartanova-ai/sonamu.git"
+  },
+  "type": "module",
   "main": "./dist/index.js",
   "exports": {
     ".": {
@@ -16,12 +21,8 @@
       "development": "./src/internal.ts"
     }
   },
-  "author": "CartaNova <dev@cartanova.ai>",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/cartanova-ai/sonamu.git"
-  },
   "dependencies": {
+    "c12": "^3.3.2",
     "date-fns": "^4.1.0",
     "date-fns-tz": "^3.2.0",
     "inflection": "^3.0.2",
@@ -30,33 +31,30 @@
     "pg": "^8.16.3",
     "rou3": "^0.7.10",
     "uuid": "^13.0.0",
-    "zod": "^4.1.12",
-    "c12": "^3.3.2"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/inflection": "^2.0.0",
-    "@biomejs/biome": "^2.3.10",
-    "@swc/cli": "^0.7.8",
-    "@swc/core": "^1.13.5",
-    "@types/node": "25.0.3",
+    "@types/node": "25.0.7",
     "nodemon": "^3.1.10",
+    "tsdown": "^0.12.5",
     "tsx": "^4.20.6",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.10"
+    "typescript": "^6.0.0",
+    "vitest": "^4.1.2"
   },
   "peerDependencies": {
-    "knex": "^3.1.0",
-    "@logtape/logtape": "1.3.5"
+    "@logtape/logtape": "2.0.0",
+    "knex": "^3.1.0"
   },
   "optionalDependencies": {
     "pg-native": "^3.5.2"
   },
   "scripts": {
     "dev": "nodemon exec",
-    "build": "swc src --config-file .swcrc -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
-    "check": "tsc --noEmit && biome format --write ./src/**/*.ts",
+    "build": "tsdown",
+    "check": "tsc --noEmit && oxlint src && oxfmt --check src",
     "check:type": "tsc --noEmit",
-    "check:format": "biome format --write ./src/**/*.ts",
+    "check:format": "oxfmt src",
     "pretest": "tsx scripts/migrate.ts",
     "test": "vitest run",
     "test:watch": "vitest watch --standalone",

package/src/backend.ts

@@ -1,8 +1,9 @@
-import type { SerializedError } from "./core/error";
-import type { JsonValue } from "./core/json";
-import type { StepAttempt, StepAttemptContext, StepKind } from "./core/step";
-import type { WorkflowRun } from "./core/workflow";
-import type { OnSubscribed } from "./database/pubsub";
+import { type SerializedError } from "./core/error";
+import { type JsonValue } from "./core/json";
+import { type SerializableRetryPolicy } from "./core/retry";
+import { type StepAttempt, type StepAttemptContext, type StepKind } from "./core/step";
+import { type WorkflowRun } from "./core/workflow";
+import { type OnSubscribed } from "./database/pubsub";
 
 export const DEFAULT_NAMESPACE_ID = "default";
 
@@ -26,6 +27,8 @@ export interface Backend {
   completeWorkflowRun(params: Readonly<CompleteWorkflowRunParams>): Promise<WorkflowRun>;
   failWorkflowRun(params: Readonly<FailWorkflowRunParams>): Promise<WorkflowRun>;
   cancelWorkflowRun(params: Readonly<CancelWorkflowRunParams>): Promise<WorkflowRun>;
+  pauseWorkflowRun(params: Readonly<PauseWorkflowRunParams>): Promise<WorkflowRun>;
+  resumeWorkflowRun(params: Readonly<ResumeWorkflowRunParams>): Promise<WorkflowRun>;
 
   // Step Attempts
   createStepAttempt(params: Readonly<CreateStepAttemptParams>): Promise<StepAttempt>;
@@ -33,8 +36,8 @@ export interface Backend {
   listStepAttempts(
     params: Readonly<ListStepAttemptsParams>,
   ): Promise<PaginatedResponse<StepAttempt>>;
-  completeStepAttempt(params: Readonly<CompleteStepAttemptParams>): Promise<StepAttempt>;
-  failStepAttempt(params: Readonly<FailStepAttemptParams>): Promise<StepAttempt>;
+  completeStepAttempt(params: Readonly<CompleteStepAttemptParams>): Promise<StepAttempt | null>;
+  failStepAttempt(params: Readonly<FailStepAttemptParams>): Promise<StepAttempt | null>;
 }
 
 export interface CreateWorkflowRunParams {
@@ -46,13 +49,19 @@ export interface CreateWorkflowRunParams {
   input: JsonValue | null;
   availableAt: Date | null; // null = immediately
   deadlineAt: Date | null; // null = no deadline
+  retryPolicy?: SerializableRetryPolicy;
 }
 
 export interface GetWorkflowRunParams {
   workflowRunId: string;
 }
 
-export type ListWorkflowRunsParams = PaginationOptions;
+export interface ListWorkflowRunsParams extends PaginationOptions {
+  status?: string[];
+  workflowName?: string;
+  createdAfter?: Date;
+  createdBefore?: Date;
+}
 
 export interface ClaimWorkflowRunParams {
   workerId: string;
@@ -81,12 +90,22 @@ export interface FailWorkflowRunParams {
   workflowRunId: string;
   workerId: string;
   error: SerializedError;
+  forceComplete?: boolean;
+  customDelayMs?: number;
 }
 
 export interface CancelWorkflowRunParams {
   workflowRunId: string;
 }
 
+export interface PauseWorkflowRunParams {
+  workflowRunId: string;
+}
+
+export interface ResumeWorkflowRunParams {
+  workflowRunId: string;
+}
+
 export interface CreateStepAttemptParams {
   workflowRunId: string;
   workerId: string;
@@ -122,6 +141,7 @@ export interface PaginationOptions {
   limit?: number;
   after?: string;
   before?: string;
+  order?: "asc" | "desc";
 }
 
 export interface PaginatedResponse<T> {

package/src/chaos.test.ts

@@ -1,8 +1,10 @@
 import { randomInt } from "node:crypto";
+
 import { describe, expect, test } from "vitest";
+
 import { OpenWorkflow } from "./client";
 import { createBackend } from "./testing/connection";
-import type { Worker } from "./worker";
+import { type Worker } from "./worker";
 
 const TOTAL_STEPS = 50;
 const WORKER_COUNT = 3;

package/src/client.test.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
+
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { z } from "zod";
+
 import { BackendPostgres } from ".";
 import { declareWorkflow, OpenWorkflow } from "./client";
 import { KNEX_GLOBAL_CONFIG } from "./testing/connection";

package/src/client.ts

@@ -1,11 +1,14 @@
-import type { Backend } from "./backend";
-import type { StandardSchemaV1 } from "./core/schema";
-import type { SchemaInput, SchemaOutput, WorkflowRun } from "./core/workflow";
+import { type Backend } from "./backend";
+import { serializeRetryPolicy } from "./core/retry";
+import { type StandardSchemaV1 } from "./core/schema";
+import { type SchemaInput, type SchemaOutput, type WorkflowRun } from "./core/workflow";
 import { validateInput } from "./core/workflow";
-import type { WorkflowFunction } from "./execution";
+import { type WorkflowFunction } from "./execution";
 import { WorkflowRegistry } from "./registry";
-import { Worker, type WorkerOptions } from "./worker";
-import { defineWorkflow, defineWorkflowSpec, type Workflow, type WorkflowSpec } from "./workflow";
+import { Worker } from "./worker";
+import { type WorkerOptions } from "./worker";
+import { defineWorkflow, defineWorkflowSpec } from "./workflow";
+import { type Workflow, type WorkflowSpec } from "./workflow";
 
 const DEFAULT_RESULT_POLL_INTERVAL_MS = 1000; // 1s
 const DEFAULT_RESULT_TIMEOUT_MS = 5 * 60 * 1000; // 5m
@@ -101,6 +104,7 @@ export class OpenWorkflow {
       input: parsedInput ?? null,
       availableAt: null,
       deadlineAt: options?.deadlineAt ?? null,
+      retryPolicy: spec.retryPolicy ? serializeRetryPolicy(spec.retryPolicy) : undefined,
     });
 
     if (options?.publishToChannel) {
@@ -319,12 +323,32 @@ export class WorkflowRunHandle<Output> {
   }
 
   /**
-   * Cancels the workflow run. Only workflows in pending, running, or sleeping
-   * status can be canceled.
+   * Cancels the workflow run. Only workflows in pending, running, sleeping,
+   * or paused status can be canceled.
    */
   async cancel(): Promise<void> {
     await this.backend.cancelWorkflowRun({
       workflowRunId: this.workflowRun.id,
     });
   }
+
+  /**
+   * Pauses the workflow run. Only workflows in pending, running, or sleeping
+   * status can be paused.
+   */
+  async pause(): Promise<void> {
+    await this.backend.pauseWorkflowRun({
+      workflowRunId: this.workflowRun.id,
+    });
+  }
+
+  /**
+   * Resumes a paused workflow run. Sets the status back to pending so that
+   * a worker can reclaim it.
+   */
+  async resume(): Promise<void> {
+    await this.backend.resumeWorkflowRun({
+      workflowRunId: this.workflowRun.id,
+    });
+  }
 }

package/src/config.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "vitest";
+
 import { defineConfig } from "./config";
 import { createBackend } from "./testing/connection";
 

package/src/config.ts

@@ -1,6 +1,7 @@
 import { loadConfig as loadC12Config } from "c12";
-import type { Backend } from "./backend";
-import type { WorkerOptions } from "./worker";
+
+import { type Backend } from "./backend";
+import { type WorkerOptions } from "./worker";
 
 export interface OpenWorkflowConfig {
   backend: Backend;

package/src/core/duration.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "vitest";
-import type { DurationString } from "./duration";
+
+import { type DurationString } from "./duration";
 import { parseDuration } from "./duration";
 import { err, ok } from "./result";
 

package/src/core/duration.ts

@@ -1,4 +1,4 @@
-import type { Result } from "./result";
+import { type Result } from "./result";
 import { err, ok } from "./result";
 
 type Years = "years" | "year" | "yrs" | "yr" | "y";

package/src/core/error.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "vitest";
+
 import { serializeError } from "./error";
 
 describe("serializeError", () => {

package/src/core/error.ts

@@ -1,4 +1,4 @@
-import type { JsonValue } from "./json";
+import { type JsonValue } from "./json";
 
 export type SerializedError = {
   name?: string;

package/src/core/result.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "vitest";
+
 import { err, ok } from "./result";
 
 describe("Result helpers", () => {

package/src/core/retry.test.ts

@@ -1,5 +1,17 @@
 import { describe, expect, test } from "vitest";
-import { calculateRetryDelayMs, DEFAULT_RETRY_POLICY, shouldRetry } from "./retry";
+
+import { type SerializedError } from "./error";
+import { type DynamicRetryPolicy, type StaticRetryPolicy } from "./retry";
+import {
+  calculateRetryDelayMs,
+  DEFAULT_RETRY_POLICY,
+  isDynamicRetryPolicy,
+  isStaticRetryPolicy,
+  mergeRetryPolicy,
+  serializeRetryPolicy,
+  shouldRetry,
+  shouldRetryByPolicy,
+} from "./retry";
 
 describe("calculateRetryDelayMs", () => {
   test("calculates exponential backoff correctly", () => {
@@ -9,14 +21,15 @@ describe("calculateRetryDelayMs", () => {
     expect(calculateRetryDelayMs(4)).toBe(8000);
     expect(calculateRetryDelayMs(5)).toBe(16_000);
     expect(calculateRetryDelayMs(6)).toBe(32_000);
-    expect(calculateRetryDelayMs(7)).toBe(64_000);
+    // attempt 7: 1s * 2^6 = 64s = 64000ms, capped at 60000ms (max)
+    expect(calculateRetryDelayMs(7)).toBe(60_000);
   });
 
   test("caps delay at maximum interval", () => {
     const { maximumIntervalMs } = DEFAULT_RETRY_POLICY;
 
-    // attempt 8: 1s * 2^7 = 128s = 128000ms, but capped at 100000ms (max)
-    expect(calculateRetryDelayMs(8)).toBe(maximumIntervalMs);
+    // attempt 7: 1s * 2^6 = 64s = 64000ms, capped at 60000ms (max)
+    expect(calculateRetryDelayMs(7)).toBe(maximumIntervalMs);
 
     // attempts 10 & 100: should still be capped
     expect(calculateRetryDelayMs(10)).toBe(maximumIntervalMs);
@@ -26,16 +39,173 @@ describe("calculateRetryDelayMs", () => {
   test("handles edge cases", () => {
     // attempt 0: 1s * 2^-1 = 0.5s = 500ms
     expect(calculateRetryDelayMs(0)).toBe(500);
-    expect(calculateRetryDelayMs(Infinity)).toBe(100_000);
+    expect(calculateRetryDelayMs(Infinity)).toBe(60_000);
   });
 });
 
 describe("shouldRetry", () => {
-  test("always returns true with default policy (infinite retries)", () => {
-    const retryPolicy = DEFAULT_RETRY_POLICY;
-    expect(shouldRetry(retryPolicy, 1)).toBe(true);
-    expect(shouldRetry(retryPolicy, 10)).toBe(true);
-    expect(shouldRetry(retryPolicy, 100)).toBe(true);
-    expect(shouldRetry(retryPolicy, 1000)).toBe(true);
+  test("returns false when attempt reaches maxAttempts", () => {
+    // 기본 정책: maxAttempts = 5
+    expect(shouldRetry(DEFAULT_RETRY_POLICY, 1)).toBe(true);
+    expect(shouldRetry(DEFAULT_RETRY_POLICY, 4)).toBe(true);
+    expect(shouldRetry(DEFAULT_RETRY_POLICY, 5)).toBe(false);
+    expect(shouldRetry(DEFAULT_RETRY_POLICY, 10)).toBe(false);
+  });
+});
+
+describe("shouldRetryByPolicy", () => {
+  test("respects maxAttempts from policy", () => {
+    expect(shouldRetryByPolicy({ maxAttempts: 3 }, 1)).toBe(true);
+    expect(shouldRetryByPolicy({ maxAttempts: 3 }, 2)).toBe(true);
+    expect(shouldRetryByPolicy({ maxAttempts: 3 }, 3)).toBe(false);
+    expect(shouldRetryByPolicy({ maxAttempts: 3 }, 4)).toBe(false);
+  });
+
+  test("uses default maxAttempts when not specified", () => {
+    expect(shouldRetryByPolicy({}, 1)).toBe(true);
+    expect(shouldRetryByPolicy({}, 4)).toBe(true);
+    expect(shouldRetryByPolicy({}, 5)).toBe(false);
+  });
+});
+
+describe("isDynamicRetryPolicy", () => {
+  test("returns true for policy with shouldRetry function", () => {
+    const dynamicPolicy: DynamicRetryPolicy = {
+      maxAttempts: 3,
+      shouldRetry: () => ({ shouldRetry: true, delayMs: 1000 }),
+    };
+    expect(isDynamicRetryPolicy(dynamicPolicy)).toBe(true);
+  });
+
+  test("returns false for static policy without shouldRetry", () => {
+    const staticPolicy: StaticRetryPolicy = {
+      maxAttempts: 5,
+      initialIntervalMs: 1000,
+    };
+    expect(isDynamicRetryPolicy(staticPolicy)).toBe(false);
+  });
+
+  test("returns false for empty policy", () => {
+    expect(isDynamicRetryPolicy({})).toBe(false);
+  });
+});
+
+describe("isStaticRetryPolicy", () => {
+  test("returns true for static policy without shouldRetry", () => {
+    const staticPolicy: StaticRetryPolicy = {
+      maxAttempts: 5,
+      initialIntervalMs: 1000,
+    };
+    expect(isStaticRetryPolicy(staticPolicy)).toBe(true);
+  });
+
+  test("returns true for empty policy", () => {
+    expect(isStaticRetryPolicy({})).toBe(true);
+  });
+
+  test("returns false for dynamic policy", () => {
+    const dynamicPolicy: DynamicRetryPolicy = {
+      maxAttempts: 3,
+      shouldRetry: () => ({ shouldRetry: true, delayMs: 1000 }),
+    };
+    expect(isStaticRetryPolicy(dynamicPolicy)).toBe(false);
+  });
+});
+
+describe("mergeRetryPolicy", () => {
+  test("returns default values when policy is undefined", () => {
+    const merged = mergeRetryPolicy(undefined);
+    expect(merged.maxAttempts).toBe(5);
+    expect(merged.initialIntervalMs).toBe(1000);
+    expect(merged.backoffCoefficient).toBe(2);
+    expect(merged.maximumIntervalMs).toBe(60_000);
+  });
+
+  test("uses provided values and fills missing with defaults for static policy", () => {
+    const merged = mergeRetryPolicy({ maxAttempts: 10, initialIntervalMs: 500 });
+    expect(merged.maxAttempts).toBe(10);
+    expect(merged.initialIntervalMs).toBe(500);
+    expect(merged.backoffCoefficient).toBe(2);
+    expect(merged.maximumIntervalMs).toBe(60_000);
+  });
+
+  test("returns only maxAttempts and shouldRetry for dynamic policy", () => {
+    const customFn = (_error: SerializedError, _attempt: number) => ({
+      shouldRetry: false,
+      delayMs: 5000,
+    });
+    const dynamicPolicy: DynamicRetryPolicy = {
+      maxAttempts: 3,
+      shouldRetry: customFn,
+    };
+    const merged = mergeRetryPolicy(dynamicPolicy);
+
+    expect(merged.maxAttempts).toBe(3);
+    expect(merged.shouldRetry).toBe(customFn);
+    // 동적 정책에서는 backoff 필드들이 없어야 합니다.
+    expect("initialIntervalMs" in merged).toBe(false);
+    expect("backoffCoefficient" in merged).toBe(false);
+    expect("maximumIntervalMs" in merged).toBe(false);
+  });
+
+  test("uses default maxAttempts for dynamic policy when not specified", () => {
+    const customFn = () => ({ shouldRetry: true, delayMs: 1000 });
+    const dynamicPolicy: DynamicRetryPolicy = {
+      shouldRetry: customFn,
+    };
+    const merged = mergeRetryPolicy(dynamicPolicy);
+
+    expect(merged.maxAttempts).toBe(5); // 기본값
+    expect(merged.shouldRetry).toBe(customFn);
+  });
+});
+
+describe("serializeRetryPolicy", () => {
+  test("returns empty object with hasDynamicPolicy=false for undefined", () => {
+    const serialized = serializeRetryPolicy(undefined);
+    expect(serialized.hasDynamicPolicy).toBe(false);
+    expect(serialized.maxAttempts).toBeUndefined();
+  });
+
+  test("serializes static fields for static policy", () => {
+    const serialized = serializeRetryPolicy({
+      maxAttempts: 10,
+      initialIntervalMs: 2000,
+    });
+    expect(serialized.maxAttempts).toBe(10);
+    expect(serialized.initialIntervalMs).toBe(2000);
+    expect(serialized.hasDynamicPolicy).toBe(false);
+    expect("shouldRetry" in serialized).toBe(false);
+  });
+
+  test("excludes backoff fields for dynamic policy", () => {
+    const dynamicPolicy: DynamicRetryPolicy = {
+      maxAttempts: 3,
+      shouldRetry: () => ({ shouldRetry: true, delayMs: 1000 }),
+    };
+    const serialized = serializeRetryPolicy(dynamicPolicy);
+
+    expect(serialized.maxAttempts).toBe(3);
+    expect(serialized.hasDynamicPolicy).toBe(true);
+    // 동적 정책에서는 backoff 필드들이 없어야 합니다.
+    expect(serialized.initialIntervalMs).toBeUndefined();
+    expect(serialized.backoffCoefficient).toBeUndefined();
+    expect(serialized.maximumIntervalMs).toBeUndefined();
+  });
+
+  test("includes backoff fields for static policy", () => {
+    const staticPolicy: StaticRetryPolicy = {
+      maxAttempts: 5,
+      initialIntervalMs: 2000,
+      backoffCoefficient: 3,
+      maximumIntervalMs: 30000,
+    };
+    const serialized = serializeRetryPolicy(staticPolicy);
+
+    expect(serialized.maxAttempts).toBe(5);
+    expect(serialized.initialIntervalMs).toBe(2000);
+    expect(serialized.backoffCoefficient).toBe(3);
+    expect(serialized.maximumIntervalMs).toBe(30000);
+    expect(serialized.hasDynamicPolicy).toBe(false);
   });
 });

package/src/core/retry.ts

@@ -1,29 +1,105 @@
-export const DEFAULT_RETRY_POLICY = {
-  initialIntervalMs: 1000, // 1s
+import { type SerializedError } from "./error";
+
+export interface RetryDecision {
+  shouldRetry: boolean;
+  delayMs: number;
+}
+
+export type RetryDecisionFn = (error: SerializedError, attempt: number) => RetryDecision;
+
+export interface StaticRetryPolicy {
+  maxAttempts?: number;
+  initialIntervalMs?: number;
+  backoffCoefficient?: number;
+  maximumIntervalMs?: number;
+}
+
+export interface DynamicRetryPolicy {
+  maxAttempts?: number;
+  shouldRetry: RetryDecisionFn;
+}
+
+export type RetryPolicy = StaticRetryPolicy | DynamicRetryPolicy;
+
+export interface SerializableRetryPolicy extends StaticRetryPolicy {
+  hasDynamicPolicy?: boolean;
+}
+
+export type MergedStaticRetryPolicy = Required<StaticRetryPolicy>;
+
+export interface MergedDynamicRetryPolicy {
+  maxAttempts: number;
+  shouldRetry: RetryDecisionFn;
+}
+
+export type MergedRetryPolicy = MergedStaticRetryPolicy | MergedDynamicRetryPolicy;
+
+export const DEFAULT_RETRY_POLICY: Required<StaticRetryPolicy> = {
+  maxAttempts: 5,
+  initialIntervalMs: 1000,
   backoffCoefficient: 2,
-  maximumIntervalMs: 100 * 1000, // 100s
-  maximumAttempts: Infinity, // unlimited
-} as const;
+  maximumIntervalMs: 60_000,
+};
 
-export type RetryPolicy = typeof DEFAULT_RETRY_POLICY;
+export function isDynamicRetryPolicy(policy: RetryPolicy): policy is DynamicRetryPolicy {
+  return "shouldRetry" in policy && typeof policy.shouldRetry === "function";
+}
+
+export function isStaticRetryPolicy(policy: RetryPolicy): policy is StaticRetryPolicy {
+  return !isDynamicRetryPolicy(policy);
+}
 
-/**
- * Calculate the next retry delay using exponential backoff.
- * @param attemptNumber - Attempt number (1-based)
- * @returns Delay in milliseconds
- */
 export function calculateRetryDelayMs(attemptNumber: number): number {
   const { initialIntervalMs, backoffCoefficient, maximumIntervalMs } = DEFAULT_RETRY_POLICY;
   const backoffMs = initialIntervalMs * backoffCoefficient ** (attemptNumber - 1);
   return Math.min(backoffMs, maximumIntervalMs);
 }
 
-/**
- * Check if an operation should be retried based on the retry policy.
- * @param retryPolicy - Retry policy
- * @param attemptNumber - Attempt number (1-based)
- * @returns True if another attempt should be made
- */
-export function shouldRetry(retryPolicy: RetryPolicy, attemptNumber: number): boolean {
-  return attemptNumber < retryPolicy.maximumAttempts;
+export function shouldRetry(retryPolicy: StaticRetryPolicy, attemptNumber: number): boolean {
+  const maxAttempts = retryPolicy.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts;
+  return attemptNumber < maxAttempts;
+}
+
+export function shouldRetryByPolicy(policy: StaticRetryPolicy, attemptNumber: number): boolean {
+  const maxAttempts = policy.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts;
+  return attemptNumber < maxAttempts;
+}
+
+export function mergeRetryPolicy(policy: StaticRetryPolicy | undefined): MergedStaticRetryPolicy;
+export function mergeRetryPolicy(policy: DynamicRetryPolicy): MergedDynamicRetryPolicy;
+export function mergeRetryPolicy(policy?: RetryPolicy): MergedRetryPolicy;
+export function mergeRetryPolicy(policy?: RetryPolicy): MergedRetryPolicy {
+  if (policy && isDynamicRetryPolicy(policy)) {
+    return {
+      maxAttempts: policy.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts,
+      shouldRetry: policy.shouldRetry,
+    };
+  }
+  return {
+    maxAttempts: policy?.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts,
+    initialIntervalMs: policy?.initialIntervalMs ?? DEFAULT_RETRY_POLICY.initialIntervalMs,
+    backoffCoefficient: policy?.backoffCoefficient ?? DEFAULT_RETRY_POLICY.backoffCoefficient,
+    maximumIntervalMs: policy?.maximumIntervalMs ?? DEFAULT_RETRY_POLICY.maximumIntervalMs,
+  };
+}
+
+export function serializeRetryPolicy(policy?: RetryPolicy): SerializableRetryPolicy {
+  if (!policy) {
+    return { hasDynamicPolicy: false };
+  }
+
+  if (isDynamicRetryPolicy(policy)) {
+    return {
+      maxAttempts: policy.maxAttempts,
+      hasDynamicPolicy: true,
+    };
+  }
+
+  return {
+    maxAttempts: policy.maxAttempts,
+    initialIntervalMs: policy.initialIntervalMs,
+    backoffCoefficient: policy.backoffCoefficient,
+    maximumIntervalMs: policy.maximumIntervalMs,
+    hasDynamicPolicy: false,
+  };
 }

package/src/core/schema.ts

@@ -68,7 +68,7 @@ export declare namespace StandardSchemaV1 {
     Schema["~standard"]["types"]
   >["output"];
 
-  // eslint-disable-next-line unicorn/require-module-specifiers
-  // biome-ignore lint/complexity/noUselessEmptyExport: needed for granular visibility control of TS namespace
+  // needed for granular visibility control of TS namespace
+  // oxlint-disable-next-line
   export {};
 }

package/src/core/step.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "vitest";
+
 import { ok } from "./result";
-import type { StepAttempt, StepAttemptCache } from "./step";
+import { type StepAttempt, type StepAttemptCache } from "./step";
 import {
   addToStepAttemptCache,
   calculateSleepResumeAt,