duron 0.1.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Geut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# Duron
+
+A powerful, type-safe job queue system for Node.js and Bun.js. Duron provides a robust foundation for executing asynchronous tasks with built-in retry logic, concurrency control, step-based execution, and comprehensive observability.
+
+## Installation
+
+```bash
+# Using bun
+bun add duron
+
+# Using npm
+npm install duron
+
+# Using pnpm
+pnpm add duron
+
+# Using yarn
+yarn add duron
+```
+
+## Quick Start
+
+### 1. Define an Action
+
+Actions are the building blocks of Duron. They define what work needs to be done:
+
+```typescript
+import { defineAction } from 'duron'
+import { z } from 'zod'
+
+const sendEmail = defineAction()({
+  name: 'send-email',
+  input: z.object({
+    to: z.string().email(),
+    subject: z.string(),
+    body: z.string(),
+  }),
+  output: z.object({
+    success: z.boolean(),
+  }),
+  handler: async (ctx) => {
+    const { to, subject, body } = ctx.input
+
+    // Use steps to break down work into retryable units
+    const result = await ctx.step('send-email', async ({ signal }) => {
+      const response = await fetch('https://api.email.com/send', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ to, subject, body }),
+        signal, // Pass signal to enable cancellation
+      })
+
+      if (!response.ok) {
+        throw new Error('Failed to send email')
+      }
+
+      return await response.json()
+    })
+
+    return { success: result.success ?? true }
+  },
+})
+```
+
+### 2. Create a Client
+
+```typescript
+import { duron } from 'duron'
+import { postgresAdapter } from 'duron/adapters/postgres'
+
+const client = duron({
+  database: postgresAdapter({
+    connection: process.env.DATABASE_URL,
+  }),
+  actions: {
+    sendEmail,
+  },
+  logger: 'info',
+})
+
+await client.start()
+```
+
+### 3. Run Actions
+
+```typescript
+// Run an action
+const jobId = await client.runAction('send-email', {
+  to: 'user@example.com',
+  subject: 'Hello',
+  body: 'Welcome!',
+})
+
+// Wait for the job to complete
+const job = await client.waitForJob(jobId)
+console.log('Job completed:', job?.output)
+```
+
+## Key Features
+
+- **Type-Safe** - Full TypeScript support with Zod validation
+- **Step-Based Execution** - Break down complex workflows into manageable, retryable steps
+- **Intelligent Retry Logic** - Configurable exponential backoff with per-action and per-step options
+- **Flexible Sync Patterns** - Pull, push, hybrid, or manual job fetching
+- **Advanced Concurrency Control** - Per-action, per-group, and dynamic concurrency limits
+- **Reliability & Recovery** - Automatic job recovery, multi-process coordination, and stuck job detection
+- **Database Adapters** - PostgreSQL (production) and PGLite (development/testing)
+- **REST API Server** - Built-in Elysia-based API with advanced filtering and pagination
+
+## Documentation
+
+- [Getting Started](https://duron.dev/docs/getting-started)
+- [Actions](https://duron.dev/docs/actions)
+- [Jobs and Steps](https://duron.dev/docs/jobs-and-steps)
+- [Client API](https://duron.dev/docs/client-api)
+- [Server API](https://duron.dev/docs/server-api)
+- [Adapters](https://duron.dev/docs/adapters)
+- [Retries](https://duron.dev/docs/retries)
+- [Error Handling](https://duron.dev/docs/error-handling)
+- [Examples](https://duron.dev/docs/examples)
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run tests
+bun test
+
+# Build
+bun run build
+
+# Type check
+bun run typecheck
+```
+
+## License
+
+MIT

package/dist/action-job.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from 'pino';
+import type { Action } from './action.js';
+import type { Adapter } from './adapters/adapter.js';
+export interface ActionJobOptions<TAction extends Action<any, any, any>> {
+    job: {
+        id: string;
+        input: any;
+        groupKey: string;
+        timeoutMs: number;
+        actionName: string;
+    };
+    action: TAction;
+    database: Adapter;
+    variables: Record<string, unknown>;
+    logger: Logger;
+}
+export declare class ActionJob<TAction extends Action<any, any, any>> {
+    #private;
+    constructor(options: ActionJobOptions<TAction>);
+    execute(): Promise<any>;
+    waitForDone(): Promise<void>;
+    cancel(): void;
+}
+//# sourceMappingURL=action-job.d.ts.map

package/dist/action-job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-job.d.ts","sourceRoot":"","sources":["../src/action-job.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAKpD,MAAM,WAAW,gBAAgB,CAAC,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;IACrE,GAAG,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;IACxF,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,MAAM,EAAE,MAAM,CAAA;CACf;AAQD,qBAAa,SAAS,CAAC,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;;gBAqB9C,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC;IAoCxC,OAAO;IA8Fb,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B,MAAM;CAmBP"}

package/dist/action-job.js

@@ -0,0 +1,108 @@
+import { ActionCancelError, ActionTimeoutError, isCancelError, StepTimeoutError, serializeError } from './errors.js';
+import { StepManager } from './step-manager.js';
+import waitForAbort from './utils/wait-for-abort.js';
+export class ActionJob {
+    #job;
+    #action;
+    #database;
+    #variables;
+    #logger;
+    #stepManager;
+    #abortController;
+    #timeoutId = null;
+    #done;
+    #resolve = null;
+    constructor(options) {
+        this.#job = options.job;
+        this.#action = options.action;
+        this.#database = options.database;
+        this.#variables = options.variables;
+        this.#logger = options.logger;
+        this.#abortController = new AbortController();
+        this.#stepManager = new StepManager({
+            jobId: options.job.id,
+            actionName: options.job.actionName,
+            adapter: options.database,
+            logger: options.logger,
+            concurrencyLimit: options.action.concurrency,
+        });
+        this.#done = new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
+    }
+    async execute() {
+        try {
+            const jobLogger = this.#logger.child({
+                jobId: this.#job.id,
+                actionName: this.#action.name,
+            });
+            const ctx = this.#stepManager.createActionContext(this.#job, this.#action, this.#variables, this.#abortController.signal, jobLogger);
+            this.#timeoutId = setTimeout(() => {
+                const timeoutError = new ActionTimeoutError(this.#action.name, this.#job.timeoutMs);
+                this.#abortController.abort(timeoutError);
+            }, this.#job.timeoutMs);
+            this.#timeoutId?.unref?.();
+            const abortWaiter = waitForAbort(this.#abortController.signal);
+            let result = null;
+            await Promise.race([
+                this.#action
+                    .handler(ctx)
+                    .then((res) => {
+                    if (res !== undefined) {
+                        result = res;
+                    }
+                })
+                    .finally(() => {
+                    abortWaiter.release();
+                }),
+                abortWaiter.promise,
+            ]);
+            if (this.#action.output) {
+                result = this.#action.output.parse(result, {
+                    error: () => 'Error parsing action output',
+                    reportInput: true,
+                });
+            }
+            const completed = await this.#database.completeJob({ jobId: this.#job.id, output: result });
+            if (!completed) {
+                throw new Error('Job not completed');
+            }
+            this.#logger.debug({ jobId: this.#job.id, actionName: this.#action.name }, '[ActionJob] Action finished executing');
+            return result;
+        }
+        catch (error) {
+            if (isCancelError(error) ||
+                (error instanceof Error && error.name === 'AbortError' && isCancelError(error.cause))) {
+                this.#logger.warn({ jobId: this.#job.id, actionName: this.#action.name }, '[ActionJob] Job cancelled');
+                await this.#database.cancelJob({ jobId: this.#job.id });
+                return;
+            }
+            const message = error instanceof ActionTimeoutError
+                ? '[ActionJob] Job timed out'
+                : error instanceof StepTimeoutError
+                    ? '[ActionJob] Step timed out'
+                    : '[ActionJob] Job failed';
+            this.#logger.error({ jobId: this.#job.id, actionName: this.#action.name }, message);
+            await this.#database.failJob({ jobId: this.#job.id, error: serializeError(error) });
+            throw error;
+        }
+        finally {
+            this.#clear();
+            this.#resolve?.();
+        }
+    }
+    waitForDone() {
+        return this.#done;
+    }
+    cancel() {
+        this.#clear();
+        const cancelError = new ActionCancelError(this.#action.name, this.#job.id);
+        this.#abortController.abort(cancelError);
+    }
+    #clear() {
+        if (this.#timeoutId) {
+            clearTimeout(this.#timeoutId);
+            this.#timeoutId = null;
+        }
+    }
+}

package/dist/action-manager.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from 'pino';
+import type { Action } from './action.js';
+import type { Adapter, Job } from './adapters/adapter.js';
+export interface ActionManagerOptions<TAction extends Action<any, any, any>> {
+    action: TAction;
+    database: Adapter;
+    variables: Record<string, unknown>;
+    logger: Logger;
+    concurrencyLimit: number;
+}
+export declare class ActionManager<TAction extends Action<any, any, any>> {
+    #private;
+    constructor(options: ActionManagerOptions<TAction>);
+    push(job: Job): Promise<void>;
+    cancelJob(jobId: string): boolean;
+    abortAll(): void;
+    idle(): Promise<boolean>;
+    drain(): Promise<void>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=action-manager.d.ts.map

package/dist/action-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-manager.d.ts","sourceRoot":"","sources":["../src/action-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAA;AAEzD,MAAM,WAAW,oBAAoB,CAAC,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;IACzE,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAQD,qBAAa,aAAa,CAAC,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;;gBAmBlD,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC;IA2B5C,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAUnC,SAAS,CAAC,KAAK,EAAE,MAAM;IAYvB,QAAQ,IAAI,IAAI;IAWV,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IASxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CA8C5B"}

package/dist/action-manager.js

@@ -0,0 +1,78 @@
+import fastq from 'fastq';
+import { ActionJob } from './action-job.js';
+export class ActionManager {
+    #action;
+    #database;
+    #variables;
+    #logger;
+    #queue;
+    #concurrencyLimit;
+    #activeJobs = new Map();
+    #stopped = false;
+    constructor(options) {
+        this.#action = options.action;
+        this.#database = options.database;
+        this.#variables = options.variables;
+        this.#logger = options.logger;
+        this.#concurrencyLimit = options.concurrencyLimit;
+        this.#queue = fastq.promise(async (job) => {
+            if (this.#stopped) {
+                return;
+            }
+            await this.#executeJob(job);
+        }, this.#concurrencyLimit);
+    }
+    async push(job) {
+        return this.#queue.push(job);
+    }
+    cancelJob(jobId) {
+        const actionJob = this.#activeJobs.get(jobId);
+        if (actionJob) {
+            actionJob.cancel();
+            return true;
+        }
+        return false;
+    }
+    abortAll() {
+        for (const actionJob of this.#activeJobs.values()) {
+            actionJob.cancel();
+        }
+    }
+    async idle() {
+        return this.#queue.idle();
+    }
+    async drain() {
+        return this.#queue.drain();
+    }
+    async stop() {
+        if (this.#stopped) {
+            return;
+        }
+        this.#stopped = true;
+        this.abortAll();
+        await this.#queue.killAndDrain();
+        await Promise.all(Array.from(this.#activeJobs.values()).map((actionJob) => actionJob.waitForDone()));
+    }
+    async #executeJob(job) {
+        const actionJob = new ActionJob({
+            job: {
+                id: job.id,
+                input: job.input,
+                groupKey: job.groupKey,
+                timeoutMs: job.timeoutMs,
+                actionName: job.actionName,
+            },
+            action: this.#action,
+            database: this.#database,
+            variables: this.#variables,
+            logger: this.#logger,
+        });
+        this.#activeJobs.set(job.id, actionJob);
+        try {
+            await actionJob.execute();
+        }
+        finally {
+            this.#activeJobs.delete(job.id);
+        }
+    }
+}

package/dist/action.d.ts

@@ -0,0 +1,129 @@
+import type { Logger } from 'pino';
+import * as z from 'zod';
+export type RetryOptions = z.infer<typeof RetryOptionsSchema>;
+export type StepOptions = z.infer<typeof StepOptionsSchema>;
+export interface ActionHandlerContext<TInput extends z.ZodObject, TVariables = Record<string, unknown>> {
+    input: z.infer<TInput>;
+    jobId: string;
+    groupKey: string;
+    var: TVariables;
+    logger: Logger;
+    step: <TResult>(name: string, cb: (ctx: StepHandlerContext) => Promise<TResult>, options?: z.input<typeof StepOptionsSchema>) => Promise<TResult>;
+}
+export interface StepHandlerContext {
+    signal: AbortSignal;
+}
+export interface ConcurrencyHandlerContext<TInput extends z.ZodObject, TVariables = Record<string, unknown>> {
+    input: z.infer<TInput>;
+    var: TVariables;
+}
+export type ActionDefinition<TInput extends z.ZodObject, TOutput extends z.ZodObject, TVariables = Record<string, unknown>> = z.input<ReturnType<typeof createActionDefinitionSchema<TInput, TOutput, TVariables>>>;
+export type Action<TInput extends z.ZodObject, TOutput extends z.ZodObject, TVariables = Record<string, unknown>> = z.infer<ReturnType<typeof createActionDefinitionSchema<TInput, TOutput, TVariables>>>;
+export declare const RetryOptionsSchema: z.ZodDefault<z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    factor: z.ZodDefault<z.ZodNumber>;
+    minTimeout: z.ZodDefault<z.ZodNumber>;
+    maxTimeout: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const StepOptionsSchema: z.ZodObject<{
+    retry: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        factor: z.ZodDefault<z.ZodNumber>;
+        minTimeout: z.ZodDefault<z.ZodNumber>;
+        maxTimeout: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    expire: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createActionDefinitionSchema<TInput extends z.ZodObject, TOutput extends z.ZodObject, TVariables = Record<string, unknown>>(): z.ZodPipe<z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodCustom<TInput, TInput>>;
+    output: z.ZodOptional<z.ZodCustom<TOutput, TOutput>>;
+    groups: z.ZodOptional<z.ZodObject<{
+        groupKey: z.ZodOptional<z.ZodCustom<(ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<string>, (ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<string>>>;
+        concurrency: z.ZodOptional<z.ZodCustom<(ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<number>, (ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<number>>>;
+    }, z.core.$strip>>;
+    steps: z.ZodDefault<z.ZodObject<{
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        retry: z.ZodDefault<z.ZodObject<{
+            limit: z.ZodDefault<z.ZodNumber>;
+            factor: z.ZodDefault<z.ZodNumber>;
+            minTimeout: z.ZodDefault<z.ZodNumber>;
+            maxTimeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        expire: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    expire: z.ZodDefault<z.ZodNumber>;
+    handler: z.ZodCustom<(ctx: ActionHandlerContext<TInput, TVariables>) => Promise<z.infer<TOutput>>, (ctx: ActionHandlerContext<TInput, TVariables>) => Promise<z.infer<TOutput>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    checksum: string;
+    name: string;
+    steps: {
+        concurrency: number;
+        retry: {
+            limit: number;
+            factor: number;
+            minTimeout: number;
+            maxTimeout: number;
+        };
+        expire: number;
+    };
+    concurrency: number;
+    expire: number;
+    handler: (ctx: ActionHandlerContext<TInput, TVariables>) => Promise<z.infer<TOutput>>;
+    version?: string | undefined;
+    input?: TInput | undefined;
+    output?: TOutput | undefined;
+    groups?: {
+        groupKey?: ((ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<string>) | undefined;
+        concurrency?: ((ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<number>) | undefined;
+    } | undefined;
+}, {
+    name: string;
+    steps: {
+        concurrency: number;
+        retry: {
+            limit: number;
+            factor: number;
+            minTimeout: number;
+            maxTimeout: number;
+        };
+        expire: number;
+    };
+    concurrency: number;
+    expire: number;
+    handler: (ctx: ActionHandlerContext<TInput, TVariables>) => Promise<z.infer<TOutput>>;
+    version?: string | undefined;
+    input?: TInput | undefined;
+    output?: TOutput | undefined;
+    groups?: {
+        groupKey?: ((ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<string>) | undefined;
+        concurrency?: ((ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<number>) | undefined;
+    } | undefined;
+}>>;
+export declare const defineAction: <TVariables = Record<string, unknown>>() => <TInput extends z.ZodObject, TOutput extends z.ZodObject>(def: ActionDefinition<TInput, TOutput, TVariables>) => {
+    checksum: string;
+    name: string;
+    steps: {
+        concurrency: number;
+        retry: {
+            limit: number;
+            factor: number;
+            minTimeout: number;
+            maxTimeout: number;
+        };
+        expire: number;
+    };
+    concurrency: number;
+    expire: number;
+    handler: (ctx: ActionHandlerContext<TInput, TVariables>) => Promise<z.core.output<TOutput>>;
+    version?: string | undefined;
+    input?: TInput | undefined;
+    output?: TOutput | undefined;
+    groups?: {
+        groupKey?: ((ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<string>) | undefined;
+        concurrency?: ((ctx: ConcurrencyHandlerContext<TInput, TVariables>) => Promise<number>) | undefined;
+    } | undefined;
+};
+//# sourceMappingURL=action.d.ts.map

package/dist/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":"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"}

package/dist/action.js

@@ -0,0 +1,87 @@
+import * as z from 'zod';
+import generateChecksum from './utils/checksum.js';
+export const RetryOptionsSchema = z
+    .object({
+    limit: z.number().default(4),
+    factor: z.number().default(2),
+    minTimeout: z.number().default(1000),
+    maxTimeout: z.number().default(30000),
+})
+    .default({ limit: 4, factor: 2, minTimeout: 1000, maxTimeout: 30000 })
+    .describe('The retry options');
+export const StepOptionsSchema = z.object({
+    retry: RetryOptionsSchema,
+    expire: z
+        .number()
+        .default(5 * 60 * 1000)
+        .describe('The expire time for the step (milliseconds)'),
+});
+export function createActionDefinitionSchema() {
+    return z
+        .object({
+        name: z.string().describe('The name of the action'),
+        version: z.string().describe('The version of the action').optional(),
+        input: z
+            .custom((val) => {
+            return !val || ('_zod' in val && 'type' in val && val.type === 'object');
+        })
+            .optional(),
+        output: z
+            .custom((val) => {
+            return !val || ('_zod' in val && 'type' in val && val.type === 'object');
+        })
+            .optional(),
+        groups: z
+            .object({
+            groupKey: z
+                .custom((val) => {
+                return !val || val instanceof Function;
+            })
+                .optional(),
+            concurrency: z
+                .custom((val) => {
+                return !val || val instanceof Function;
+            })
+                .optional(),
+        })
+            .optional(),
+        steps: z
+            .object({
+            concurrency: z.number().default(10).describe('How many steps can run concurrently for this action'),
+            retry: RetryOptionsSchema.describe('How to retry on failure for the steps of this action'),
+            expire: z
+                .number()
+                .default(5 * 60 * 1000)
+                .describe('How long a step can run for (milliseconds)'),
+        })
+            .default({
+            concurrency: 10,
+            retry: { limit: 4, factor: 2, minTimeout: 1000, maxTimeout: 30000 },
+            expire: 5 * 60 * 1000,
+        }),
+        concurrency: z.number().default(100).describe('How many jobs can run concurrently for this action'),
+        expire: z
+            .number()
+            .default(15 * 60 * 1000)
+            .describe('How long a job can run for (milliseconds)'),
+        handler: z
+            .custom((val) => {
+            return val instanceof Function;
+        })
+            .describe('The handler for the action'),
+    })
+        .transform((def) => {
+        const checksum = [def.name, def.version, def.handler.toString()].filter(Boolean).join(':');
+        return {
+            ...def,
+            checksum: generateChecksum(checksum),
+        };
+    });
+}
+export const defineAction = () => {
+    return (def) => {
+        return createActionDefinitionSchema().parse(def, {
+            reportInput: true,
+        });
+    };
+};