I am learning async/await and Task. So i learned that Task basically inherit actor.
Imagine I have a model:

class SomeModel: ObservableObject {
   @Published var downloads: [Int] = []

   func doSome() async throw {
      // MAKE URL
      downloads.append(1)

      try await /// MAKE REQUEST
      downloads.append(data) // after request
    
   }
}

And I have a simple View

struct DownloadView: View {

  @EnvironmentObject var model: SomeModel


  var body: some View {
    List {
      // USE model.downloads 
    }
    .task {
        do {
          try await model.doSome()
        } catch {}
    }
}

I get an error that I am updating UI from background thread. Thats ok.
Then i add

func doSome() async throw {
      // MAKE URL
      downloads.append(1)

      try await /// MAKE REQUEST
      await MainActor.run {
            downloads.append(data)
       } // after request
}

And I have still Error. System does not know that first append is Always main actor? Or this is a security from dummies if some on pus some suspended code before first append?

How I understand hierarchical await is needed for System know what tree of sub jobs need to suspend. But a suspension point is after first append, so it could not pass on different actor.

Code for reproduce:
Model

struct DownloadFile: Identifiable {
    var id: String { return name }
    let name: String
    let size: Int
    let date: Date
    
    static let mockFiles = [DownloadFile(name: "File1", size: 100, date: Date()),
                            DownloadFile(name: "File2", size: 100, date: Date()),
                            DownloadFile(name: "File3", size: 100, date: Date()),
                            DownloadFile(name: "File4", size: 100, date: Date()),
                            DownloadFile(name: "File5", size: 100, date: Date()),
                            DownloadFile(name: "FIle6", size: 100, date: Date())]
    
    static let empty = DownloadFile(name: "", size: 0, date: Date())
}

FirstView

struct ContentView: View {
    @State var files: [DownloadFile] = []
    let model: ViewModel
    
    @State var selected = DownloadFile.empty {
      didSet {
        isDisplayingDownload = true
      }
    }
    
    @State var isDisplayingDownload = false
    
    var body: some View {
      NavigationStack {
        VStack {
          // The list of files available for download.
          List {
            Section(content: {
              if files.isEmpty {
                ProgressView().padding()
              }
              ForEach(files) { file in
                Button(action: {
                  selected = file
                }, label: {
                    Text(file.name)
                })
              }
            })
          }
          .listStyle(.insetGrouped)
        }
        .task {
            try? await Task.sleep(for: .seconds(1))
            files = DownloadFile.mockFiles
        }
        .navigationDestination(isPresented: $isDisplayingDownload) {
          DownloadView(file: selected).environmentObject(model)
        }
      }
    }
}

Second view

struct DownloadView: View {
    let file: DownloadFile
    @EnvironmentObject var model: ViewModel
    @State var result: String = ""
    var body: some View {
        VStack {
            Text(file.name)
            if model.downloads.isEmpty {
                Button {
                    Task {
                        result = try await model.download(file: file)
                    }
                } label: {
                    Text("-- Download --")
                }
            }
            Text(result)
        }
    }
}

viewModel

class ViewModel: ObservableObject {
    @Published var downloads: [String] = []
    
    func download(file: DownloadFile) async throws -> String {
        downloads.append(file.name)

        try await Task.sleep(for: .seconds(2))
        return "Download Finished"
    }
}