@yigitahmetsahin/workflow-ts 3.3.0 → 3.4.1

package/README.md

@@ -184,9 +184,9 @@ const conditionalWork = new Work({
 });
 ```
 
-### `.seal()`
+### `.seal(options?)`
 
-Seal the workflow to prevent further modifications. Returns an `ISealedWorkflow` that only exposes the `run()` method.
+Seal the workflow to prevent further modifications. Returns an `ISealedWorkflow` that only exposes the `run()` and `isSealed()` methods.
 
 ```typescript
 const sealed = new Workflow<{ userId: string }>()
@@ -204,19 +204,50 @@ const sealed = new Workflow<{ userId: string }>()
 // sealed.serial(...) // ❌ Error: Property 'serial' does not exist
 // sealed.parallel(...) // ❌ Error: Property 'parallel' does not exist
 
+// Check if sealed
+console.log(sealed.isSealed()); // true
+
 // Only run() is available:
 const result = await sealed.run({ userId: '123' }); // ✅ OK
 ```
 
+#### With Sealing Work
+
+You can pass an `ISealingWorkDefinition` (similar to `IWorkDefinition` but without `name`) to wrap the workflow execution:
+
+```typescript
+const workflow = new Workflow<{ userId: string }>()
+  .serial({ name: 'fetchUser', execute: async (ctx) => ({ id: ctx.data.userId }) });
+
+const sealed = workflow.seal({
+  execute: async (ctx) => {
+    console.log('Before:', ctx.data.userId);
+    const result = await workflow.run(ctx.data);
+    console.log('After');
+    return result;
+  },
+  // Optional: supports same options as IWorkDefinition
+  // shouldRun: (ctx) => ctx.data.enabled,
+  // onError: (error, ctx) => console.error(error),
+  // silenceError: true,
+});
+
+// Has name 'seal' and custom execute function
+console.log(sealed.name); // 'seal'
+await sealed.execute({ data: { userId: '123' }, workResults: ... }); // Uses custom execute
+await sealed.run({ userId: '123' }); // Bypasses custom execute
+```
+
 This is useful when you want to:
 
 - **Enforce immutability** - Ensure the workflow definition cannot be accidentally modified after construction
 - **Expose a clean API** - Pass a sealed workflow to other parts of your code that should only execute it, not modify it
 - **Type safety** - Get compile-time errors if someone tries to add more works to a finalized workflow
+- **Wrap execution** - Add logging, metrics, or other cross-cutting concerns via custom execute
 
 ```typescript
 // Example: Factory function that returns a sealed workflow
