Class WaitBlockHandler

apps/sim/executor/handlers/wait/wait-handler.ts:99–197

 * up once `resumeAt` is reached. Async caps at 30 days.
 */
export class WaitBlockHandler implements BlockHandler {
  canHandle(block: SerializedBlock): boolean {
    return block.metadata?.id === BlockType.WAIT
  }

  async execute(
    ctx: ExecutionContext,
    block: SerializedBlock,
    inputs: Record<string, any>
  ): Promise<BlockOutput> {
    return this.executeWithNode(ctx, block, inputs, { nodeId: block.id })
  }

  async executeWithNode(
    ctx: ExecutionContext,
    block: SerializedBlock,
    inputs: Record<string, any>,
    nodeMetadata: {
      nodeId: string
      loopId?: string
      parallelId?: string
      branchIndex?: number
      branchTotal?: number
      originalBlockId?: string
      isLoopNode?: boolean
      executionOrder?: number
    }
  ): Promise<BlockOutput> {
    const isAsync = inputs.async === true || inputs.async === 'true'
    const timeValue = Number.parseFloat(inputs.timeValue || '10')
    const timeUnit = isAsync ? inputs.timeUnitLong || 'minutes' : inputs.timeUnit || 'seconds'

    if (!Number.isFinite(timeValue) || timeValue <= 0) {
      throw new Error('Wait amount must be a positive number')
    }

    if (!isWaitUnit(timeUnit)) {
      throw new Error(`Unknown wait unit: ${timeUnit}`)
    }

    if (isAsync && timeUnit === 'seconds') {
      throw new Error('Seconds are not allowed in async mode')
    }

    const waitMs = Math.round(timeValue * UNIT_TO_MS[timeUnit])

    if (isAsync) {
      if (waitMs > MAX_ASYNC_WAIT_MS) {
        throw new Error('Wait time exceeds maximum of 30 days')
      }
    } else if (waitMs > MAX_INPROCESS_WAIT_MS) {
      throw new Error(
        'Wait time exceeds maximum of 5 minutes; enable async mode to wait up to 30 days'
      )
    }

    if (!isAsync) {
      const completed = await sleep(waitMs, {