@outputai/core 0.12.0 → 0.12.1-next.1243f78.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.12.0",
+  "version": "0.12.1-next.1243f78.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/helpers/function.js

@@ -1,19 +1,3 @@
-/**
- * Returns a function that invokes the fn argument only once when called, 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;
-  };
-};
-
 /**
  * Calls a given function and in case it throws errors, returns `undefined`
  * @param {Function} fn

package/src/helpers/function.spec.js

@@ -1,51 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { runOnce, tryOrUndefined } from './function.js';
-
-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();
-  } );
-} );
+import { tryOrUndefined } from './function.js';
 
 describe( 'tryOrUndefined', () => {
   it( 'returns the invoked function result', () => {

package/src/helpers/promise.js

@@ -1,29 +1,11 @@
-/**
- * Builds a promise that can be resolved from the outside.
- */
-export class CancellablePromise {
-  #promise = null;
-  #complete = null;
-  #completed = false;
+import { setTimeout as delay } from 'node:timers/promises';
 
-  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();
+export const sleepCancellable = async ( timeoutMs, signal ) => {
+  try {
+    await delay( timeoutMs, true, { ref: false, signal } );
+  } catch ( error ) {
+    if ( error?.name !== 'AbortError' ) {
+      throw error;
+    }
   }
 };

package/src/helpers/promise.spec.js

@@ -1,35 +1,62 @@
 import { describe, it, expect, vi } from 'vitest';
-import { CancellablePromise } from './promise.js';
+import { sleepCancellable } from './promise.js';
 
-describe( 'CancellablePromise', () => {
-  it( 'exposes a pending promise until it is completed', async () => {
-    const cancellable = new CancellablePromise();
-    const onComplete = vi.fn();
+// Long enough that a sleep reaching it means the abort was not honored and the test times out.
+const neverElapses = 60000;
+
+describe( 'sleepCancellable', () => {
+  it( 'resolves only once the timeout elapses', async () => {
+    const order = [];
+    const sleeping = sleepCancellable( 10 ).then( () => order.push( 'slept' ) );
 
-    cancellable.promise.then( onComplete );
     await Promise.resolve();
+    expect( order ).toEqual( [] );
+
+    await sleeping;
+    expect( order ).toEqual( [ 'slept' ] );
+  } );
 
-    expect( cancellable.completed ).toBe( false );
-    expect( onComplete ).not.toHaveBeenCalled();
+  it( 'resolves without a signal', async () => {
+    await expect( sleepCancellable( 10 ) ).resolves.toBeUndefined();
+  } );
 
-    cancellable.complete();
-    await cancellable.promise;
+  it( 'resolves immediately when the signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
 
-    expect( cancellable.completed ).toBe( true );
-    expect( onComplete ).toHaveBeenCalledOnce();
+    await expect( sleepCancellable( neverElapses, controller.signal ) ).resolves.toBeUndefined();
   } );
 
-  it( 'can be completed multiple times without resolving again', async () => {
-    const cancellable = new CancellablePromise();
-    const onComplete = vi.fn();
+  it( 'resolves as soon as the signal aborts mid sleep', async () => {
+    const controller = new AbortController();
+    const sleeping = sleepCancellable( neverElapses, controller.signal );
 
-    cancellable.promise.then( onComplete );
-    cancellable.complete();
-    cancellable.complete();
-    await cancellable.promise;
-    await Promise.resolve();
+    controller.abort();
+
+    await expect( sleeping ).resolves.toBeUndefined();
+  } );
+
+  it( 'swallows the abort reason instead of rejecting with it', async () => {
+    const controller = new AbortController();
+    const sleeping = sleepCancellable( neverElapses, controller.signal );
+
+    controller.abort( new Error( 'shutting down' ) );
+
+    await expect( sleeping ).resolves.toBeUndefined();
+  } );
+
+  it( 'rethrows a rejection that is not an abort', async () => {
+    const failure = new Error( 'timer failed' );
+    vi.doMock( 'node:timers/promises', () => ( { setTimeout: () => Promise.reject( failure ) } ) );
+    vi.resetModules();
+
+    try {
+      const { sleepCancellable: sleeping } = await import( './promise.js' );
 
-    expect( cancellable.completed ).toBe( true );
-    expect( onComplete ).toHaveBeenCalledOnce();
+      await expect( sleeping( 10 ) ).rejects.toBe( failure );
+    } finally {
+      vi.doUnmock( 'node:timers/promises' );
+      vi.resetModules();
+    }
   } );
 } );

package/src/worker/catalog_workflow/catalog_publisher.js

@@ -0,0 +1,149 @@
+import { Client, WorkflowNotFoundError } from '@temporalio/client';
+import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '@temporalio/common';
+import { WORKFLOW_CATALOG } from '#consts';
+import { catalogId as workflowId, taskQueue } from '../configs.js';
+import { createChildLogger } from '#logger';
+import { sleepCancellable } from '#helpers/promise';
+import { serializeError } from '#helpers/error_serializer';
+
+const log = createChildLogger( 'Catalog' );
+
+const MAX_RETRIES = 2;
+const RETRY_DELAY = 10_000;
+
+// The default 10s is not enough for a cold worker: the workflow bundle takes 7-8s to activate,
+// so the first workflow task can exceed it and get retried. Temporal caps this at 120s.
+const WORKFLOW_TASK_TIMEOUT = 30_000;
+
+/** Make sure the latest version of the catalog workflow is running. Stateful. */
+export class CatalogPublisher {
+  #connection = null;
+  #namespace = null;
+  #catalog = null;
+  #catalogHash = null;
+  #client = null;
+  #signal = null;
+
+  #abortCtrl = new AbortController();
+  #running = false;
+  #execution = null;
+
+  async #describe() {
+    log.info( 'Checking running catalog hash against worker hash...' );
+
+    try {
+      const description = await this.#client.workflow.getHandle( workflowId ).describe();
+      return description.closeTime ? null : {
+        runId: description.runId,
+        hash: description.memo?.hash
+      };
+    } catch ( error ) {
+      if ( !( error instanceof WorkflowNotFoundError ) ) {
+        log.warn( 'Ignoring error while describing catalog workflow', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
+      }
+      return null;
+    }
+  };
+
+  async #terminate( runId ) {
+    log.info( 'Terminating previous catalog workflow...' );
+
+    try {
+      const handle = await this.#client.workflow.getHandle( workflowId, runId );
+      await handle.terminate( `Systematic terminating. Superseded by catalog ${this.#catalogHash}` );
+    } catch ( error ) {
+      if ( !( error instanceof WorkflowNotFoundError ) ) {
+        log.warn( 'Ignoring error while terminating previous catalog workflow', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
+      }
+    }
+  };
+
+  async #start() {
+    log.info( 'Starting catalog workflow...' );
+
+    try {
+      await this.#client.workflow.start( WORKFLOW_CATALOG, {
+        taskQueue,
+        workflowId,
+        workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
+        workflowTaskTimeout: WORKFLOW_TASK_TIMEOUT,
+        args: [ this.#catalog ],
+        memo: {
+          workflowNames: this.#catalog.workflowNames,
+          hash: this.#catalogHash
+        }
+      } );
+      return true;
+    } catch ( error ) {
+      // if catalog exists and its hash is the same as the one from the worker, ignore the error
+      if ( error instanceof WorkflowExecutionAlreadyStartedError ) {
+        const description = await this.#describe();
+        if ( description && description.hash === this.#catalogHash ) {
+          return false;
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  /** Run the sequence to start the catalog */
+  async #execute( signal, retries = 0 ) {
+    if ( signal.aborted ) {
+      return;
+    }
+
+    try {
+      const description = await this.#describe();
+
+      if ( description ) {
+        if ( description.hash === this.#catalogHash ) {
+          log.info( 'Current catalog workflow hash matches worker, restart skipped' );
+          return;
+        }
+        await this.#terminate( description.runId );
+      }
+
+      const success = await this.#start();
+      log.info( success ? 'Catalog workflow started' : 'Found a catalog workflow with matching hashes, start skipped' );
+    } catch ( error ) {
+      if ( retries < MAX_RETRIES ) {
+        log.warn( 'Error while starting catalog workflow, retrying...', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
+        await sleepCancellable( RETRY_DELAY, signal );
+        await this.#execute( signal, retries + 1 );
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  constructor( { connection, namespace, catalog, catalogHash, signal } ) {
+    this.#connection = connection;
+    this.#namespace = namespace;
+    this.#catalog = catalog;
+    this.#catalogHash = catalogHash;
+    this.#signal = signal;
+    this.#client = new Client( { connection: this.#connection, namespace: this.#namespace } );
+  }
+
+  get running() {
+    return this.#running;
+  }
+
+  run() {
+    if ( this.#execution ) {
+      return this.#execution;
+    }
+
+    const signal = AbortSignal.any( [ this.#signal, this.#abortCtrl.signal ] );
+
+    this.#running = true;
+    this.#execution = this.#execute( signal ).finally( _ => this.#running = false );
+    return this.#execution;
+  }
+
+  interrupt() {
+    this.#abortCtrl.abort();
+    return this.#execution ?? Promise.resolve();
+  }
+};

package/src/worker/catalog_workflow/catalog_publisher.spec.js

@@ -0,0 +1,317 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { WorkflowNotFoundError } from '@temporalio/client';
+import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '@temporalio/common';
+import { CatalogPublisher } from './catalog_publisher.js';
+
+const {
+  catalogId,
+  describeMock,
+  getHandleMock,
+  mockLog,
+  serializeErrorMock,
+  sleepMock,
+  startMock,
+  taskQueue,
+  terminateMock
+} = vi.hoisted( () => ( {
+  catalogId: 'test-catalog',
+  describeMock: vi.fn(),
+  getHandleMock: vi.fn(),
+  mockLog: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+  serializeErrorMock: vi.fn( error => ( { message: error.message } ) ),
+  sleepMock: vi.fn(),
+  startMock: vi.fn(),
+  taskQueue: 'test-queue',
+  terminateMock: vi.fn()
+} ) );
+
+vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
+vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
+vi.mock( '#consts', () => ( { WORKFLOW_CATALOG: 'catalog' } ) );
+vi.mock( '#helpers/promise', () => ( { sleepCancellable: sleepMock } ) );
+vi.mock( '../configs.js', () => ( { catalogId, taskQueue } ) );
+vi.mock( '@temporalio/client', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    Client: vi.fn().mockImplementation( function () {
+      return { workflow: { start: startMock, getHandle: getHandleMock } };
+    } )
+  };
+} );
+
+const RETRY_DELAY = 10_000;
+const namespace = 'default';
+const catalogHash = 'catalog-hash';
+const catalog = { workflows: [], workflowNames: { workflow: 'workflow' }, activities: {} };
+
+const startArguments = {
+  taskQueue,
+  workflowId: catalogId,
+  workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
+  workflowTaskTimeout: 30_000,
+  args: [ catalog ],
+  memo: {
+    workflowNames: catalog.workflowNames,
+    hash: catalogHash
+  }
+};
+
+const compactError = message => ( { error: { message } } );
+
+const running = hash => ( { closeTime: undefined, runId: 'run-1', memo: { hash } } );
+const notFound = () => new WorkflowNotFoundError( 'not found' );
+const alreadyStarted = () => new WorkflowExecutionAlreadyStartedError( 'already started', catalogId, 'catalog' );
+
+const createPublisher = ( signal = new AbortController().signal ) =>
+  new CatalogPublisher( { connection: {}, namespace, catalog, catalogHash, signal } );
+
+const flushPromises = async () => Array
+  .from( { length: 10 } )
+  .reduce( promise => promise.then( () => Promise.resolve() ), Promise.resolve() );
+
+describe( 'CatalogPublisher', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    getHandleMock.mockReturnValue( { describe: describeMock, terminate: terminateMock } );
+    describeMock.mockRejectedValue( notFound() );
+    terminateMock.mockResolvedValue( undefined );
+    startMock.mockResolvedValue( undefined );
+    sleepMock.mockResolvedValue( undefined );
+  } );
+
+  describe( 'publish paths', () => {
+    it( 'starts the catalog when nothing is running', async () => {
+      const publisher = createPublisher();
+
+      await publisher.run();
+
+      expect( terminateMock ).not.toHaveBeenCalled();
+      expect( startMock ).toHaveBeenCalledWith( 'catalog', startArguments );
+      expect( mockLog.info ).toHaveBeenCalledWith( 'Catalog workflow started' );
+      expect( mockLog.warn ).not.toHaveBeenCalled();
+      expect( publisher.running ).toBe( false );
+    } );
+
+    it( 'starts the catalog when the previous one is closed', async () => {
+      describeMock.mockResolvedValue( { closeTime: '2024-01-01T00:00:00Z' } );
+
+      await createPublisher().run();
+
+      expect( terminateMock ).not.toHaveBeenCalled();
+      expect( startMock ).toHaveBeenCalledWith( 'catalog', startArguments );
+    } );
+
+    it( 'skips the restart when the running hash matches', async () => {
+      describeMock.mockResolvedValue( running( catalogHash ) );
+
+      await createPublisher().run();
+
+      expect( terminateMock ).not.toHaveBeenCalled();
+      expect( startMock ).not.toHaveBeenCalled();
+      expect( mockLog.info ).toHaveBeenCalledWith( 'Current catalog workflow hash matches worker, restart skipped' );
+    } );
+
+    it( 'terminates and starts when the running catalog carries no memo', async () => {
+      describeMock.mockResolvedValue( { closeTime: undefined, runId: 'run-1', memo: undefined } );
+
+      await createPublisher().run();
+
+      expect( mockLog.warn ).not.toHaveBeenCalled();
+      expect( terminateMock ).toHaveBeenCalledOnce();
+      expect( startMock ).toHaveBeenCalledWith( 'catalog', startArguments );
+    } );
+
+    it( 'terminates the pinned run then starts when the running hash differs', async () => {
+      describeMock.mockResolvedValue( running( 'old-hash' ) );
+
+      await createPublisher().run();
+
+      expect( getHandleMock ).toHaveBeenCalledWith( catalogId, 'run-1' );
+      expect( terminateMock ).toHaveBeenCalledWith( `Systematic terminating. Superseded by catalog ${catalogHash}` );
+      expect( startMock ).toHaveBeenCalledWith( 'catalog', startArguments );
+    } );
+  } );
+
+  describe( 'race paths', () => {
+    it( 'ignores an already started error when the published hash matches', async () => {
+      describeMock
+        .mockRejectedValueOnce( notFound() )
+        .mockResolvedValueOnce( running( catalogHash ) );
+      startMock.mockRejectedValue( alreadyStarted() );
+
+      await createPublisher().run();
+
+      expect( startMock ).toHaveBeenCalledOnce();
+      expect( terminateMock ).not.toHaveBeenCalled();
+      expect( mockLog.info ).toHaveBeenCalledWith( 'Found a catalog workflow with matching hashes, start skipped' );
+      expect( mockLog.info ).not.toHaveBeenCalledWith( 'Catalog workflow started' );
+    } );
+
+    it( 'retires the winner on retry when an already started error exposes a different hash', async () => {
+      describeMock
+        .mockRejectedValueOnce( notFound() )
+        .mockResolvedValue( running( 'other-hash' ) );
+      startMock
+        .mockRejectedValueOnce( alreadyStarted() )
+        .mockResolvedValue( undefined );
+
+      await createPublisher().run();
+
+      expect( sleepMock ).toHaveBeenCalledOnce();
+      expect( terminateMock ).toHaveBeenCalledOnce();
+      expect( startMock ).toHaveBeenCalledTimes( 2 );
+      expect( mockLog.warn ).toHaveBeenCalledWith(
+        'Error while starting catalog workflow, retrying...',
+        compactError( 'already started' )
+      );
+    } );
+
+    it( 'warns and attempts a start when describing fails', async () => {
+      const error = new Error( 'describe failed' );
+      describeMock.mockRejectedValue( error );
+
+      await createPublisher().run();
+
+      expect( serializeErrorMock ).toHaveBeenCalledWith( error, { dropKeys: [ 'stack' ] } );
+      expect( mockLog.warn ).toHaveBeenCalledWith(
+        'Ignoring error while describing catalog workflow',
+        compactError( 'describe failed' )
+      );
+      expect( startMock ).toHaveBeenCalledWith( 'catalog', startArguments );
+    } );
+
+    it( 'warns and still starts when terminating the previous catalog fails', async () => {
+      describeMock.mockResolvedValue( running( 'old-hash' ) );
+      terminateMock.mockRejectedValue( new Error( 'terminate failed' ) );
+
+      await createPublisher().run();
+
+      expect( mockLog.warn ).toHaveBeenCalledWith(
+        'Ignoring error while terminating previous catalog workflow',
+        compactError( 'terminate failed' )
+      );
+      expect( startMock ).toHaveBeenCalledWith( 'catalog', startArguments );
+    } );
+  } );
+
+  describe( 'failure', () => {
+    it( 'rejects with the original error after exhausting the retries', async () => {
+      const error = new Error( 'start failed' );
+      startMock.mockRejectedValue( error );
+      const publisher = createPublisher();
+
+      await expect( publisher.run() ).rejects.toBe( error );
+
+      expect( startMock ).toHaveBeenCalledTimes( 3 );
+      expect( sleepMock ).toHaveBeenCalledTimes( 2 );
+      expect( publisher.running ).toBe( false );
+    } );
+
+    it( 'waits the retry delay with the abort signal between attempts', async () => {
+      startMock.mockRejectedValue( new Error( 'start failed' ) );
+
+      await expect( createPublisher().run() ).rejects.toThrow( 'start failed' );
+
+      expect( sleepMock ).toHaveBeenCalledWith( RETRY_DELAY, expect.any( AbortSignal ) );
+    } );
+  } );
+
+  describe( 'abort paths', () => {
+    it( 'publishes nothing when already aborted', async () => {
+      const controller = new AbortController();
+      controller.abort();
+
+      await expect( createPublisher( controller.signal ).run() ).resolves.toBeUndefined();
+
+      expect( describeMock ).not.toHaveBeenCalled();
+      expect( startMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'stops retrying when the signal aborts during the backoff', async () => {
+      const controller = new AbortController();
+      startMock.mockRejectedValue( new Error( 'start failed' ) );
+      sleepMock.mockImplementation( async () => controller.abort() );
+
+      await expect( createPublisher( controller.signal ).run() ).resolves.toBeUndefined();
+
+      expect( startMock ).toHaveBeenCalledOnce();
+      expect( sleepMock ).toHaveBeenCalledOnce();
+    } );
+
+    it( 'stops retrying when interrupted during the backoff', async () => {
+      startMock.mockRejectedValue( new Error( 'start failed' ) );
+      const publisher = createPublisher();
+      sleepMock.mockImplementation( async () => {
+        publisher.interrupt();
+      } );
+
+      await expect( publisher.run() ).resolves.toBeUndefined();
+
+      expect( startMock ).toHaveBeenCalledOnce();
+    } );
+
+    it( 'still starts when the abort lands between terminating and starting', async () => {
+      const controller = new AbortController();
+      describeMock.mockResolvedValue( running( 'old-hash' ) );
+      terminateMock.mockImplementation( async () => controller.abort() );
+
+      await createPublisher( controller.signal ).run();
+
+      expect( terminateMock ).toHaveBeenCalledOnce();
+      expect( startMock ).toHaveBeenCalledWith( 'catalog', startArguments );
+    } );
+  } );
+
+  describe( 'lifecycle', () => {
+    it( 'reports running while the sequence is pending', async () => {
+      const deferred = {};
+      describeMock.mockReturnValue( new Promise( resolve => {
+        deferred.resolve = resolve;
+      } ) );
+      const publisher = createPublisher();
+
+      const run = publisher.run();
+      await flushPromises();
+
+      expect( publisher.running ).toBe( true );
+
+      deferred.resolve( running( catalogHash ) );
+      await run;
+
+      expect( publisher.running ).toBe( false );
+    } );
+
+    it( 'returns the same execution and publishes once when run more than once', async () => {
+      const publisher = createPublisher();
+
+      const first = publisher.run();
+      const second = publisher.run();
+
+      expect( second ).toBe( first );
+
+      await first;
+
+      expect( describeMock ).toHaveBeenCalledOnce();
+      expect( startMock ).toHaveBeenCalledOnce();
+    } );
+
+    it( 'resolves when interrupted before running', async () => {
+      const publisher = createPublisher();
+
+      await expect( publisher.interrupt() ).resolves.toBeUndefined();
+
+      expect( publisher.running ).toBe( false );
+      expect( describeMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'reports the failure when interrupting after a rejected run', async () => {
+      startMock.mockRejectedValue( new Error( 'start failed' ) );
+      const publisher = createPublisher();
+
+      await expect( publisher.run() ).rejects.toThrow( 'start failed' );
+
+      await expect( publisher.interrupt() ).rejects.toThrow( 'start failed' );
+    } );
+  } );
+} );

package/src/worker/configs.js

@@ -36,10 +36,10 @@ const envVarSchema = z.object( {
   OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 2 * 60 * 1000 ) ), // 2min
   // Whether to send activity heartbeats (enabled by default)
   OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
-  // Set temporal worker shutdown force time
-  TEMPORAL_SHUTDOWN_FORCE_TIME: durationSchema,
-  // Set temporal worker shutdown grace time
-  TEMPORAL_SHUTDOWN_GRACE_TIME: durationSchema,
+  // Set temporal worker shutdown force time, kept under the 30s most platforms allow before SIGKILL
+  TEMPORAL_SHUTDOWN_FORCE_TIME: durationSchema.default( '25s' ),
+  // Set temporal worker shutdown grace time, when in-flight activities are asked to cancel
+  TEMPORAL_SHUTDOWN_GRACE_TIME: durationSchema.default( '20s' ),
   // HTTP CONNECT proxy for Temporal gRPC connections (e.g. "proxy-host:8080").
   // Must be a bare host:port — no scheme (Temporal's native HTTP CONNECT
   // option is not a URL).