-function createUserWorkflow(): ISealedWorkflow<{ userId: string }, { user: User }> {
+function buildUserWorkflow(): ISealedWorkflow<{ userId: string }, { user: User }> {
   return new Workflow<{ userId: string }>()
     .serial({
       name: 'user',
@@ -226,7 +257,7 @@ function createUserWorkflow(): ISealedWorkflow<{ userId: string }, { user: User
 }
 
 // Consumers can only run the workflow
-const workflow = createUserWorkflow();
+const workflow = buildUserWorkflow();
 const result = await workflow.run({ userId: '123' });
 ```
 

package/dist/index.cjs

@@ -83,14 +83,25 @@ var WorkResultsMap = class {
 var Workflow = class {
   constructor(options = {}) {
     this.works = [];
+    this._sealed = false;
     this.options = { failFast: true, ...options };
   }
+  /**
+   * Check if the workflow is sealed
+   */
+  isSealed() {
+    return this._sealed;
+  }
   /**
    * Add a serial work to the workflow.
    * Accepts either an inline work definition or a Work instance.
    * The work name and result type are automatically inferred.
+   * @throws Error if the workflow is sealed
    */
   serial(work) {
+    if (this._sealed) {
+      throw new Error("Cannot add work to a sealed workflow");
+    }
     this.works.push({
       type: "serial",
       works: [getWorkDefinition(work)]
@@ -101,6 +112,7 @@ var Workflow = class {
    * Add parallel works to the workflow.
    * Accepts an array of work definitions or Work instances.
    * All work names and result types are automatically inferred.
+   * @throws Error if the workflow is sealed
    *
    * @example
    * ```typescript
@@ -111,28 +123,25 @@ var Workflow = class {
    * ```
    */
   parallel(works) {
+    if (this._sealed) {
+      throw new Error("Cannot add work to a sealed workflow");
+    }
     this.works.push({
       type: "parallel",
       works: works.map((w) => getWorkDefinition(w))
     });
     return this;
   }
-  /**
-   * Seal the workflow to prevent further modifications.
-   * Returns a SealedWorkflow that can only be executed with run().
-   *
-   * @example
-   * ```typescript
-   * const sealed = new Workflow<{ userId: string }>()
-   *   .serial({ name: 'step1', execute: async () => 'result' })
-   *   .seal();
-   *
-   * // sealed.serial() - TypeScript error! Method doesn't exist
-   * // sealed.parallel() - TypeScript error! Method doesn't exist
-   * await sealed.run({ userId: '123' }); // OK
-   * ```
-   */
-  seal() {
+  seal(sealingWork) {
+    this._sealed = true;
+    if (sealingWork?.execute) {
+      return {
+        name: "seal",
+        isSealed: () => this._sealed,
+        run: this.run.bind(this),
+        execute: sealingWork.execute
+      };
+    }
     return this;
   }
   /**
@@ -150,19 +159,9 @@ var Workflow = class {
       for (const workGroup of this.works) {
         try {
           if (workGroup.type === "serial") {
-            await this.executeWork(
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              workGroup.works[0],
-              context,
-              workResults
-            );
+            await this.executeWork(workGroup.works[0], context, workResults);
           } else {
-            await this.executeParallelWorks(
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              workGroup.works,
-              context,
-              workResults
-            );
+            await this.executeParallelWorks(workGroup.works, context, workResults);
           }
         } catch (error) {
           const err = error instanceof Error ? error : new Error(String(error));

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/workflow.types.ts","../src/work.ts","../src/workflow.ts"],"sourcesContent":["export * from './workflow';\nexport * from './workflow.types';\nexport * from './work';\n","/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Get a work result with compile-time type checking */\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;\n  /** Check if a work result exists */\n  has(name: string): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  silenceError?: boolean;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n\n/**\n * A sealed workflow that can only be executed, not modified.\n * Use workflow.seal() to create a sealed workflow.\n */\nexport interface ISealedWorkflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /**\n   * Execute the workflow with initial data\n   */\n  run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n","import { IWorkDefinition, IWorkflowContext } from './workflow.types';\n\n/**\n * A standalone Work unit that can be added to workflows.\n * Implements IWorkDefinition so it can be used anywhere a work definition is expected.\n *\n * @example\n * ```typescript\n * const fetchUser = new Work({\n *   name: 'fetchUser',\n *   execute: async (ctx) => {\n *     return { id: ctx.data.userId, name: 'John' };\n *   },\n * });\n *\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial(fetchUser)\n *   .parallel([work1, work2]);\n * ```\n */\nexport class Work<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  /** Unique name for the work */\n  readonly name: TName;\n\n  /** Execute function - receives context and returns result */\n  readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n\n  /** Optional: condition to determine if work should run */\n  readonly shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n\n  /** Optional: called when work fails */\n  readonly onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  readonly silenceError?: boolean;\n\n  constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>) {\n    this.name = definition.name;\n    this.execute = definition.execute;\n    this.shouldRun = definition.shouldRun;\n    this.onError = definition.onError;\n    this.silenceError = definition.silenceError;\n  }\n}\n\n/**\n * Type that accepts a work definition (either inline object or Work instance).\n * Since Work implements IWorkDefinition, this is simply IWorkDefinition.\n */\nexport type WorkInput<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;\n\n/**\n * Helper to get the work definition from a WorkInput.\n * Since Work implements IWorkDefinition, this simply returns the input.\n */\nexport function getWorkDefinition<\n  TName extends string,\n  TData,\n  TResult,\n  TAvailableWorkResults extends Record<string, unknown>,\n>(\n  input: WorkInput<TName, TData, TResult, TAvailableWorkResults>\n): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  return input;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n  ISealedWorkflow,\n} from './workflow.types';\nimport { WorkInput, getWorkDefinition } from './work';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, IWorkResult<unknown>>();\n\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]> {\n    const result = this.map.get(name);\n    if (!result) {\n      throw new Error(\n        `Work result \"${String(name)}\" not found. This work may not have executed yet.`\n      );\n    }\n    return result as IWorkResult<TWorkResults[K]>;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void {\n    this.map.set(name, value);\n  }\n\n  has(name: string): boolean {\n    return this.map.has(name as keyof TWorkResults);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\n/**\n * Options for configuring workflow behavior\n */\nexport interface WorkflowOptions {\n  /**\n   * Whether to stop execution immediately when a work fails.\n   * - true: Stop on first failure (default)\n   * - false: Continue executing remaining works, fail at the end if any work failed\n   * @default true\n   */\n  failFast?: boolean;\n}\n\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> {\n  private works: IWorkflowWork[] = [];\n  private options: Required<WorkflowOptions>;\n\n  constructor(options: WorkflowOptions = {}) {\n    this.options = { failFast: true, ...options };\n  }\n\n  /**\n   * Add a serial work to the workflow.\n   * Accepts either an inline work definition or a Work instance.\n   * The work name and result type are automatically inferred.\n   */\n  serial<TName extends string, TResult>(\n    work: WorkInput<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    this.works.push({\n      type: 'serial',\n      works: [getWorkDefinition(work)],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * Accepts an array of work definitions or Work instances.\n   * All work names and result types are automatically inferred.\n   *\n   * @example\n   * ```typescript\n   * workflow.parallel([\n   *   { name: 'work1', execute: async () => 'result1' },\n   *   { name: 'work2', execute: async () => 123 },\n   * ]);\n   * ```\n   */\n  parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(\n    works: TParallelWorks\n  ): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    this.works.push({\n      type: 'parallel',\n      works: works.map((w) => getWorkDefinition(w)) as unknown as IWorkDefinition<\n        string,\n        TData,\n        unknown,\n        TWorkResults\n      >[],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Seal the workflow to prevent further modifications.\n   * Returns a SealedWorkflow that can only be executed with run().\n   *\n   * @example\n   * ```typescript\n   * const sealed = new Workflow<{ userId: string }>()\n   *   .serial({ name: 'step1', execute: async () => 'result' })\n   *   .seal();\n   *\n   * // sealed.serial() - TypeScript error! Method doesn't exist\n   * // sealed.parallel() - TypeScript error! Method doesn't exist\n   * await sealed.run({ userId: '123' }); // OK\n   * ```\n   */\n  seal(): ISealedWorkflow<TData, TWorkResults> {\n    return this;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n    const collectedErrors: Error[] = [];\n\n    try {\n      for (const workGroup of this.works) {\n        try {\n          if (workGroup.type === 'serial') {\n            await this.executeWork(\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              workGroup.works[0] as IWorkDefinition<string, TData, any, any>,\n              context,\n              workResults\n            );\n          } else {\n            await this.executeParallelWorks(\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              workGroup.works as IWorkDefinition<string, TData, any, any>[],\n              context,\n              workResults\n            );\n          }\n        } catch (error) {\n          const err = error instanceof Error ? error : new Error(String(error));\n          if (this.options.failFast) {\n            throw err;\n          }\n          collectedErrors.push(err);\n        }\n      }\n\n      // If failFast is false, check for collected errors\n      if (collectedErrors.length > 0) {\n        return {\n          status: WorkflowStatus.FAILED,\n          context,\n          workResults,\n          totalDuration: Date.now() - startTime,\n          error: collectedErrors[0],\n        };\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        const skippedResult: IWorkResult = {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n        workResults.set(work.name as keyof TWorkResults, skippedResult);\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      const workResult: IWorkResult = {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      };\n\n      // Store result in context for subsequent works\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, workResult as any);\n      workResults.set(work.name as keyof TWorkResults, workResult);\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      const failedResult: IWorkResult = {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, failedResult as any);\n      workResults.set(work.name as keyof TWorkResults, failedResult);\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution (unless silenceError is true)\n      if (!work.silenceError) {\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          const skippedResult: IWorkResult = {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          };\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n          workResults.set(work.name as keyof TWorkResults, skippedResult);\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        const workResult: IWorkResult = {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n        // Only track as error if silenceError is not set\n        if (!result.work.silenceError) {\n          errors.push({ work: result.work, error: result.error });\n        }\n      } else {\n        const workResult: IWorkResult = {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n      }\n    }\n\n    // Call error handlers for all failed works (including silenced ones)\n    for (const result of results) {\n      if ('error' in result && result.error && result.work.onError) {\n        await result.work.onError(result.error, context);\n      }\n    }\n\n    // Throw the first non-silenced error to stop workflow\n    if (errors.length > 0) {\n      throw errors[0].error;\n    }\n  }\n}\n\n/**\n * Helper type to extract work results from parallel works array.\n * Since Work implements IWorkDefinition, we can use Extract directly.\n */\ntype ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}
+{"version":3,"sources":["../src/index.ts","../src/workflow.types.ts","../src/work.ts","../src/workflow.ts"],"sourcesContent":["export * from './workflow';\nexport * from './workflow.types';\nexport * from './work';\n","/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Get a work result with compile-time type checking */\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;\n  /** Check if a work result exists */\n  has(name: string): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  silenceError?: boolean;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n\n/**\n * Interface for the Workflow class.\n * Defines all methods available on a workflow before sealing.\n */\nexport interface IWorkflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /**\n   * Add a serial work to the workflow\n   */\n  serial<TName extends string, TResult>(\n    work: IWorkDefinition<TName, TData, TResult, TWorkResults>\n  ): IWorkflow<TData, TWorkResults & { [K in TName]: TResult }>;\n\n  /**\n   * Add parallel works to the workflow\n   */\n\n  parallel(\n    works: readonly IWorkDefinition<string, TData, any, TWorkResults>[]\n  ): IWorkflow<TData, any>;\n\n  /**\n   * Seal the workflow to prevent further modifications\n   */\n  seal(): ISealedWorkflow<TData, TWorkResults>;\n  seal(\n    sealingWork: ISealingWorkDefinition<TData, TWorkResults>\n  ): ISealedWorkflowWithExecute<TData, TWorkResults>;\n\n  /**\n   * Check if the workflow is sealed\n   */\n  isSealed(): boolean;\n\n  /**\n   * Execute the workflow with initial data\n   */\n  run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n\n/**\n * A limited work definition for sealing a workflow.\n * Similar to IWorkDefinition but without 'name' (hardcoded as 'seal').\n * The execute function returns IWorkflowResult instead of a custom result type.\n */\nexport type ISealingWorkDefinition<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = Omit<\n  IWorkDefinition<'seal', TData, IWorkflowResult<TData, TWorkResults>, TWorkResults>,\n  'name'\n>;\n\n/**\n * A sealed workflow that can only be executed, not modified.\n * Use workflow.seal() to create a sealed workflow.\n */\nexport interface ISealedWorkflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /**\n   * Check if the workflow is sealed\n   */\n  isSealed(): boolean;\n\n  /**\n   * Execute the workflow with initial data\n   */\n  run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n\n/**\n * A sealed workflow with a custom execute function.\n * Created when seal() is called with an execute option.\n */\nexport interface ISealedWorkflowWithExecute<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> extends ISealedWorkflow<TData, TWorkResults> {\n  /**\n   * Hardcoded name for the sealed workflow\n   */\n  readonly name: 'seal';\n\n  /**\n   * Custom execute function provided during sealing.\n   * Receives context (like a Work).\n   */\n  execute(\n    context: IWorkflowContext<TData, TWorkResults>\n  ): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n\n/**\n * Options for configuring workflow behavior\n */\nexport interface WorkflowOptions {\n  /**\n   * Whether to stop execution immediately when a work fails.\n   * - true: Stop on first failure (default)\n   * - false: Continue executing remaining works, fail at the end if any work failed\n   * @default true\n   */\n  failFast?: boolean;\n}\n\n/**\n * Helper type to extract work results from parallel works array.\n * Since Work implements IWorkDefinition, we can use Extract directly.\n */\nexport type ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n","import { IWorkDefinition, IWorkflowContext } from './workflow.types';\n\n/**\n * A standalone Work unit that can be added to workflows.\n * Implements IWorkDefinition so it can be used anywhere a work definition is expected.\n *\n * @example\n * ```typescript\n * const fetchUser = new Work({\n *   name: 'fetchUser',\n *   execute: async (ctx) => {\n *     return { id: ctx.data.userId, name: 'John' };\n *   },\n * });\n *\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial(fetchUser)\n *   .parallel([work1, work2]);\n * ```\n */\nexport class Work<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  /** Unique name for the work */\n  readonly name: TName;\n\n  /** Execute function - receives context and returns result */\n  readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n\n  /** Optional: condition to determine if work should run */\n  readonly shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n\n  /** Optional: called when work fails */\n  readonly onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  readonly silenceError?: boolean;\n\n  constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>) {\n    this.name = definition.name;\n    this.execute = definition.execute;\n    this.shouldRun = definition.shouldRun;\n    this.onError = definition.onError;\n    this.silenceError = definition.silenceError;\n  }\n}\n\n/**\n * Type that accepts a work definition (either inline object or Work instance).\n * Since Work implements IWorkDefinition, this is simply IWorkDefinition.\n */\nexport type WorkInput<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;\n\n/**\n * Helper to get the work definition from a WorkInput.\n * Since Work implements IWorkDefinition, this simply returns the input.\n */\nexport function getWorkDefinition<\n  TName extends string,\n  TData,\n  TResult,\n  TAvailableWorkResults extends Record<string, unknown>,\n>(\n  input: WorkInput<TName, TData, TResult, TAvailableWorkResults>\n): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  return input;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n  IWorkflow,\n  ISealedWorkflow,\n  ISealingWorkDefinition,\n  ISealedWorkflowWithExecute,\n  WorkflowOptions,\n  ParallelWorksToRecord,\n} from './workflow.types';\nimport { WorkInput, getWorkDefinition } from './work';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, IWorkResult<unknown>>();\n\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]> {\n    const result = this.map.get(name);\n    if (!result) {\n      throw new Error(\n        `Work result \"${String(name)}\" not found. This work may not have executed yet.`\n      );\n    }\n    return result as IWorkResult<TWorkResults[K]>;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void {\n    this.map.set(name, value);\n  }\n\n  has<K extends keyof TWorkResults>(name: K): boolean {\n    return this.map.has(name);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> implements IWorkflow<TData, TWorkResults> {\n  private works: IWorkflowWork[] = [];\n  private options: Required<WorkflowOptions>;\n  private _sealed = false;\n\n  constructor(options: WorkflowOptions = {}) {\n    this.options = { failFast: true, ...options };\n  }\n\n  /**\n   * Check if the workflow is sealed\n   */\n  isSealed(): boolean {\n    return this._sealed;\n  }\n\n  /**\n   * Add a serial work to the workflow.\n   * Accepts either an inline work definition or a Work instance.\n   * The work name and result type are automatically inferred.\n   * @throws Error if the workflow is sealed\n   */\n  serial<TName extends string, TResult>(\n    work: WorkInput<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    if (this._sealed) {\n      throw new Error('Cannot add work to a sealed workflow');\n    }\n    this.works.push({\n      type: 'serial',\n      works: [getWorkDefinition(work)],\n    });\n    return this as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * Accepts an array of work definitions or Work instances.\n   * All work names and result types are automatically inferred.\n   * @throws Error if the workflow is sealed\n   *\n   * @example\n   * ```typescript\n   * workflow.parallel([\n   *   { name: 'work1', execute: async () => 'result1' },\n   *   { name: 'work2', execute: async () => 123 },\n   * ]);\n   * ```\n   */\n  parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(\n    works: TParallelWorks\n  ): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    if (this._sealed) {\n      throw new Error('Cannot add work to a sealed workflow');\n    }\n    this.works.push({\n      type: 'parallel',\n      works: works.map((w) => getWorkDefinition(w)),\n    });\n    return this as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Seal the workflow to prevent further modifications.\n   * Returns a SealedWorkflow that can only be executed with run().\n   *\n   * @example\n   * ```typescript\n   * // Without options - returns ISealedWorkflow\n   * const sealed = new Workflow<{ userId: string }>()\n   *   .serial({ name: 'step1', execute: async () => 'result' })\n   *   .seal();\n   *\n   * sealed.isSealed(); // true\n   * await sealed.run({ userId: '123' }); // OK\n   *\n   * // With sealing work - returns ISealedWorkflowWithExecute\n   * const sealedWithExecute = workflow.seal({\n   *   execute: async (ctx) => {\n   *     console.log('Before:', ctx.data);\n   *     const result = await workflow.run(ctx.data);\n   *     console.log('After');\n   *     return result;\n   *   },\n   *   // Optional: shouldRun, onError, silenceError (like IWorkDefinition)\n   * });\n   *\n   * sealedWithExecute.name; // 'seal'\n   * await sealedWithExecute.execute({ data: initialData, workResults: ... });\n   * ```\n   */\n  seal(): ISealedWorkflow<TData, TWorkResults>;\n  seal(\n    sealingWork: ISealingWorkDefinition<TData, TWorkResults>\n  ): ISealedWorkflowWithExecute<TData, TWorkResults>;\n  seal(\n    sealingWork?: ISealingWorkDefinition<TData, TWorkResults>\n  ): ISealedWorkflow<TData, TWorkResults> | ISealedWorkflowWithExecute<TData, TWorkResults> {\n    this._sealed = true;\n    if (sealingWork?.execute) {\n      return {\n        name: 'seal',\n        isSealed: () => this._sealed,\n        run: this.run.bind(this),\n        execute: sealingWork.execute,\n      };\n    }\n    return this;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n    const collectedErrors: Error[] = [];\n\n    try {\n      for (const workGroup of this.works) {\n        try {\n          if (workGroup.type === 'serial') {\n            await this.executeWork(workGroup.works[0], context, workResults);\n          } else {\n            await this.executeParallelWorks(workGroup.works, context, workResults);\n          }\n        } catch (error) {\n          const err = error instanceof Error ? error : new Error(String(error));\n          if (this.options.failFast) {\n            throw err;\n          }\n          collectedErrors.push(err);\n        }\n      }\n\n      // If failFast is false, check for collected errors\n      if (collectedErrors.length > 0) {\n        return {\n          status: WorkflowStatus.FAILED,\n          context,\n          workResults,\n          totalDuration: Date.now() - startTime,\n          error: collectedErrors[0],\n        };\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        const skippedResult: IWorkResult = {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n        workResults.set(work.name as keyof TWorkResults, skippedResult);\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      const workResult: IWorkResult = {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      };\n\n      // Store result in context for subsequent works\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, workResult as any);\n      workResults.set(work.name as keyof TWorkResults, workResult);\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      const failedResult: IWorkResult = {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, failedResult as any);\n      workResults.set(work.name as keyof TWorkResults, failedResult);\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution (unless silenceError is true)\n      if (!work.silenceError) {\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          const skippedResult: IWorkResult = {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          };\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n          workResults.set(work.name as keyof TWorkResults, skippedResult);\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        const workResult: IWorkResult = {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n        // Only track as error if silenceError is not set\n        if (!result.work.silenceError) {\n          errors.push({ work: result.work, error: result.error });\n        }\n      } else {\n        const workResult: IWorkResult = {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n      }\n    }\n\n    // Call error handlers for all failed works (including silenced ones)\n    for (const result of results) {\n      if ('error' in result && result.error && result.work.onError) {\n        await result.work.onError(result.error, context);\n      }\n    }\n\n    // Throw the first non-silenced error to stop workflow\n    if (errors.length > 0) {\n      throw errors[0].error;\n    }\n  }\n}\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}

package/dist/index.d.cts

@@ -79,16 +79,91 @@ interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends
     totalDuration: number;
     error?: Error;
 }
+/**
+ * Interface for the Workflow class.
+ * Defines all methods available on a workflow before sealing.
+ */
+interface IWorkflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Add a serial work to the workflow
+     */
+    serial<TName extends string, TResult>(work: IWorkDefinition<TName, TData, TResult, TWorkResults>): IWorkflow<TData, TWorkResults & {
+        [K in TName]: TResult;
+    }>;
+    /**
+     * Add parallel works to the workflow
+     */
+    parallel(works: readonly IWorkDefinition<string, TData, any, TWorkResults>[]): IWorkflow<TData, any>;
+    /**
+     * Seal the workflow to prevent further modifications
+     */
+    seal(): ISealedWorkflow<TData, TWorkResults>;
+    seal(sealingWork: ISealingWorkDefinition<TData, TWorkResults>): ISealedWorkflowWithExecute<TData, TWorkResults>;
+    /**
+     * Check if the workflow is sealed
+     */
+    isSealed(): boolean;
+    /**
+     * Execute the workflow with initial data
+     */
+    run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;
+}
+/**
+ * A limited work definition for sealing a workflow.
+ * Similar to IWorkDefinition but without 'name' (hardcoded as 'seal').
+ * The execute function returns IWorkflowResult instead of a custom result type.
+ */
+type ISealingWorkDefinition<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> = Omit<IWorkDefinition<'seal', TData, IWorkflowResult<TData, TWorkResults>, TWorkResults>, 'name'>;
 /**
  * A sealed workflow that can only be executed, not modified.
  * Use workflow.seal() to create a sealed workflow.
  */
 interface ISealedWorkflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Check if the workflow is sealed
+     */
+    isSealed(): boolean;
     /**
      * Execute the workflow with initial data
      */
     run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;
 }
+/**
+ * A sealed workflow with a custom execute function.
+ * Created when seal() is called with an execute option.
+ */
+interface ISealedWorkflowWithExecute<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> extends ISealedWorkflow<TData, TWorkResults> {
+    /**
+     * Hardcoded name for the sealed workflow
+     */
+    readonly name: 'seal';
+    /**
+     * Custom execute function provided during sealing.
+     * Receives context (like a Work).
+     */
+    execute(context: IWorkflowContext<TData, TWorkResults>): Promise<IWorkflowResult<TData, TWorkResults>>;
+}
+/**
+ * Options for configuring workflow behavior
+ */
+interface WorkflowOptions {
+    /**
+     * Whether to stop execution immediately when a work fails.
+     * - true: Stop on first failure (default)
+     * - false: Continue executing remaining works, fail at the end if any work failed
+     * @default true
+     */
+    failFast?: boolean;
+}
+/**
+ * Helper type to extract work results from parallel works array.
+ * Since Work implements IWorkDefinition, we can use Extract directly.
+ */
+type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
+    [K in T[number]['name']]: Extract<T[number], {
+        name: K;
+    }> extends IWorkDefinition<string, any, infer R, any> ? R : never;
+};
 
 /**
  * A standalone Work unit that can be added to workflows.
@@ -167,26 +242,20 @@ declare function getWorkDefinition<TName extends string, TData, TResult, TAvaila
  * const result = await workflow.run({ userId: '123' });
  * ```
  */
-/**
- * Options for configuring workflow behavior
- */
-interface WorkflowOptions {
-    /**
-     * Whether to stop execution immediately when a work fails.
-     * - true: Stop on first failure (default)
-     * - false: Continue executing remaining works, fail at the end if any work failed
-     * @default true
-     */
-    failFast?: boolean;
-}
-declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = NonNullable<unknown>> {
+declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = NonNullable<unknown>> implements IWorkflow<TData, TWorkResults> {
     private works;
     private options;
+    private _sealed;
     constructor(options?: WorkflowOptions);
+    /**
+     * Check if the workflow is sealed
+     */
+    isSealed(): boolean;
     /**
      * Add a serial work to the workflow.
      * Accepts either an inline work definition or a Work instance.
      * The work name and result type are automatically inferred.
+     * @throws Error if the workflow is sealed
      */
     serial<TName extends string, TResult>(work: WorkInput<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
         [K in TName]: TResult;
@@ -195,6 +264,7 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
      * Add parallel works to the workflow.
      * Accepts an array of work definitions or Work instances.
      * All work names and result types are automatically inferred.
+     * @throws Error if the workflow is sealed
      *
      * @example
      * ```typescript
@@ -211,16 +281,31 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
      *
      * @example
      * ```typescript
+     * // Without options - returns ISealedWorkflow
      * const sealed = new Workflow<{ userId: string }>()
      *   .serial({ name: 'step1', execute: async () => 'result' })
      *   .seal();
      *
-     * // sealed.serial() - TypeScript error! Method doesn't exist
-     * // sealed.parallel() - TypeScript error! Method doesn't exist
+     * sealed.isSealed(); // true
      * await sealed.run({ userId: '123' }); // OK
+     *
+     * // With sealing work - returns ISealedWorkflowWithExecute
+     * const sealedWithExecute = workflow.seal({
+     *   execute: async (ctx) => {
+     *     console.log('Before:', ctx.data);
+     *     const result = await workflow.run(ctx.data);
+     *     console.log('After');
+     *     return result;
+     *   },
+     *   // Optional: shouldRun, onError, silenceError (like IWorkDefinition)
+     * });
+     *
+     * sealedWithExecute.name; // 'seal'
+     * await sealedWithExecute.execute({ data: initialData, workResults: ... });
      * ```
      */
     seal(): ISealedWorkflow<TData, TWorkResults>;
+    seal(sealingWork: ISealingWorkDefinition<TData, TWorkResults>): ISealedWorkflowWithExecute<TData, TWorkResults>;
     /**
      * Execute the workflow with initial data
      */
@@ -234,14 +319,5 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
      */
     private executeParallelWorks;
 }
-/**
- * Helper type to extract work results from parallel works array.
- * Since Work implements IWorkDefinition, we can use Extract directly.
- */
-type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
-    [K in T[number]['name']]: Extract<T[number], {
-        name: K;
-    }> extends IWorkDefinition<string, any, infer R, any> ? R : never;
-};
 
-export { type ISealedWorkflow, type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, Work, type WorkInput, WorkStatus, Workflow, type WorkflowOptions, WorkflowStatus, getWorkDefinition };
+export { type ISealedWorkflow, type ISealedWorkflowWithExecute, type ISealingWorkDefinition, type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflow, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, type ParallelWorksToRecord, Work, type WorkInput, WorkStatus, Workflow, type WorkflowOptions, WorkflowStatus, getWorkDefinition };

package/dist/index.d.ts

@@ -79,16 +79,91 @@ interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends
     totalDuration: number;
     error?: Error;
 }
+/**
+ * Interface for the Workflow class.
+ * Defines all methods available on a workflow before sealing.
+ */
+interface IWorkflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Add a serial work to the workflow
+     */
+    serial<TName extends string, TResult>(work: IWorkDefinition<TName, TData, TResult, TWorkResults>): IWorkflow<TData, TWorkResults & {
+        [K in TName]: TResult;
+    }>;
+    /**
+     * Add parallel works to the workflow
+     */
+    parallel(works: readonly IWorkDefinition<string, TData, any, TWorkResults>[]): IWorkflow<TData, any>;
+    /**
+     * Seal the workflow to prevent further modifications
+     */
+    seal(): ISealedWorkflow<TData, TWorkResults>;
+    seal(sealingWork: ISealingWorkDefinition<TData, TWorkResults>): ISealedWorkflowWithExecute<TData, TWorkResults>;
+    /**
+     * Check if the workflow is sealed
+     */
+    isSealed(): boolean;
+    /**
+     * Execute the workflow with initial data
+     */
+    run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;
+}
+/**
+ * A limited work definition for sealing a workflow.
+ * Similar to IWorkDefinition but without 'name' (hardcoded as 'seal').
+ * The execute function returns IWorkflowResult instead of a custom result type.
+ */
+type ISealingWorkDefinition<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> = Omit<IWorkDefinition<'seal', TData, IWorkflowResult<TData, TWorkResults>, TWorkResults>, 'name'>;
 /**
  * A sealed workflow that can only be executed, not modified.
  * Use workflow.seal() to create a sealed workflow.
  */
 interface ISealedWorkflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Check if the workflow is sealed
+     */
+    isSealed(): boolean;
     /**
      * Execute the workflow with initial data
      */
     run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;
 }
+/**
+ * A sealed workflow with a custom execute function.
+ * Created when seal() is called with an execute option.
+ */
+interface ISealedWorkflowWithExecute<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> extends ISealedWorkflow<TData, TWorkResults> {
+    /**
+     * Hardcoded name for the sealed workflow
+     */
+    readonly name: 'seal';
+    /**
+     * Custom execute function provided during sealing.
+     * Receives context (like a Work).
+     */
+    execute(context: IWorkflowContext<TData, TWorkResults>): Promise<IWorkflowResult<TData, TWorkResults>>;
+}
+/**
+ * Options for configuring workflow behavior
+ */
+interface WorkflowOptions {
+    /**
+     * Whether to stop execution immediately when a work fails.
+     * - true: Stop on first failure (default)
+     * - false: Continue executing remaining works, fail at the end if any work failed
+     * @default true
+     */
+    failFast?: boolean;
+}
+/**
+ * Helper type to extract work results from parallel works array.
+ * Since Work implements IWorkDefinition, we can use Extract directly.
+ */
+type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
+    [K in T[number]['name']]: Extract<T[number], {
+        name: K;
+    }> extends IWorkDefinition<string, any, infer R, any> ? R : never;
+};
 
 /**
  * A standalone Work unit that can be added to workflows.
@@ -167,26 +242,20 @@ declare function getWorkDefinition<TName extends string, TData, TResult, TAvaila
  * const result = await workflow.run({ userId: '123' });
  * ```
  */
-/**
- * Options for configuring workflow behavior
- */
-interface WorkflowOptions {
-    /**
-     * Whether to stop execution immediately when a work fails.
-     * - true: Stop on first failure (default)
-     * - false: Continue executing remaining works, fail at the end if any work failed
-     * @default true
-     */
-    failFast?: boolean;
-}
-declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = NonNullable<unknown>> {
+declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = NonNullable<unknown>> implements IWorkflow<TData, TWorkResults> {
     private works;
     private options;
+    private _sealed;
     constructor(options?: WorkflowOptions);
+    /**
+     * Check if the workflow is sealed
+     */
+    isSealed(): boolean;
     /**
      * Add a serial work to the workflow.
      * Accepts either an inline work definition or a Work instance.
      * The work name and result type are automatically inferred.
+     * @throws Error if the workflow is sealed
      */
     serial<TName extends string, TResult>(work: WorkInput<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
         [K in TName]: TResult;
@@ -195,6 +264,7 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
      * Add parallel works to the workflow.
      * Accepts an array of work definitions or Work instances.
      * All work names and result types are automatically inferred.
+     * @throws Error if the workflow is sealed
      *
      * @example
      * ```typescript
@@ -211,16 +281,31 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
      *
      * @example
      * ```typescript
+     * // Without options - returns ISealedWorkflow
      * const sealed = new Workflow<{ userId: string }>()
      *   .serial({ name: 'step1', execute: async () => 'result' })
      *   .seal();
      *
-     * // sealed.serial() - TypeScript error! Method doesn't exist
-     * // sealed.parallel() - TypeScript error! Method doesn't exist
+     * sealed.isSealed(); // true
      * await sealed.run({ userId: '123' }); // OK
+     *
+     * // With sealing work - returns ISealedWorkflowWithExecute
+     * const sealedWithExecute = workflow.seal({
+     *   execute: async (ctx) => {
+     *     console.log('Before:', ctx.data);
+     *     const result = await workflow.run(ctx.data);
+     *     console.log('After');
+     *     return result;
+     *   },
+     *   // Optional: shouldRun, onError, silenceError (like IWorkDefinition)
+     * });
+     *
+     * sealedWithExecute.name; // 'seal'
+     * await sealedWithExecute.execute({ data: initialData, workResults: ... });
      * ```
      */
     seal(): ISealedWorkflow<TData, TWorkResults>;
+    seal(sealingWork: ISealingWorkDefinition<TData, TWorkResults>): ISealedWorkflowWithExecute<TData, TWorkResults>;
     /**
      * Execute the workflow with initial data
      */
@@ -234,14 +319,5 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
      */
     private executeParallelWorks;
 }
-/**
- * Helper type to extract work results from parallel works array.
- * Since Work implements IWorkDefinition, we can use Extract directly.
- */
-type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
-    [K in T[number]['name']]: Extract<T[number], {
-        name: K;
-    }> extends IWorkDefinition<string, any, infer R, any> ? R : never;
-};
 
-export { type ISealedWorkflow, type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, Work, type WorkInput, WorkStatus, Workflow, type WorkflowOptions, WorkflowStatus, getWorkDefinition };
+export { type ISealedWorkflow, type ISealedWorkflowWithExecute, type ISealingWorkDefinition, type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflow, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, type ParallelWorksToRecord, Work, type WorkInput, WorkStatus, Workflow, type WorkflowOptions, WorkflowStatus, getWorkDefinition };

package/dist/index.js

@@ -53,14 +53,25 @@ var WorkResultsMap = class {
 var Workflow = class {
   constructor(options = {}) {
     this.works = [];
+    this._sealed = false;
     this.options = { failFast: true, ...options };
   }
+  /**
+   * Check if the workflow is sealed
+   */
+  isSealed() {
+    return this._sealed;
+  }
   /**
    * Add a serial work to the workflow.
    * Accepts either an inline work definition or a Work instance.
    * The work name and result type are automatically inferred.
+   * @throws Error if the workflow is sealed
    */
   serial(work) {
+    if (this._sealed) {
+      throw new Error("Cannot add work to a sealed workflow");
+    }
     this.works.push({
       type: "serial",
       works: [getWorkDefinition(work)]
@@ -71,6 +82,7 @@ var Workflow = class {
    * Add parallel works to the workflow.
    * Accepts an array of work definitions or Work instances.
    * All work names and result types are automatically inferred.
+   * @throws Error if the workflow is sealed
    *
    * @example
    * ```typescript
@@ -81,28 +93,25 @@ var Workflow = class {
    * ```
    */
   parallel(works) {
+    if (this._sealed) {
+      throw new Error("Cannot add work to a sealed workflow");
+    }
     this.works.push({
       type: "parallel",
       works: works.map((w) => getWorkDefinition(w))
     });
     return this;
   }
-  /**
-   * Seal the workflow to prevent further modifications.
-   * Returns a SealedWorkflow that can only be executed with run().
-   *
-   * @example
-   * ```typescript
-   * const sealed = new Workflow<{ userId: string }>()
-   *   .serial({ name: 'step1', execute: async () => 'result' })
-   *   .seal();
-   *
-   * // sealed.serial() - TypeScript error! Method doesn't exist
-   * // sealed.parallel() - TypeScript error! Method doesn't exist
-   * await sealed.run({ userId: '123' }); // OK
-   * ```
-   */
-  seal() {
+  seal(sealingWork) {
+    this._sealed = true;
+    if (sealingWork?.execute) {
+      return {
+        name: "seal",
+        isSealed: () => this._sealed,
+        run: this.run.bind(this),
+        execute: sealingWork.execute
+      };
+    }
     return this;
   }
   /**
@@ -120,19 +129,9 @@ var Workflow = class {
       for (const workGroup of this.works) {
         try {
           if (workGroup.type === "serial") {
-            await this.executeWork(
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              workGroup.works[0],
-              context,
-              workResults
-            );
+            await this.executeWork(workGroup.works[0], context, workResults);
           } else {
-            await this.executeParallelWorks(
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              workGroup.works,
-              context,
-              workResults
-            );
+            await this.executeParallelWorks(workGroup.works, context, workResults);
           }
         } catch (error) {
           const err = error instanceof Error ? error : new Error(String(error));

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/workflow.types.ts","../src/work.ts","../src/workflow.ts"],"sourcesContent":["/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Get a work result with compile-time type checking */\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;\n  /** Check if a work result exists */\n  has(name: string): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  silenceError?: boolean;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n\n/**\n * A sealed workflow that can only be executed, not modified.\n * Use workflow.seal() to create a sealed workflow.\n */\nexport interface ISealedWorkflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /**\n   * Execute the workflow with initial data\n   */\n  run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n","import { IWorkDefinition, IWorkflowContext } from './workflow.types';\n\n/**\n * A standalone Work unit that can be added to workflows.\n * Implements IWorkDefinition so it can be used anywhere a work definition is expected.\n *\n * @example\n * ```typescript\n * const fetchUser = new Work({\n *   name: 'fetchUser',\n *   execute: async (ctx) => {\n *     return { id: ctx.data.userId, name: 'John' };\n *   },\n * });\n *\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial(fetchUser)\n *   .parallel([work1, work2]);\n * ```\n */\nexport class Work<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  /** Unique name for the work */\n  readonly name: TName;\n\n  /** Execute function - receives context and returns result */\n  readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n\n  /** Optional: condition to determine if work should run */\n  readonly shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n\n  /** Optional: called when work fails */\n  readonly onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  readonly silenceError?: boolean;\n\n  constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>) {\n    this.name = definition.name;\n    this.execute = definition.execute;\n    this.shouldRun = definition.shouldRun;\n    this.onError = definition.onError;\n    this.silenceError = definition.silenceError;\n  }\n}\n\n/**\n * Type that accepts a work definition (either inline object or Work instance).\n * Since Work implements IWorkDefinition, this is simply IWorkDefinition.\n */\nexport type WorkInput<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;\n\n/**\n * Helper to get the work definition from a WorkInput.\n * Since Work implements IWorkDefinition, this simply returns the input.\n */\nexport function getWorkDefinition<\n  TName extends string,\n  TData,\n  TResult,\n  TAvailableWorkResults extends Record<string, unknown>,\n>(\n  input: WorkInput<TName, TData, TResult, TAvailableWorkResults>\n): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  return input;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n  ISealedWorkflow,\n} from './workflow.types';\nimport { WorkInput, getWorkDefinition } from './work';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, IWorkResult<unknown>>();\n\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]> {\n    const result = this.map.get(name);\n    if (!result) {\n      throw new Error(\n        `Work result \"${String(name)}\" not found. This work may not have executed yet.`\n      );\n    }\n    return result as IWorkResult<TWorkResults[K]>;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void {\n    this.map.set(name, value);\n  }\n\n  has(name: string): boolean {\n    return this.map.has(name as keyof TWorkResults);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\n/**\n * Options for configuring workflow behavior\n */\nexport interface WorkflowOptions {\n  /**\n   * Whether to stop execution immediately when a work fails.\n   * - true: Stop on first failure (default)\n   * - false: Continue executing remaining works, fail at the end if any work failed\n   * @default true\n   */\n  failFast?: boolean;\n}\n\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> {\n  private works: IWorkflowWork[] = [];\n  private options: Required<WorkflowOptions>;\n\n  constructor(options: WorkflowOptions = {}) {\n    this.options = { failFast: true, ...options };\n  }\n\n  /**\n   * Add a serial work to the workflow.\n   * Accepts either an inline work definition or a Work instance.\n   * The work name and result type are automatically inferred.\n   */\n  serial<TName extends string, TResult>(\n    work: WorkInput<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    this.works.push({\n      type: 'serial',\n      works: [getWorkDefinition(work)],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * Accepts an array of work definitions or Work instances.\n   * All work names and result types are automatically inferred.\n   *\n   * @example\n   * ```typescript\n   * workflow.parallel([\n   *   { name: 'work1', execute: async () => 'result1' },\n   *   { name: 'work2', execute: async () => 123 },\n   * ]);\n   * ```\n   */\n  parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(\n    works: TParallelWorks\n  ): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    this.works.push({\n      type: 'parallel',\n      works: works.map((w) => getWorkDefinition(w)) as unknown as IWorkDefinition<\n        string,\n        TData,\n        unknown,\n        TWorkResults\n      >[],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Seal the workflow to prevent further modifications.\n   * Returns a SealedWorkflow that can only be executed with run().\n   *\n   * @example\n   * ```typescript\n   * const sealed = new Workflow<{ userId: string }>()\n   *   .serial({ name: 'step1', execute: async () => 'result' })\n   *   .seal();\n   *\n   * // sealed.serial() - TypeScript error! Method doesn't exist\n   * // sealed.parallel() - TypeScript error! Method doesn't exist\n   * await sealed.run({ userId: '123' }); // OK\n   * ```\n   */\n  seal(): ISealedWorkflow<TData, TWorkResults> {\n    return this;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n    const collectedErrors: Error[] = [];\n\n    try {\n      for (const workGroup of this.works) {\n        try {\n          if (workGroup.type === 'serial') {\n            await this.executeWork(\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              workGroup.works[0] as IWorkDefinition<string, TData, any, any>,\n              context,\n              workResults\n            );\n          } else {\n            await this.executeParallelWorks(\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              workGroup.works as IWorkDefinition<string, TData, any, any>[],\n              context,\n              workResults\n            );\n          }\n        } catch (error) {\n          const err = error instanceof Error ? error : new Error(String(error));\n          if (this.options.failFast) {\n            throw err;\n          }\n          collectedErrors.push(err);\n        }\n      }\n\n      // If failFast is false, check for collected errors\n      if (collectedErrors.length > 0) {\n        return {\n          status: WorkflowStatus.FAILED,\n          context,\n          workResults,\n          totalDuration: Date.now() - startTime,\n          error: collectedErrors[0],\n        };\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        const skippedResult: IWorkResult = {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n        workResults.set(work.name as keyof TWorkResults, skippedResult);\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      const workResult: IWorkResult = {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      };\n\n      // Store result in context for subsequent works\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, workResult as any);\n      workResults.set(work.name as keyof TWorkResults, workResult);\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      const failedResult: IWorkResult = {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, failedResult as any);\n      workResults.set(work.name as keyof TWorkResults, failedResult);\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution (unless silenceError is true)\n      if (!work.silenceError) {\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          const skippedResult: IWorkResult = {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          };\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n          workResults.set(work.name as keyof TWorkResults, skippedResult);\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        const workResult: IWorkResult = {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n        // Only track as error if silenceError is not set\n        if (!result.work.silenceError) {\n          errors.push({ work: result.work, error: result.error });\n        }\n      } else {\n        const workResult: IWorkResult = {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n      }\n    }\n\n    // Call error handlers for all failed works (including silenced ones)\n    for (const result of results) {\n      if ('error' in result && result.error && result.work.onError) {\n        await result.work.onError(result.error, context);\n      }\n    }\n\n    // Throw the first non-silenced error to stop workflow\n    if (errors.length > 0) {\n      throw errors[0].error;\n    }\n  }\n}\n\n/**\n * Helper type to extract work results from parallel works array.\n * Since Work implements IWorkDefinition, we can use Extract directly.\n */\ntype ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}
+{"version":3,"sources":["../src/workflow.types.ts","../src/work.ts","../src/workflow.ts"],"sourcesContent":["/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Get a work result with compile-time type checking */\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;\n  /** Check if a work result exists */\n  has(name: string): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  silenceError?: boolean;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n\n/**\n * Interface for the Workflow class.\n * Defines all methods available on a workflow before sealing.\n */\nexport interface IWorkflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /**\n   * Add a serial work to the workflow\n   */\n  serial<TName extends string, TResult>(\n    work: IWorkDefinition<TName, TData, TResult, TWorkResults>\n  ): IWorkflow<TData, TWorkResults & { [K in TName]: TResult }>;\n\n  /**\n   * Add parallel works to the workflow\n   */\n\n  parallel(\n    works: readonly IWorkDefinition<string, TData, any, TWorkResults>[]\n  ): IWorkflow<TData, any>;\n\n  /**\n   * Seal the workflow to prevent further modifications\n   */\n  seal(): ISealedWorkflow<TData, TWorkResults>;\n  seal(\n    sealingWork: ISealingWorkDefinition<TData, TWorkResults>\n  ): ISealedWorkflowWithExecute<TData, TWorkResults>;\n\n  /**\n   * Check if the workflow is sealed\n   */\n  isSealed(): boolean;\n\n  /**\n   * Execute the workflow with initial data\n   */\n  run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n\n/**\n * A limited work definition for sealing a workflow.\n * Similar to IWorkDefinition but without 'name' (hardcoded as 'seal').\n * The execute function returns IWorkflowResult instead of a custom result type.\n */\nexport type ISealingWorkDefinition<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = Omit<\n  IWorkDefinition<'seal', TData, IWorkflowResult<TData, TWorkResults>, TWorkResults>,\n  'name'\n>;\n\n/**\n * A sealed workflow that can only be executed, not modified.\n * Use workflow.seal() to create a sealed workflow.\n */\nexport interface ISealedWorkflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /**\n   * Check if the workflow is sealed\n   */\n  isSealed(): boolean;\n\n  /**\n   * Execute the workflow with initial data\n   */\n  run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n\n/**\n * A sealed workflow with a custom execute function.\n * Created when seal() is called with an execute option.\n */\nexport interface ISealedWorkflowWithExecute<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> extends ISealedWorkflow<TData, TWorkResults> {\n  /**\n   * Hardcoded name for the sealed workflow\n   */\n  readonly name: 'seal';\n\n  /**\n   * Custom execute function provided during sealing.\n   * Receives context (like a Work).\n   */\n  execute(\n    context: IWorkflowContext<TData, TWorkResults>\n  ): Promise<IWorkflowResult<TData, TWorkResults>>;\n}\n\n/**\n * Options for configuring workflow behavior\n */\nexport interface WorkflowOptions {\n  /**\n   * Whether to stop execution immediately when a work fails.\n   * - true: Stop on first failure (default)\n   * - false: Continue executing remaining works, fail at the end if any work failed\n   * @default true\n   */\n  failFast?: boolean;\n}\n\n/**\n * Helper type to extract work results from parallel works array.\n * Since Work implements IWorkDefinition, we can use Extract directly.\n */\nexport type ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n","import { IWorkDefinition, IWorkflowContext } from './workflow.types';\n\n/**\n * A standalone Work unit that can be added to workflows.\n * Implements IWorkDefinition so it can be used anywhere a work definition is expected.\n *\n * @example\n * ```typescript\n * const fetchUser = new Work({\n *   name: 'fetchUser',\n *   execute: async (ctx) => {\n *     return { id: ctx.data.userId, name: 'John' };\n *   },\n * });\n *\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial(fetchUser)\n *   .parallel([work1, work2]);\n * ```\n */\nexport class Work<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  /** Unique name for the work */\n  readonly name: TName;\n\n  /** Execute function - receives context and returns result */\n  readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n\n  /** Optional: condition to determine if work should run */\n  readonly shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n\n  /** Optional: called when work fails */\n  readonly onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n\n  /** Optional: if true, errors won't stop the workflow (result will be undefined) */\n  readonly silenceError?: boolean;\n\n  constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>) {\n    this.name = definition.name;\n    this.execute = definition.execute;\n    this.shouldRun = definition.shouldRun;\n    this.onError = definition.onError;\n    this.silenceError = definition.silenceError;\n  }\n}\n\n/**\n * Type that accepts a work definition (either inline object or Work instance).\n * Since Work implements IWorkDefinition, this is simply IWorkDefinition.\n */\nexport type WorkInput<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;\n\n/**\n * Helper to get the work definition from a WorkInput.\n * Since Work implements IWorkDefinition, this simply returns the input.\n */\nexport function getWorkDefinition<\n  TName extends string,\n  TData,\n  TResult,\n  TAvailableWorkResults extends Record<string, unknown>,\n>(\n  input: WorkInput<TName, TData, TResult, TAvailableWorkResults>\n): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  return input;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n  IWorkflow,\n  ISealedWorkflow,\n  ISealingWorkDefinition,\n  ISealedWorkflowWithExecute,\n  WorkflowOptions,\n  ParallelWorksToRecord,\n} from './workflow.types';\nimport { WorkInput, getWorkDefinition } from './work';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, IWorkResult<unknown>>();\n\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]> {\n    const result = this.map.get(name);\n    if (!result) {\n      throw new Error(\n        `Work result \"${String(name)}\" not found. This work may not have executed yet.`\n      );\n    }\n    return result as IWorkResult<TWorkResults[K]>;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void {\n    this.map.set(name, value);\n  }\n\n  has<K extends keyof TWorkResults>(name: K): boolean {\n    return this.map.has(name);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> implements IWorkflow<TData, TWorkResults> {\n  private works: IWorkflowWork[] = [];\n  private options: Required<WorkflowOptions>;\n  private _sealed = false;\n\n  constructor(options: WorkflowOptions = {}) {\n    this.options = { failFast: true, ...options };\n  }\n\n  /**\n   * Check if the workflow is sealed\n   */\n  isSealed(): boolean {\n    return this._sealed;\n  }\n\n  /**\n   * Add a serial work to the workflow.\n   * Accepts either an inline work definition or a Work instance.\n   * The work name and result type are automatically inferred.\n   * @throws Error if the workflow is sealed\n   */\n  serial<TName extends string, TResult>(\n    work: WorkInput<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    if (this._sealed) {\n      throw new Error('Cannot add work to a sealed workflow');\n    }\n    this.works.push({\n      type: 'serial',\n      works: [getWorkDefinition(work)],\n    });\n    return this as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * Accepts an array of work definitions or Work instances.\n   * All work names and result types are automatically inferred.\n   * @throws Error if the workflow is sealed\n   *\n   * @example\n   * ```typescript\n   * workflow.parallel([\n   *   { name: 'work1', execute: async () => 'result1' },\n   *   { name: 'work2', execute: async () => 123 },\n   * ]);\n   * ```\n   */\n  parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(\n    works: TParallelWorks\n  ): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    if (this._sealed) {\n      throw new Error('Cannot add work to a sealed workflow');\n    }\n    this.works.push({\n      type: 'parallel',\n      works: works.map((w) => getWorkDefinition(w)),\n    });\n    return this as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Seal the workflow to prevent further modifications.\n   * Returns a SealedWorkflow that can only be executed with run().\n   *\n   * @example\n   * ```typescript\n   * // Without options - returns ISealedWorkflow\n   * const sealed = new Workflow<{ userId: string }>()\n   *   .serial({ name: 'step1', execute: async () => 'result' })\n   *   .seal();\n   *\n   * sealed.isSealed(); // true\n   * await sealed.run({ userId: '123' }); // OK\n   *\n   * // With sealing work - returns ISealedWorkflowWithExecute\n   * const sealedWithExecute = workflow.seal({\n   *   execute: async (ctx) => {\n   *     console.log('Before:', ctx.data);\n   *     const result = await workflow.run(ctx.data);\n   *     console.log('After');\n   *     return result;\n   *   },\n   *   // Optional: shouldRun, onError, silenceError (like IWorkDefinition)\n   * });\n   *\n   * sealedWithExecute.name; // 'seal'\n   * await sealedWithExecute.execute({ data: initialData, workResults: ... });\n   * ```\n   */\n  seal(): ISealedWorkflow<TData, TWorkResults>;\n  seal(\n    sealingWork: ISealingWorkDefinition<TData, TWorkResults>\n  ): ISealedWorkflowWithExecute<TData, TWorkResults>;\n  seal(\n    sealingWork?: ISealingWorkDefinition<TData, TWorkResults>\n  ): ISealedWorkflow<TData, TWorkResults> | ISealedWorkflowWithExecute<TData, TWorkResults> {\n    this._sealed = true;\n    if (sealingWork?.execute) {\n      return {\n        name: 'seal',\n        isSealed: () => this._sealed,\n        run: this.run.bind(this),\n        execute: sealingWork.execute,\n      };\n    }\n    return this;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n    const collectedErrors: Error[] = [];\n\n    try {\n      for (const workGroup of this.works) {\n        try {\n          if (workGroup.type === 'serial') {\n            await this.executeWork(workGroup.works[0], context, workResults);\n          } else {\n            await this.executeParallelWorks(workGroup.works, context, workResults);\n          }\n        } catch (error) {\n          const err = error instanceof Error ? error : new Error(String(error));\n          if (this.options.failFast) {\n            throw err;\n          }\n          collectedErrors.push(err);\n        }\n      }\n\n      // If failFast is false, check for collected errors\n      if (collectedErrors.length > 0) {\n        return {\n          status: WorkflowStatus.FAILED,\n          context,\n          workResults,\n          totalDuration: Date.now() - startTime,\n          error: collectedErrors[0],\n        };\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        const skippedResult: IWorkResult = {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n        workResults.set(work.name as keyof TWorkResults, skippedResult);\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      const workResult: IWorkResult = {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      };\n\n      // Store result in context for subsequent works\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, workResult as any);\n      workResults.set(work.name as keyof TWorkResults, workResult);\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      const failedResult: IWorkResult = {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, failedResult as any);\n      workResults.set(work.name as keyof TWorkResults, failedResult);\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution (unless silenceError is true)\n      if (!work.silenceError) {\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          const skippedResult: IWorkResult = {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          };\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n          workResults.set(work.name as keyof TWorkResults, skippedResult);\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        const workResult: IWorkResult = {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n        // Only track as error if silenceError is not set\n        if (!result.work.silenceError) {\n          errors.push({ work: result.work, error: result.error });\n        }\n      } else {\n        const workResult: IWorkResult = {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n      }\n    }\n\n    // Call error handlers for all failed works (including silenced ones)\n    for (const result of results) {\n      if ('error' in result && result.error && result.work.onError) {\n        await result.work.onError(result.error, context);\n      }\n    }\n\n    // Throw the first non-silenced error to stop workflow\n    if (errors.length > 0) {\n      throw errors[0].error;\n    }\n  }\n}\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yigitahmetsahin/workflow-ts",
-  "version": "3.3.0",
+  "version": "3.4.1",
   "description": "A simple, extensible TypeScript workflow engine supporting serial and parallel work execution with full type inference",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -21,10 +21,9 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src examples && tsc --noEmit",
-    "lint:fix": "eslint src examples --fix",
     "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "lint": "npm run format && eslint src examples --fix && tsc --noEmit",
+    "lint:check": "prettier --check . && eslint src examples && tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
   "keywords": [