@outputai/core 0.7.0 → 0.7.1-next.0e958f3.0

package/src/interface/workflow_activity_options.js

@@ -0,0 +1,16 @@
+import { FatalError, ValidationError } from '#errors';
+
+export const defaultOptions = {
+  activityOptions: {
+    startToCloseTimeout: '20m',
+    heartbeatTimeout: '5m',
+    retry: {
+      initialInterval: '10s',
+      backoffCoefficient: 2.0,
+      maximumInterval: '2m',
+      maximumAttempts: 3,
+      nonRetryableErrorTypes: [ ValidationError.name, FatalError.name ]
+    }
+  },
+  disableTrace: false
+};

package/src/interface/workflow_utils.js

@@ -1,5 +1,5 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { validateExecuteInParallel } from './validations/static.js';
+import { validateExecuteInParallel } from './validations/index.js';
 
 /**
  * Execute jobs in parallel with optional concurrency limit.

package/src/interface/zod_integration.spec.js

@@ -495,7 +495,7 @@ describe( 'Zod Schema Integration Tests', () => {
         await errorStep( { age: 16, email: 'invalid' } );
         expect.fail( 'Should have thrown an error' );
       } catch ( error ) {
-        expect( error.message ).toContain( 'Step error_test input validation failed' );
+        expect( error.message ).toContain( 'Step "error_test" input validation failed' );
       }
     } );
 
@@ -527,7 +527,7 @@ describe( 'Zod Schema Integration Tests', () => {
       const metadata = testStep[METADATA_ACCESS_SYMBOL];
       expect( metadata.inputSchema ).toBe( zodSchema );
       expect( metadata.inputSchema ).not.toBe( null );
-      expect( metadata.inputSchema._def ).toBeDefined(); // Zod-specific property
+      expect( metadata.inputSchema._zod?.def ).toBeDefined(); // Zod v4-specific property
     } );
 
     it( 'should handle deeply nested Zod schemas', async () => {

package/src/internal_utils/aggregations.js

@@ -1,4 +1,3 @@
-import { deepMergeWithResolver } from '#utils';
 import { Attribute } from '#trace_attribute';
 import Decimal from 'decimal.js';
 
@@ -43,12 +42,3 @@ export const aggregateAttributes = attributes => ( {
     total: attributes.filter( a => Attribute.HTTPRequestCount.TYPE === a.type ).length
   }
 } );
-
-/**
- * Combine two or more aggregation objects into a single Aggregation, adding up the totals and merging keys.
- *
- * @param {Aggregation} aggregations
- * @returns {Aggregation}
- */
-export const mergeAggregations = ( ...aggregations ) =>
-  aggregations.reduce( ( final, item ) => deepMergeWithResolver( final, item, ( a, b ) => Decimal( a ?? 0 ).add( b ?? 0 ).toNumber() ), {} );

