@outputai/core 0.14.0 → 0.14.1-next.1ec4416.0

package/src/worker/configs.spec.js

@@ -1,213 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const CONFIG_KEYS = [
-  'OUTPUT_CATALOG_ID',
-  'TEMPORAL_ADDRESS',
-  'TEMPORAL_API_KEY',
-  'TEMPORAL_NAMESPACE',
-  'TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS',
-  'TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTIONS',
-  'TEMPORAL_MAX_CACHED_WORKFLOWS',
-  'TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS',
-  'TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS',
-  'TEMPORAL_WORKER_TUNER',
-  'OUTPUT_WORKER_TELEMETRY_INTERVAL_MS',
-  'OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS',
-  'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED',
-  'TEMPORAL_SHUTDOWN_FORCE_TIME',
-  'TEMPORAL_SHUTDOWN_GRACE_TIME',
-  'OUTPUT_HOOK_FLUSH_TIMEOUT_MS'
-];
-
-const setEnv = ( overrides = {} ) => {
-  process.env.OUTPUT_CATALOG_ID = overrides.OUTPUT_CATALOG_ID ?? 'test-catalog';
-  CONFIG_KEYS.forEach( key => {
-    if ( overrides[key] !== undefined ) {
-      process.env[key] = String( overrides[key] );
-    }
-  } );
-};
-
-const clearEnv = () => {
-  CONFIG_KEYS.forEach( key => delete process.env[key] );
-};
-
-async function loadConfigs() {
-  vi.resetModules();
-  return import( './configs.js' );
-}
-
-describe( 'worker/configs', () => {
-  beforeEach( () => clearEnv() );
-  afterEach( () => clearEnv() );
-
-  it( 'throws when OUTPUT_CATALOG_ID is missing', async () => {
-    clearEnv();
-    vi.resetModules();
-
-    await expect( import( './configs.js' ) ).rejects.toThrow();
-  } );
-
-  it( 'throws when OUTPUT_CATALOG_ID does not match regex', async () => {
-    setEnv( { OUTPUT_CATALOG_ID: 'invalid space' } );
-    vi.resetModules();
-
-    await expect( import( './configs.js' ) ).rejects.toThrow();
-  } );
-
-  it( 'uses defaults when only OUTPUT_CATALOG_ID is set', async () => {
-    setEnv();
-    const configs = await loadConfigs();
-
-    expect( configs.address ).toBe( 'localhost:7233' );
-    expect( configs.namespace ).toBe( 'default' );
-    expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 40 );
-    expect( configs.maxConcurrentWorkflowTaskExecutions ).toBe( 200 );
-    expect( configs.maxCachedWorkflows ).toBe( 1000 );
-    expect( configs.maxConcurrentActivityTaskPolls ).toBe( 5 );
-    expect( configs.maxConcurrentWorkflowTaskPolls ).toBe( 5 );
-    expect( configs.workerTuner ).toBeUndefined();
-    expect( configs.workerTelemetryIntervalMs ).toBe( 0 );
-    expect( configs.activityHeartbeatIntervalMs ).toBe( 2 * 60 * 1000 );
-    expect( configs.activityHeartbeatEnabled ).toBe( true );
-    expect( configs.shutdownForceTime ).toBe( '20s' );
-    expect( configs.shutdownGraceTime ).toBe( '15s' );
-    expect( configs.hookFlushTimeoutMs ).toBe( 5000 );
-    expect( configs.taskQueue ).toBe( 'test-catalog' );
-    expect( configs.catalogId ).toBe( 'test-catalog' );
-  } );
-
-  it( 'treats empty string for optional number as default (preprocess)', async () => {
-    setEnv( { TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '' } );
-    const configs = await loadConfigs();
-
-    expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 40 );
-  } );
-
-  it( 'treats empty string for worker telemetry interval as default', async () => {
-    setEnv( { OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '' } );
-    const configs = await loadConfigs();
-
-    expect( configs.workerTelemetryIntervalMs ).toBe( 0 );
-  } );
-
-  it( 'parses Temporal worker tuner JSON', async () => {
-    const workerTuner = {
-      tunerOptions: {
-        targetMemoryUsage: 0.8,
-        targetCpuUsage: 0.9
-      },
-      activityTaskSlotOptions: {
-        minimumSlots: 1,
-        maximumSlots: 100,
-        rampThrottle: '50ms'
-      }
-    };
-
-    setEnv( { TEMPORAL_WORKER_TUNER: JSON.stringify( workerTuner ) } );
-    const configs = await loadConfigs();
-
-    expect( configs.workerTuner ).toEqual( workerTuner );
-  } );
-
-  it( 'parses custom numeric env vars', async () => {
-    setEnv( {
-      TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '10',
-      TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTIONS: '50',
-      TEMPORAL_MAX_CACHED_WORKFLOWS: '500',
-      OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '30000',
-      OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: '60000'
-    } );
-    const configs = await loadConfigs();
-
-    expect( configs.maxConcurrentActivityTaskExecutions ).toBe( 10 );
-    expect( configs.maxConcurrentWorkflowTaskExecutions ).toBe( 50 );
-    expect( configs.maxCachedWorkflows ).toBe( 500 );
-    expect( configs.workerTelemetryIntervalMs ).toBe( 30000 );
-    expect( configs.activityHeartbeatIntervalMs ).toBe( 60000 );
-  } );
-
-  it( 'parses Temporal shutdown durations', async () => {
-    setEnv( {
-      TEMPORAL_SHUTDOWN_FORCE_TIME: '15000',
-      TEMPORAL_SHUTDOWN_GRACE_TIME: '15s'
-    } );
-    const configs = await loadConfigs();
-
-    expect( configs.shutdownForceTime ).toBe( '15000' );
-    expect( configs.shutdownGraceTime ).toBe( '15s' );
-  } );
-
-  it( 'falls back to the defaults when Temporal shutdown durations are empty', async () => {
-    setEnv( {
-      TEMPORAL_SHUTDOWN_FORCE_TIME: '',
-      TEMPORAL_SHUTDOWN_GRACE_TIME: '',
-      OUTPUT_HOOK_FLUSH_TIMEOUT_MS: ''
-    } );
-    const configs = await loadConfigs();
-
-    expect( configs.shutdownForceTime ).toBe( '20s' );
-    expect( configs.shutdownGraceTime ).toBe( '15s' );
-    expect( configs.hookFlushTimeoutMs ).toBe( 5000 );
-  } );
-
-  it( 'throws when Temporal shutdown durations are invalid', async () => {
-    setEnv( { TEMPORAL_SHUTDOWN_FORCE_TIME: 'soon' } );
-    vi.resetModules();
-
-    await expect( import( './configs.js' ) ).rejects.toThrow();
-  } );
-
-  it( 'allows zero for worker telemetry interval', async () => {
-    setEnv( { OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '0' } );
-    const configs = await loadConfigs();
-
-    expect( configs.workerTelemetryIntervalMs ).toBe( 0 );
-  } );
-
-  it( 'throws when worker telemetry interval is negative', async () => {
-    setEnv( { OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '-1' } );
-    vi.resetModules();
-
-    await expect( import( './configs.js' ) ).rejects.toThrow();
-  } );
-
-  it( 'throws when optional number is zero or negative', async () => {
-    setEnv( { TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_EXECUTIONS: '0' } );
-    vi.resetModules();
-
-    await expect( import( './configs.js' ) ).rejects.toThrow();
-  } );
-
-  it( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: "true"|"1"|"on" → true', async () => {
-    for ( const val of [ 'true', '1', 'on' ] ) {
-      setEnv( { OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: val } );
-      const configs = await loadConfigs();
-      expect( configs.activityHeartbeatEnabled ).toBe( true );
-      clearEnv();
-    }
-  } );
-
-  it( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: "false"|other → false, undefined → true', async () => {
-    setEnv( { OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: 'false' } );
-    const configsFalse = await loadConfigs();
-    expect( configsFalse.activityHeartbeatEnabled ).toBe( false );
-
-    setEnv( { OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: '0' } );
-    const configsZero = await loadConfigs();
-    expect( configsZero.activityHeartbeatEnabled ).toBe( false );
-
-    clearEnv();
-    setEnv(); // only OUTPUT_CATALOG_ID; OUTPUT_ACTIVITY_HEARTBEAT_ENABLED absent → default true
-    const configsDefault = await loadConfigs();
-    expect( configsDefault.activityHeartbeatEnabled ).toBe( true );
-  } );
-
-  it( 'parses TEMPORAL_ADDRESS and TEMPORAL_NAMESPACE', async () => {
-    setEnv( { TEMPORAL_ADDRESS: 'temporal:7233', TEMPORAL_NAMESPACE: 'my-ns' } );
-    const configs = await loadConfigs();
-
-    expect( configs.address ).toBe( 'temporal:7233' );
-    expect( configs.namespace ).toBe( 'my-ns' );
-  } );
-} );

