feat: Update package.json to 2.2.1

2.2.1
feat: Update package.json to 2.2.0
2026-05-15 11:30:09 +00:00 · 2021-02-26 09:52:12 +00:00 · 2021-02-26 18:51:35 +09:00 · 2021-02-26 07:47:03 +00:00 · 2021-02-26 16:42:54 +09:00 · 2021-02-26 11:42:30 +09:00
29 changed files with 1643 additions and 1729 deletions
--- a/.github/workflows/build-debug.yml
+++ b/.github/workflows/build-debug.yml
@@ -7,12 +7,12 @@ on:
    tags:
      - "!*" # not a tag push
  pull_request:
-    types:
-      - opened
-      - synchronize
+    branches:
+      - "master"

 jobs:
  build-dotnet:
+    if: "!(contains(github.event.head_commit.message, '[skip ci]') || contains(github.event.head_commit.message, '[ci skip]'))"
    runs-on: ubuntu-latest
    env:
      DOTNET_CLI_TELEMETRY_OPTOUT: 1
@@ -26,42 +26,61 @@ jobs:
      - run: dotnet test -c Debug ./src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj

  build-unity:
-    if: "(github.event == 'push' && github.repository_owner == 'Cysharp') || startsWith(github.event.pull_request.head.label, 'Cysharp:')"
+    if: "!(contains(github.event.head_commit.message, '[skip ci]') || contains(github.event.head_commit.message, '[ci skip]')) && ((github.event_name == 'push' && github.repository_owner == 'Cysharp') || startsWith(github.event.pull_request.head.label, 'Cysharp:'))"
    strategy:
      matrix:
-        unity: ["2019.3.9f1", "2020.1.0b5"]
+        unity: ["2019.3.9f1", "2019.4.13f1", "2020.1.12f1"]
        include:
          - unity: 2019.3.9f1
-            license: UNITY_2019_3
-          - unity: 2020.1.0b5
-            license: UNITY_2020_1
+            license: UNITY_LICENSE_2019
+          - unity: 2019.4.13f1
+            license: UNITY_LICENSE_2019
+          - unity: 2020.1.12f1
+            license: UNITY_LICENSE_2020
    runs-on: ubuntu-latest
-    container:
-      # with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
-      image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
    steps:
-      - run: apt update && apt install git -y
      - uses: actions/checkout@v2
-      - run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
+      # Execute scripts: RuntimeUnitTestToolkit
+      # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend mono /BuildTarget StandaloneLinux64
+      - name: Build UnitTest(Linux64, mono)
+        uses: game-ci/unity-builder@v2.0-alpha-6
        env:
          UNITY_LICENSE: ${{ secrets[matrix.license] }}
-      - name: Activate Unity, always returns a success. But if a subsequent run fails, the activation may have failed(if succeeded, shows `Next license update check is after` and not shows other message(like GUID != GUID). If fails not). In that case, upload the artifact's .alf file to https://license.unity3d.com/manual to get the .ulf file and set it to secrets.
-        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
-
-      # Execute scripts: RuntimeUnitTestToolkit
-      - name: Build UnitTest(Linux64, mono)
-        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend mono /BuildTarget StandaloneLinux64
-        working-directory: src/UniTask
+        with:
+          projectPath: src/UniTask
+          unityVersion: ${{ matrix.unity }}
+          targetPlatform: StandaloneLinux64
+          buildMethod: UnitTestBuilder.BuildUnitTest
+          customParameters: /headless /ScriptBackend mono
+          versioning: None
      - name: Execute UnitTest
        run: ./src/UniTask/bin/UnitTest/StandaloneLinux64_Mono2x/test

      # Execute scripts: Export Package
+      #  /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
      - name: Export unitypackage
-        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+        uses: game-ci/unity-builder@v2.0-alpha-6
+        env:
+          UNITY_LICENSE: ${{ secrets[matrix.license] }}
+        with:
+          projectPath: src/UniTask
+          unityVersion: ${{ matrix.unity }}
+          targetPlatform: StandaloneLinux64
+          buildMethod: PackageExporter.Export
+          versioning: None
+
+      - name: check all .meta is commited
+        run: |
+          if git ls-files --others --exclude-standard -t | grep --regexp='[.]meta$'; then
+            echo "Detected .meta file generated. Do you forgot commit a .meta file?"
+            exit 1
+          else
+            echo "Great, all .meta files are commited."
+          fi
        working-directory: src/UniTask

      # Store artifacts.
      - uses: actions/upload-artifact@v2
        with:
-          name: UniTask.unitypackage.zip
+          name: UniTask.unitypackage-${{ matrix.unity }}.zip
          path: ./src/UniTask/*.unitypackage
--- a/.github/workflows/build-release.yml
+++ b/.github/workflows/build-release.yml
@@ -1,61 +1,128 @@
-name: Build-Release
+name: build-release

 on:
-  push:
-    tags:
-      - "[0-9]+.[0-9]+.[0-9]+*"
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "tag: git tag you want create. (sample 1.0.0)"
+        required: true
+      dry_run:
+        description: "dry_run: true will never create relase/nuget."
+        required: true
+        default: "false"
+
+env:
+  GIT_TAG: ${{ github.event.inputs.tag }}
+  DRY_RUN: ${{ github.event.inputs.dry_run }}
+  DRY_RUN_BRANCH_PREFIX: "test_release"
+  DOTNET_SDK_VERISON_3: 3.1.x

 jobs:
-  build-dotnet:
+  update-packagejson:
    runs-on: ubuntu-latest
+    env:
+      TARGET_FILE: ./src/UniTask/Assets/Plugins/UniTask/package.json
+    outputs:
+      sha: ${{ steps.commit.outputs.sha }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: before
+        run: cat ${{ env.TARGET_FILE}}
+      - name: update package.json to version ${{ env.GIT_TAG }}
+        run: sed -i -e "s/\(\"version\":\) \"\(.*\)\",/\1 \"${{ env.GIT_TAG }}\",/" ${{ env.TARGET_FILE }}
+      - name: after
+        run: cat ${{ env.TARGET_FILE}}
+      - name: Commit files
+        id: commit
+        run: |
+          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git commit -m "feat: Update package.json to ${{ env.GIT_TAG }}" -a
+          echo "::set-output name=sha::$(git rev-parse HEAD)"
+      - name: check sha
+        run: echo "SHA ${SHA}"
+        env:
+          SHA: ${{ steps.commit.outputs.sha }}
+      - name: tag
+        run: git tag ${{ env.GIT_TAG }}
+        if: env.DRY_RUN == 'false'
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ github.ref }}
+          tags: true
+        if: env.DRY_RUN == 'false'
+      - name: Push changes (dry_run)
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ env.DRY_RUN_BRANCH_PREFIX }}-${{ env.GIT_TAG }}
+          tags: false
+        if: env.DRY_RUN == 'true'
+
+  build-dotnet:
+    needs: [update-packagejson]
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
    env:
      DOTNET_CLI_TELEMETRY_OPTOUT: 1
      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
      NUGET_XMLDOC_MODE: skip
    steps:
+      - run: echo ${{ needs.update-packagejson.outputs.sha }}
      - uses: actions/checkout@v2
+        with:
+          ref: ${{ needs.update-packagejson.outputs.sha }}
      - uses: actions/setup-dotnet@v1
        with:
-          dotnet-version: 3.1.x
-      # set release tag(*.*.*) to env.GIT_TAG
-      - run: echo "GIT_TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
-
+          dotnet-version: "${{ env.DOTNET_SDK_VERSION_3 }}"
      # build and pack
      - run: dotnet build -c Release -p:Version=${{ env.GIT_TAG }}
      - run: dotnet test -c Release --no-build
-      - run: dotnet pack ./src/UniTask.NetCore/UniTask.NetCore.csproj -c Release --no-build -p:Version=${{ env.GIT_TAG }}
-
+      - run: dotnet pack ./src/UniTask.NetCore/UniTask.NetCore.csproj -c Release --no-build -p:Version=${{ env.GIT_TAG }} -o ./publish
      # Store artifacts.
      - uses: actions/upload-artifact@v1
        with:
          name: nuget
-          path: ./src/UniTask.NetCore/bin/Release/UniTask.${{ env.GIT_TAG }}.nupkg
+          path: ./publish/

  build-unity:
+    needs: [update-packagejson]
    strategy:
      matrix:
        unity: ["2019.3.9f1"]
        include:
          - unity: 2019.3.9f1
-            license: UNITY_2019_3
+            license: UNITY_LICENSE_2019
    runs-on: ubuntu-latest
-    container:
-      # with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
-      image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
+    timeout-minutes: 15
    steps:
-      - run: apt update && apt install git -y
+      - run: echo ${{ needs.update-packagejson.outputs.sha }}
      - uses: actions/checkout@v2
-      - run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
+        with:
+          ref: ${{ needs.update-packagejson.outputs.sha }}
+      # Execute scripts: Export Package
+      # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+      - name: Export unitypackage
+        uses: game-ci/unity-builder@v2.0-alpha-6
        env:
          UNITY_LICENSE: ${{ secrets[matrix.license] }}
-      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
+        with:
+          projectPath: src/UniTask
+          unityVersion: ${{ matrix.unity }}
+          targetPlatform: StandaloneLinux64
+          buildMethod: PackageExporter.Export
+          versioning: None

-      # set release tag(*.*.*) to env.GIT_TAG
-      - run: echo "GIT_TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
-
-      # Execute scripts: Export Package
-      - name: Export unitypackage
-        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+      - name: check all .meta is commited
+        run: |
+          if git ls-files --others --exclude-standard -t | grep --regexp='[.]meta$'; then
+            echo "Detected .meta file generated. Do you forgot commit a .meta file?"
+            exit 1
+          else
+            echo "Great, all .meta files are commited."
+          fi
        working-directory: src/UniTask

      # Store artifacts.
@@ -65,7 +132,8 @@ jobs:
          path: ./src/UniTask/UniTask.${{ env.GIT_TAG }}.unitypackage

  create-release:
-    needs: [build-dotnet, build-unity]
+    if: github.event.inputs.dry_run == 'false'
+    needs: [update-packagejson, build-dotnet, build-unity]
    runs-on: ubuntu-latest
    env:
      DOTNET_CLI_TELEMETRY_OPTOUT: 1
@@ -75,25 +143,22 @@ jobs:
      # setup dotnet for nuget push
      - uses: actions/setup-dotnet@v1
        with:
-          dotnet-version: 3.1.x
-      # set release tag(*.*.*) to env.GIT_TAG
-      - run: echo "GIT_TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
-
+          dotnet-version: "${{ env.DOTNET_SDK_VERSION_3 }}"
      # Create Releases
      - uses: actions/create-release@v1
        id: create_release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
-          tag_name: ${{ github.ref }}
-          release_name: Ver.${{ github.ref }}
-
+          tag_name: ${{ env.GIT_TAG }}
+          release_name: Ver.${{ env.GIT_TAG }}
+          commitish: ${{ needs.update-packagejson.outputs.sha }}
+          draft: true
+          prerelease: false
      # Download(All) Artifacts to current directory
-      - uses: actions/download-artifact@v2-preview
-
+      - uses: actions/download-artifact@v2
      # Upload to NuGet
-      - run: dotnet nuget push "./nuget/*.nupkg" -s https://www.nuget.org/api/v2/package -k ${{ secrets.NUGET_KEY }}
-
+      - run: dotnet nuget push "./nuget/*.nupkg" --skip-duplicate -s https://www.nuget.org/api/v2/package -k ${{ secrets.NUGET_KEY }}
      # Upload to Releases(unitypackage)
      - uses: actions/upload-release-asset@v1
        env:
@@ -103,3 +168,14 @@ jobs:
          asset_path: ./UniTask.${{ env.GIT_TAG }}.unitypackage/UniTask.${{ env.GIT_TAG }}.unitypackage
          asset_name: UniTask.${{ env.GIT_TAG }}.unitypackage
          asset_content_type: application/octet-stream
+
+  cleanup:
+    if: github.event.inputs.dry_run == 'true'
+    needs: [build-dotnet, build-unity]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete branch
+        uses: dawidd6/action-delete-branch@v3
+        with:
+          github_token: ${{ github.token }}
+          branches: ${{ env.DRY_RUN_BRANCH_PREFIX }}-${{ env.GIT_TAG }}
--- a/.gitignore
+++ b/.gitignore
@@ -259,3 +259,5 @@ src/UniTask/Unity.EditorCoroutines.Editor.csproj
 src/UniTask/.vsconfig

 src/UniTask/Logs/ApiUpdaterCheck.txt
+
+src/UniTask/Assembly-CSharp-firstpass.csproj
--- a/README.md
+++ b/README.md
@@ -2,20 +2,20 @@ UniTask
 ===
 [![GitHub Actions](https://github.com/Cysharp/UniTask/workflows/Build-Debug/badge.svg)](https://github.com/Cysharp/UniTask/actions) [![Releases](https://img.shields.io/github/release/Cysharp/UniTask.svg)](https://github.com/Cysharp/UniTask/releases)

-Provides an efficient allocation free async/await integration to Unity.
+Provides an efficient allocation free async/await integration for Unity.

-* Struct based `UniTask<T>` and custom AsyncMethodBuilder to achive zero allocation
-* All Unity AsyncOperations and Coroutine to awaitable
-* PlayerLoop based task(`UniTask.Yield`, `UniTask.Delay`, `UniTask.DelayFrame`, etc..) that enable to replace all coroutine operation
+* Struct based `UniTask<T>` and custom AsyncMethodBuilder to achieve zero allocation
+* Makes all Unity AsyncOperations and Coroutines awaitable
+* PlayerLoop based task(`UniTask.Yield`, `UniTask.Delay`, `UniTask.DelayFrame`, etc..) that enable replacing all coroutine operations
 * MonoBehaviour Message Events and uGUI Events as awaitable/async-enumerable
-* Completely run on Unity's PlayerLoop so don't use thread and run on WebGL, wasm, etc.
+* Runs completely on Unity's PlayerLoop so doesn't use threads and runs on WebGL, wasm, etc.
 * Asynchronous LINQ, with Channel and AsyncReactiveProperty
-* TaskTracker window to prevent memory leak
+* TaskTracker window to prevent memory leaks
 * Highly compatible behaviour with Task/ValueTask/IValueTaskSource

-Techinical details, see blog post: [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ
+For technical details, see blog post: [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ
 ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)  
-Advanced tips, see blog post: [Extends UnityWebRequest via async decorator pattern — Advanced Techniques of UniTask](https://medium.com/@neuecc/extends-unitywebrequest-via-async-decorator-pattern-advanced-techniques-of-unitask-ceff9c5ee846)
+For advanced tips, see blog post: [Extends UnityWebRequest via async decorator pattern — Advanced Techniques of UniTask](https://medium.com/@neuecc/extends-unitywebrequest-via-async-decorator-pattern-advanced-techniques-of-unitask-ceff9c5ee846)

 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
@@ -24,6 +24,7 @@ Advanced tips, see blog post: [Extends UnityWebRequest via async decorator patte
 - [Getting started](#getting-started)
 - [Basics of UniTask and AsyncOperation](#basics-of-unitask-and-asyncoperation)
 - [Cancellation and Exception handling](#cancellation-and-exception-handling)
+- [Timeout handling](#timeout-handling)
 - [Progress](#progress)
 - [PlayerLoop](#playerloop)
 - [async void vs async UniTaskVoid](#async-void-vs-async-unitaskvoid)
@@ -72,7 +73,7 @@ async UniTask<string> DemoAsync()
    // .ToUniTask accepts progress callback(and all options), Progress.Create is a lightweight alternative of IProgress<T>
    var asset3 = await Resources.LoadAsync<TextAsset>("baz").ToUniTask(Progress.Create<float>(x => Debug.Log(x)));

-    // await frame-based operation like coroutine
+    // await frame-based operation like a coroutine
    await UniTask.DelayFrame(100); 

    // replacement of yield return new WaitForSeconds/WaitForSecondsRealtime
@@ -97,10 +98,10 @@ async UniTask<string> DemoAsync()
    // special helper of WaitUntil
    await UniTask.WaitUntilValueChanged(this, x => x.isActive);

-    // You can await IEnumerator coroutine
+    // You can await IEnumerator coroutines
    await FooCoroutineEnumerator();

-    // You can await standard task
+    // You can await a standard task
    await Task.Run(() => 100);

    // Multithreading, run on ThreadPool under this code
@@ -122,14 +123,11 @@ async UniTask<string> DemoAsync()
    var task2 = GetTextAsync(UnityWebRequest.Get("http://bing.com"));
    var task3 = GetTextAsync(UnityWebRequest.Get("http://yahoo.com"));

-    // concurrent async-wait and get result easily by tuple syntax
+    // concurrent async-wait and get results easily by tuple syntax
    var (google, bing, yahoo) = await UniTask.WhenAll(task1, task2, task3);

    // shorthand of WhenAll, tuple can await directly
    var (google2, bing2, yahoo2) = await (task1, task2, task3);
-    
-    // You can handle timeout easily
-    await GetTextAsync(UnityWebRequest.Get("http://unity.com")).Timeout(TimeSpan.FromMilliseconds(300));

    // return async-value.(or you can use `UniTask`(no result), `UniTaskVoid`(fire and forget)).
    return (asset as TextAsset)?.text ?? throw new InvalidOperationException("Asset not found");
@@ -138,9 +136,9 @@ async UniTask<string> DemoAsync()

 Basics of UniTask and AsyncOperation
 ---
-UniTask feature rely on C# 7.0([task-like custom async method builder feature](https://github.com/dotnet/roslyn/blob/master/docs/features/task-types.md)) so required Unity version is after `Unity 2018.3`, officialy lower support version is `Unity 2018.4.13f1`.
+UniTask features rely on C# 7.0([task-like custom async method builder feature](https://github.com/dotnet/roslyn/blob/master/docs/features/task-types.md)) so the required Unity version is after `Unity 2018.3`, the official lowest version supported is `Unity 2018.4.13f1`.

-Why UniTask(custom task-like object) is required? Because Task is too heavy, not matched to Unity threading(single-thread). UniTask does not use thread and SynchronizationContext/ExecutionContext because almost Unity's asynchronous object is automaticaly dispatched by Unity's engine layer. It acquires more fast and more less allocation, completely integrated with Unity.
+Why is UniTask(custom task-like object) required? Because Task is too heavy and not matched to Unity threading (single-thread). UniTask does not use threads and SynchronizationContext/ExecutionContext because Unity's asynchronous object is automaticaly dispatched by Unity's engine layer. It achieves faster and lower allocation, and is completely integrated with Unity.

 You can await `AsyncOperation`, `ResourceRequest`, `AssetBundleRequest`, `AssetBundleCreateRequest`, `UnityWebRequestAsyncOperation`, `AsyncGPUReadbackRequest`, `IEnumerator` and others when `using Cysharp.Threading.Tasks;`.

@@ -152,13 +150,13 @@ UniTask provides three pattern of extension methods.
 * .ToUniTask(IProgress, PlayerLoopTiming, CancellationToken);
 ```

-`WithCancellation` is a simple version of `ToUniTask`, both returns `UniTask`. Details of cancellation, see: [Cancellation and Exception handling](#cancellation-and-exception-handling) section.
+`WithCancellation` is a simple version of `ToUniTask`, both return `UniTask`. For details of cancellation, see: [Cancellation and Exception handling](#cancellation-and-exception-handling) section.

-> Note: WithCancellation is returned from native timing of PlayerLoop but ToUniTask is returned from specified PlayerLoopTiming. Details of timing, see: [PlayerLoop](#playerloop) section.
+> Note: await directly is returned from native timing of PlayerLoop but WithCancellation and ToUniTask are returned from specified PlayerLoopTiming. For details of timing, see: [PlayerLoop](#playerloop) section.

-> Note: AssetBundleRequest has `asset` and `allAssets`, in default await returns `asset`. If you want to get `allAssets`, you can use `AwaitForAllAssets()` method.
+> Note: AssetBundleRequest has `asset` and `allAssets`, default await returns `asset`. If you want to get `allAssets`, you can use `AwaitForAllAssets()` method.

-The type of `UniTask` can use utility like `UniTask.WhenAll`, `UniTask.WhenAny`. It is like Task.WhenAll/WhenAny but return type is more useful, returns value tuple so can deconsrtuct each result and pass multiple type.
+The type of `UniTask` can use utilities like `UniTask.WhenAll`, `UniTask.WhenAny`. They are like `Task.WhenAll`/`Task.WhenAny` but the return type is more useful. They return value tuples so you can deconstruct each result and pass multiple types.

 ```csharp
 public async UniTaskVoid LoadManyAsync()
@@ -177,7 +175,7 @@ async UniTask<Sprite> LoadAsSprite(string path)
 }
 ```

-If you want to convert callback to UniTask, you can use `UniTaskCompletionSource<T>` that is the lightweight edition of `TaskCompletionSource<T>`. 
+If you want to convert a callback to UniTask, you can use `UniTaskCompletionSource<T>` which is a lightweight edition of `TaskCompletionSource<T>`. 

 ```csharp
 public UniTask<int> WrapByUniTaskCompletionSource()
@@ -194,7 +192,7 @@ public UniTask<int> WrapByUniTaskCompletionSource()

 You can convert Task -> UniTask: `AsUniTask`, `UniTask` -> `UniTask<AsyncUnit>`: `AsAsyncUnitUniTask`, `UniTask<T>` -> `UniTask`: `AsUniTask`. `UniTask<T>` -> `UniTask`'s conversion cost is free.

-If you want to convert async to coroutine, you can use `.ToCoroutine()`, this is useful to use only allow coroutine system.
+If you want to convert async to coroutine, you can use `.ToCoroutine()`, this is useful if you want to only allow using the coroutine system.

 UniTask can not await twice. This is a similar constraint to the [ValueTask/IValueTaskSource](https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.valuetask-1?view=netcore-3.1) introduced in .NET Standard 2.1.

@@ -213,13 +211,13 @@ await task;
 await task; // NG, throws Exception
 ```

-Store to the class field, you can use `UniTask.Lazy` that gurantee call multipletimes. `.Preserve()` allows for multiple calls (internally cached results). This is useful when multiple calls in a function scope.
+Store to the class field, you can use `UniTask.Lazy` that supports calling multiple times. `.Preserve()` allows for multiple calls (internally cached results). This is useful when there are multiple calls in a function scope.

-Also `UniTaskCompletionSource` can await multipletimes and await from many caller.
+Also `UniTaskCompletionSource` can await multiple times and await from many callers.

 Cancellation and Exception handling
 ---
-Some UniTask factory methods have `CancellationToken cancellationToken = default` parameter. Andalso some async operation for unity have `WithCancellation(CancellationToken)` and `ToUniTask(..., CancellationToken cancellation = default)` extension methods. 
+Some UniTask factory methods have a `CancellationToken cancellationToken = default` parameter. Also some async operations for Unity have `WithCancellation(CancellationToken)` and `ToUniTask(..., CancellationToken cancellation = default)` extension methods. 

 You can pass `CancellationToken` to parameter by standard [`CancellationTokenSource`](https://docs.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource).

@@ -236,18 +234,18 @@ await UnityWebRequest.Get("http://google.co.jp").SendWebRequest().WithCancellati
 await UniTask.DelayFrame(1000, cancellationToken: cts.Token);
 ```

-CancellationToken can create by `CancellationTokenSource` or MonoBehaviour's extension method `GetCancellationTokenOnDestroy`.
+CancellationToken can be created by `CancellationTokenSource` or MonoBehaviour's extension method `GetCancellationTokenOnDestroy`.

 ```csharp
 // this CancellationToken lifecycle is same as GameObject.
 await UniTask.DelayFrame(1000, cancellationToken: this.GetCancellationTokenOnDestroy());
 ```

-When detect cancellation, all methods throws `OperationCanceledException` and propagate to upstream. `OperationCanceledException` is special exception, if not handled this exception, finally it is propagated to `UniTaskScheduler.UnobservedTaskException`.
+When cancellation is detected, all methods throw `OperationCanceledException` and propagate upstream. `OperationCanceledException` is a special exception, if this exception is not handled, it is propagated finally to `UniTaskScheduler.UnobservedTaskException`.

-Default behaviour of received unhandled exception is write log as exception. Log level can change by `UniTaskScheduler.UnobservedExceptionWriteLogType`. If you want to change custom beavhiour, set action to `UniTaskScheduler.UnobservedTaskException.`
+The default behaviour of received unhandled exception is to write log as exception. Log level can be changed using `UniTaskScheduler.UnobservedExceptionWriteLogType`. If you want to use custom behaviour, set an action to `UniTaskScheduler.UnobservedTaskException.`

-If you want to cancel behaviour in async UniTask method, throws `OperationCanceledException` manually.
+If you want to cancel behaviour in an async UniTask method, throw `OperationCanceledException` manually.

 ```csharp
 public async UniTask<int> FooAsync()
@@ -257,7 +255,7 @@ public async UniTask<int> FooAsync()
 }
 ```

-If you handle exception but want to ignore(propagete to global cancellation handling), use exception filter.
+If you handle an exception but want to ignore(propagate to global cancellation handling), use an exception filter.

 ```csharp
 public async UniTask<int> BarAsync()
@@ -274,7 +272,7 @@ public async UniTask<int> BarAsync()
 }
 ```

-throws/catch `OperationCanceledException` is slightly heavy, if you want to care performance, use `UniTask.SuppressCancellationThrow` to avoid OperationCanceledException throw. It returns `(bool IsCanceled, T Result)` instead of throw.
+throws/catch `OperationCanceledException` is slightly heavy, so if performance is a concern, use `UniTask.SuppressCancellationThrow` to avoid OperationCanceledException throw. It returns `(bool IsCanceled, T Result)` instead of throwing.

 ```csharp
 var (isCanceled, _) = await UniTask.DelayFrame(10, cancellationToken: cts.Token).SuppressCancellationThrow();
@@ -284,11 +282,105 @@ if (isCanceled)
 }
 ```

-Note: Only suppress throws if you call it directly into the most source method. Otherwise, the return value will be converted, but the entire pipeline will not be suppressed throws.
+Note: Only suppress throws if you call directly into the most source method. Otherwise, the return value will be converted, but the entire pipeline will not suppress throws.
+
+Timeout handling
+---
+Timeout is a variation of cancellation. You can set timeout by `CancellationTokenSouce.CancelAfterSlim(TimeSpan)` and pass CancellationToken to async methods.
+
+```csharp
+var cts = new CancellationTokenSource();
+cts.CancelAfterSlim(TimeSpan.FromSeconds(5)); // 5sec timeout.
+
+try
+{
+    await UnityWebRequest.Get("http://foo").SendWebRequest().WithCancellation(cts.Token);
+}
+catch (OperationCanceledException ex)
+{
+    if (ex.CancellationToken == cts.Token)
+    {
+        UnityEngine.Debug.Log("Timeout");
+    }
+}
+```
+
+> `CancellationTokenSouce.CancelAfter` is a standard api. However in Unity you should not use it because it depends threading timer. `CancelAfterSlim` is UniTask's extension methods, it uses PlayerLoop instead.
+
+If you want to use timeout with other source of cancellation, use `CancellationTokenSource.CreateLinkedTokenSource`.
+
+```csharp
+var cancelToken = new CancellationTokenSource();
+cancelButton.onClick.AddListener(()=>
+{
+    cancelToken.Cancel(); // cancel from button click.
+});
+
+var timeoutToken = new CancellationTokenSource();
+timeoutToken.CancelAfterSlim(TimeSpan.FromSeconds(5)); // 5sec timeout.
+
+try
+{
+    // combine token
+    var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancelToken.Token, timeoutToken.Token);
+
+    await UnityWebRequest.Get("http://foo").SendWebRequest().WithCancellation(linkedTokenSource.Token);
+}
+catch (OperationCanceledException ex)
+{
+    if (timeoutToken.IsCancellationRequested)
+    {
+        UnityEngine.Debug.Log("Timeout.");
+    }
+    else if (cancelToken.IsCancellationRequested)
+    {
+        UnityEngine.Debug.Log("Cancel clicked.");
+    }
+}
+```
+
+Optimize for reduce allocation of CancellationTokenSource for timeout per call async method, you can use UniTask's `TimeoutController`.
+
+```csharp
+TimeoutController timeoutController = new TimeoutController(); // setup to field for reuse.
+
+async UniTask FooAsync()
+{
+    try
+    {
+        // you can pass timeoutController.Timeout(TimeSpan) to cancellationToken.
+        await UnityWebRequest.Get("http://foo").SendWebRequest()
+            .WithCancellation(timeoutController.Timeout(TimeSpan.FromSeconds(5)));
+        timeoutController.Reset(); // call Reset(Stop timeout timer and ready for reuse) when succeed.
+    }
+    catch (OperationCanceledException ex)
+    {
+        if (timeoutController.IsTimeout())
+        {
+            UnityEngine.Debug.Log("timeout");
+        }
+    }
+}
+```
+
+If you want to use timeout with other source of cancellation, use `new TimeoutController(CancellationToken)`.
+
+```csharp
+TimeoutController timeoutController;
+CancellationTokenSource clickCancelSource;
+
+void Start()
+{
+    this.clickCancelSource = new CancellationTokenSource();
+    this.timeoutController = new TimeoutController(clickCancelSource);
+}
+```
+
+Note: UniTask has `.Timeout`, `.TimeoutWithoutException` methods however, if possible, do not use these, please pass `CancellationToken`. Because `.Timeout` work from external of task, can not stop timeoutted task. `.Timeout` means ignore result when timeout. If you pass a `CancellationToken` to the method, it will act from inside of the task, so it is possible to stop a running task.

 Progress
 ---
-Some async operation for unity have `ToUniTask(IProgress<float> progress = null, ...)` extension methods. 
+Some async operations for unity have `ToUniTask(IProgress<float> progress = null, ...)` extension methods. 

 ```csharp
 var progress = Progress.Create<float>(x => Debug.Log(x));
@@ -298,9 +390,9 @@ var request = await UnityWebRequest.Get("http://google.co.jp")
    .ToUniTask(progress: progress);
 ```

-You should not use standard `new System.Progress<T>`, because it causes allocation every times. Use `Cysharp.Threading.Tasks.Progress` instead. This progress factory has two methods, `Create` and `CreateOnlyValueChanged`. `CreateOnlyValueChanged` calls only when progress value changed.
+You should not use standard `new System.Progress<T>`, because it causes allocation every time. Use `Cysharp.Threading.Tasks.Progress` instead. This progress factory has two methods, `Create` and `CreateOnlyValueChanged`. `CreateOnlyValueChanged` calls only when the progress value has changed.

-Implements IProgress interface to caller is more better, there is no allocation of lambda.
+Implementing IProgress interface to caller is better as there is no lambda allocation.

 ```csharp
 public class Foo : MonoBehaviour, IProgress<float>
@@ -321,7 +413,7 @@ public class Foo : MonoBehaviour, IProgress<float>

 PlayerLoop
 ---
-UniTask is run on custom [PlayerLoop](https://docs.unity3d.com/ScriptReference/LowLevel.PlayerLoop.html). UniTask's playerloop based method(such as `Delay`, `DelayFrame`, `asyncOperation.ToUniTask`, etc...) accepts this `PlayerLoopTiming`.
+UniTask is run on a custom [PlayerLoop](https://docs.unity3d.com/ScriptReference/LowLevel.PlayerLoop.html). UniTask's playerloop based methods (such as `Delay`, `DelayFrame`, `asyncOperation.ToUniTask`, etc...) accept this `PlayerLoopTiming`.

 ```csharp
 public enum PlayerLoopTiming
@@ -356,25 +448,25 @@ public enum PlayerLoopTiming

 It indicates when to run, you can check [PlayerLoopList.md](https://gist.github.com/neuecc/bc3a1cfd4d74501ad057e49efcd7bdae) to Unity's default playerloop and injected UniTask's custom loop.

-`PlayerLoopTiming.Update` is similar as `yield return null` in coroutine, but it is called before Update(Update and uGUI events(button.onClick, etc...) are called on `ScriptRunBehaviourUpdate`, yield return null is called on `ScriptRunDelayedDynamicFrameRate`). `PlayerLoopTiming.FixedUpdate` is similar as `WaitForFixedUpdate`, `PlayerLoopTiming.LastPostLateUpdate` is similar as `WaitForEndOfFrame` in coroutine.
+`PlayerLoopTiming.Update` is similar to `yield return null` in a coroutine, but it is called before Update(Update and uGUI events(button.onClick, etc...) are called on `ScriptRunBehaviourUpdate`, yield return null is called on `ScriptRunDelayedDynamicFrameRate`). `PlayerLoopTiming.FixedUpdate` is similar to `WaitForFixedUpdate`, `PlayerLoopTiming.LastPostLateUpdate` is similar to `WaitForEndOfFrame` in coroutine.

-> `await UniTask.WaitForEndOfFrame()` is not equilavelnt to coroutine's `yield return new WaitForEndOfFrame()`. Coroutine's WaitForEndOfFrame seems to run after the PlayerLoop is done. Some methods that require coroutine's end of frame(`ScreenCapture.CaptureScreenshotAsTexture`, `CommandBuffer`, etc) does not work correctly when replace to async/await. In that case, use a coroutine.
+> `await UniTask.WaitForEndOfFrame()` is not equivalent to coroutine's `yield return new WaitForEndOfFrame()`. Coroutine's WaitForEndOfFrame seems to run after the PlayerLoop is done. Some methods that require coroutine's end of frame(`ScreenCapture.CaptureScreenshotAsTexture`, `CommandBuffer`, etc) do not work correctly when replaced with async/await. In these cases, use a coroutine instead.

-`yield return null` and `UniTask.Yield` is similar but different. `yield return null` always return next frame but `UniTask.Yield` return next called, that is, call `UniTask.Yield(PlayerLoopTiming.Update)` on `PreUpdate`, it returns same frame. `UniTask.NextFrame()` gurantees return next frame, this would be expected to behave exactly the same as `yield return null`.
+`yield return null` and `UniTask.Yield` are similar but different. `yield return null` always returns next frame but `UniTask.Yield` returns next called. That is, call `UniTask.Yield(PlayerLoopTiming.Update)` on `PreUpdate`, it returns same frame. `UniTask.NextFrame()` guarantees return next frame, you can expect this to behave exactly the same as `yield return null`.

-> UniTask.Yield(without CancellationToken) is a special type, returns `YieldAwaitable` and run on YieldRunner. It is most lightweight and faster.
+> UniTask.Yield(without CancellationToken) is a special type, returns `YieldAwaitable` and run on YieldRunner. It is most lightweight and fastest.

-AsyncOperation is returned from native timing. For example, await `SceneManager.LoadSceneAsync` is returned from `EarlyUpdate.UpdatePreloading` and after called, loaded scene's `Start` called from `EarlyUpdate.ScriptRunDelayedStartupFrame`. Also `await UnityWebRequest` is returned from `EarlyUpdate.ExecuteMainThreadJobs`.
+`AsyncOperation` is returned from native timing. For example, await `SceneManager.LoadSceneAsync` is returned from `EarlyUpdate.UpdatePreloading` and after being called, the loaded scene's `Start` is called from `EarlyUpdate.ScriptRunDelayedStartupFrame`. Also `await UnityWebRequest` is returned from `EarlyUpdate.ExecuteMainThreadJobs`.

-In UniTask, await directly and `WithCancellation` use native timing, `ToUniTask` use specified timing. This is usually not a particular problem, but with `LoadSceneAsync`, causes different order of Start and continuation after await. so recommend not to use `LoadSceneAsync.ToUniTask`.
+In UniTask, await directly uses native timing, `WithCancellation` and `ToUniTask` use specified timing. This is usually not a particular problem, but with `LoadSceneAsync`, it causes a different order of Start and continuation after await. So it is recommended not to use `LoadSceneAsync.ToUniTask`.

-In stacktrace, you can check where is running in playerloop.
+In the stacktrace, you can check where it is running in playerloop.

 ![image](https://user-images.githubusercontent.com/46207/83735571-83caea80-a68b-11ea-8d22-5e22864f0d24.png)

-In default, UniTask's PlayerLoop is initialized at `[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]`.
+By default, UniTask's PlayerLoop is initialized at `[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]`.

-The order in which methods are called in BeforeSceneLoad is indeterminate, so if you want to use UniTask in other BeforeSceneLoad methods, you should try to initialize it before this.
+The order in which methods are called in BeforeSceneLoad is nondeterministic, so if you want to use UniTask in other BeforeSceneLoad methods, you should try to initialize it before this.

 ```csharp
 // AfterAssembliesLoaded is called before BeforeSceneLoad
@@ -386,9 +478,9 @@ public static void InitUniTaskLoop()
 }
 ```

-If you import Unity's `Entities` package, that reset custom player loop to default at `BeforeSceneLoad` and inject ECS's loop. When Unity call ECS's inject method after UniTask's initialize method, UniTask will no longer work.
+If you import Unity's `Entities` package, that resets the custom player loop to default at `BeforeSceneLoad` and injects ECS's loop. When Unity calls ECS's inject method after UniTask's initialize method, UniTask will no longer work.

-To solve this issue, you can re-initialize UniTask PlayerLoop after ECS initialized.
+To solve this issue, you can re-initialize the UniTask PlayerLoop after ECS is initialized.

 ```csharp
 // Get ECS Loop.
@@ -398,7 +490,7 @@ var playerLoop = ScriptBehaviourUpdateOrder.CurrentPlayerLoop;
 PlayerLoopHelper.Initialize(ref playerLoop);
 ```

-You can diagnostic UniTask's player loop is ready by `PlayerLoopHelper.IsInjectedUniTaskPlayerLoop()`. And also `PlayerLoopHelper.DumpCurrentPlayerLoop` shows current all playerloop to console.
+You can diagnose whether UniTask's player loop is ready by calling `PlayerLoopHelper.IsInjectedUniTaskPlayerLoop()`. And also `PlayerLoopHelper.DumpCurrentPlayerLoop` logs all current playerloops to console.

 ```csharp
 void Start()
@@ -408,9 +500,40 @@ void Start()
 }
 ```

+You can optimize loop cost slightly by remove unuse PlayerLoopTiming injection. You can call `PlayerLoopHelper.Initialize(InjectPlayerLoopTimings)` on initialize.
+
+```csharp
+var loop = PlayerLoop.GetCurrentPlayerLoop();
+PlayerLoopHelper.Initialize(ref loop, InjectPlayerLoopTimings.Minimum); // minimum is Update | FixedUpdate | LastPostLateUpdate
+```
+
+`InjectPlayerLoopTimings` has three preset, `All` and `Standard`(All without last except LastPostLateUpdate), `Minimum`(`Update | FixedUpdate | LastPostLateUpdate`). Default is All and you can combine custom inject timings like `InjectPlayerLoopTimings.Update | InjectPlayerLoopTimings.FixedUpdate | InjectPlayerLoopTimings.PreLateUpdate`.
+
+You can make error to use uninjected `PlayerLoopTiming` by [Microsoft.CodeAnalysis.BannedApiAnalyzers](https://github.com/dotnet/roslyn-analyzers/blob/master/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/BannedApiAnalyzers.Help.md). For example, you can setup `BannedSymbols.txt` like this for `InjectPlayerLoopTimings.Minimum`.
+
+```txt
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.Initialization; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastInitialization; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.EarlyUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastEarlyUpdate; Isn't injected this PlayerLoop in this project.d
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastFixedUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.PreUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastPreUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.PreLateUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastPreLateUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.PostLateUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.TimeUpdate; Isn't injected this PlayerLoop in this project.
+F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastTimeUpdate; Isn't injected this PlayerLoop in this project.
+```
+
+You can configure `RS0030` severity to error.
+
+![image](https://user-images.githubusercontent.com/46207/109150837-bb933880-77ac-11eb-85ba-4fd15819dbd0.png)
+
 async void vs async UniTaskVoid
 ---
-`async void` is a standard C# task system so does not run on UniTask systems. It is better not to use. `async UniTaskVoid` is a lightweight version of `async UniTask` because it does not have awaitable completion and report error immediately to `UniTaskScheduler.UnobservedTaskException`. If you don't require to await it(fire and forget), use `UniTaskVoid` is better. Unfortunately to dismiss warning, require to using with `Forget()`.
+`async void` is a standard C# task system so it does not run on UniTask systems. It is better not to use it. `async UniTaskVoid` is a lightweight version of `async UniTask` because it does not have awaitable completion and reports errors immediately to `UniTaskScheduler.UnobservedTaskException`. If you don't require awaiting (fire and forget), using `UniTaskVoid` is better. Unfortunately to dismiss warning, you're required to call `Forget()`.

 ```csharp
 public async UniTaskVoid FireAndForgetMethod()
@@ -425,7 +548,7 @@ public void Caller()
 }
 ```

-Also UniTask have `Forget` method, it is similar with UniTaskVoid and same effects with it. However still UniTaskVoid is more efficient if completely do not use await。
+Also UniTask has the `Forget` method, it is similar to `UniTaskVoid` and has the same effects. However `UniTaskVoid` is more efficient if you completely don't use `await`。

 ```csharp
 public async UniTask DoAsync()
@@ -440,7 +563,7 @@ public void Caller()
 }
 ```

-Using async lambda in register event, it is used `async void`. To avoid it, you can use `UniTask.Action` or `UniTask.UnityAction` that creates delegate via `async UniTaskVoid` lambda.
+To use an async lambda registered to an event, don't use `async void`. Instead you can use `UniTask.Action` or `UniTask.UnityAction`, both of which create a delegate via `async UniTaskVoid` lambda.

 ```csharp
 Action actEvent;
@@ -455,7 +578,7 @@ actEvent += UniTask.Action(async () => { await UniTask.Yield(); });
 unityEvent += UniTask.UnityAction(async () => { await UniTask.Yield(); });
 ```

-`UniTaskVoid` can also use in MonoBehaviour's `Start` method.
+`UniTaskVoid` can also be used in MonoBehaviour's `Start` method.

 ```csharp
 class Sample : MonoBehaviour
@@ -469,7 +592,7 @@ class Sample : MonoBehaviour

 UniTaskTracker
 ---
-useful for check(leak) UniTasks. You can open tracker window in `Window -> UniTask Tracker`.
+useful for checking (leaked) UniTasks. You can open tracker window in `Window -> UniTask Tracker`.

 ![image](https://user-images.githubusercontent.com/46207/83527073-4434bf00-a522-11ea-86e9-3b3975b26266.png)

@@ -479,15 +602,15 @@ useful for check(leak) UniTasks. You can open tracker window in `Window -> UniTa
 * Enable Tracking(Toggle) - Start to track async/await UniTask. Performance impact: low.
 * Enable StackTrace(Toggle) - Capture StackTrace when task is started. Performance impact: high.

-For debug use, enable tracking and capture stacktrace is useful but it it decline performance. Recommended usage is enable both to find task leak, and when done, finally disable both.
+UniTaskTracker is intended for debugging use only as enabling tracking and capturing stacktraces is useful but has a heavy performance impact. Recommended usage is to enable both tracking and stacktraces to find task leaks and to disable them both when done.

 External Assets
 ---
-In default, UniTask supports TextMeshPro(`BindTo(TMP_Text)` and `TMP_InputField` event extensions like standard uGUI `InputField`), DOTween(`Tween` as awaitable) and Addressables(`AsyncOperationHandle` and `AsyncOpereationHandle<T>` as awaitable).
+By default, UniTask supports TextMeshPro(`BindTo(TMP_Text)` and `TMP_InputField` event extensions like standard uGUI `InputField`), DOTween(`Tween` as awaitable) and Addressables(`AsyncOperationHandle` and `AsyncOperationHandle<T>` as awaitable).

-There are defined in separated asmdef like `UniTask.TextMeshPro`, `UniTask.DOTween`, `UniTask.Addressables`.
+There are defined in separated asmdefs like `UniTask.TextMeshPro`, `UniTask.DOTween`, `UniTask.Addressables`.

-TextMeshPro and Addressables support are automatically enabled when import there package from package manager. However DOTween support, require to `com.demigiant.dotween` import from [OpenUPM](https://openupm.com/packages/com.demigiant.dotween/) or define `UNITASK_DOTWEEN_SUPPORT` to enable it.
+TextMeshPro and Addressables support are automatically enabled when importing their packages from package manager. However for DOTween support, it is required to import `com.demigiant.dotween` from [OpenUPM](https://openupm.com/packages/com.demigiant.dotween/) or to define `UNITASK_DOTWEEN_SUPPORT` to enable it.

 ```csharp
 // sequential
@@ -502,11 +625,11 @@ await UniTask.WhenAll(
    transform.DOScale(10, 3).WithCancellation(ct));
 ```

-DOTween support's default behaviour(`await`, `WithCancellation`, `ToUniTask`) awaits tween is killed. It works both Complete(true/false) and Kill(true/false). But if you want to tween reuse(`SetAutoKill(false)`), it does not work you expected. Or, if you want to await for another timing, the following extension methods exist in Tween, `AwaitForComplete`, `AwaitForPause`, `AwaitForPlay`, `AwaitForRewind`, `AwaitForStepComplete`.
+DOTween support's default behaviour(`await`, `WithCancellation`, `ToUniTask`) awaits tween is killed. It works on both Complete(true/false) and Kill(true/false). But if you want to reuse tweens (`SetAutoKill(false)`), it does not work as expected. If you want to await for another timing, the following extension methods exist in Tween, `AwaitForComplete`, `AwaitForPause`, `AwaitForPlay`, `AwaitForRewind`, `AwaitForStepComplete`.

 AsyncEnumerable and Async LINQ
 ---
-Unity 2020.2 supports C# 8.0 so you can use `await foreach`. This is the new Update notation in async era.
+Unity 2020.2 supports C# 8.0 so you can use `await foreach`. This is the new Update notation in the async era.

 ```csharp
 // Unity 2020.2, C# 8.0
@@ -534,7 +657,7 @@ await okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).ForEachAsy
 });
 ```

-Fire and Forget style(for example, event handling), also you can use `Subscribe`.
+Fire and Forget style(for example, event handling), you can also use `Subscribe`.

 ```csharp
 okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).Subscribe(_ =>
@@ -558,7 +681,7 @@ SelectAwaitWithCancellation(Func<T, CancellationToken, UniTask<TR>> selector)

 If you want to use the `async` method inside the func, use the `***Await` or `***AwaitWithCancellation`.

-How to create async iterator, C# 8.0 supports async iterator(`async yield return`) but it only allows `IAsyncEnumerable<T>` and of course requires C# 8.0. UniTask supports `UniTaskAsyncEnumerable.Create` method to create custom async iterator.
+How to create an async iterator: C# 8.0 supports async iterator(`async yield return`) but it only allows `IAsyncEnumerable<T>` and of course requires C# 8.0. UniTask supports `UniTaskAsyncEnumerable.Create` method to create custom async iterator.

 ```csharp
 // IAsyncEnumerable, C# 8.0 version of async iterator. ( do not use this style, IAsyncEnumerable is not controled in UniTask).
@@ -634,7 +757,7 @@ async UniTask TripleClick(CancellationToken token)
 }
 ```

-All MonoBehaviour message events can convert async-streams by `AsyncTriggers` that can enable by `using Cysharp.Threading.Tasks.Triggers;`.
+All MonoBehaviour message events can convert async-streams by `AsyncTriggers` that can be enabled by `using Cysharp.Threading.Tasks.Triggers;`.

 ```csharp
 using Cysharp.Threading.Tasks.Triggers;
@@ -650,7 +773,7 @@ async UniTaskVoid MonitorCollision()
 }
 ```

-Similar as uGUI event, AsyncTrigger can get by `GetAsync***Trigger` and trigger it self is UniTaskAsyncEnumerable.
+Similar to uGUI event, AsyncTrigger can be created using `GetAsync***Trigger` and triggers itself as UniTaskAsyncEnumerable.

 ```csharp
 // use await multiple times, get AsyncTriggerHandler is more efficient.
@@ -667,7 +790,7 @@ await this.GetAsyncMoveTrigger().ForEachAsync(axisEventData =>
 });
 ```

-`AsyncReactiveProperty`, `AsyncReadOnlyReactiveProperty` is UniTask version of UniTask's ReactiveProperty. `BindTo` extension method of `IUniTaskAsyncEnumerable<T>` for binding asynchronous stream values to Unity components(Text/Selectable/TMP/Text).
+`AsyncReactiveProperty`, `AsyncReadOnlyReactiveProperty` is UniTask's version of ReactiveProperty. `BindTo` extension method of `IUniTaskAsyncEnumerable<T>` for binding asynchronous stream values to Unity components(Text/Selectable/TMP/Text).

 ```csharp
 var rp = new AsyncReactiveProperty<int>(99);
@@ -702,9 +825,9 @@ await button.OnClickAsAsyncEnumerable().ForEachAwaitAsync(async x =>
 });
 ```

-It is useful(prevent double-click) but not useful in sometimes.
+It is useful (prevent double-click) but not useful sometimes.

-Using `Queue()` method, which will also queue events during asynchronous processing.
+Using the `Queue()` method will also queue events during asynchronous processing.

 ```csharp
 // queued message in asynchronous processing
@@ -725,13 +848,13 @@ button.OnClickAsAsyncEnumerable().Subscribe(async x =>

 Channel
 ---
-`Channel` is same as [System.Threading.Tasks.Channels](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.channels?view=netcore-3.1) that is similar as GoLang Channel.
+`Channel` is the same as [System.Threading.Tasks.Channels](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.channels?view=netcore-3.1) which is similar to a GoLang Channel.

-Currently only supports multiple-producer, single-consumer unbounded channel. It can create by `Channel.CreateSingleConsumerUnbounded<T>()`.
+Currently it only supports multiple-producer, single-consumer unbounded channels. It can create by `Channel.CreateSingleConsumerUnbounded<T>()`.

-For producer(`.Writer`), `TryWrite` to push value and `TryComplete` to complete channel. For consumer(`.Reader`), `TryRead`, `WaitToReadAsync`, `ReadAsync`, `Completion` and `ReadAllAsync` to read queued messages.
+For producer(`.Writer`), use `TryWrite` to push value and `TryComplete` to complete channel. For consumer(`.Reader`), use `TryRead`, `WaitToReadAsync`, `ReadAsync`, `Completion` and `ReadAllAsync` to read queued messages.

-`ReadAllAsync` returns `IUniTaskAsyncEnumerable<T>` so query LINQ operators. Reader only allows single-consumer but use `.Publish()` query operator to enable multicast message. For example, make pub/sub utility.
+`ReadAllAsync` returns `IUniTaskAsyncEnumerable<T>` so query LINQ operators. Reader only allows single-consumer but uses `.Publish()` query operator to enable multicast message. For example, make pub/sub utility.

 ```csharp
 public class AsyncMessageBroker<T> : IDisposable
@@ -768,7 +891,7 @@ public class AsyncMessageBroker<T> : IDisposable

 For Unit Testing
 ---
-Unity's `[UnityTest]` attribute can test coroutine(IEnumerator) but can not test async. `UniTask.ToCoroutine` bridges async/await to coroutine so you can test async method.
+Unity's `[UnityTest]` attribute can test coroutine(IEnumerator) but can not test async. `UniTask.ToCoroutine` bridges async/await to coroutine so you can test async methods.

 ```csharp
 [UnityTest]
@@ -791,33 +914,34 @@ public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () =>
 });
 ```

-UniTask itself's unit test is written by Unity Test Runner and [Cysharp/RuntimeUnitTestToolkit](https://github.com/Cysharp/RuntimeUnitTestToolkit) to check on CI and IL2CPP working.
+UniTask's own unit tests are written using Unity Test Runner and [Cysharp/RuntimeUnitTestToolkit](https://github.com/Cysharp/RuntimeUnitTestToolkit) to integrate with CI and check if IL2CPP is working.

 ThreadPool limitation
 ---
-Most UniTask methods run in a single thread (PlayerLoop), but only `UniTask.Run` and `UniTask.SwitchToThreadPool` run on a thread pool. If you use a thread pool, it won't work with WebGL and so on.
+Most UniTask methods run on a single thread (PlayerLoop), with only `UniTask.Run` and `UniTask.SwitchToThreadPool` running on a thread pool. If you use a thread pool, it won't work with WebGL and so on.

-`UniTask.Run` will be deprecated in the future (marked with an Obsolete) and only `RunOnThreadPool` will be used. Also, if you use `UniTask.Run`, consider whether you can use `UniTask.Create` or `UniTask.Void`.
+`UniTask.Run` will be deprecated in the future (marked with an Obsolete) and only `RunOnThreadPool` will be used. If you use `UniTask.Run`, consider whether you can use `UniTask.Create` or `UniTask.Void`.

 IEnumerator.ToUniTask limitation
 ---
-You can convert coroutine(IEnumerator) to UniTask(or await directly) but has some limitations.
+You can convert coroutine(IEnumerator) to UniTask(or await directly) but it has some limitations.

 * `WaitForEndOfFrame`/`WaitForFixedUpdate`/`Coroutine` is not supported.
-* Consuming loop timing is not same as StartCoroutine, it is used specified PlayerLoopTiming, and default's `PlayerLoopTiming.Update` is run before MonoBehaviour's Update and StartCoroutine's loop.
+* Consuming loop timing is not the same as `StartCoroutine`, it uses the specified `PlayerLoopTiming` and the default `PlayerLoopTiming.Update` is run before MonoBehaviour's `Update` and `StartCoroutine`'s loop.

-If you want to convert fully compatible from coroutine to async, use `IEnumerator.ToUniTask(MonoBehaviour coroutineRunner)` overload. It executes StartCoroutine on an instance of the argument MonoBehaviour and waits for it to complete in UniTask.
+If you want fully compatible conversion from coroutine to async, use the `IEnumerator.ToUniTask(MonoBehaviour coroutineRunner)` overload. It executes StartCoroutine on an instance of the argument MonoBehaviour and waits for it to complete in UniTask.

 For UnityEditor
 ---
-UniTask can run on Unity Edtitor like Editor Coroutine. However, there are some limitations.
+UniTask can run on Unity Editor like an Editor Coroutine. However, there are some limitations.

-* Delay, DelayFrame is not work correctly because can not get deltaTime in editor. Return the result of the await immediately; you can use `DelayType.Realtime` to wait for the right time.
-* All PlayerLoopTiming run on timing, `EditorApplication.update`.
+* UniTask.Delay's DelayType.DeltaTime, UnscaledDeltaTime do not work correctly because they can not get deltaTime in editor. Therefore run on EditMode, automatically change DelayType to `DelayType.Realtime` that wait for the right time.
+* All PlayerLoopTiming run on the timing `EditorApplication.update`.
+* `-batchmode` with `-quit` does not work because does not run `EditorApplication.update`(quit on single frame) so should not use `-quit` and quit manually with `Environment.Exit(0)`.

 Compare with Standard Task API
 ---
-UniTask has many standard Task-like APIs. This table shows what is the alternative apis.
+UniTask has many standard Task-like APIs. This table shows what the alternative apis are.

 Use standard type.

@@ -863,7 +987,7 @@ Use UniTask type.

 Pooling Configuration
 ---
-UniTask is aggressively caching async promise object to achive zero allocation(technical details, see blog post [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)). In default, cache all promises but you can configure `TaskPool.SetMaxPoolSize` to your value, the value indicates cache size per type. `TaskPool.GetCacheSizeInfo` returns current cached object in pool.
+UniTask aggressively caches async promise objects to achieve zero allocation (for technical details, see blog post [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)). By default, it caches all promises but you can configure `TaskPool.SetMaxPoolSize` to your value, the value indicates cache size per type. `TaskPool.GetCacheSizeInfo` returns currently cached objects in pool.

 ```csharp
 foreach (var (type, size) in TaskPool.GetCacheSizeInfo())
@@ -874,17 +998,17 @@ foreach (var (type, size) in TaskPool.GetCacheSizeInfo())

 Allocation on Profiler
 ---
-In UnityEditor profiler shows allocation of compiler generated AsyncStateMachine but it only occurs in debug(development) build. C# Compiler generate AsyncStateMachine as class on Debug build and as struct on Release build.
+In UnityEditor the profiler shows allocation of compiler generated AsyncStateMachine but it only occurs in debug(development) build. C# Compiler generates AsyncStateMachine as class on Debug build and as struct on Release build.

-After Unity 2020.1 supports Code Optimization option on UnityEditor(right, footer).
+Unity supports Code Optimization option starting in 2020.1 (right, footer).

 ![](https://user-images.githubusercontent.com/46207/89967342-2f944600-dc8c-11ea-99fc-0b74527a16f6.png)

-You can change C# compiler optimization to release, it removes AsyncStateMachine allocation. Andalso optimization option can set via `Compilation.CompilationPipeline-codeOptimization`, and `Compilation.CodeOptimization`.
+You can change C# compiler optimization to release to remove AsyncStateMachine allocation in development builds. This optimization option can also be set via `Compilation.CompilationPipeline-codeOptimization`, and `Compilation.CodeOptimization`.

 UniTaskSynchronizationContext
 ---
-Unity's default SynchronizationContext(`UnitySynchronizationContext`) is poor implementation for performance. UniTask itself is bypass `SynchronizationContext`(and `ExecutionContext`) so does not use it but if exists in `async Task`, still used it. `UniTaskSynchronizationContext` is replacement of `UnitySynchronizationContext`, it is better for performance.
+Unity's default SynchronizationContext(`UnitySynchronizationContext`) is a poor implementation for performance. UniTask bypasses `SynchronizationContext`(and `ExecutionContext`) so it does not use it but if exists in `async Task`, still used it. `UniTaskSynchronizationContext` is a replacement of `UnitySynchronizationContext` which is better for performance.

 ```csharp
 public class SyncContextInjecter
@@ -897,19 +1021,19 @@ public class SyncContextInjecter
 }
 ```

-This is an optional choice and is not always recommended; `UniTaskSynchronizationContext` is less performance than `async UniTask` and is not a complete UniTask replacement. It also does not guarantee full behavioral compatibility with the `UnitySynchronizationContext`.
+This is an optional choice and is not always recommended; `UniTaskSynchronizationContext` is less performant than `async UniTask` and is not a complete UniTask replacement. It also does not guarantee full behavioral compatibility with the `UnitySynchronizationContext`.

 API References
 ---
-UniTask's API References is hosted at [cysharp.github.io/UniTask](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.html) by [DocFX](https://dotnet.github.io/docfx/) and [Cysharp/DocfXTemplate](https://github.com/Cysharp/DocfxTemplate).
+UniTask's API References are hosted at [cysharp.github.io/UniTask](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.html) by [DocFX](https://dotnet.github.io/docfx/) and [Cysharp/DocfXTemplate](https://github.com/Cysharp/DocfxTemplate).

-For example, UniTask's factory methods can see at [UniTask#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.UniTask.html#methods-1). UniTaskAsyncEnumerable's factory/extension methods can see at [UniTaskAsyncEnumerable#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.Linq.UniTaskAsyncEnumerable.html#methods-1).
+For example, UniTask's factory methods can be seen at [UniTask#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.UniTask.html#methods-1). UniTaskAsyncEnumerable's factory/extension methods can be seen at [UniTaskAsyncEnumerable#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.Linq.UniTaskAsyncEnumerable.html#methods-1).

 UPM Package
 ---
 ### Install via git URL

-After Unity 2019.3.4f1, Unity 2020.1a21, that support path query parameter of git package. You can add `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask` to Package Manager
+Requires a version of unity that supports path query parameter for git packages (Unity >= 2019.3.4f1, Unity >= 2020.1a21). You can add `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask` to Package Manager

 ![image](https://user-images.githubusercontent.com/46207/79450714-3aadd100-8020-11ea-8aae-b8d87fc4d7be.png)

@@ -917,7 +1041,7 @@ After Unity 2019.3.4f1, Unity 2020.1a21, that support path query parameter of gi

 or add `"com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask"` to `Packages/manifest.json`.

-If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#2.1.0`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.1.0`.
+If you want to set a target version, UniTask uses the `*.*.*` release tag so you can specify a version like `#2.1.0`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.1.0`.

 ### Install via OpenUPM

@@ -933,11 +1057,11 @@ For .NET Core, use NuGet.

 > PM> Install-Package [UniTask](https://www.nuget.org/packages/UniTask)

-UniTask of .NET Core version is a subset of Unity UniTask, removed PlayerLoop dependent methods.
+UniTask of .NET Core version is a subset of Unity UniTask with PlayerLoop dependent methods removed.

 It runs at higher performance than the standard Task/ValueTask, but you should be careful to ignore the ExecutionContext/SynchronizationContext when using it. `AysncLocal` also does not work because it ignores ExecutionContext.

-If you use UniTask internally, but provide ValueTask as an external API, you can write like the following(Inspired by [PooledAwait](https://github.com/mgravell/PooledAwait)).
+If you use UniTask internally, but provide ValueTask as an external API, you can write it like the following(Inspired by [PooledAwait](https://github.com/mgravell/PooledAwait)).

 ```csharp
 public class ZeroAllocAsyncAwaitInDotNetCore
@@ -970,7 +1094,7 @@ public ValueTask TestAsync()

 .NET Core version is intended to allow users to use UniTask as an interface when sharing code with Unity (such as [Cysharp/MagicOnion](https://github.com/Cysharp/MagicOnion/)). .NET Core version of UniTask enables smooth code sharing.

-Utility methods such as WhenAll which is equivalent to UniTask are provided as [Cysharp/ValueTaskSupplement](https://github.com/Cysharp/ValueTaskSupplement).
+Utility methods such as WhenAll which are equivalent to UniTask are provided as [Cysharp/ValueTaskSupplement](https://github.com/Cysharp/ValueTaskSupplement).

 License
 ---
--- a/src/UniTask.NetCore/UniTask.NetCore.csproj
+++ b/src/UniTask.NetCore/UniTask.NetCore.csproj
@@ -41,6 +41,7 @@
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTaskSynchronizationContext.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\CancellationTokenSourceExtensions.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\EnumeratorAsyncExtensions.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\TimeoutController.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\PlayerLoopHelper.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Delay.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Run.cs;
--- a/src/UniTask.NetCoreTests/WithCancellationTest.cs
+++ b/src/UniTask.NetCoreTests/WithCancellationTest.cs
@@ -16,7 +16,7 @@ namespace NetCoreTests
        {
            CancellationTokenSource cts = new CancellationTokenSource();

-            var v = await UniTask.Run(() => 10).WithCancellation(cts.Token);
+            var v = await UniTask.Run(() => 10).AttachExternalCancellation(cts.Token);

            v.Should().Be(10);
        }
@@ -30,7 +30,7 @@ namespace NetCoreTests
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
                return 10;
-            }).WithCancellation(cts.Token);
+            }).AttachExternalCancellation(cts.Token);

            cts.Cancel();

--- a/src/UniTask/Assets/Editor/EditorRunnerChecker.cs
+++ b/src/UniTask/Assets/Editor/EditorRunnerChecker.cs
@@ -20,8 +20,9 @@ public static class EditorRunnerChecker
    {
        Debug.Log("Start");

-        var r = await UnityWebRequest.Get("https://bing.com/").SendWebRequest().ToUniTask();
-        Debug.Log(r.downloadHandler.text.Substring(0, 100));
+        //var r = await UnityWebRequest.Get("https://bing.com/").SendWebRequest().ToUniTask();
+        //Debug.Log(r.downloadHandler.text.Substring(0, 100));
+        await UniTask.Yield();

        Debug.Log("End");
    }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenSourceExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenSourceExtensions.cs
@@ -7,6 +7,7 @@ using System;

 namespace Cysharp.Threading.Tasks
 {
+
    public static class CancellationTokenSourceExtensions
    {
        public static void CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/UnityWebRequestExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/UnityWebRequestExtensions.cs
@@ -7,6 +7,8 @@ using UnityEngine.Networking;

 namespace Cysharp.Threading.Tasks.Internal
 {
+#if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT)
+    
    internal static class UnityWebRequestResultExtensions
    {
        public static bool IsError(this UnityWebRequest unityWebRequest)
@@ -21,4 +23,6 @@ namespace Cysharp.Threading.Tasks.Internal
 #endif
        }
    }
+
+#endif
 }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs
@@ -98,6 +98,79 @@ namespace Cysharp.Threading.Tasks
 #endif
    }

+    [Flags]
+    public enum InjectPlayerLoopTimings
+    {
+        /// <summary>
+        /// Preset: All loops(default).
+        /// </summary>
+        All =
+            Initialization | LastInitialization |
+            EarlyUpdate | LastEarlyUpdate |
+            FixedUpdate | LastFixedUpdate |
+            PreUpdate | LastPreUpdate |
+            Update | LastUpdate |
+            PreLateUpdate | LastPreLateUpdate |
+            PostLateUpdate | LastPostLateUpdate
+#if UNITY_2020_2_OR_NEWER
+            | TimeUpdate | LastTimeUpdate,
+#else
+            ,
+#endif
+
+        /// <summary>
+        /// Preset: All without last except LastPostLateUpdate.
+        /// </summary>
+        Standard =
+            Initialization |
+            EarlyUpdate |
+            FixedUpdate |
+            PreUpdate |
+            Update |
+            PreLateUpdate |
+            PostLateUpdate | LastPostLateUpdate
+#if UNITY_2020_2_OR_NEWER
+            | TimeUpdate
+#endif
+            ,
+
+        /// <summary>
+        /// Preset: Minimum pattern, Update | FixedUpdate | LastPostLateUpdate
+        /// </summary>
+        Minimum =
+            Update | FixedUpdate | LastPostLateUpdate,
+
+        // PlayerLoopTiming
+
+        Initialization = 1,
+        LastInitialization = 2,
+
+        EarlyUpdate = 4,
+        LastEarlyUpdate = 8,
+
+        FixedUpdate = 16,
+        LastFixedUpdate = 32,
+
+        PreUpdate = 64,
+        LastPreUpdate = 128,
+
+        Update = 256,
+        LastUpdate = 512,
+
+        PreLateUpdate = 1024,
+        LastPreLateUpdate = 2048,
+
+        PostLateUpdate = 4096,
+        LastPostLateUpdate = 8192
+
+#if UNITY_2020_2_OR_NEWER
+        ,
+        // Unity 2020.2 added TimeUpdate https://docs.unity3d.com/2020.2/Documentation/ScriptReference/PlayerLoop.TimeUpdate.html
+        TimeUpdate = 16384,
+        LastTimeUpdate = 32768
+#endif
+    }
+
    public interface IPlayerLoopItem
    {
        bool MoveNext();
@@ -105,6 +178,9 @@ namespace Cysharp.Threading.Tasks

    public static class PlayerLoopHelper
    {
+        static readonly ContinuationQueue ThrowMarkerContinuationQueue = new ContinuationQueue(PlayerLoopTiming.Initialization);
+        static readonly PlayerLoopRunner ThrowMarkerPlayerLoopRunner = new PlayerLoopRunner(PlayerLoopTiming.Initialization);
+
        public static SynchronizationContext UnitySynchronizationContext => unitySynchronizationContetext;
        public static int MainThreadId => mainThreadId;
        internal static string ApplicationDataPath => applicationDataPath;
@@ -118,8 +194,9 @@ namespace Cysharp.Threading.Tasks
        static PlayerLoopRunner[] runners;
        internal static bool IsEditorApplicationQuitting { get; private set; }
        static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem,
-            Type loopRunnerYieldType, ContinuationQueue cq, Type lastLoopRunnerYieldType, ContinuationQueue lastCq,
-            Type loopRunnerType, PlayerLoopRunner runner, Type lastLoopRunnerType, PlayerLoopRunner lastRunner)
+            bool injectOnFirst,
+            Type loopRunnerYieldType, ContinuationQueue cq,
+            Type loopRunnerType, PlayerLoopRunner runner)
        {

 #if UNITY_EDITOR
@@ -134,22 +211,11 @@ namespace Cysharp.Threading.Tasks
                        runner.Run();
                        runner.Clear();
                    }
-                    if (lastRunner != null)
-                    {
-                        lastRunner.Run();
-                        lastRunner.Clear();
-                    }
-
                    if (cq != null)
                    {
                        cq.Run();
                        cq.Clear();
                    }
-                    if (lastCq != null)
-                    {
-                        lastCq.Run();
-                        lastCq.Clear();
-                    }
                    IsEditorApplicationQuitting = false;
                }
            };
@@ -161,40 +227,38 @@ namespace Cysharp.Threading.Tasks
                updateDelegate = cq.Run
            };

-            var lastYieldLoop = new PlayerLoopSystem
-            {
-                type = lastLoopRunnerYieldType,
-                updateDelegate = lastCq.Run
-            };
-
            var runnerLoop = new PlayerLoopSystem
            {
                type = loopRunnerType,
                updateDelegate = runner.Run
            };

-            var lastRunnerLoop = new PlayerLoopSystem
-            {
-                type = lastLoopRunnerType,
-                updateDelegate = lastRunner.Run
-            };
-
            // Remove items from previous initializations.
-            var source = loopSystem.subSystemList
-                .Where(ls => ls.type != loopRunnerYieldType && ls.type != loopRunnerType && ls.type != lastLoopRunnerYieldType && ls.type != lastLoopRunnerType)
-                .ToArray();
+            var source = RemoveRunner(loopSystem, loopRunnerYieldType, loopRunnerType);
+            var dest = new PlayerLoopSystem[source.Length + 2];

-            var dest = new PlayerLoopSystem[source.Length + 4];
-
-            Array.Copy(source, 0, dest, 2, source.Length);
-            dest[0] = yieldLoop;
-            dest[1] = runnerLoop;
-            dest[dest.Length - 2] = lastYieldLoop;
-            dest[dest.Length - 1] = lastRunnerLoop;
+            Array.Copy(source, 0, dest, injectOnFirst ? 2 : 0, source.Length);
+            if (injectOnFirst)
+            {
+                dest[0] = yieldLoop;
+                dest[1] = runnerLoop;
+            }
+            else
+            {
+                dest[dest.Length - 2] = yieldLoop;
+                dest[dest.Length - 1] = runnerLoop;
+            }

            return dest;
        }

+        static PlayerLoopSystem[] RemoveRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType, Type loopRunnerType)
+        {
+            return loopSystem.subSystemList
+                .Where(ls => ls.type != loopRunnerYieldType && ls.type != loopRunnerType)
+                .ToArray();
+        }
+
        static PlayerLoopSystem[] InsertUniTaskSynchronizationContext(PlayerLoopSystem loopSystem)
        {
            var loop = new PlayerLoopSystem
@@ -311,7 +375,23 @@ namespace Cysharp.Threading.Tasks
            throw new Exception("Target PlayerLoopSystem does not found. Type:" + systemType.FullName);
        }

-        public static void Initialize(ref PlayerLoopSystem playerLoop)
+        static void InsertLoop(PlayerLoopSystem[] copyList, InjectPlayerLoopTimings injectTimings, Type loopType, InjectPlayerLoopTimings targetTimings,
+            int index, bool injectOnFirst, Type loopRunnerYieldType, Type loopRunnerType, PlayerLoopTiming playerLoopTiming)
+        {
+            var i = FindLoopSystemIndex(copyList, loopType);
+            if ((injectTimings & targetTimings) == targetTimings)
+            {
+                copyList[i].subSystemList = InsertRunner(copyList[i], injectOnFirst,
+                    loopRunnerYieldType, yielders[index] = new ContinuationQueue(playerLoopTiming),
+                    loopRunnerType, runners[index] = new PlayerLoopRunner(playerLoopTiming));
+            }
+            else
+            {
+                copyList[i].subSystemList = RemoveRunner(copyList[i], loopRunnerYieldType, loopRunnerType);
+            }
+        }
+
+        public static void Initialize(ref PlayerLoopSystem playerLoop, InjectPlayerLoopTimings injectTimings = InjectPlayerLoopTimings.All)
        {
 #if UNITY_2020_2_OR_NEWER
            yielders = new ContinuationQueue[16];
@@ -323,58 +403,82 @@ namespace Cysharp.Threading.Tasks

            var copyList = playerLoop.subSystemList.ToArray();

-            var i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Initialization));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(PlayerLoopTiming.Initialization),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), yielders[1] = new ContinuationQueue(PlayerLoopTiming.LastInitialization),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[0] = new PlayerLoopRunner(PlayerLoopTiming.Initialization),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), runners[1] = new PlayerLoopRunner(PlayerLoopTiming.LastInitialization));
+            // Initialization
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Initialization),
+                InjectPlayerLoopTimings.Initialization, 0, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), PlayerLoopTiming.Initialization);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Initialization),
+                InjectPlayerLoopTimings.LastInitialization, 1, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), PlayerLoopTiming.LastInitialization);
+
            // EarlyUpdate
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.EarlyUpdate));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[2] = new ContinuationQueue(PlayerLoopTiming.EarlyUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldEarlyUpdate), yielders[3] = new ContinuationQueue(PlayerLoopTiming.LastEarlyUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), runners[2] = new PlayerLoopRunner(PlayerLoopTiming.EarlyUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastEarlyUpdate), runners[3] = new PlayerLoopRunner(PlayerLoopTiming.LastEarlyUpdate));
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.EarlyUpdate),
+                InjectPlayerLoopTimings.EarlyUpdate, 2, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), PlayerLoopTiming.EarlyUpdate);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.EarlyUpdate),
+                InjectPlayerLoopTimings.LastEarlyUpdate, 3, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldEarlyUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastEarlyUpdate), PlayerLoopTiming.LastEarlyUpdate);
+
            // FixedUpdate
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.FixedUpdate));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[4] = new ContinuationQueue(PlayerLoopTiming.FixedUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldFixedUpdate), yielders[5] = new ContinuationQueue(PlayerLoopTiming.LastFixedUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), runners[4] = new PlayerLoopRunner(PlayerLoopTiming.FixedUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastFixedUpdate), runners[5] = new PlayerLoopRunner(PlayerLoopTiming.LastFixedUpdate));
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.FixedUpdate),
+                InjectPlayerLoopTimings.FixedUpdate, 4, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), PlayerLoopTiming.FixedUpdate);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.FixedUpdate),
+                InjectPlayerLoopTimings.LastFixedUpdate, 5, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldFixedUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastFixedUpdate), PlayerLoopTiming.LastFixedUpdate);
+
            // PreUpdate
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.PreUpdate));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[6] = new ContinuationQueue(PlayerLoopTiming.PreUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreUpdate), yielders[7] = new ContinuationQueue(PlayerLoopTiming.LastPreUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), runners[6] = new PlayerLoopRunner(PlayerLoopTiming.PreUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreUpdate), runners[7] = new PlayerLoopRunner(PlayerLoopTiming.LastPreUpdate));
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreUpdate),
+                InjectPlayerLoopTimings.PreUpdate, 6, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), PlayerLoopTiming.PreUpdate);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreUpdate),
+                InjectPlayerLoopTimings.LastPreUpdate, 7, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreUpdate), PlayerLoopTiming.LastPreUpdate);
+
            // Update
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Update));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[8] = new ContinuationQueue(PlayerLoopTiming.Update),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldUpdate), yielders[9] = new ContinuationQueue(PlayerLoopTiming.LastUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), runners[8] = new PlayerLoopRunner(PlayerLoopTiming.Update),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastUpdate), runners[9] = new PlayerLoopRunner(PlayerLoopTiming.LastUpdate));
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Update),
+                InjectPlayerLoopTimings.Update, 8, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), PlayerLoopTiming.Update);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Update),
+                InjectPlayerLoopTimings.LastUpdate, 9, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastUpdate), PlayerLoopTiming.LastUpdate);
+
            // PreLateUpdate
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.PreLateUpdate));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[10] = new ContinuationQueue(PlayerLoopTiming.PreLateUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreLateUpdate), yielders[11] = new ContinuationQueue(PlayerLoopTiming.LastPreLateUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), runners[10] = new PlayerLoopRunner(PlayerLoopTiming.PreLateUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreLateUpdate), runners[11] = new PlayerLoopRunner(PlayerLoopTiming.LastPreLateUpdate));
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreLateUpdate),
+                InjectPlayerLoopTimings.PreLateUpdate, 10, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), PlayerLoopTiming.PreLateUpdate);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreLateUpdate),
+                InjectPlayerLoopTimings.LastPreLateUpdate, 11, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreLateUpdate), PlayerLoopTiming.LastPreLateUpdate);
+
            // PostLateUpdate
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.PostLateUpdate));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[12] = new ContinuationQueue(PlayerLoopTiming.PostLateUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPostLateUpdate), yielders[13] = new ContinuationQueue(PlayerLoopTiming.LastPostLateUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[12] = new PlayerLoopRunner(PlayerLoopTiming.PostLateUpdate),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), runners[13] = new PlayerLoopRunner(PlayerLoopTiming.LastPostLateUpdate));
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PostLateUpdate),
+                InjectPlayerLoopTimings.PostLateUpdate, 12, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), PlayerLoopTiming.PostLateUpdate);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PostLateUpdate),
+                InjectPlayerLoopTimings.LastPostLateUpdate, 13, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPostLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), PlayerLoopTiming.LastPostLateUpdate);
+
 #if UNITY_2020_2_OR_NEWER
            // TimeUpdate
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.TimeUpdate));
-            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldTimeUpdate), yielders[14] = new ContinuationQueue(PlayerLoopTiming.TimeUpdate),
-                                                                    typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldTimeUpdate), yielders[15] = new ContinuationQueue(PlayerLoopTiming.LastTimeUpdate),
-                                                                    typeof(UniTaskLoopRunners.UniTaskLoopRunnerTimeUpdate), runners[14] = new PlayerLoopRunner(PlayerLoopTiming.TimeUpdate),
-                                                                    typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastTimeUpdate), runners[15] = new PlayerLoopRunner(PlayerLoopTiming.LastTimeUpdate));
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.TimeUpdate),
+                InjectPlayerLoopTimings.TimeUpdate, 14, true,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldTimeUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerTimeUpdate), PlayerLoopTiming.TimeUpdate);
+
+            InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.TimeUpdate),
+                InjectPlayerLoopTimings.LastTimeUpdate, 15, false,
+                typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldTimeUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastTimeUpdate), PlayerLoopTiming.LastTimeUpdate);
 #endif

            // Insert UniTaskSynchronizationContext to Update loop
-            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Update));
+            var i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Update));
            copyList[i].subSystemList = InsertUniTaskSynchronizationContext(copyList[i]);

            playerLoop.subSystemList = copyList;
@@ -383,12 +487,27 @@ namespace Cysharp.Threading.Tasks

        public static void AddAction(PlayerLoopTiming timing, IPlayerLoopItem action)
        {
-            runners[(int)timing].AddAction(action);
+            var runner = runners[(int)timing];
+            if (runner == null)
+            {
+                ThrowInvalidLoopTiming(timing);
+            }
+            runner.AddAction(action);
+        }
+
+        static void ThrowInvalidLoopTiming(PlayerLoopTiming playerLoopTiming)
+        {
+            throw new InvalidOperationException("Target playerLoopTiming is not injected. Please check PlayerLoopHelper.Initialize. PlayerLoopTiming:" + playerLoopTiming);
        }

        public static void AddContinuation(PlayerLoopTiming timing, Action continuation)
        {
-            yielders[(int)timing].Enqueue(continuation);
+            var q = yielders[(int)timing];
+            if (q == null)
+            {
+                ThrowInvalidLoopTiming(timing);
+            }
+            q.Enqueue(continuation);
        }

        // Diagnostics helper
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/TimeoutController.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/TimeoutController.cs
@@ -0,0 +1,258 @@
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using System;
+using Cysharp.Threading.Tasks.Internal;
+
+namespace Cysharp.Threading.Tasks
+{
+    // CancellationTokenSource itself can not reuse but CancelAfter(Timeout.InfiniteTimeSpan) allows reuse if did not reach timeout.
+    // Similar discussion:
+    // https://github.com/dotnet/runtime/issues/4694
+    // https://github.com/dotnet/runtime/issues/48492
+    // This TimeoutController emulate similar implementation, using CancelAfterSlim; to achieve zero allocation timeout.
+
+    public sealed class TimeoutController : IDisposable
+    {
+        CancellationTokenSource timeoutSource;
+        CancellationTokenSource linkedSource;
+        StoppableDelayRealtimePromise timeoutDelay;
+
+        readonly CancellationTokenSource originalLinkCancellationTokenSource;
+
+        public TimeoutController()
+        {
+            this.timeoutSource = new CancellationTokenSource();
+            this.originalLinkCancellationTokenSource = null;
+            this.linkedSource = null;
+            this.timeoutDelay = null;
+        }
+
+        public TimeoutController(CancellationTokenSource linkCancellationTokenSource)
+        {
+            this.timeoutSource = new CancellationTokenSource();
+            this.originalLinkCancellationTokenSource = linkCancellationTokenSource;
+            this.linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, linkCancellationTokenSource.Token);
+            this.timeoutDelay = null;
+        }
+
+        public CancellationToken Timeout(TimeSpan timeout)
+        {
+            if (originalLinkCancellationTokenSource != null && originalLinkCancellationTokenSource.IsCancellationRequested)
+            {
+                return originalLinkCancellationTokenSource.Token;
+            }
+
+            if (timeoutSource.IsCancellationRequested)
+            {
+                timeoutSource.Dispose();
+                timeoutSource = new CancellationTokenSource();
+                if (linkedSource != null)
+                {
+                    this.linkedSource.Cancel();
+                    this.linkedSource.Dispose();
+                    this.linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, originalLinkCancellationTokenSource.Token);
+                }
+            }
+
+            if (timeoutDelay == null)
+            {
+                RunDelayAsync(timeout).Forget(); // timeoutDelay = ... in RunDelayAsync(immediately, before await)
+            }
+            else
+            {
+                timeoutDelay.RestartStopwatch(); // already running RunDelayAsync
+            }
+
+            return (linkedSource != null) ? linkedSource.Token : timeoutSource.Token;
+        }
+
+        public bool IsTimeout()
+        {
+            return timeoutSource.IsCancellationRequested;
+        }
+
+        public void Reset()
+        {
+            if (timeoutDelay != null)
+            {
+                timeoutDelay.Stop(); // stop delay, will finish RunDelayAsync
+                timeoutDelay = null;
+            }
+        }
+
+        async UniTaskVoid RunDelayAsync(TimeSpan timeout)
+        {
+            timeoutDelay = StoppableDelayRealtimePromise.Create(timeout, PlayerLoopTiming.Update, (linkedSource == null) ? CancellationToken.None : linkedSource.Token, out var version);
+            try
+            {
+                var reason = await new UniTask<DelayResult>(timeoutDelay, version);
+                if (reason == DelayResult.DelayCompleted)
+                {
+                    // UnityEngine.Debug.Log("DEBUG:Timeout Complete, try to call timeoutSource.Cancel");
+                    timeoutSource.Cancel();
+                }
+                else if (reason == DelayResult.LinkedTokenCanceled)
+                {
+                    // UnityEngine.Debug.Log("DEBUG:LinkedSource IsCancellationRequested");
+                }
+                else if (reason == DelayResult.ExternalStopped)
+                {
+                    // Reset(Promise.Stop) called, do nothing.
+                    // UnityEngine.Debug.Log("DEBUG:Reset called");
+                }
+            }
+            finally
+            {
+                timeoutDelay = null;
+            }
+        }
+
+        public void Dispose()
+        {
+            if (timeoutDelay != null)
+            {
+                timeoutDelay.Stop();
+            }
+            timeoutSource.Dispose();
+            if (linkedSource != null)
+            {
+                linkedSource.Dispose();
+            }
+        }
+
+        enum DelayResult
+        {
+            LinkedTokenCanceled,
+            ExternalStopped,
+            DelayCompleted, // as Timeout.
+        }
+
+        // Stop + SuppressCancellationThrow.
+        sealed class StoppableDelayRealtimePromise : IUniTaskSource<DelayResult>, IPlayerLoopItem, ITaskPoolNode<StoppableDelayRealtimePromise>
+        {
+            static OperationCanceledException ExterenalStopException = new OperationCanceledException();
+
+            static TaskPool<StoppableDelayRealtimePromise> pool;
+            StoppableDelayRealtimePromise nextNode;
+            public ref StoppableDelayRealtimePromise NextNode => ref nextNode;
+
+            static StoppableDelayRealtimePromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(StoppableDelayRealtimePromise), () => pool.Size);
+            }
+
+            long delayTimeSpanTicks;
+            ValueStopwatch stopwatch;
+            CancellationToken cancellationToken;
+            bool externalStop;
+
+            UniTaskCompletionSourceCore<DelayResult> core;
+
+            StoppableDelayRealtimePromise()
+            {
+            }
+
+            public static StoppableDelayRealtimePromise Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (!pool.TryPop(out var result))
+                {
+                    result = new StoppableDelayRealtimePromise();
+                }
+
+                result.stopwatch = ValueStopwatch.StartNew();
+                result.delayTimeSpanTicks = delayTimeSpan.Ticks;
+                result.cancellationToken = cancellationToken;
+                result.externalStop = false;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public void Stop()
+            {
+                externalStop = true;
+            }
+
+            public void RestartStopwatch()
+            {
+                stopwatch = ValueStopwatch.StartNew();
+            }
+
+            public DelayResult GetResult(short token)
+            {
+                try
+                {
+                    return core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    core.TrySetResult(DelayResult.LinkedTokenCanceled);
+                    return false;
+                }
+
+                if (externalStop)
+                {
+                    core.TrySetResult(DelayResult.ExternalStopped);
+                    return false;
+                }
+
+                if (stopwatch.IsInvalid)
+                {
+                    core.TrySetResult(DelayResult.DelayCompleted);
+                    return false;
+                }
+
+                if (stopwatch.ElapsedTicks >= delayTimeSpanTicks)
+                {
+                    core.TrySetResult(DelayResult.DelayCompleted);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                stopwatch = default;
+                cancellationToken = default;
+                externalStop = false;
+                return pool.TryPush(this);
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/TimeoutController.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/TimeoutController.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6347ab34d2db6d744a654e8d62d96b96
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.cs
@@ -2,7 +2,9 @@

 using System.Threading;
 using UnityEngine;
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT
 using UnityEngine.EventSystems;
+#endif

 namespace Cysharp.Threading.Tasks.Triggers
 {
@@ -715,6 +717,7 @@ namespace Cysharp.Threading.Tasks.Triggers
 #endregion

 #region CollisionEnter
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnCollisionEnterHandler
    {
@@ -771,9 +774,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnCollisionEnterHandler)new AsyncTriggerHandler<Collision>(this, cancellationToken, true)).OnCollisionEnterAsync();
        }
    }
+#endif
 #endregion

 #region CollisionEnter2D
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT

    public interface IAsyncOnCollisionEnter2DHandler
    {
@@ -830,9 +835,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnCollisionEnter2DHandler)new AsyncTriggerHandler<Collision2D>(this, cancellationToken, true)).OnCollisionEnter2DAsync();
        }
    }
+#endif
 #endregion

 #region CollisionExit
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnCollisionExitHandler
    {
@@ -889,9 +896,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnCollisionExitHandler)new AsyncTriggerHandler<Collision>(this, cancellationToken, true)).OnCollisionExitAsync();
        }
    }
+#endif
 #endregion

 #region CollisionExit2D
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT

    public interface IAsyncOnCollisionExit2DHandler
    {
@@ -948,9 +957,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnCollisionExit2DHandler)new AsyncTriggerHandler<Collision2D>(this, cancellationToken, true)).OnCollisionExit2DAsync();
        }
    }
+#endif
 #endregion

 #region CollisionStay
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnCollisionStayHandler
    {
@@ -1007,9 +1018,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnCollisionStayHandler)new AsyncTriggerHandler<Collision>(this, cancellationToken, true)).OnCollisionStayAsync();
        }
    }
+#endif
 #endregion

 #region CollisionStay2D
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT

    public interface IAsyncOnCollisionStay2DHandler
    {
@@ -1066,9 +1079,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnCollisionStay2DHandler)new AsyncTriggerHandler<Collision2D>(this, cancellationToken, true)).OnCollisionStay2DAsync();
        }
    }
+#endif
 #endregion

 #region ControllerColliderHit
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnControllerColliderHitHandler
    {
@@ -1125,6 +1140,7 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnControllerColliderHitHandler)new AsyncTriggerHandler<ControllerColliderHit>(this, cancellationToken, true)).OnControllerColliderHitAsync();
        }
    }
+#endif
 #endregion

 #region Disable
@@ -1423,6 +1439,7 @@ namespace Cysharp.Threading.Tasks.Triggers
 #endregion

 #region JointBreak
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnJointBreakHandler
    {
@@ -1479,9 +1496,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnJointBreakHandler)new AsyncTriggerHandler<float>(this, cancellationToken, true)).OnJointBreakAsync();
        }
    }
+#endif
 #endregion

 #region JointBreak2D
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT

    public interface IAsyncOnJointBreak2DHandler
    {
@@ -1538,6 +1557,7 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnJointBreak2DHandler)new AsyncTriggerHandler<Joint2D>(this, cancellationToken, true)).OnJointBreak2DAsync();
        }
    }
+#endif
 #endregion

 #region MouseDown
@@ -2145,7 +2165,7 @@ namespace Cysharp.Threading.Tasks.Triggers
 #endregion

 #region ParticleUpdateJobScheduled
-#if UNITY_2019_3_OR_NEWER
+#if UNITY_2019_3_OR_NEWER && (!UNITY_2019_1_OR_NEWER || UNITASK_PARTICLESYSTEM_SUPPORT)

    public interface IAsyncOnParticleUpdateJobScheduledHandler
    {
@@ -2796,6 +2816,7 @@ namespace Cysharp.Threading.Tasks.Triggers
 #endregion

 #region TriggerEnter
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnTriggerEnterHandler
    {
@@ -2852,9 +2873,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnTriggerEnterHandler)new AsyncTriggerHandler<Collider>(this, cancellationToken, true)).OnTriggerEnterAsync();
        }
    }
+#endif
 #endregion

 #region TriggerEnter2D
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT

    public interface IAsyncOnTriggerEnter2DHandler
    {
@@ -2911,9 +2934,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnTriggerEnter2DHandler)new AsyncTriggerHandler<Collider2D>(this, cancellationToken, true)).OnTriggerEnter2DAsync();
        }
    }
+#endif
 #endregion

 #region TriggerExit
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnTriggerExitHandler
    {
@@ -2970,9 +2995,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnTriggerExitHandler)new AsyncTriggerHandler<Collider>(this, cancellationToken, true)).OnTriggerExitAsync();
        }
    }
+#endif
 #endregion

 #region TriggerExit2D
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT

    public interface IAsyncOnTriggerExit2DHandler
    {
@@ -3029,9 +3056,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnTriggerExit2DHandler)new AsyncTriggerHandler<Collider2D>(this, cancellationToken, true)).OnTriggerExit2DAsync();
        }
    }
+#endif
 #endregion

 #region TriggerStay
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT

    public interface IAsyncOnTriggerStayHandler
    {
@@ -3088,9 +3117,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnTriggerStayHandler)new AsyncTriggerHandler<Collider>(this, cancellationToken, true)).OnTriggerStayAsync();
        }
    }
+#endif
 #endregion

 #region TriggerStay2D
+#if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT

    public interface IAsyncOnTriggerStay2DHandler
    {
@@ -3147,6 +3178,7 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnTriggerStay2DHandler)new AsyncTriggerHandler<Collider2D>(this, cancellationToken, true)).OnTriggerStay2DAsync();
        }
    }
+#endif
 #endregion

 #region Validate
@@ -3386,6 +3418,7 @@ namespace Cysharp.Threading.Tasks.Triggers
 #endregion

 #region BeginDrag
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnBeginDragHandler
    {
@@ -3442,9 +3475,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnBeginDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnBeginDragAsync();
        }
    }
+#endif
 #endregion

 #region Cancel
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnCancelHandler
    {
@@ -3501,9 +3536,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnCancelHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, true)).OnCancelAsync();
        }
    }
+#endif
 #endregion

 #region Deselect
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnDeselectHandler
    {
@@ -3560,9 +3597,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnDeselectHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, true)).OnDeselectAsync();
        }
    }
+#endif
 #endregion

 #region Drag
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnDragHandler
    {
@@ -3619,9 +3658,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnDragAsync();
        }
    }
+#endif
 #endregion

 #region Drop
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnDropHandler
    {
@@ -3678,9 +3719,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnDropHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnDropAsync();
        }
    }
+#endif
 #endregion

 #region EndDrag
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnEndDragHandler
    {
@@ -3737,9 +3780,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnEndDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnEndDragAsync();
        }
    }
+#endif
 #endregion

 #region InitializePotentialDrag
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnInitializePotentialDragHandler
    {
@@ -3796,9 +3841,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnInitializePotentialDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnInitializePotentialDragAsync();
        }
    }
+#endif
 #endregion

 #region Move
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnMoveHandler
    {
@@ -3855,9 +3902,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnMoveHandler)new AsyncTriggerHandler<AxisEventData>(this, cancellationToken, true)).OnMoveAsync();
        }
    }
+#endif
 #endregion

 #region PointerClick
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnPointerClickHandler
    {
@@ -3914,9 +3963,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnPointerClickHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnPointerClickAsync();
        }
    }
+#endif
 #endregion

 #region PointerDown
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnPointerDownHandler
    {
@@ -3973,9 +4024,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnPointerDownHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnPointerDownAsync();
        }
    }
+#endif
 #endregion

 #region PointerEnter
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnPointerEnterHandler
    {
@@ -4032,9 +4085,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnPointerEnterHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnPointerEnterAsync();
        }
    }
+#endif
 #endregion

 #region PointerExit
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnPointerExitHandler
    {
@@ -4091,9 +4146,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnPointerExitHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnPointerExitAsync();
        }
    }
+#endif
 #endregion

 #region PointerUp
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnPointerUpHandler
    {
@@ -4150,9 +4207,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnPointerUpHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnPointerUpAsync();
        }
    }
+#endif
 #endregion

 #region Scroll
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnScrollHandler
    {
@@ -4209,9 +4268,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnScrollHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, true)).OnScrollAsync();
        }
    }
+#endif
 #endregion

 #region Select
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnSelectHandler
    {
@@ -4268,9 +4329,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnSelectHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, true)).OnSelectAsync();
        }
    }
+#endif
 #endregion

 #region Submit
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnSubmitHandler
    {
@@ -4327,9 +4390,11 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnSubmitHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, true)).OnSubmitAsync();
        }
    }
+#endif
 #endregion

 #region UpdateSelected
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT

    public interface IAsyncOnUpdateSelectedHandler
    {
@@ -4386,6 +4451,7 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((IAsyncOnUpdateSelectedHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, true)).OnUpdateSelectedAsync();
        }
    }
+#endif
 #endregion

 }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.tt
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.tt
@@ -106,24 +106,36 @@
    Func<(string argType, string argName)[], string> BuildMethodArgument = x => string.Join(", ", x.Select(y => y.argType + " " + y.argName));
    Func<(string argType, string argName)[], string> BuildResultParameter = x => x.Length == 0 ? "AsyncUnit.Default" : "(" + string.Join(", ", x.Select(y => y.argName)) + ")";

-    Func<string, bool> Is2019_3 = x => x == "ParticleUpdateJobScheduled";
+    Func<string, bool> IsParticleSystem = x => x == "ParticleUpdateJobScheduled";
    Func<string, bool> IsMouseTrigger = x => x.StartsWith("Mouse");
+    Func<string, string> RequirePhysicsModule = x => (x.StartsWith("Collision") || x.StartsWith("Collider") || x.StartsWith("ControllerCollider") || x.StartsWith("Joint") || x.StartsWith("Trigger"))
+        ? (x.Contains("2D") ? "UNITASK_PHYSICS2D_SUPPORT" : "UNITASK_PHYSICS_SUPPORT") 
+        : null;
+    Func<string, bool> IsUguiSystem = x => x != null;
 #>
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

 using System.Threading;
 using UnityEngine;
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT
 using UnityEngine.EventSystems;
+#endif

 namespace Cysharp.Threading.Tasks.Triggers
 {
 <# foreach(var t in triggers) { #>
 #region <#= t.triggerName #>
-<# if(Is2019_3(t.triggerName)) { #>
-#if UNITY_2019_3_OR_NEWER
+<# if(IsUguiSystem(t.handlerInterface)) { #>
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT
+<# } #>
+<# if(IsParticleSystem(t.triggerName)) { #>
+#if UNITY_2019_3_OR_NEWER && (!UNITY_2019_1_OR_NEWER || UNITASK_PARTICLESYSTEM_SUPPORT)
 <# } #>
 <# if(IsMouseTrigger(t.triggerName)) { #>
 #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
+<# } #>
+<# if(RequirePhysicsModule(t.triggerName) != null) { #>
+#if !UNITY_2019_1_OR_NEWER || <#= RequirePhysicsModule(t.triggerName) #>
 <# } #>

    public interface <#= ToInterfaceName(t.methodName) #>
@@ -181,7 +193,13 @@ namespace Cysharp.Threading.Tasks.Triggers
            return ((<#= ToInterfaceName(t.methodName) #>)new AsyncTriggerHandler<<#= t.returnType #>>(this, cancellationToken, true)).<#= t.methodName #>Async();
        }
    }
-<# if(Is2019_3(t.triggerName) || IsMouseTrigger(t.triggerName)) { #>
+<# if(IsUguiSystem(t.handlerInterface)) { #>
+#endif
+<# } #>
+<# if(RequirePhysicsModule(t.triggerName) != null) { #>
+#endif
+<# } #>
+<# if(IsParticleSystem(t.triggerName) || IsMouseTrigger(t.triggerName)) { #>
 #endif
 <# } #>
 #endregion
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs
@@ -106,6 +106,14 @@ namespace Cysharp.Threading.Tasks
                throw new ArgumentOutOfRangeException("Delay does not allow minus delayTimeSpan. delayTimeSpan:" + delayTimeSpan);
            }

+#if UNITY_EDITOR
+            // force use Realtime.
+            if (PlayerLoopHelper.IsMainThread && !UnityEditor.EditorApplication.isPlaying)
+            {
+                delayType = DelayType.Realtime;
+            }
+#endif
+
            switch (delayType)
            {
                case DelayType.UnscaledDeltaTime:
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.asmdef
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.asmdef
@@ -1,7 +1,7 @@
 {
    "name": "UniTask",
-    "references": [
-    ],
+    "rootNamespace": "",
+    "references": [],
    "includePlatforms": [],
    "excludePlatforms": [],
    "allowUnsafeCode": false,
@@ -14,6 +14,31 @@
            "name": "com.unity.modules.assetbundle",
            "expression": "",
            "define": "UNITASK_ASSETBUNDLE_SUPPORT"
+        },
+        {
+            "name": "com.unity.modules.physics",
+            "expression": "",
+            "define": "UNITASK_PHYSICS_SUPPORT"
+        },
+        {
+            "name": "com.unity.modules.physics2d",
+            "expression": "",
+            "define": "UNITASK_PHYSICS2D_SUPPORT"
+        },
+        {
+            "name": "com.unity.modules.particlesystem",
+            "expression": "",
+            "define": "UNITASK_PARTICLESYSTEM_SUPPORT"
+        },
+        {
+            "name": "com.unity.ugui",
+            "expression": "",
+            "define": "UNITASK_UGUI_SUPPORT"
+        },
+        {
+            "name": "com.unity.modules.unitywebrequest",
+            "expression": "",
+            "define": "UNITASK_WEBREQUEST_SUPPORT"
        }
    ],
    "noEngineReferences": false
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.cs
@@ -192,7 +192,7 @@ namespace Cysharp.Threading.Tasks
        /// <summary>
        /// Ignore task result when cancel raised first.
        /// </summary>
-        public static UniTask WithCancellation(this UniTask task, CancellationToken cancellationToken)
+        public static UniTask AttachExternalCancellation(this UniTask task, CancellationToken cancellationToken)
        {
            if (!cancellationToken.CanBeCanceled)
            {
@@ -209,13 +209,13 @@ namespace Cysharp.Threading.Tasks
                return task;
            }

-            return new UniTask(new WithCancellationSource(task, cancellationToken), 0);
+            return new UniTask(new AttachExternalCancellationSource(task, cancellationToken), 0);
        }

        /// <summary>
        /// Ignore task result when cancel raised first.
        /// </summary>
-        public static UniTask<T> WithCancellation<T>(this UniTask<T> task, CancellationToken cancellationToken)
+        public static UniTask<T> AttachExternalCancellation<T>(this UniTask<T> task, CancellationToken cancellationToken)
        {
            if (!cancellationToken.CanBeCanceled)
            {
@@ -232,10 +232,10 @@ namespace Cysharp.Threading.Tasks
                return task;
            }

-            return new UniTask<T>(new WithCancellationSource<T>(task, cancellationToken), 0);
+            return new UniTask<T>(new AttachExternalCancellationSource<T>(task, cancellationToken), 0);
        }

-        sealed class WithCancellationSource : IUniTaskSource
+        sealed class AttachExternalCancellationSource : IUniTaskSource
        {
            static readonly Action<object> cancellationCallbackDelegate = CancellationCallback;

@@ -243,7 +243,7 @@ namespace Cysharp.Threading.Tasks
            CancellationTokenRegistration tokenRegistration;
            UniTaskCompletionSourceCore<AsyncUnit> core;

-            public WithCancellationSource(UniTask task, CancellationToken cancellationToken)
+            public AttachExternalCancellationSource(UniTask task, CancellationToken cancellationToken)
            {
                this.cancellationToken = cancellationToken;
                this.tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this);
@@ -269,7 +269,7 @@ namespace Cysharp.Threading.Tasks

            static void CancellationCallback(object state)
            {
-                var self = (WithCancellationSource)state;
+                var self = (AttachExternalCancellationSource)state;
                self.core.TrySetCanceled(self.cancellationToken);
            }

@@ -294,7 +294,7 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class WithCancellationSource<T> : IUniTaskSource<T>
+        sealed class AttachExternalCancellationSource<T> : IUniTaskSource<T>
        {
            static readonly Action<object> cancellationCallbackDelegate = CancellationCallback;

@@ -302,7 +302,7 @@ namespace Cysharp.Threading.Tasks
            CancellationTokenRegistration tokenRegistration;
            UniTaskCompletionSourceCore<T> core;

-            public WithCancellationSource(UniTask<T> task, CancellationToken cancellationToken)
+            public AttachExternalCancellationSource(UniTask<T> task, CancellationToken cancellationToken)
            {
                this.cancellationToken = cancellationToken;
                this.tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this);
@@ -327,7 +327,7 @@ namespace Cysharp.Threading.Tasks

            static void CancellationCallback(object state)
            {
-                var self = (WithCancellationSource<T>)state;
+                var self = (AttachExternalCancellationSource<T>)state;
                self.core.TrySetCanceled(self.cancellationToken);
            }

--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AssetBundleRequestAllAssets.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AssetBundleRequestAllAssets.cs
@@ -21,10 +21,7 @@ namespace Cysharp.Threading.Tasks

        public static UniTask<UnityEngine.Object[]> AwaitForAllAssets(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object[]>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult<UnityEngine.Object[]>(asyncOperation.allAssets);
-            return new UniTask<UnityEngine.Object[]>(AssetBundleRequestAllAssetsWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+            return AwaitForAllAssets(asyncOperation, cancellationToken: cancellationToken);
        }

        public static UniTask<UnityEngine.Object[]> AwaitForAllAssets(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
@@ -84,129 +81,6 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class AssetBundleRequestAllAssetsWithCancellationSource : IUniTaskSource<UnityEngine.Object[]>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestAllAssetsWithCancellationSource>
-        {
-            static TaskPool<AssetBundleRequestAllAssetsWithCancellationSource> pool;
-            AssetBundleRequestAllAssetsWithCancellationSource nextNode;
-            public ref AssetBundleRequestAllAssetsWithCancellationSource NextNode => ref nextNode;
-
-            static AssetBundleRequestAllAssetsWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestAllAssetsWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            AssetBundleRequest asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<UnityEngine.Object[]> core;
-
-            AssetBundleRequestAllAssetsWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource<UnityEngine.Object[]> Create(AssetBundleRequest asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<UnityEngine.Object[]>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AssetBundleRequestAllAssetsWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    core.TrySetResult(asyncOperation.allAssets);
-                }
-            }
-
-            public UnityEngine.Object[] GetResult(short token)
-            {
-                return core.GetResult(token);
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
        sealed class AssetBundleRequestAllAssetsConfiguredSource : IUniTaskSource<UnityEngine.Object[]>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestAllAssetsConfiguredSource>
        {
            static TaskPool<AssetBundleRequestAllAssetsConfiguredSource> pool;
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AsyncGPUReadback.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AsyncGPUReadback.cs
@@ -1,4 +1,4 @@
-#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

 using System;
 using System.Threading;
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.cs
@@ -5,7 +5,7 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using UnityEngine;
 using Cysharp.Threading.Tasks.Internal;
-#if ENABLE_UNITYWEBREQUEST
+#if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT)
 using UnityEngine.Networking;
 #endif

@@ -23,10 +23,7 @@ namespace Cysharp.Threading.Tasks

        public static UniTask WithCancellation(this AsyncOperation asyncOperation, CancellationToken cancellationToken)
        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.CompletedTask;
-            return new UniTask(AsyncOperationWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+            return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
        }

        public static UniTask ToUniTask(this AsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
@@ -77,125 +74,6 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class AsyncOperationWithCancellationSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationWithCancellationSource>
-        {
-            static TaskPool<AsyncOperationWithCancellationSource> pool;
-            AsyncOperationWithCancellationSource nextNode;
-            public ref AsyncOperationWithCancellationSource NextNode => ref nextNode;
-
-            static AsyncOperationWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AsyncOperationWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            AsyncOperation asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<AsyncUnit> core;
-
-            AsyncOperationWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource Create(AsyncOperation asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AsyncOperationWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    core.TrySetResult(AsyncUnit.Default);
-                }
-            }
-
-            public void GetResult(short token)
-            {
-                core.GetResult(token);
-            }
-
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
        sealed class AsyncOperationConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationConfiguredSource>
        {
            static TaskPool<AsyncOperationConfiguredSource> pool;
@@ -315,10 +193,7 @@ namespace Cysharp.Threading.Tasks

        public static UniTask<UnityEngine.Object> WithCancellation(this ResourceRequest asyncOperation, CancellationToken cancellationToken)
        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
-            return new UniTask<UnityEngine.Object>(ResourceRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+            return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
        }

        public static UniTask<UnityEngine.Object> ToUniTask(this ResourceRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
@@ -373,129 +248,6 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class ResourceRequestWithCancellationSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<ResourceRequestWithCancellationSource>
-        {
-            static TaskPool<ResourceRequestWithCancellationSource> pool;
-            ResourceRequestWithCancellationSource nextNode;
-            public ref ResourceRequestWithCancellationSource NextNode => ref nextNode;
-
-            static ResourceRequestWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(ResourceRequestWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            ResourceRequest asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<UnityEngine.Object> core;
-
-            ResourceRequestWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource<UnityEngine.Object> Create(ResourceRequest asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<UnityEngine.Object>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new ResourceRequestWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    core.TrySetResult(asyncOperation.asset);
-                }
-            }
-
-            public UnityEngine.Object GetResult(short token)
-            {
-                return core.GetResult(token);
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
        sealed class ResourceRequestConfiguredSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<ResourceRequestConfiguredSource>
        {
            static TaskPool<ResourceRequestConfiguredSource> pool;
@@ -620,10 +372,7 @@ namespace Cysharp.Threading.Tasks

        public static UniTask<UnityEngine.Object> WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
-            return new UniTask<UnityEngine.Object>(AssetBundleRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+            return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
        }

        public static UniTask<UnityEngine.Object> ToUniTask(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
@@ -678,129 +427,6 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class AssetBundleRequestWithCancellationSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestWithCancellationSource>
-        {
-            static TaskPool<AssetBundleRequestWithCancellationSource> pool;
-            AssetBundleRequestWithCancellationSource nextNode;
-            public ref AssetBundleRequestWithCancellationSource NextNode => ref nextNode;
-
-            static AssetBundleRequestWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            AssetBundleRequest asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<UnityEngine.Object> core;
-
-            AssetBundleRequestWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource<UnityEngine.Object> Create(AssetBundleRequest asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<UnityEngine.Object>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AssetBundleRequestWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    core.TrySetResult(asyncOperation.asset);
-                }
-            }
-
-            public UnityEngine.Object GetResult(short token)
-            {
-                return core.GetResult(token);
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
        sealed class AssetBundleRequestConfiguredSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestConfiguredSource>
        {
            static TaskPool<AssetBundleRequestConfiguredSource> pool;
@@ -926,10 +552,7 @@ namespace Cysharp.Threading.Tasks

        public static UniTask<AssetBundle> WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken)
        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<AssetBundle>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
-            return new UniTask<AssetBundle>(AssetBundleCreateRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+            return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
        }

        public static UniTask<AssetBundle> ToUniTask(this AssetBundleCreateRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
@@ -984,129 +607,6 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class AssetBundleCreateRequestWithCancellationSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestWithCancellationSource>
-        {
-            static TaskPool<AssetBundleCreateRequestWithCancellationSource> pool;
-            AssetBundleCreateRequestWithCancellationSource nextNode;
-            public ref AssetBundleCreateRequestWithCancellationSource NextNode => ref nextNode;
-
-            static AssetBundleCreateRequestWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AssetBundleCreateRequestWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            AssetBundleCreateRequest asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<AssetBundle> core;
-
-            AssetBundleCreateRequestWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource<AssetBundle> Create(AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<AssetBundle>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AssetBundleCreateRequestWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    core.TrySetResult(asyncOperation.assetBundle);
-                }
-            }
-
-            public AssetBundle GetResult(short token)
-            {
-                return core.GetResult(token);
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
        sealed class AssetBundleCreateRequestConfiguredSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestConfiguredSource>
        {
            static TaskPool<AssetBundleCreateRequestConfiguredSource> pool;
@@ -1221,7 +721,7 @@ namespace Cysharp.Threading.Tasks
        #endregion
 #endif

-#if ENABLE_UNITYWEBREQUEST
+#if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT)
        #region UnityWebRequestAsyncOperation

        public static UnityWebRequestAsyncOperationAwaiter GetAwaiter(this UnityWebRequestAsyncOperation asyncOperation)
@@ -1232,17 +732,7 @@ namespace Cysharp.Threading.Tasks

        public static UniTask<UnityWebRequest> WithCancellation(this UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken)
        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityWebRequest>(cancellationToken);
-            if (asyncOperation.isDone)
-            {
-                if (asyncOperation.webRequest.IsError())
-                {
-                    return UniTask.FromException<UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest));
-                }
-                return UniTask.FromResult(asyncOperation.webRequest);
-            }
-            return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+            return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
        }

        public static UniTask<UnityWebRequest> ToUniTask(this UnityWebRequestAsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
@@ -1312,138 +802,6 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class UnityWebRequestAsyncOperationWithCancellationSource : IUniTaskSource<UnityWebRequest>, IPlayerLoopItem, ITaskPoolNode<UnityWebRequestAsyncOperationWithCancellationSource>
-        {
-            static TaskPool<UnityWebRequestAsyncOperationWithCancellationSource> pool;
-            UnityWebRequestAsyncOperationWithCancellationSource nextNode;
-            public ref UnityWebRequestAsyncOperationWithCancellationSource NextNode => ref nextNode;
-
-            static UnityWebRequestAsyncOperationWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(UnityWebRequestAsyncOperationWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            UnityWebRequestAsyncOperation asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<UnityWebRequest> core;
-
-            UnityWebRequestAsyncOperationWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource<UnityWebRequest> Create(UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<UnityWebRequest>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new UnityWebRequestAsyncOperationWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    var result = asyncOperation.webRequest;
-                    if (result.IsError())
-                    {
-                        core.TrySetException(new UnityWebRequestException(result));
-                    }
-                    else
-                    {
-                        core.TrySetResult(result);
-                    }
-                }
-            }
-
-            public UnityWebRequest GetResult(short token)
-            {
-                return core.GetResult(token);
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    asyncOperation.webRequest.Abort();
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
        sealed class UnityWebRequestAsyncOperationConfiguredSource : IUniTaskSource<UnityWebRequest>, IPlayerLoopItem, ITaskPoolNode<UnityWebRequestAsyncOperationConfiguredSource>
        {
            static TaskPool<UnityWebRequestAsyncOperationConfiguredSource> pool;
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.tt
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.tt
@@ -11,7 +11,7 @@
        ("ResourceRequest", "UnityEngine.Object", "asset"),
        ("AssetBundleRequest", "UnityEngine.Object", "asset"), // allAssets?
        ("AssetBundleCreateRequest", "AssetBundle", "assetBundle"),
-        ("UnityWebRequestAsyncOperation", "UnityWebRequest", "webRequest") // -> #if ENABLE_UNITYWEBREQUEST
+        ("UnityWebRequestAsyncOperation", "UnityWebRequest", "webRequest") // -> #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT)
    };

    Func<string, string> ToUniTaskReturnType = x => (x == "void") ? "UniTask" : $"UniTask<{x}>";
@@ -27,7 +27,7 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using UnityEngine;
 using Cysharp.Threading.Tasks.Internal;
-#if ENABLE_UNITYWEBREQUEST
+#if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT)
 using UnityEngine.Networking;
 #endif

@@ -37,7 +37,7 @@ namespace Cysharp.Threading.Tasks
    {
 <# foreach(var t in types) { #>
 <# if(IsUnityWebRequest(t)) { #>
-#if ENABLE_UNITYWEBREQUEST
+#if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT)
 <# } else if(IsAssetBundleModule(t)) { #>
 #if UNITASK_ASSETBUNDLE_SUPPORT
 <# } #>
@@ -51,21 +51,7 @@ namespace Cysharp.Threading.Tasks

        public static <#= ToUniTaskReturnType(t.returnType) #> WithCancellation(this <#= t.typeName #> asyncOperation, CancellationToken cancellationToken)
        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<#= IsVoid(t) ? "" : "<" + t.returnType + ">" #>(cancellationToken);
-<# if(IsUnityWebRequest(t)) { #>
-            if (asyncOperation.isDone)
-            {
-                if (asyncOperation.webRequest.IsError())
-                {
-                    return UniTask.FromException<UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest));
-                }
-                return UniTask.FromResult(asyncOperation.webRequest);
-            }
-<# } else { #>
-            if (asyncOperation.isDone) return <#= IsVoid(t) ? "UniTask.CompletedTask" : $"UniTask.FromResult(asyncOperation.{t.returnField})" #>;
-<# } #>
-            return new <#= ToUniTaskReturnType(t.returnType) #>(<#= t.typeName #>WithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+            return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
        }

        public static <#= ToUniTaskReturnType(t.returnType) #> ToUniTask(this <#= t.typeName #> asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
@@ -151,150 +137,6 @@ namespace Cysharp.Threading.Tasks
            }
        }

-        sealed class <#= t.typeName #>WithCancellationSource : <#= ToIUniTaskSourceReturnType(t.returnType) #>, IPlayerLoopItem, ITaskPoolNode<<#= t.typeName #>WithCancellationSource>
-        {
-            static TaskPool<<#= t.typeName #>WithCancellationSource> pool;
-            <#= t.typeName #>WithCancellationSource nextNode;
-            public ref <#= t.typeName #>WithCancellationSource NextNode => ref nextNode;
-
-            static <#= t.typeName #>WithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(<#= t.typeName #>WithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            <#= t.typeName #> asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<<#= IsVoid(t) ? "AsyncUnit" : t.returnType #>> core;
-
-            <#= t.typeName #>WithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static <#= ToIUniTaskSourceReturnType(t.returnType) #> Create(<#= t.typeName #> asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<#= IsVoid(t) ? "" : $"<{t.returnType}>" #>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new <#= t.typeName #>WithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-<# if(IsUnityWebRequest(t)) { #>
-                    var result = asyncOperation.webRequest;
-                    if (result.IsError())
-                    {
-                        core.TrySetException(new UnityWebRequestException(result));
-                    }
-                    else
-                    {
-                        core.TrySetResult(result);
-                    }
-<# } else { #>
-                    core.TrySetResult(<#= IsVoid(t) ? "AsyncUnit.Default" : $"asyncOperation.{t.returnField}" #>);
-<# } #>
-                }
-            }
-
-            public <#= t.returnType #> GetResult(short token)
-            {
-<# if (!IsVoid(t)) { #>
-                return core.GetResult(token);
-<# } else { #>
-                core.GetResult(token);
-<# } #>
-            }
-
-<# if (!IsVoid(t)) { #>
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-<# } #>
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-<# if(IsUnityWebRequest(t)) { #>
-                    asyncOperation.webRequest.Abort();
-<# } #>
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
        sealed class <#= t.typeName #>ConfiguredSource : <#= ToIUniTaskSourceReturnType(t.returnType) #>, IPlayerLoopItem, ITaskPoolNode<<#= t.typeName #>ConfiguredSource>
        {
            static TaskPool<<#= t.typeName #>ConfiguredSource> pool;
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.uGUI.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.uGUI.cs
@@ -1,5 +1,5 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
-
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT
 using System;
 using System.Threading;
 using UnityEngine;
@@ -364,6 +364,7 @@ namespace Cysharp.Threading.Tasks

        public AsyncUnityEventHandler(UnityEvent unityEvent, CancellationToken cancellationToken, bool callOnce)
        {
+            this.cancellationToken = cancellationToken;
            if (cancellationToken.IsCancellationRequested)
            {
                isDisposed = true;
@@ -372,7 +373,6 @@ namespace Cysharp.Threading.Tasks

            this.action = Invoke;
            this.unityEvent = unityEvent;
-            this.cancellationToken = cancellationToken;
            this.callOnce = callOnce;

            unityEvent.AddListener(action);
@@ -388,6 +388,10 @@ namespace Cysharp.Threading.Tasks
        public UniTask OnInvokeAsync()
        {
            core.Reset();
+            if (isDisposed)
+            {
+                core.TrySetCanceled(this.cancellationToken);
+            }
            return new UniTask(this, core.Version);
        }

@@ -470,6 +474,7 @@ namespace Cysharp.Threading.Tasks

        public AsyncUnityEventHandler(UnityEvent<T> unityEvent, CancellationToken cancellationToken, bool callOnce)
        {
+            this.cancellationToken = cancellationToken;
            if (cancellationToken.IsCancellationRequested)
            {
                isDisposed = true;
@@ -478,7 +483,6 @@ namespace Cysharp.Threading.Tasks

            this.action = Invoke;
            this.unityEvent = unityEvent;
-            this.cancellationToken = cancellationToken;
            this.callOnce = callOnce;

            unityEvent.AddListener(action);
@@ -494,6 +498,10 @@ namespace Cysharp.Threading.Tasks
        public UniTask<T> OnInvokeAsync()
        {
            core.Reset();
+            if (isDisposed)
+            {
+                core.TrySetCanceled(this.cancellationToken);
+            }
            return new UniTask<T>(this, core.Version);
        }

@@ -813,4 +821,6 @@ namespace Cysharp.Threading.Tasks
            }
        }
    }
-}
+}
+
+#endif
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityBindingExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityBindingExtensions.cs
@@ -1,12 +1,15 @@
 using System;
 using System.Threading;
 using UnityEngine;
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT
 using UnityEngine.UI;
+#endif

 namespace Cysharp.Threading.Tasks
 {
    public static class UnityBindingExtensions
    {
+#if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT
        // <string> -> Text

        public static void BindTo(this IUniTaskAsyncEnumerable<string> source, Text text, bool rebindOnError = true)
@@ -180,6 +183,7 @@ namespace Cysharp.Threading.Tasks
                }
            }
        }
+#endif

        // <T> -> Action

--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityWebRequestException.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UnityWebRequestException.cs
@@ -1,4 +1,4 @@
-#if ENABLE_UNITYWEBREQUEST
+#if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT)

 using System;
 using System.Collections.Generic;
--- a/src/UniTask/Assets/Plugins/UniTask/package.json
+++ b/src/UniTask/Assets/Plugins/UniTask/package.json
@@ -1,7 +1,7 @@
 {
    "name": "com.cysharp.unitask",
    "displayName": "UniTask",
-    "version": "2.1.1",
+    "version": "2.2.1",
    "unity": "2018.4",
    "description": "Provides an efficient async/await integration to Unity.",
    "keywords": [ "async/await", "async", "Task", "UniTask" ],
--- a/src/UniTask/Assets/Scenes/EditorTest1.cs
+++ b/src/UniTask/Assets/Scenes/EditorTest1.cs
@@ -11,30 +11,33 @@ public class Test1
    public static async UniTaskVoid TestFunc()
    {
        await DoSomeThing();
-        string[] scenes = new string[]
-        {
-            "Assets/Scenes/SandboxMain.unity",
-        };
+        //string[] scenes = new string[]
+        //{
+        //    "Assets/Scenes/SandboxMain.unity",
+        //};

-        try
-        {
-            Debug.Log("Build Begin");
-            BuildPipeline.BuildPlayer(scenes, Application.dataPath + "../target", BuildTarget.StandaloneWindows, BuildOptions.CompressWithLz4);
-            Debug.Log("Build After");
-        }
-        catch (Exception e)
-        {
-            Debug.LogError(e.Message);
-        }
+        //try
+        //{
+        //    Debug.Log("Build Begin");
+        //    BuildPipeline.BuildPlayer(scenes, Application.dataPath + "../target", BuildTarget.StandaloneWindows, BuildOptions.CompressWithLz4);
+        //    Debug.Log("Build After");
+        //}
+        //catch (Exception e)
+        //{
+        //    Debug.LogError(e.Message);
+        //}
    }

    public static async UniTask DoSomeThing()
    {
        Debug.Log("Dosomething");
-        await UniTask.Delay(1500, DelayType.Realtime);
+        await UniTask.Delay(1500, DelayType.DeltaTime);
        Debug.Log("Dosomething 2");
-        await UniTask.Delay(1000, DelayType.Realtime);
+        await UniTask.Delay(1000, DelayType.DeltaTime);
        Debug.Log("Dosomething 3");
+        Debug.Log("and Quit.");
+
+        Environment.Exit(0);
    }
 }

--- a/src/UniTask/Assets/Scenes/MiddlewareSample.cs
+++ b/src/UniTask/Assets/Scenes/MiddlewareSample.cs
@@ -1,471 +1,471 @@
-using Cysharp.Threading.Tasks;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using UnityEngine;
-using UnityEngine.Networking;
-using UnityEngine.SceneManagement;
-using UnityEngine.UI;
-
-namespace Cysharp.Threading.Tasks.Sample
-{
-    //public class Sample2
-    //{
-    //    public Sample2()
-    //    {
-    //        // デコレーターの詰まったClientを生成（これは一度作ったらフィールドに保存可）
-    //        var client = new NetworkClient("http://localhost", TimeSpan.FromSeconds(10),
-    //            new QueueRequestDecorator(),
-    //            new LoggingDecorator(),
-    //            new AppendTokenDecorator(),
-    //            new SetupHeaderDecorator());
-
-
-    //        await client.PostAsync("/User/Register", new { Id = 100 });
-
-
-    //    }
-    //}
-
-
-    public class ReturnToTitleDecorator : IAsyncDecorator
-    {
-        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
-        {
-            try
-            {
-                return await next(context, cancellationToken);
-            }
-            catch (Exception ex)
-            {
-                if (ex is OperationCanceledException)
-                {
-                    // キャンセルはきっと想定されている処理なのでそのまんまスルー（呼び出し側でOperationCanceledExceptionとして飛んでいく)
-                    throw;
-                }
-
-                if (ex is UnityWebRequestException uwe)
-                {
-                    // ステータスコードを使って、タイトルに戻す例外です、とかリトライさせる例外です、とかハンドリングさせると便利
-                    // if (uwe.ResponseCode) { }...
-                }
-
-                // サーバー例外のMessageを直接出すなんて乱暴なことはデバッグ時だけですよ勿論。
-                var result = await MessageDialog.ShowAsync(ex.Message);
-
-                // OK か Cancelかで分岐するなら。今回はボタン一個、OKのみの想定なので無視
-                // if (result == DialogResult.Ok) { }...
-
-                // シーン呼び出しはawaitしないこと！awaitして正常終了しちゃうと、この通信の呼び出し元に処理が戻って続行してしまいます
-                // のでForget。
-                SceneManager.LoadSceneAsync("TitleScene").ToUniTask().Forget();
-
-
-                // そしてOperationCanceledExceptionを投げて、この通信の呼び出し元の処理はキャンセル扱いにして終了させる
-                throw new OperationCanceledException();
-            }
-        }
-    }
-
-    public enum DialogResult
-    {
-        Ok,
-        Cancel
-    }
-
-    public static class MessageDialog
-    {
-        public static async UniTask<DialogResult> ShowAsync(string message)
-        {
-            // (例えば)Prefabで作っておいたダイアログを生成する
-            var view = await Resources.LoadAsync("Prefabs/Dialog");
-
-            // Ok, Cancelボタンのどちらかが押されるのを待機
-            return await (view as GameObject).GetComponent<MessageDialogView>().ClickResult;
-        }
-    }
-
-    public class MessageDialogView : MonoBehaviour
-    {
-        [SerializeField] Button okButton = default;
-        [SerializeField] Button closeButton = default;
-
-        UniTaskCompletionSource<DialogResult> taskCompletion;
-
-        // これでどちらかが押されるまで無限に待つを表現
-        public UniTask<DialogResult> ClickResult => taskCompletion.Task;
-
-        private void Start()
-        {
-            taskCompletion = new UniTaskCompletionSource<DialogResult>();
-
-            okButton.onClick.AddListener(() =>
-            {
-                taskCompletion.TrySetResult(DialogResult.Ok);
-            });
-
-            closeButton.onClick.AddListener(() =>
-            {
-                taskCompletion.TrySetResult(DialogResult.Cancel);
-            });
-        }
-
-        // もしボタンが押されずに消滅した場合にネンノタメ。
-        private void OnDestroy()
-        {
-            taskCompletion.TrySetResult(DialogResult.Cancel);
-        }
-    }
-
-    public class MockDecorator : IAsyncDecorator
-    {
-        Dictionary<string, object> mock;
-
-        // Pathと型を1:1にして事前定義したオブジェクトを返す辞書を渡す
-        public MockDecorator(Dictionary<string, object> mock)
-        {
-            this.mock = mock;
-        }
-
-        public UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
-        {
-            if (mock.TryGetValue(context.Path, out var value))
-            {
-                // 一致したものがあればそれを返す（実際の通信は行わない）
-                return new UniTask<ResponseContext>(new ResponseContext(value));
-            }
-            else
-            {
-                return next(context, cancellationToken);
-            }
-        }
-    }
-
-    //public class LoggingDecorator : IAsyncDecorator
-    //{
-    //    public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
-    //    {
-    //        var sw = Stopwatch.StartNew();
-    //        try
-    //        {
-    //            UnityEngine.Debug.Log("Start Network Request:" + context.Path);
-
-    //            var response = await next(context, cancellationToken);
-
-    //            UnityEngine.Debug.Log($"Complete Network Request: {context.Path} , Elapsed: {sw.Elapsed}, Size: {response.GetRawData().Length}");
-
-    //            return response;
-    //        }
-    //        catch (Exception ex)
-    //        {
-    //            if (ex is OperationCanceledException)
-    //            {
-    //                UnityEngine.Debug.Log("Request Canceled:" + context.Path);
-    //            }
-    //            else if (ex is TimeoutException)
-    //            {
-    //                UnityEngine.Debug.Log("Request Timeout:" + context.Path);
-    //            }
-    //            else if (ex is UnityWebRequestException webex)
-    //            {
-    //                if (webex.IsHttpError)
-    //                {
-    //                    UnityEngine.Debug.Log($"Request HttpError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
-    //                }
-    //                else if (webex.IsNetworkError)
-    //                {
-    //                    UnityEngine.Debug.Log($"Request NetworkError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
-    //                }
-    //            }
-    //            throw;
-    //        }
-    //        finally
-    //        {
-    //            /* log other */
-    //        }
-    //    }
-    //}
-
-    public class SetupHeaderDecorator : IAsyncDecorator
-    {
-        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
-        {
-            context.RequestHeaders["x-app-timestamp"] = context.Timestamp.ToString();
-            context.RequestHeaders["x-user-id"] = "132141411"; // どこかから持ってくる
-            context.RequestHeaders["x-access-token"] = "fafafawfafewaea"; // どこかから持ってくる2
-
-            var respsonse = await next(context, cancellationToken);
-
-            var nextToken = respsonse.ResponseHeaders["token"];
-            // UserProfile.Token = nextToken; // どこかにセットするということにする
-
-            return respsonse;
-        }
-    }
-
-
-    public class AppendTokenDecorator : IAsyncDecorator
-    {
-        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
-        {
-            string token = "token"; // どっかから取ってくるということにする
-            RETRY:
-            try
-            {
-                context.RequestHeaders["x-accesss-token"] = token;
-                return await next(context, cancellationToken);
-            }
-            catch (UnityWebRequestException ex)
-            {
-                // 例えば700はTokenを再取得してください的な意味だったとする
-                if (ex.ResponseCode == 700)
-                {
-                    // 別口でTokenを取得します的な処理
-                    var newToken = await new NetworkClient(context.BasePath, context.Timeout).PostAsync<string>("/Auth/GetToken", "access_token", cancellationToken);
-                    context.Reset(this);
-                    goto RETRY;
-                }
-
-                goto RETRY;
-            }
-        }
-    }
-
-    public class QueueRequestDecorator : IAsyncDecorator
-    {
-        readonly Queue<(UniTaskCompletionSource<ResponseContext>, RequestContext, CancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>>)> q = new Queue<(UniTaskCompletionSource<ResponseContext>, RequestContext, CancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>>)>();
-        bool running;
-
-        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
-        {
-            if (q.Count == 0)
-            {
-                return await next(context, cancellationToken);
-            }
-            else
-            {
-                var completionSource = new UniTaskCompletionSource<ResponseContext>();
-                q.Enqueue((completionSource, context, cancellationToken, next));
-                if (!running)
-                {
-                    Run().Forget();
-                }
-                return await completionSource.Task;
-            }
-        }
-
-        async UniTaskVoid Run()
-        {
-            running = true;
-            try
-            {
-                while (q.Count != 0)
-                {
-                    var (tcs, context, cancellationToken, next) = q.Dequeue();
-                    try
-                    {
-                        var response = await next(context, cancellationToken);
-                        tcs.TrySetResult(response);
-                    }
-                    catch (Exception ex)
-                    {
-                        tcs.TrySetException(ex);
-                    }
-                }
-            }
-            finally
-            {
-                running = false;
-            }
-        }
-    }
-
-
-    public class RequestContext
-    {
-        int decoratorIndex;
-        readonly IAsyncDecorator[] decorators;
-        Dictionary<string, string> headers;
-
-        public string BasePath { get; }
-        public string Path { get; }
-        public object Value { get; }
-        public TimeSpan Timeout { get; }
-        public DateTimeOffset Timestamp { get; private set; }
-
-        public IDictionary<string, string> RequestHeaders
-        {
-            get
-            {
-                if (headers == null)
-                {
-                    headers = new Dictionary<string, string>();
-                }
-                return headers;
-            }
-        }
-
-        public RequestContext(string basePath, string path, object value, TimeSpan timeout, IAsyncDecorator[] filters)
-        {
-            this.decoratorIndex = -1;
-            this.decorators = filters;
-            this.BasePath = basePath;
-            this.Path = path;
-            this.Value = value;
-            this.Timeout = timeout;
-            this.Timestamp = DateTimeOffset.UtcNow;
-        }
-
-        internal Dictionary<string, string> GetRawHeaders() => headers;
-        internal IAsyncDecorator GetNextDecorator() => decorators[++decoratorIndex];
-
-        public void Reset(IAsyncDecorator currentFilter)
-        {
-            decoratorIndex = Array.IndexOf(decorators, currentFilter);
-            if (headers != null)
-            {
-                headers.Clear();
-            }
-            Timestamp = DateTimeOffset.UtcNow;
-        }
-    }
-
-    public class ResponseContext
-    {
-        bool hasValue;
-        object value;
-        readonly byte[] bytes;
-
-        public long StatusCode { get; }
-        public Dictionary<string, string> ResponseHeaders { get; }
-
-        public ResponseContext(object value, Dictionary<string, string> header = null)
-        {
-            this.hasValue = true;
-            this.value = value;
-            this.StatusCode = 200;
-            this.ResponseHeaders = (header ?? new Dictionary<string, string>());
-        }
-
-        public ResponseContext(byte[] bytes, long statusCode, Dictionary<string, string> responseHeaders)
-        {
-            this.hasValue = false;
-            this.bytes = bytes;
-            this.StatusCode = statusCode;
-            this.ResponseHeaders = responseHeaders;
-        }
-
-        public byte[] GetRawData() => bytes;
-
-        public T GetResponseAs<T>()
-        {
-            if (hasValue)
-            {
-                return (T)value;
-            }
-
-            value = JsonUtility.FromJson<T>(Encoding.UTF8.GetString(bytes));
-            hasValue = true;
-            return (T)value;
-        }
-    }
-
-    public interface IAsyncDecorator
-    {
-        UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next);
-    }
-
-
-    public class NetworkClient : IAsyncDecorator
-    {
-        readonly Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next;
-        readonly IAsyncDecorator[] decorators;
-        readonly TimeSpan timeout;
-        readonly IProgress<float> progress;
-        readonly string basePath;
-
-        public NetworkClient(string basePath, TimeSpan timeout, params IAsyncDecorator[] decorators)
-            : this(basePath, timeout, null, decorators)
-        {
-        }
-
-        public NetworkClient(string basePath, TimeSpan timeout, IProgress<float> progress, params IAsyncDecorator[] decorators)
-        {
-            this.next = InvokeRecursive; // setup delegate
-
-            this.basePath = basePath;
-            this.timeout = timeout;
-            this.progress = progress;
-            this.decorators = new IAsyncDecorator[decorators.Length + 1];
-            Array.Copy(decorators, this.decorators, decorators.Length);
-            this.decorators[this.decorators.Length - 1] = this;
-        }
-
-        public async UniTask<T> PostAsync<T>(string path, T value, CancellationToken cancellationToken = default)
-        {
-            var request = new RequestContext(basePath, path, value, timeout, decorators);
-            var response = await InvokeRecursive(request, cancellationToken);
-            return response.GetResponseAs<T>();
-        }
-
-
-        UniTask<ResponseContext> InvokeRecursive(RequestContext context, CancellationToken cancellationToken)
-        {
-            return context.GetNextDecorator().SendAsync(context, cancellationToken, next); // マジカル再帰処理
-        }
-
-        async UniTask<ResponseContext> IAsyncDecorator.SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> _)
-        {
-            // Postしか興味ないからPostにしかしないよ！
-            // パフォーマンスを最大限にしたい場合はuploadHandler, downloadHandlerをカスタマイズすること
-
-            // JSONでbodyに送るというパラメータで送るという雑設定。
-            var data = JsonUtility.ToJson(context.Value);
-            var formData = new Dictionary<string, string> { { "body", data } };
-
-            using (var req = UnityWebRequest.Post(basePath + context.Path, formData))
-            {
-                var header = context.GetRawHeaders();
-                if (header != null)
-                {
-                    foreach (var item in header)
-                    {
-                        req.SetRequestHeader(item.Key, item.Value);
-                    }
-                }
-
-                // Timeout処理はCancellationTokenSourceのCancelAfterSlim(UniTask拡張)を使ってサクッと処理
-                var linkToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-                linkToken.CancelAfterSlim(timeout);
-                try
-                {
-                    // 完了待ちや終了処理はUniTaskの拡張自体に丸投げ
-                    await req.SendWebRequest().ToUniTask(progress: progress, cancellationToken: linkToken.Token);
-                }
-                catch (OperationCanceledException)
-                {
-                    // 元キャンセレーションソースがキャンセルしてなければTimeoutによるものと判定
-                    if (!cancellationToken.IsCancellationRequested)
-                    {
-                        throw new TimeoutException();
-                    }
-                }
-                finally
-                {
-                    // Timeoutに引っかからなかった場合にてるのでCancelAfterSlimの裏で回ってるループをこれで終わらせとく
-                    if (!linkToken.IsCancellationRequested)
-                    {
-                        linkToken.Cancel();
-                    }
-                }
-
-                // UnityWebRequestを先にDisposeしちゃうので先に必要なものを取得しておく（性能的には無駄なのでパフォーマンスを最大限にしたい場合は更に一工夫を）
-                return new ResponseContext(req.downloadHandler.data, req.responseCode, req.GetResponseHeaders());
-            }
-        }
-    }
-}
+//using Cysharp.Threading.Tasks;
+//using System;
+//using System.Collections.Generic;
+//using System.Diagnostics;
+//using System.Linq;
+//using System.Text;
+//using System.Threading;
+//using System.Threading.Tasks;
+//using UnityEngine;
+//using UnityEngine.Networking;
+//using UnityEngine.SceneManagement;
+//using UnityEngine.UI;
+
+//namespace Cysharp.Threading.Tasks.Sample
+//{
+//    //public class Sample2
+//    //{
+//    //    public Sample2()
+//    //    {
+//    //        // デコレーターの詰まったClientを生成（これは一度作ったらフィールドに保存可）
+//    //        var client = new NetworkClient("http://localhost", TimeSpan.FromSeconds(10),
+//    //            new QueueRequestDecorator(),
+//    //            new LoggingDecorator(),
+//    //            new AppendTokenDecorator(),
+//    //            new SetupHeaderDecorator());
+
+
+//    //        await client.PostAsync("/User/Register", new { Id = 100 });
+
+
+//    //    }
+//    //}
+
+
+//    public class ReturnToTitleDecorator : IAsyncDecorator
+//    {
+//        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
+//        {
+//            try
+//            {
+//                return await next(context, cancellationToken);
+//            }
+//            catch (Exception ex)
+//            {
+//                if (ex is OperationCanceledException)
+//                {
+//                    // キャンセルはきっと想定されている処理なのでそのまんまスルー（呼び出し側でOperationCanceledExceptionとして飛んでいく)
+//                    throw;
+//                }
+
+//                if (ex is UnityWebRequestException uwe)
+//                {
+//                    // ステータスコードを使って、タイトルに戻す例外です、とかリトライさせる例外です、とかハンドリングさせると便利
+//                    // if (uwe.ResponseCode) { }...
+//                }
+
+//                // サーバー例外のMessageを直接出すなんて乱暴なことはデバッグ時だけですよ勿論。
+//                var result = await MessageDialog.ShowAsync(ex.Message);
+
+//                // OK か Cancelかで分岐するなら。今回はボタン一個、OKのみの想定なので無視
+//                // if (result == DialogResult.Ok) { }...
+
+//                // シーン呼び出しはawaitしないこと！awaitして正常終了しちゃうと、この通信の呼び出し元に処理が戻って続行してしまいます
+//                // のでForget。
+//                SceneManager.LoadSceneAsync("TitleScene").ToUniTask().Forget();
+
+
+//                // そしてOperationCanceledExceptionを投げて、この通信の呼び出し元の処理はキャンセル扱いにして終了させる
+//                throw new OperationCanceledException();
+//            }
+//        }
+//    }
+
+//    public enum DialogResult
+//    {
+//        Ok,
+//        Cancel
+//    }
+
+//    public static class MessageDialog
+//    {
+//        public static async UniTask<DialogResult> ShowAsync(string message)
+//        {
+//            // (例えば)Prefabで作っておいたダイアログを生成する
+//            var view = await Resources.LoadAsync("Prefabs/Dialog");
+
+//            // Ok, Cancelボタンのどちらかが押されるのを待機
+//            return await (view as GameObject).GetComponent<MessageDialogView>().ClickResult;
+//        }
+//    }
+
+//    public class MessageDialogView : MonoBehaviour
+//    {
+//        [SerializeField] Button okButton = default;
+//        [SerializeField] Button closeButton = default;
+
+//        UniTaskCompletionSource<DialogResult> taskCompletion;
+
+//        // これでどちらかが押されるまで無限に待つを表現
+//        public UniTask<DialogResult> ClickResult => taskCompletion.Task;
+
+//        private void Start()
+//        {
+//            taskCompletion = new UniTaskCompletionSource<DialogResult>();
+
+//            okButton.onClick.AddListener(() =>
+//            {
+//                taskCompletion.TrySetResult(DialogResult.Ok);
+//            });
+
+//            closeButton.onClick.AddListener(() =>
+//            {
+//                taskCompletion.TrySetResult(DialogResult.Cancel);
+//            });
+//        }
+
+//        // もしボタンが押されずに消滅した場合にネンノタメ。
+//        private void OnDestroy()
+//        {
+//            taskCompletion.TrySetResult(DialogResult.Cancel);
+//        }
+//    }
+
+//    public class MockDecorator : IAsyncDecorator
+//    {
+//        Dictionary<string, object> mock;
+
+//        // Pathと型を1:1にして事前定義したオブジェクトを返す辞書を渡す
+//        public MockDecorator(Dictionary<string, object> mock)
+//        {
+//            this.mock = mock;
+//        }
+
+//        public UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
+//        {
+//            if (mock.TryGetValue(context.Path, out var value))
+//            {
+//                // 一致したものがあればそれを返す（実際の通信は行わない）
+//                return new UniTask<ResponseContext>(new ResponseContext(value));
+//            }
+//            else
+//            {
+//                return next(context, cancellationToken);
+//            }
+//        }
+//    }
+
+//    //public class LoggingDecorator : IAsyncDecorator
+//    //{
+//    //    public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
+//    //    {
+//    //        var sw = Stopwatch.StartNew();
+//    //        try
+//    //        {
+//    //            UnityEngine.Debug.Log("Start Network Request:" + context.Path);
+
+//    //            var response = await next(context, cancellationToken);
+
+//    //            UnityEngine.Debug.Log($"Complete Network Request: {context.Path} , Elapsed: {sw.Elapsed}, Size: {response.GetRawData().Length}");
+
+//    //            return response;
+//    //        }
+//    //        catch (Exception ex)
+//    //        {
+//    //            if (ex is OperationCanceledException)
+//    //            {
+//    //                UnityEngine.Debug.Log("Request Canceled:" + context.Path);
+//    //            }
+//    //            else if (ex is TimeoutException)
+//    //            {
+//    //                UnityEngine.Debug.Log("Request Timeout:" + context.Path);
+//    //            }
+//    //            else if (ex is UnityWebRequestException webex)
+//    //            {
+//    //                if (webex.IsHttpError)
+//    //                {
+//    //                    UnityEngine.Debug.Log($"Request HttpError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
+//    //                }
+//    //                else if (webex.IsNetworkError)
+//    //                {
+//    //                    UnityEngine.Debug.Log($"Request NetworkError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
+//    //                }
+//    //            }
+//    //            throw;
+//    //        }
+//    //        finally
+//    //        {
+//    //            /* log other */
+//    //        }
+//    //    }
+//    //}
+
+//    public class SetupHeaderDecorator : IAsyncDecorator
+//    {
+//        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
+//        {
+//            context.RequestHeaders["x-app-timestamp"] = context.Timestamp.ToString();
+//            context.RequestHeaders["x-user-id"] = "132141411"; // どこかから持ってくる
+//            context.RequestHeaders["x-access-token"] = "fafafawfafewaea"; // どこかから持ってくる2
+
+//            var respsonse = await next(context, cancellationToken);
+
+//            var nextToken = respsonse.ResponseHeaders["token"];
+//            // UserProfile.Token = nextToken; // どこかにセットするということにする
+
+//            return respsonse;
+//        }
+//    }
+
+
+//    public class AppendTokenDecorator : IAsyncDecorator
+//    {
+//        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
+//        {
+//            string token = "token"; // どっかから取ってくるということにする
+//            RETRY:
+//            try
+//            {
+//                context.RequestHeaders["x-accesss-token"] = token;
+//                return await next(context, cancellationToken);
+//            }
+//            catch (UnityWebRequestException ex)
+//            {
+//                // 例えば700はTokenを再取得してください的な意味だったとする
+//                if (ex.ResponseCode == 700)
+//                {
+//                    // 別口でTokenを取得します的な処理
+//                    var newToken = await new NetworkClient(context.BasePath, context.Timeout).PostAsync<string>("/Auth/GetToken", "access_token", cancellationToken);
+//                    context.Reset(this);
+//                    goto RETRY;
+//                }
+
+//                goto RETRY;
+//            }
+//        }
+//    }
+
+//    public class QueueRequestDecorator : IAsyncDecorator
+//    {
+//        readonly Queue<(UniTaskCompletionSource<ResponseContext>, RequestContext, CancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>>)> q = new Queue<(UniTaskCompletionSource<ResponseContext>, RequestContext, CancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>>)>();
+//        bool running;
+
+//        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
+//        {
+//            if (q.Count == 0)
+//            {
+//                return await next(context, cancellationToken);
+//            }
+//            else
+//            {
+//                var completionSource = new UniTaskCompletionSource<ResponseContext>();
+//                q.Enqueue((completionSource, context, cancellationToken, next));
+//                if (!running)
+//                {
+//                    Run().Forget();
+//                }
+//                return await completionSource.Task;
+//            }
+//        }
+
+//        async UniTaskVoid Run()
+//        {
+//            running = true;
+//            try
+//            {
+//                while (q.Count != 0)
+//                {
+//                    var (tcs, context, cancellationToken, next) = q.Dequeue();
+//                    try
+//                    {
+//                        var response = await next(context, cancellationToken);
+//                        tcs.TrySetResult(response);
+//                    }
+//                    catch (Exception ex)
+//                    {
+//                        tcs.TrySetException(ex);
+//                    }
+//                }
+//            }
+//            finally
+//            {
+//                running = false;
+//            }
+//        }
+//    }
+
+
+//    public class RequestContext
+//    {
+//        int decoratorIndex;
+//        readonly IAsyncDecorator[] decorators;
+//        Dictionary<string, string> headers;
+
+//        public string BasePath { get; }
+//        public string Path { get; }
+//        public object Value { get; }
+//        public TimeSpan Timeout { get; }
+//        public DateTimeOffset Timestamp { get; private set; }
+
+//        public IDictionary<string, string> RequestHeaders
+//        {
+//            get
+//            {
+//                if (headers == null)
+//                {
+//                    headers = new Dictionary<string, string>();
+//                }
+//                return headers;
+//            }
+//        }
+
+//        public RequestContext(string basePath, string path, object value, TimeSpan timeout, IAsyncDecorator[] filters)
+//        {
+//            this.decoratorIndex = -1;
+//            this.decorators = filters;
+//            this.BasePath = basePath;
+//            this.Path = path;
+//            this.Value = value;
+//            this.Timeout = timeout;
+//            this.Timestamp = DateTimeOffset.UtcNow;
+//        }
+
+//        internal Dictionary<string, string> GetRawHeaders() => headers;
+//        internal IAsyncDecorator GetNextDecorator() => decorators[++decoratorIndex];
+
+//        public void Reset(IAsyncDecorator currentFilter)
+//        {
+//            decoratorIndex = Array.IndexOf(decorators, currentFilter);
+//            if (headers != null)
+//            {
+//                headers.Clear();
+//            }
+//            Timestamp = DateTimeOffset.UtcNow;
+//        }
+//    }
+
+//    public class ResponseContext
+//    {
+//        bool hasValue;
+//        object value;
+//        readonly byte[] bytes;
+
+//        public long StatusCode { get; }
+//        public Dictionary<string, string> ResponseHeaders { get; }
+
+//        public ResponseContext(object value, Dictionary<string, string> header = null)
+//        {
+//            this.hasValue = true;
+//            this.value = value;
+//            this.StatusCode = 200;
+//            this.ResponseHeaders = (header ?? new Dictionary<string, string>());
+//        }
+
+//        public ResponseContext(byte[] bytes, long statusCode, Dictionary<string, string> responseHeaders)
+//        {
+//            this.hasValue = false;
+//            this.bytes = bytes;
+//            this.StatusCode = statusCode;
+//            this.ResponseHeaders = responseHeaders;
+//        }
+
+//        public byte[] GetRawData() => bytes;
+
+//        public T GetResponseAs<T>()
+//        {
+//            if (hasValue)
+//            {
+//                return (T)value;
+//            }
+
+//            value = JsonUtility.FromJson<T>(Encoding.UTF8.GetString(bytes));
+//            hasValue = true;
+//            return (T)value;
+//        }
+//    }
+
+//    public interface IAsyncDecorator
+//    {
+//        UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next);
+//    }
+
+
+//    public class NetworkClient : IAsyncDecorator
+//    {
+//        readonly Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next;
+//        readonly IAsyncDecorator[] decorators;
+//        readonly TimeSpan timeout;
+//        readonly IProgress<float> progress;
+//        readonly string basePath;
+
+//        public NetworkClient(string basePath, TimeSpan timeout, params IAsyncDecorator[] decorators)
+//            : this(basePath, timeout, null, decorators)
+//        {
+//        }
+
+//        public NetworkClient(string basePath, TimeSpan timeout, IProgress<float> progress, params IAsyncDecorator[] decorators)
+//        {
+//            this.next = InvokeRecursive; // setup delegate
+
+//            this.basePath = basePath;
+//            this.timeout = timeout;
+//            this.progress = progress;
+//            this.decorators = new IAsyncDecorator[decorators.Length + 1];
+//            Array.Copy(decorators, this.decorators, decorators.Length);
+//            this.decorators[this.decorators.Length - 1] = this;
+//        }
+
+//        public async UniTask<T> PostAsync<T>(string path, T value, CancellationToken cancellationToken = default)
+//        {
+//            var request = new RequestContext(basePath, path, value, timeout, decorators);
+//            var response = await InvokeRecursive(request, cancellationToken);
+//            return response.GetResponseAs<T>();
+//        }
+
+
+//        UniTask<ResponseContext> InvokeRecursive(RequestContext context, CancellationToken cancellationToken)
+//        {
+//            return context.GetNextDecorator().SendAsync(context, cancellationToken, next); // マジカル再帰処理
+//        }
+
+//        async UniTask<ResponseContext> IAsyncDecorator.SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> _)
+//        {
+//            // Postしか興味ないからPostにしかしないよ！
+//            // パフォーマンスを最大限にしたい場合はuploadHandler, downloadHandlerをカスタマイズすること
+
+//            // JSONでbodyに送るというパラメータで送るという雑設定。
+//            var data = JsonUtility.ToJson(context.Value);
+//            var formData = new Dictionary<string, string> { { "body", data } };
+
+//            using (var req = UnityWebRequest.Post(basePath + context.Path, formData))
+//            {
+//                var header = context.GetRawHeaders();
+//                if (header != null)
+//                {
+//                    foreach (var item in header)
+//                    {
+//                        req.SetRequestHeader(item.Key, item.Value);
+//                    }
+//                }
+
+//                // Timeout処理はCancellationTokenSourceのCancelAfterSlim(UniTask拡張)を使ってサクッと処理
+//                var linkToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+//                linkToken.CancelAfterSlim(timeout);
+//                try
+//                {
+//                    // 完了待ちや終了処理はUniTaskの拡張自体に丸投げ
+//                    await req.SendWebRequest().ToUniTask(progress: progress, cancellationToken: linkToken.Token);
+//                }
+//                catch (OperationCanceledException)
+//                {
+//                    // 元キャンセレーションソースがキャンセルしてなければTimeoutによるものと判定
+//                    if (!cancellationToken.IsCancellationRequested)
+//                    {
+//                        throw new TimeoutException();
+//                    }
+//                }
+//                finally
+//                {
+//                    // Timeoutに引っかからなかった場合にてるのでCancelAfterSlimの裏で回ってるループをこれで終わらせとく
+//                    if (!linkToken.IsCancellationRequested)
+//                    {
+//                        linkToken.Cancel();
+//                    }
+//                }
+
+//                // UnityWebRequestを先にDisposeしちゃうので先に必要なものを取得しておく（性能的には無駄なのでパフォーマンスを最大限にしたい場合は更に一工夫を）
+//                return new ResponseContext(req.downloadHandler.data, req.responseCode, req.GetResponseHeaders());
+//            }
+//        }
+//    }
+//}
--- a/src/UniTask/Assets/Scenes/SandboxMain.cs
+++ b/src/UniTask/Assets/Scenes/SandboxMain.cs
@@ -18,7 +18,6 @@ using UnityEngine.SceneManagement;
 using UnityEngine.Rendering;
 using System.IO;
 using System.Linq.Expressions;