package/src/internal_utils/aggregations.spec.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { Attribute } from '#trace_attribute';
-import { aggregateAttributes, mergeAggregations } from './aggregations.js';
+import { aggregateAttributes } from './aggregations.js';
 
 describe( 'aggregateAttributes', () => {
   it( 'returns zeroed aggregations when there are no attributes', () => {
@@ -90,50 +90,3 @@ describe( 'aggregateAttributes', () => {
   } );
 } );
 
-describe( 'mergeAggregations', () => {
-  it( 'returns an empty object when no aggregations are provided', () => {
-    expect( mergeAggregations() ).toEqual( {} );
-  } );
-
-  it( 'sums nested aggregation values', () => {
-    expect( mergeAggregations(
-      {
-        cost: { total: 1.2 },
-        tokens: { total: 10, input: 6 },
-        httpRequests: { total: 2 }
-      },
-      {
-        cost: { total: 0.3 },
-        tokens: { total: 5, input: 2, output: 3 },
-        httpRequests: { total: 1 }
-      }
-    ) ).toEqual( {
-      cost: { total: 1.5 },
-      tokens: { total: 15, input: 8, output: 3 },
-      httpRequests: { total: 3 }
-    } );
-  } );
-
-  it( 'handles undefined or partial aggregation objects', () => {
-    expect( mergeAggregations(
-      undefined,
-      { cost: { total: 2 } },
-      { tokens: { total: 4, reasoning: 1 } },
-      { httpRequests: { total: 3 } }
-    ) ).toEqual( {
-      cost: { total: 2 },
-      tokens: { total: 4, reasoning: 1 },
-      httpRequests: { total: 3 }
-    } );
-  } );
-
-  it( 'does not mutate source aggregation objects', () => {
-    const first = { cost: { total: 1 }, tokens: { total: 2 }, httpRequests: { total: 3 } };
-    const second = { cost: { total: 4 }, tokens: { total: 5 }, httpRequests: { total: 6 } };
-
-    mergeAggregations( first, second );
-
-    expect( first ).toEqual( { cost: { total: 1 }, tokens: { total: 2 }, httpRequests: { total: 3 } } );
-    expect( second ).toEqual( { cost: { total: 4 }, tokens: { total: 5 }, httpRequests: { total: 6 } } );
-  } );
-} );

package/src/internal_utils/errors.js

@@ -1,10 +1,16 @@
+import { ApplicationFailure } from '@temporalio/common';
+
 /**
- * Extract a property from the error .details.
- * If error does not have details, navigate up the .cause chain.
- *
- * @param {Error} e
- * @param {string} key
- * @returns {any} The value of the property
+ * Builds a Temporal ApplicationFailure based on an error attaching info to its details
+ * @param {Error} error
+ * @param {unknown} info
+ * @returns {ApplicationFailure}
  */
-export const extractErrorDetail = ( e, key ) =>
-  e ? ( e.details?.find?.( d => d[key] )?.[key] ?? extractErrorDetail( e.cause, key ) ) : null;
+export const buildApplicationFailureWithDetails = ( error, info ) =>
+  ApplicationFailure.create( {
+    message: error.message,
+    type: error.type ?? error.constructor?.name ?? error.name,
+    nonRetryable: error.nonRetryable,
+    details: ( Array.isArray( error.details ) ? error.details : [] ).concat( info ),
+    cause: error
+  } );

package/src/internal_utils/errors.spec.js

@@ -1,43 +1,89 @@
 import { describe, expect, it } from 'vitest';
-import { extractErrorDetail } from './errors.js';
+import { ApplicationFailure } from '@temporalio/common';
+import { buildApplicationFailureWithDetails } from './errors.js';
 
-describe( 'extractErrorDetail', () => {
-  it( 'returns a matching value from error details', () => {
-    const error = new Error( 'failed' );
-    error.details = [
-      { requestId: 'req-1' },
-      { workflowId: 'workflow-1' }
-    ];
+class CustomFailure extends Error {}
 
-    expect( extractErrorDetail( error, 'workflowId' ) ).toBe( 'workflow-1' );
+describe( 'buildApplicationFailureWithDetails', () => {
+  it( 'wraps a regular error in an ApplicationFailure with appended details', () => {
+    const error = new Error( 'step failed' );
+    const info = { aggregations: { cost: { total: 1 } } };
+
+    const failure = buildApplicationFailureWithDetails( error, info );
+
+    expect( failure ).toBeInstanceOf( ApplicationFailure );
+    expect( failure ).toMatchObject( {
+      message: 'step failed',
+      type: 'Error',
+      nonRetryable: false,
+      details: [ info ],
+      cause: error
+    } );
   } );
 
-  it( 'walks the cause chain until it finds matching details', () => {
-    const root = new Error( 'root' );
-    root.details = [ { traceId: 'trace-1' } ];
-    const wrapped = new Error( 'wrapped', { cause: root } );
+  it( 'uses the original constructor name for custom errors', () => {
+    const error = new CustomFailure( 'custom failed' );
+    const info = { trace: { destinations: { local: '/tmp/trace' } } };
 
-    expect( extractErrorDetail( wrapped, 'traceId' ) ).toBe( 'trace-1' );
+    const failure = buildApplicationFailureWithDetails( error, info );
+
+    expect( failure ).toMatchObject( {
+      message: 'custom failed',
+      type: 'CustomFailure',
+      details: [ info ],
+      cause: error
+    } );
   } );
 
-  it( 'prefers details from the current error over causes', () => {
-    const root = new Error( 'root' );
-    root.details = [ { traceId: 'root-trace' } ];
-    const wrapped = new Error( 'wrapped', { cause: root } );
-    wrapped.details = [ { traceId: 'wrapped-trace' } ];
+  it( 'preserves existing details and appends new info without mutating the original error', () => {
+    const existingDetails = [ { domain: { reason: 'bad-input' } } ];
+    const error = new Error( 'step failed' );
+    error.details = existingDetails;
+    const info = { aggregations: { httpRequests: { total: 1 } } };
+
+    const failure = buildApplicationFailureWithDetails( error, info );
 
-    expect( extractErrorDetail( wrapped, 'traceId' ) ).toBe( 'wrapped-trace' );
+    expect( failure.details ).toEqual( [
+      { domain: { reason: 'bad-input' } },
+      info
+    ] );
+    expect( error.details ).toBe( existingDetails );
+    expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
   } );
 
-  it( 'returns null when the key is not found', () => {
-    const root = new Error( 'root' );
-    root.details = [ { traceId: 'trace-1' } ];
-    const wrapped = new Error( 'wrapped', { cause: root } );
+  it( 'ignores non-array details on the original error', () => {
+    const error = new Error( 'step failed' );
+    error.details = { domain: { reason: 'bad-input' } };
+    const info = { aggregations: { tokens: { total: 3 } } };
 
-    expect( extractErrorDetail( wrapped, 'missing' ) ).toBeNull();
+    const failure = buildApplicationFailureWithDetails( error, info );
+
+    expect( failure.details ).toEqual( [ info ] );
   } );
 
-  it( 'returns null for empty errors', () => {
-    expect( extractErrorDetail( null, 'traceId' ) ).toBeNull();
+  it( 'preserves ApplicationFailure type, nonRetryable flag, and details while avoiding self-cause', () => {
+    const original = ApplicationFailure.create( {
+      message: 'application failed',
+      type: 'DomainFailure',
+      nonRetryable: true,
+      details: [ { domain: { reason: 'bad-input' } } ]
+    } );
+    const info = { aggregations: { cost: { total: 2 } } };
+
+    const failure = buildApplicationFailureWithDetails( original, info );
+
+    expect( failure ).toBeInstanceOf( ApplicationFailure );
+    expect( failure ).not.toBe( original );
+    expect( failure.cause ).toBe( original );
+    expect( failure.cause ).not.toBe( failure );
+    expect( failure ).toMatchObject( {
+      message: 'application failed',
+      type: 'DomainFailure',
+      nonRetryable: true,
+      details: [
+        { domain: { reason: 'bad-input' } },
+        info
+      ]
+    } );
   } );
 } );

package/src/utils/index.d.ts

@@ -159,3 +159,22 @@ export function allSettledWithTimeout<T>(
   promises: Array<T | PromiseLike<T>>,
   timeoutMs: number
 ): Promise<PromiseSettledResult<Awaited<T>>[]>;
+
+/**
+ * Promise wrapper that can be resolved externally.
+ */
+export class CancellablePromise {
+  /** The internal promise */
+  readonly promise: Promise<void>;
+  /** Whether the promise is already resolved or not */
+  readonly completed: boolean;
+  /** Resolves the promise */
+  complete(): void;
+}
+
+/**
+ * Returns a function that invokes the wrapped function once.
+ */
+export function runOnce<Args extends unknown[], Return>(
+  fn: ( ...args: Args ) => Return
+): ( ...args: Args ) => Return;

package/src/utils/utils.js

@@ -279,3 +279,49 @@ export const allSettledWithTimeout = ( () => {
     }
   };
 } )();
+
+/**
+ * Builds a promise that can be resolved from the outside.
+ */
+export class CancellablePromise {
+  #promise = null;
+  #complete = null;
+  #completed = false;
+
+  constructor() {
+    this.#promise = new Promise( resolve => {
+      this.#complete = () => {
+        resolve();
+        this.#completed = true;
+      };
+    } );
+  }
+  /** Retrieves the promise */
+  get promise() {
+    return this.#promise;
+  }
+  /** Returns whether the promise is resolved or not */
+  get completed() {
+    return this.#completed;
+  }
+  /** Resolves the promise */
+  complete() {
+    this.#complete();
+  }
+};
+
+/**
+ * Returns a function that invokes the fn argument when called once, further calls do nothing.
+ * @param {Function} fn
+ * @returns {Function}
+ */
+export const runOnce = fn => {
+  const state = { executed: false, result: undefined };
+  return ( ...args ) => {
+    if ( !state.executed ) {
+      state.executed = true;
+      return state.result = fn( ...args );
+    }
+    return state.result;
+  };
+};

package/src/utils/utils.spec.js

@@ -8,7 +8,9 @@ import {
   deepMergeWithResolver,
   isPlainObject,
   toUrlSafeBase64,
-  allSettledWithTimeout
+  allSettledWithTimeout,
+  CancellablePromise,
+  runOnce
 } from './utils.js';
 
 describe( 'clone', () => {
@@ -142,6 +144,85 @@ describe( 'allSettledWithTimeout', () => {
   } );
 } );
 
+describe( 'CancellablePromise', () => {
+  it( 'exposes a pending promise until it is completed', async () => {
+    const cancellable = new CancellablePromise();
+    const onComplete = vi.fn();
+
+    cancellable.promise.then( onComplete );
+    await Promise.resolve();
+
+    expect( cancellable.completed ).toBe( false );
+    expect( onComplete ).not.toHaveBeenCalled();
+
+    cancellable.complete();
+    await cancellable.promise;
+
+    expect( cancellable.completed ).toBe( true );
+    expect( onComplete ).toHaveBeenCalledOnce();
+  } );
+
+  it( 'can be completed multiple times without resolving again', async () => {
+    const cancellable = new CancellablePromise();
+    const onComplete = vi.fn();
+
+    cancellable.promise.then( onComplete );
+    cancellable.complete();
+    cancellable.complete();
+    await cancellable.promise;
+    await Promise.resolve();
+
+    expect( cancellable.completed ).toBe( true );
+    expect( onComplete ).toHaveBeenCalledOnce();
+  } );
+} );
+
+describe( 'runOnce', () => {
+  it( 'calls the wrapped function only once', () => {
+    const fn = vi.fn();
+    const once = runOnce( fn );
+
+    once();
+    once();
+    once();
+
+    expect( fn ).toHaveBeenCalledOnce();
+  } );
+
+  it( 'passes arguments and replays the first call result', () => {
+    const fn = vi.fn( ( a, b ) => a + b );
+    const once = runOnce( fn );
+
+    expect( once( 2, 3 ) ).toBe( 5 );
+    expect( once( 4, 5 ) ).toBe( 5 );
+    expect( once( 6, 7 ) ).toBe( 5 );
+    expect( fn ).toHaveBeenCalledWith( 2, 3 );
+    expect( fn ).toHaveBeenCalledOnce();
+  } );
+
+  it( 'replays the first returned promise', () => {
+    const result = Promise.resolve( 'done' );
+    const fn = vi.fn( () => result );
+    const once = runOnce( fn );
+
+    expect( once() ).toBe( result );
+    expect( once() ).toBe( result );
+    expect( fn ).toHaveBeenCalledOnce();
+  } );
+
+  it( 'does not retry when the first call throws', () => {
+    const error = new Error( 'boom' );
+    const fn = vi.fn( () => {
+      throw error;
+    } );
+    const once = runOnce( fn );
+
+    expect( () => once() ).toThrow( error );
+    expect( once() ).toBeUndefined();
+    expect( fn ).toHaveBeenCalledOnce();
+  } );
+} );
+
 describe( 'serializeFetchResponse', () => {
   it( 'serializes JSON response body and flattens headers', async () => {
     const payload = { a: 1, b: 'two' };

package/src/worker/bundle.js

@@ -0,0 +1,26 @@
+import { bundleWorkflowCode } from '@temporalio/worker';
+import { loadWorkflows, loadActivities, createWorkflowsEntryPoint } from './loader.js';
+import { webpackConfigHook } from './bundler_options.js';
+import { workflowInterceptorModules } from './interceptors/modules.js';
+
+/**
+ * Bundle a project's workflows exactly as the worker does, without a Temporal server.
+ *
+ * Mirrors the worker's startup prep (`loadWorkflows` -> `loadActivities` ->
+ * `createWorkflowsEntryPoint`) and then runs the same bundler (`bundleWorkflowCode`)
+ * with the same inputs `Worker.create` derives — `webpackConfigHook` and
+ * `workflowInterceptorModules` — so it stays in parity with worker startup. Rejects if
+ * the Temporal webpack bundler fails, e.g. a `node:` built-in in the workflow's
+ * transitive import graph.
+ *
+ * @param {string} rootDir directory to discover workflows in
+ * @returns {Promise<import('@temporalio/worker').WorkflowBundleWithSourceMap>}
+ */
+export async function bundleWorkflows( rootDir ) {
+  const workflows = await loadWorkflows( rootDir );
+  // Writes worker/temp/__activity_options.js, which the workflow interceptor module
+  // imports — the worker generates it via loadActivities() before Worker.create bundles.
+  await loadActivities( rootDir, workflows );
+  const workflowsPath = createWorkflowsEntryPoint( workflows );
+  return bundleWorkflowCode( { workflowsPath, workflowInterceptorModules, webpackConfigHook } );
+}

package/src/worker/bundle.spec.js

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Stub the activity interceptor so the real interceptors/index.js imports cleanly.
+vi.mock( './interceptors/activity.js', () => ( { ActivityExecutionInterceptor: class {} } ) );
+
+vi.mock( '@temporalio/worker', () => ( {
+  bundleWorkflowCode: vi.fn().mockResolvedValue( { code: '', sourceMap: '' } )
+} ) );
+
+vi.mock( './loader.js', () => ( {
+  loadWorkflows: vi.fn().mockResolvedValue( [] ),
+  loadActivities: vi.fn().mockResolvedValue( {} ),
+  createWorkflowsEntryPoint: vi.fn().mockReturnValue( '/fake/workflows/entrypoint.js' )
+} ) );
+
+vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
+
+import { bundleWorkflowCode } from '@temporalio/worker';
+import { loadWorkflows, loadActivities, createWorkflowsEntryPoint } from './loader.js';
+import { webpackConfigHook } from './bundler_options.js';
+import { initInterceptors } from './interceptors/index.js';
+import { workflowInterceptorModules } from './interceptors/modules.js';
+import { bundleWorkflows } from './bundle.js';
+
+describe( 'output-worker --check parity', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    loadWorkflows.mockResolvedValue( [] );
+    loadActivities.mockResolvedValue( {} );
+    createWorkflowsEntryPoint.mockReturnValue( '/fake/workflows/entrypoint.js' );
+    bundleWorkflowCode.mockResolvedValue( { code: '', sourceMap: '' } );
+  } );
+
+  it( 'worker registers the shared workflow interceptor modules', () => {
+    const { workflowModules } = initInterceptors( { activities: {}, workflows: [], connection: {} } );
+    // The check (bundleWorkflows) and the worker must register the very same modules.
+    expect( workflowModules ).toBe( workflowInterceptorModules );
+  } );
+
+  it( 'check bundles with the same inputs Worker.create derives', async () => {
+    await bundleWorkflows( '/project' );
+
+    expect( loadWorkflows ).toHaveBeenCalledWith( '/project' );
+    expect( loadActivities ).toHaveBeenCalledWith( '/project', [] );
+    expect( createWorkflowsEntryPoint ).toHaveBeenCalledWith( [] );
+    expect( bundleWorkflowCode ).toHaveBeenCalledWith( {
+      workflowsPath: '/fake/workflows/entrypoint.js',
+      workflowInterceptorModules,
+      webpackConfigHook
+    } );
+  } );
+} );

package/src/worker/catalog_workflow/catalog_job.js

@@ -0,0 +1,148 @@
+import { Client, WorkflowNotFoundError } from '@temporalio/client';
+import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '@temporalio/common';
+import { WORKFLOW_CATALOG } from '#consts';
+import { catalogId, taskQueue } from '../configs.js';
+import { createChildLogger } from '#logger';
+import { CancellablePromise } from '#utils';
+
+const log = createChildLogger( 'Catalog' );
+
+class CancellationError extends Error {};
+
+// Note, functions don't log on "WorkflowNotFound" errors,
+// because they happen when the catalog is not running at all.
+
+/** Make sure the latest version of the catalog workflow is running. Stateful. */
+export class CatalogJob {
+  #cancellation = new CancellablePromise();
+  #connection = null;
+  #namespace = null;
+  #catalog = null;
+  #catalogHash = null;
+
+  #running = false;
+  #executePromise = null;
+  #onErrorCb = null;
+  #error = null;
+
+  #runCancellable = promise => Promise
+    .race( [ promise, this.#cancellation.promise.then( () => {
+      throw new CancellationError();
+    } ) ] );
+
+  /** Check if the currently running catalog has the same hash as instance. */
+  async #checkCatalogIsTheSame( handle ) {
+    log.info( 'Checking running catalog hash against worker hash...' );
+    return this.#runCancellable( handle.query( 'get_hash' ) ).then( h => h === this.#catalogHash ).catch( e => {
+      if ( e instanceof CancellationError ) {
+        throw e;
+      }
+      if ( !( e instanceof WorkflowNotFoundError ) ) {
+        log.warn( 'Error retrieving catalog hash', { error: e } );
+      }
+      return false;
+    } );
+  };
+
+  /**  Check if the catalog workflow is running. */
+  async #checkCatalogRunning( handle ) {
+    log.info( 'Checking if the catalog workflow is running...' );
+    return this.#runCancellable( handle.describe() ).then( d => !d.closeTime ).catch( e => {
+      if ( e instanceof CancellationError ) {
+        throw e;
+      }
+      if ( !( e instanceof WorkflowNotFoundError ) ) {
+        log.warn( 'Error describing catalog workflow', { error: e } );
+      }
+      return false;
+    } );
+  };
+
+  /** Complete previous running catalog workflow. */
+  async #completePreviousCatalog( handle ) {
+    log.info( 'Completing previous catalog workflow...' );
+    return this.#runCancellable( handle.executeUpdate( 'complete', { args: [] } ) ).catch( e => {
+      if ( e instanceof CancellationError ) {
+        throw e;
+      }
+      if ( !( e instanceof WorkflowNotFoundError ) ) {
+        log.warn( 'Error completing previous catalog workflow', { error: e } );
+      }
+    } );
+  };
+
+  /** Run the sequence to start the catalog */
+  async #execute() {
+    const client = new Client( { connection: this.#connection, namespace: this.#namespace } );
+    const handle = client.workflow.getHandle( catalogId );
+
+    if ( await this.#checkCatalogRunning( handle ) ) {
+      if ( await this.#checkCatalogIsTheSame( handle ) ) {
+        log.info( 'Current catalog workflow hash matches worker, restart skipped' );
+        return;
+      }
+      await this.#completePreviousCatalog( handle );
+    }
+
+    const startArguments = {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
+      args: [ this.#catalog, this.#catalogHash ]
+    };
+
+    log.info( 'Starting catalog workflow...' );
+    try {
+      await this.#runCancellable( client.workflow.start( WORKFLOW_CATALOG, startArguments ) );
+    } catch ( error ) {
+      // if the error was caused by the catalog existing and its hash is the same as the one from the worker, just ignore the error
+      if ( error instanceof WorkflowExecutionAlreadyStartedError && await this.#checkCatalogIsTheSame( handle ) ) {
+        log.info( 'Ignoring start error: it failed because execution already started but catalog hash matches worker' );
+      } else {
+        throw error;
+      }
+    }
+    log.info( 'Startup completed' );
+  }
+
+  constructor( { connection, namespace, catalog, catalogHash } ) {
+    this.#connection = connection;
+    this.#namespace = namespace;
+    this.#catalog = catalog;
+    this.#catalogHash = catalogHash;
+  }
+
+  onError( cb ) {
+    this.#onErrorCb = cb;
+  }
+
+  get running() {
+    return this.#running;
+  }
+
+  interrupt() {
+    if ( this.#running ) {
+      this.#cancellation.complete();
+    }
+    return this.#executePromise ?? Promise.resolve();
+  }
+
+  get error() {
+    return this.#error;
+  }
+
+  async run() {
+    this.#running = true;
+    this.#executePromise = this.#execute()
+      .catch( error => {
+        if ( !( error instanceof CancellationError ) ) {
+          this.#error = error;
+          this.#onErrorCb?.( error );
+        }
+      } )
+      .finally( () => {
+        this.#running = false;
+      } );
+    return this.#executePromise;
+  }
+};