package/src/worker/configs_tuner_schema.spec.js

@@ -1,127 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { workerTunerEnvSchema } from './configs_tuner_schema.js';
-
-const parseWorkerTuner = value => workerTunerEnvSchema.parse( value );
-
-describe( 'worker/configs_tuner_schema', () => {
-  it( 'treats empty string as unset', () => {
-    expect( parseWorkerTuner( '' ) ).toBeUndefined();
-  } );
-
-  it( 'parses resource-based Temporal worker tuner JSON', () => {
-    const workerTuner = {
-      tunerOptions: {
-        targetMemoryUsage: 0.8,
-        targetCpuUsage: 0.9
-      },
-      activityTaskSlotOptions: {
-        minimumSlots: 1,
-        maximumSlots: 100,
-        rampThrottle: '50ms'
-      }
-    };
-
-    expect( parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toEqual( workerTuner );
-  } );
-
-  it( 'parses per-task Temporal worker tuner JSON', () => {
-    const resourceBasedSupplier = {
-      type: 'resource-based',
-      tunerOptions: {
-        targetMemoryUsage: 0.8,
-        targetCpuUsage: 0.9
-      },
-      minimumSlots: 1,
-      maximumSlots: 100,
-      rampThrottle: '50ms'
-    };
-    const workerTuner = {
-      workflowTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      },
-      activityTaskSlotSupplier: resourceBasedSupplier,
-      localActivityTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      },
-      nexusTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      }
-    };
-
-    expect( parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toEqual( workerTuner );
-  } );
-
-  it( 'throws when tuner is not valid JSON', () => {
-    expect( () => parseWorkerTuner( '{invalid' ) ).toThrow();
-  } );
-
-  it( 'throws when tuner is not a JSON object', () => {
-    expect( () => parseWorkerTuner( '[]' ) ).toThrow();
-  } );
-
-  it( 'throws when tuner is missing required per-task suppliers', () => {
-    const workerTuner = {
-      workflowTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      },
-      activityTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      }
-    };
-
-    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
-  } );
-
-  it( 'throws when tuner uses custom suppliers', () => {
-    const workerTuner = {
-      workflowTaskSlotSupplier: {
-        type: 'custom'
-      },
-      activityTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      },
-      localActivityTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      },
-      nexusTaskSlotSupplier: {
-        type: 'fixed-size',
-        numSlots: 10
-      }
-    };
-
-    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
-  } );
-
-  it( 'throws when target usage is outside range', () => {
-    const workerTuner = {
-      tunerOptions: {
-        targetMemoryUsage: 1.5,
-        targetCpuUsage: 0.9
-      }
-    };
-
-    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
-  } );
-
-  it( 'throws when minimum slots exceeds maximum slots', () => {
-    const workerTuner = {
-      tunerOptions: {
-        targetMemoryUsage: 0.8,
-        targetCpuUsage: 0.9
-      },
-      activityTaskSlotOptions: {
-        minimumSlots: 10,
-        maximumSlots: 5
-      }
-    };
-
-    expect( () => parseWorkerTuner( JSON.stringify( workerTuner ) ) ).toThrow();
-  } );
-} );