-using Cysharp.Threading.Tasks.Sample;


 // using DG.Tweening;
@@ -269,32 +268,33 @@ public class SandboxMain : MonoBehaviour

    async Task Test1()
    {
-        var r = await TcsAsync("https://bing.com/");
+        // var r = await TcsAsync("https://bing.com/");
+        await Task.Yield();
        Debug.Log("TASKASYNC");
    }

-    async UniTaskVoid Test2()
-    {
-        try
-        {
-            //var cts = new CancellationTokenSource();
-            //var r = UniAsync("https://bing.com/", cts.Token);
-            //cts.Cancel();
-            //await r;
-            Debug.Log("SendWebRequestDone:" + PlayerLoopInfo.CurrentLoopType);
+    //async UniTaskVoid Test2()
+    //{
+    //    try
+    //    {
+    //        //var cts = new CancellationTokenSource();
+    //        //var r = UniAsync("https://bing.com/", cts.Token);
+    //        //cts.Cancel();
+    //        //await r;
+    //        Debug.Log("SendWebRequestDone:" + PlayerLoopInfo.CurrentLoopType);


-            //        var foo = await UnityWebRequest.Get("https://bing.com/").SendWebRequest();
-            //          foo.downloadHandler.text;
-            //
-            _ = await UnityWebRequest.Get("https://bing.com/").SendWebRequest().WithCancellation(CancellationToken.None);
-            Debug.Log("SendWebRequestWithCancellationDone:" + PlayerLoopInfo.CurrentLoopType);
-        }
-        catch
-        {
-            Debug.Log("Canceled");
-        }
-    }
+    //        //        var foo = await UnityWebRequest.Get("https://bing.com/").SendWebRequest();
+    //        //          foo.downloadHandler.text;
+    //        //
+    //        _ = await UnityWebRequest.Get("https://bing.com/").SendWebRequest().WithCancellation(CancellationToken.None);
+    //        Debug.Log("SendWebRequestWithCancellationDone:" + PlayerLoopInfo.CurrentLoopType);
+    //    }
+    //    catch
+    //    {
+    //        Debug.Log("Canceled");
+    //    }
+    //}

    IEnumerator Test3(string url)
    {
@@ -303,17 +303,17 @@ public class SandboxMain : MonoBehaviour
        Debug.Log("COROUTINE");
    }

-    static async Task<UnityWebRequest> TcsAsync(string url)
-    {
-        var req = await UnityWebRequest.Get(url).SendWebRequest();
-        return req;
-    }
+    //static async Task<UnityWebRequest> TcsAsync(string url)
+    //{
+    //    var req = await UnityWebRequest.Get(url).SendWebRequest();
+    //    return req;
+    //}

-    static async UniTask<UnityWebRequest> UniAsync(string url, CancellationToken cancellationToken)
-    {
-        var req = await UnityWebRequest.Get(url).SendWebRequest().WithCancellation(cancellationToken);
-        return req;
-    }
+    //static async UniTask<UnityWebRequest> UniAsync(string url, CancellationToken cancellationToken)
+    //{
+    //    var req = await UnityWebRequest.Get(url).SendWebRequest().WithCancellation(cancellationToken);
+    //    return req;
+    //}

    async Task<int> Test()
    {
@@ -542,26 +542,116 @@ public class SandboxMain : MonoBehaviour
            {
                Debug.LogError(e);
                return;
+
+                
            }
        }
        Debug.Log("TestAsync Finished.");
    }

+
+
+
    async UniTaskVoid Start()
    {
-        var cts = new CancellationTokenSource();

-        TestAsync(cts.Token).Forget();
+        // UniTask.Delay(TimeSpan.FromSeconds(1)).TimeoutWithoutException
+
+
+        var currentLoop = PlayerLoop.GetDefaultPlayerLoop();
+        PlayerLoopHelper.Initialize(ref currentLoop, InjectPlayerLoopTimings.Minimum); // minimum is Update | FixedUpdate | LastPostLateUpdate
+
+
+        
+
+
+        var cancelToken = new CancellationTokenSource();
+        cancelButton.onClick.AddListener(()=>
+        {
+            cancelToken.Cancel(); // cancel from button click.
+        });
+
+        var timeoutToken = new CancellationTokenSource();
+        timeoutToken.CancelAfterSlim(TimeSpan.FromSeconds(5)); // 5sec timeout.
+
+        try
+        {
+            // combine token
+            var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancelToken.Token, timeoutToken.Token);
+
+            await UnityWebRequest.Get("http://foo").SendWebRequest().WithCancellation(linkedTokenSource.Token);
+        }
+        catch (OperationCanceledException ex)
+        {
+            if (timeoutToken.IsCancellationRequested)
+            {
+                UnityEngine.Debug.Log("Timeout.");
+            }
+            else if (cancelToken.IsCancellationRequested)
+            {
+                UnityEngine.Debug.Log("Cancel clicked.");
+            }
+            _ = ex;
+        }
+
+
+
+
+        
+
+        // TestAsync(cts.Token).Forget();

        okButton.onClick.AddListener(UniTask.UnityAction(async () =>
        {
-            cts.Cancel();
+            // try timeout
+            try
+            {
+                //await UniTask.Delay(TimeSpan.FromSeconds(2), cancellationToken: timeoutController.Timeout(TimeSpan.FromSeconds(3)));
+                UnityEngine.Debug.Log("Delay Complete, Reset(and reuse).");
+                //timeoutController.Reset();
+            }
+            catch (OperationCanceledException ex)
+            {
+                //UnityEngine.Debug.Log("Timeout! FromTimeout?:" + timeoutController.IsTimeout());
+                _ = ex;
+            }
+
+            await UniTask.Yield();
+        }));
+
+        cancelButton.onClick.AddListener(UniTask.UnityAction(async () =>
+        {
+            //clickCancelSource.Cancel();
+
+            //RunCheck(PlayerLoopTiming.Initialization).Forget();
+            //RunCheck(PlayerLoopTiming.LastInitialization).Forget();
+            //RunCheck(PlayerLoopTiming.EarlyUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.LastEarlyUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.FixedUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.LastFixedUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.PreUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.LastPreUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.Update).Forget();
+            //RunCheck(PlayerLoopTiming.LastUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.PreLateUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.LastPreLateUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.PostLateUpdate).Forget();
+            //RunCheck(PlayerLoopTiming.LastPostLateUpdate).Forget();
+
            await UniTask.Yield();
        }));

        await UniTask.Yield();
    }