package/src/worker/connection_monitor.spec.js

@@ -1,328 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { ConnectionLostError, TemporalConnectionMonitor } from './connection_monitor.js';
-
-const CHECK_TIMEOUT_MS = 50;
-const CHECK_INTERVAL_MS = 100;
-
-const { scheduledDelays, delayMock, mockLog } = vi.hoisted( () => {
-  const scheduledDelays = [];
-  const abortError = () => Object.assign( new Error( 'The operation was aborted' ), { name: 'AbortError' } );
-
-  // Mirrors node:timers/promises: rejects with an AbortError when the signal aborts, or if already aborted.
-  const delayMock = vi.fn( ( ms, value, options ) => new Promise( ( resolve, reject ) => {
-    const signal = options?.signal;
-
-    if ( signal?.aborted ) {
-      reject( abortError() );
-      return;
-    }
-
-    scheduledDelays.push( { ms, value, options, resolve } );
-    signal?.addEventListener( 'abort', () => reject( abortError() ), { once: true } );
-  } ) );
-
-  return {
-    scheduledDelays,
-    delayMock,
-    mockLog: { info: vi.fn(), warn: vi.fn(), error: vi.fn() }
-  };
-} );
-
-vi.mock( 'node:timers/promises', () => ( { setTimeout: delayMock } ) );
-vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
-
-const delayOptions = { ref: false, signal: expect.any( AbortSignal ) };
-
-const createMonitor = ( check, overrides = {}, signal = new AbortController().signal ) =>
-  new TemporalConnectionMonitor( {
-    connection: { workflowService: { getSystemInfo: check } },
-    signal,
-    overrides: { checkIntervalMs: CHECK_INTERVAL_MS, checkTimeoutMs: CHECK_TIMEOUT_MS, ...overrides }
-  } );
-
-const flushPromises = async () => Array
-  .from( { length: 10 } )
-  .reduce( promise => promise.then( () => Promise.resolve() ), Promise.resolve() );
-
-const resolveNextDelay = ms => {
-  const index = scheduledDelays.findIndex( scheduled => scheduled.ms === ms );
-  expect( index ).not.toBe( -1 );
-  const [ scheduled ] = scheduledDelays.splice( index, 1 );
-  scheduled.resolve( scheduled.value );
-};
-
-describe( 'TemporalConnectionMonitor', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    scheduledDelays.length = 0;
-  } );
-
-  describe( 'health checks', () => {
-    it( 'logs healthy and schedules the next check when the workflow service is reachable', async () => {
-      const check = vi.fn().mockResolvedValue( {} );
-      const monitor = createMonitor( check );
-
-      const run = monitor.start();
-      await flushPromises();
-
-      expect( check ).toHaveBeenCalledWith( {} );
-      expect( mockLog.info ).toHaveBeenCalledWith( 'Healthy' );
-      expect( delayMock ).toHaveBeenCalledWith( CHECK_TIMEOUT_MS, 0, delayOptions );
-      expect( delayMock ).toHaveBeenCalledWith( CHECK_INTERVAL_MS, true, delayOptions );
-      expect( monitor.running ).toBe( true );
-
-      await monitor.stop();
-      await run;
-
-      expect( monitor.running ).toBe( false );
-    } );
-
-    it( 'counts a timed out check as a transient failure', async () => {
-      const check = vi.fn().mockReturnValue( new Promise( () => {} ) );
-      const monitor = createMonitor( check );
-
-      const run = monitor.start();
-      resolveNextDelay( CHECK_TIMEOUT_MS );
-      await flushPromises();
-
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Connection unhealthy', {
-        error: 'Connection health check timed out',
-        failures: 1
-      } );
-
-      await monitor.stop();
-      await run;
-    } );
-
-    it( 'logs recovered without a healthy line when the first check fails', async () => {
-      const check = vi.fn()
-        .mockRejectedValueOnce( new Error( 'temporary outage' ) )
-        .mockResolvedValue( {} );
-      const monitor = createMonitor( check );
-
-      const run = monitor.start();
-      await flushPromises();
-
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Connection unhealthy', { error: 'temporary outage', failures: 1 } );
-
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-
-      expect( mockLog.info ).toHaveBeenCalledOnce();
-      expect( mockLog.info ).toHaveBeenCalledWith( 'Recovered' );
-
-      await monitor.stop();
-      await run;
-    } );
-
-    it( 'logs healthy once while the connection stays reachable', async () => {
-      const check = vi.fn().mockResolvedValue( {} );
-      const monitor = createMonitor( check );
-
-      const run = monitor.start();
-      await flushPromises();
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-
-      expect( check ).toHaveBeenCalledTimes( 3 );
-      expect( mockLog.info ).toHaveBeenCalledOnce();
-      expect( mockLog.info ).toHaveBeenCalledWith( 'Healthy' );
-
-      await monitor.stop();
-      await run;
-    } );
-
-    it( 'logs recovered on a later failure without repeating healthy', async () => {
-      const check = vi.fn()
-        .mockResolvedValueOnce( {} )
-        .mockRejectedValueOnce( new Error( 'temporary outage' ) )
-        .mockResolvedValue( {} );
-      const monitor = createMonitor( check );
-
-      const run = monitor.start();
-      await flushPromises();
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-
-      expect( mockLog.info ).toHaveBeenCalledTimes( 2 );
-      expect( mockLog.info ).toHaveBeenNthCalledWith( 1, 'Healthy' );
-      expect( mockLog.info ).toHaveBeenNthCalledWith( 2, 'Recovered' );
-
-      await monitor.stop();
-      await run;
-    } );
-
-    it( 'describes non error rejections with their string value', async () => {
-      const check = vi.fn().mockRejectedValue( 'socket hang up' );
-      const monitor = createMonitor( check, { maxFailures: 2 } );
-
-      const run = monitor.start();
-      const rejection = expect( run ).rejects.toThrow( ConnectionLostError );
-
-      await flushPromises();
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-      await rejection;
-
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Connection unhealthy', { error: 'socket hang up', failures: 1 } );
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Connection lost', { error: 'socket hang up', failures: 2 } );
-    } );
-  } );
-
-  describe( 'connection loss', () => {
-    it( 'rejects after the maximum consecutive failures', async () => {
-      const check = vi.fn().mockRejectedValue( new Error( 'connection refused' ) );
-      const monitor = createMonitor( check, { maxFailures: 3 } );
-
-      const run = monitor.start();
-      const rejection = expect( run ).rejects.toThrow( ConnectionLostError );
-
-      await flushPromises();
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-      resolveNextDelay( CHECK_INTERVAL_MS );
-      await flushPromises();
-      await rejection;
-
-      expect( check ).toHaveBeenCalledTimes( 3 );
-      expect( mockLog.warn ).toHaveBeenCalledTimes( 3 );
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Connection lost', { error: 'connection refused', failures: 3 } );
-      expect( monitor.running ).toBe( false );
-    } );
-
-    it( 'preserves the original failure as the error cause', async () => {
-      const error = new Error( 'connection refused' );
-      const check = vi.fn().mockRejectedValue( error );
-      const monitor = createMonitor( check, { maxFailures: 1 } );
-
-      await expect( monitor.start() ).rejects.toMatchObject( {
-        name: 'ConnectionLostError',
-        message: 'Connection lost',
-        cause: error
-      } );
-    } );
-
-    it( 'stops watching once the connection is lost', async () => {
-      const check = vi.fn().mockRejectedValue( new Error( 'connection refused' ) );
-      const monitor = createMonitor( check, { maxFailures: 1 } );
-
-      await expect( monitor.start() ).rejects.toThrow( ConnectionLostError );
-      await flushPromises();
-
-      expect( check ).toHaveBeenCalledOnce();
-      expect( monitor.running ).toBe( false );
-    } );
-
-    it( 'reports the loss through stop so it is never silent', async () => {
-      const check = vi.fn().mockRejectedValue( new Error( 'connection refused' ) );
-      const monitor = createMonitor( check, { maxFailures: 1 } );
-
-      await expect( monitor.start() ).rejects.toThrow( ConnectionLostError );
-      await expect( monitor.stop() ).rejects.toThrow( ConnectionLostError );
-    } );
-  } );
-
-  describe( 'abort', () => {
-    it( 'never checks when the signal is already aborted', async () => {
-      const controller = new AbortController();
-      controller.abort();
-      const check = vi.fn();
-      const monitor = createMonitor( check, {}, controller.signal );
-
-      await expect( monitor.start() ).resolves.toBeUndefined();
-
-      expect( check ).not.toHaveBeenCalled();
-      expect( monitor.running ).toBe( false );
-    } );
-
-    it( 'stops without reporting when aborted during a check', async () => {
-      const controller = new AbortController();
-      const check = vi.fn().mockReturnValue( new Promise( () => {} ) );
-      const monitor = createMonitor( check, {}, controller.signal );
-
-      const run = monitor.start();
-      await flushPromises();
-
-      expect( monitor.running ).toBe( true );
-
-      controller.abort();
-
-      await expect( run ).resolves.toBeUndefined();
-      expect( mockLog.warn ).not.toHaveBeenCalled();
-      expect( monitor.running ).toBe( false );
-    } );
-
-    it( 'stops without reporting when aborted between checks', async () => {
-      const controller = new AbortController();
-      const check = vi.fn().mockResolvedValue( {} );
-      const monitor = createMonitor( check, {}, controller.signal );
-
-      const run = monitor.start();
-      await flushPromises();
-
-      expect( mockLog.info ).toHaveBeenCalledWith( 'Healthy' );
-
-      controller.abort();
-
-      await expect( run ).resolves.toBeUndefined();
-      expect( check ).toHaveBeenCalledOnce();
-      expect( mockLog.warn ).not.toHaveBeenCalled();
-    } );
-  } );
-
-  describe( 'lifecycle', () => {
-    it( 'returns the same watch when started more than once', async () => {
-      const check = vi.fn().mockReturnValue( new Promise( () => {} ) );
-      const monitor = createMonitor( check );
-
-      const first = monitor.start();
-      const second = monitor.start();
-
-      expect( second ).toBe( first );
-      expect( check ).toHaveBeenCalledOnce();
-
-      await monitor.stop();
-      await first;
-    } );
-
-    it( 'stops an in flight check without reporting a failure', async () => {
-      const check = vi.fn().mockReturnValue( new Promise( () => {} ) );
-      const monitor = createMonitor( check, { maxFailures: 1 } );
-
-      const run = monitor.start();
-
-      expect( monitor.running ).toBe( true );
-
-      await monitor.stop();
-      await run;
-
-      expect( mockLog.warn ).not.toHaveBeenCalled();
-      expect( monitor.running ).toBe( false );
-    } );
-
-    it( 'never watches when stopped before starting', async () => {
-      const check = vi.fn();
-      const monitor = createMonitor( check );
-
-      await expect( monitor.stop() ).resolves.toBeUndefined();
-      await expect( monitor.start() ).resolves.toBeUndefined();
-
-      expect( check ).not.toHaveBeenCalled();
-      expect( monitor.running ).toBe( false );
-    } );
-
-    it( 'applies the timing and failure threshold overrides', async () => {
-      const check = vi.fn().mockRejectedValue( new Error( 'fast failure' ) );
-      const monitor = createMonitor( check, { maxFailures: 1, checkIntervalMs: 7, checkTimeoutMs: 3 } );
-
-      await expect( monitor.start() ).rejects.toThrow( ConnectionLostError );
-
-      expect( delayMock ).toHaveBeenCalledWith( 3, 0, delayOptions );
-      expect( delayMock ).not.toHaveBeenCalledWith( 7, true, delayOptions );
-    } );
-  } );
-} );