+    async UniTaskVoid RunCheck(PlayerLoopTiming timing)
+    {
+        //await UniTask.Yield(timing);
+        //UnityEngine.Debug.Log("Yield:" + timing);
+        await UniTask.DelayFrame(1, timing);
+        UnityEngine.Debug.Log("Delay:" + timing);
+    }
+
    private void Application_logMessageReceived2(string condition, string stackTrace, LogType type)
    {
        throw new NotImplementedException();
--- a/src/UniTask/Assets/TempAsm/FooMonoBehaviour.cs
+++ b/src/UniTask/Assets/TempAsm/FooMonoBehaviour.cs
@@ -12,16 +12,16 @@ public class FooMonoBehaviour : MonoBehaviour

    }

-    private async UniTask Download(UnityWebRequest req, string filePath)
-    {
-        var foo = req.SendWebRequest();
+    //private async UniTask Download(UnityWebRequest req, string filePath)
+    //{
+    //    _ = req.SendWebRequest();


-        

-        var aaa = await foo;
-        Debug.Log(aaa);

-        //File.WriteAllText(filePath, req.downloadHandler.text ?? string.Empty);
-    }
+    //    // var aaa = await foo;
+    //    // Debug.Log(aaa);
+    //    await UniTask.Yield();
+    //    //File.WriteAllText(filePath, req.downloadHandler.text ?? string.Empty);
+    //}
 }
Author	SHA1	Message	Date
github-actions[bot]	e57a4332ec	feat: Update package.json to 2.2.1	2021-02-26 09:52:12 +00:00
neuecc	e88e553cc9	2.2.1	2021-02-26 18:51:35 +09:00
github-actions[bot]	a1a38d0d7c	feat: Update package.json to 2.2.0	2021-02-26 07:47:03 +00:00
Yoshifumi Kawai	c9bebd6550	Merge pull request #238 from Cysharp/custom-loop-injector Ver 2.2.0	2021-02-26 16:42:54 +09:00
neuecc	42047070dd	more ci	2021-02-26 11:42:30 +09:00
neuecc	316f3bd963	cm	2021-02-26 11:00:47 +09:00
neuecc	5f96e646d4	netcore	2021-02-26 10:27:22 +09:00
neuecc	186114996c	docs: update TOC	2021-02-25 13:13:40 +00:00
neuecc	841b6e85ae	fix	2021-02-25 22:13:14 +09:00
neuecc	7ac9853cf6	(BreakingChange)AsyncOperation.WithCancellation same ToUniTask(ctoken)	2021-02-25 22:11:18 +09:00
neuecc	0ec45b9da6	(Breaking Changed)UniTask.WithCancellation -> IgnoreWhenCanceled	2021-02-25 21:56:52 +09:00
neuecc	dfd0fe9fe4	Add TimeoutController	2021-02-25 20:30:44 +09:00
neuecc	4710268e0a	Add PlayerLoopHelper.Initialize(InbjectPlayerLoopTimings)	2021-02-25 19:26:37 +09:00
neuecc	cae512e4de	Delay automatically fallback to Realtime when run on EditMode #234	2021-02-25 19:25:48 +09:00
neuecc	6351d4c5a4	test1	2021-02-25 11:12:15 +09:00
github-actions[bot]	1173bb4f34	feat: Update package.json to 2.1.2	2021-02-08 10:44:53 +00:00
neuecc	e4272b5337	one more back to 2.1.1	2021-02-08 19:43:57 +09:00
neuecc	b660506e31	com.unity.modules.unitywebrequest	2021-02-08 19:43:32 +09:00
github-actions[bot]	2c101aef08	feat: Update package.json to 2.1.2	2021-02-08 10:37:58 +00:00
neuecc	498b2a4f81	Merge remote-tracking branch 'origin/master'	2021-02-08 19:37:25 +09:00
neuecc	a8c2fd420a	back to 2.1.1	2021-02-08 19:37:09 +09:00
Yoshifumi Kawai	dade7fdc76	Merge pull request #230 from Cysharp/fix/checkout_version chore: fix checkout version on unity	2021-02-08 19:34:19 +09:00
Ikiru Yoshizaki	1c8b16f798	chore: fix checkout version on unity	2021-02-08 19:32:53 +09:00
neuecc	89649d8777	remove unity generate csproj	2021-02-08 19:22:54 +09:00
github-actions[bot]	9894bf875b	feat: Update package.json to 2.1.2	2021-02-08 10:14:07 +00:00
Yoshifumi Kawai	45a800330b	Merge pull request #229 from Cysharp/moreasmdef define UNITASK_PHYSICS_SUPPORT, UNITASK_PHYSICS2D_SUPPORT, UNITASK_PARTICLESYSTEM_SUPPORT, UNITASK_UGUI_SUPPORT, UNITASK_WEBREQUEST_SUPPORT	2021-02-08 19:11:00 +09:00
neuecc	a35e5f929d	UNITASK_WEBREQUEST_SUPPORT	2021-02-08 19:09:02 +09:00
neuecc	9a3f10d4bf	versionDefines for physics etc.	2021-02-08 18:08:56 +09:00
Ikiru Yoshizaki	19b5f921a1	chore: add original cli command	2021-02-08 16:53:46 +09:00
Yoshifumi Kawai	8cd577904e	Merge pull request #228 from Cysharp/chore/image chore: new docker image to build	2021-02-08 16:16:56 +09:00
Ikiru Yoshizaki	309d661bcc	fix: actions name update to game-ci/unity-builder	2021-02-08 16:08:43 +09:00
Ikiru Yoshizaki	8736024d9b	Merge branch 'master' into chore/image	2021-02-08 15:54:18 +09:00
Ikiru Yoshizaki	97680e57a8	chore: new unity build with unityci/editor	2021-02-08 15:54:07 +09:00
Yoshifumi Kawai	638522600a	Merge pull request #220 from taigacon/master Fix using AsyncUnityEventHandler with a already canceled token	2021-02-08 14:51:21 +09:00
Yoshifumi Kawai	081113a62c	Merge pull request #224 from neilsarkar/master Grammar edits for README.md	2021-02-08 14:01:03 +09:00
Ikiru Yoshizaki	7535c84581	chore: use unity-editor	2021-02-08 11:47:14 +09:00
Ikiru Yoshizaki	690f3a2ead	chore: move 2020.1 beta to ga image	2021-02-08 11:36:39 +09:00
Ikiru Yoshizaki	88371d08b9	chore: new docker image to build	2021-02-08 11:26:31 +09:00
Yoshifumi Kawai	6d382450cf	Merge pull request #226 from Cysharp/chore/release chore: release on workflow_dispatch	2021-02-08 11:22:27 +09:00
Ikiru Yoshizaki	19f2a6f282	chore: pr build should run for master only	2021-02-04 03:01:21 +09:00
Ikiru Yoshizaki	7ed0b016ea	chore: release on workflow_dispatch	2021-02-04 02:59:52 +09:00
Ikiru Yoshizaki	f72a51e13d	chore: detect forgotten .meta file commit	2021-02-04 02:58:29 +09:00
Neil Sarkar	0e2dbbe754	Minor copyedit `AsyncOpereationHandle<T>` -> `AsyncOperationHandle<T>`	2021-02-03 10:25:35 -05:00
Neil Sarkar	cff51a0425	Minor copyedit oldest version -> lowest version	2021-02-03 10:18:32 -05:00
Neil Sarkar	7cac4bbbab	Grammar fixes for README.md	2021-02-03 10:07:32 -05:00
taigacon	3f4a46bca6	Fix using AsyncUnityEventHandler with a already canceled token	2021-01-25 20:02:56 +08:00