diff --git a/eng/pipelines/common/platform-matrix.yml b/eng/pipelines/common/platform-matrix.yml
index ad3dbd4db8bc0d..d22f2d0e8902e3 100644
--- a/eng/pipelines/common/platform-matrix.yml
+++ b/eng/pipelines/common/platform-matrix.yml
@@ -27,244 +27,6 @@ parameters:
 
 jobs:
 
-# Linux arm
-- ${{ if or(containsValue(parameters.platforms, 'Linux_arm'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      archType: arm
-      targetRid: linux-arm
-      platform: Linux_arm
-      container:
-        image: ubuntu-16.04-cross-20210719121212-8a8d3be
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/arm'
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Linux arm64
-
-- ${{ if or(containsValue(parameters.platforms, 'Linux_arm64'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      archType: arm64
-      targetRid: linux-arm64
-      platform: Linux_arm64
-      container:
-        ${{ if eq(parameters.container, '') }}:
-          image: ubuntu-16.04-cross-arm64-20210719121212-8a8d3be
-        ${{ if ne(parameters.container, '') }}:
-          image: ${{ parameters.container }}
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/arm64'
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Linux musl x64
-
-- ${{ if or(containsValue(parameters.platforms, 'Linux_musl_x64'), eq(parameters.platformGroup, 'all')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      osSubgroup: _musl
-      archType: x64
-      targetRid: linux-musl-x64
-      platform: Linux_musl_x64
-      container:
-        image: alpine-3.13-WithNode-20210910135845-c401c85
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Linux musl arm
-
-- ${{ if or(containsValue(parameters.platforms, 'Linux_musl_arm'), eq(parameters.platformGroup, 'all')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      osSubgroup: _musl
-      archType: arm
-      targetRid: linux-musl-arm
-      platform: Linux_musl_arm
-      container:
-        image: ubuntu-16.04-cross-arm-alpine-20210923140502-78f7860
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/arm'
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Linux musl arm64
-
-- ${{ if or(containsValue(parameters.platforms, 'Linux_musl_arm64'), eq(parameters.platformGroup, 'all')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      osSubgroup: _musl
-      archType: arm64
-      targetRid: linux-musl-arm64
-      platform: Linux_musl_arm64
-      container:
-        image: ubuntu-16.04-cross-arm64-alpine-20210923140502-78f7860
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/arm64'
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Linux x64
-
-- ${{ if or(containsValue(parameters.platforms, 'Linux_x64'), containsValue(parameters.platforms, 'CoreClrTestBuildHost'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      archType: x64
-      targetRid: linux-x64
-      platform: Linux_x64
-      container:
-        ${{ if eq(parameters.container, '') }}:
-          image: centos-7-20210714125435-9b5bbc2
-        ${{ if ne(parameters.container, '') }}:
-          image: ${{ parameters.container }}
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Linux x86
-
-- ${{ if containsValue(parameters.platforms, 'Linux_x86') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      archType: x86
-      targetRid: linux-x86
-      platform: Linux_x86
-      container:
-        image: ubuntu-18.04-cross-x86-linux-20211022152824-f853169
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/x86'
-        disableClrTest: true
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Linux x64 Source Build
-
-- ${{ if containsValue(parameters.platforms, 'SourceBuild_Linux_x64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      archType: x64
-      targetRid: linux-x64
-      platform: Linux_x64
-      container:
-        image: centos-7-source-build-20210714125450-5d87b80
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-        buildingOnSourceBuildImage: true
-
-# Linux s390x
-
-- ${{ if containsValue(parameters.platforms, 'Linux_s390x') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Linux
-      archType: s390x
-      targetRid: linux-s390x
-      platform: Linux_s390x
-      container:
-        image: ubuntu-18.04-cross-s390x-20201102145728-d6e0352
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/s390x'
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
 # WebAssembly
 
 - ${{ if containsValue(parameters.platforms, 'Browser_wasm') }}:
@@ -291,505 +53,21 @@ jobs:
 
 # WebAssembly on Windows
 
-- ${{ if containsValue(parameters.platforms, 'Browser_wasm_win') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      hostedOs: windows
-      osGroup: Browser
-      archType: wasm
-      targetRid: browser-wasm
-      platform: Browser_wasm_win
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# FreeBSD
-- ${{ if containsValue(parameters.platforms, 'FreeBSD_x64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: FreeBSD
-      archType: x64
-      targetRid: freebsd-x64
-      platform: FreeBSD_x64
-      container:
-        image: ubuntu-18.04-cross-freebsd-12-20210917001307-f13d79e
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        buildConfig: ${{ parameters.buildConfig }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/x64'
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Android x64
-
-- ${{ if containsValue(parameters.platforms, 'Android_x64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Android
-      archType: x64
-      targetRid: android-x64
-      platform: Android_x64
-      container:
-        image: ubuntu-18.04-android-20200422191843-e2c3f83
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Android x86
-
-- ${{ if containsValue(parameters.platforms, 'Android_x86') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Android
-      archType: x86
-      targetRid: android-x86
-      platform: Android_x86
-      container:
-        image: ubuntu-18.04-android-20200422191843-e2c3f83
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Android arm
-
-- ${{ if containsValue(parameters.platforms, 'Android_arm') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Android
-      archType: arm
-      targetRid: android-arm
-      platform: Android_arm
-      container:
-        image: ubuntu-18.04-android-20200422191843-e2c3f83
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Android arm64
-
-- ${{ if containsValue(parameters.platforms, 'Android_arm64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Android
-      archType: arm64
-      targetRid: android-arm64
-      platform: Android_arm64
-      container:
-        image: ubuntu-18.04-android-20200422191843-e2c3f83
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Mac Catalyst x64
-
-- ${{ if containsValue(parameters.platforms, 'MacCatalyst_x64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: MacCatalyst
-      archType: x64
-      targetRid: maccatalyst-x64
-      platform: MacCatalyst_x64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Mac Catalyst arm64
-
-- ${{ if containsValue(parameters.platforms, 'MacCatalyst_arm64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: MacCatalyst
-      archType: arm64
-      targetRid: maccatalyst-arm64
-      platform: MacCatalyst_arm64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# tvOS arm64
-
-- ${{ if containsValue(parameters.platforms, 'tvOS_arm64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: tvOS
-      archType: arm64
-      targetRid: tvos-arm64
-      platform: tvOS_arm64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# tvOS Simulator x64
-
-- ${{ if containsValue(parameters.platforms, 'tvOSSimulator_x64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: tvOSSimulator
-      archType: x64
-      targetRid: tvossimulator-x64
-      platform: tvOSSimulator_x64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# tvOS Simulator arm64
-
-- ${{ if containsValue(parameters.platforms, 'tvOSSimulator_arm64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: tvOSSimulator
-      archType: arm64
-      targetRid: tvossimulator-arm64
-      platform: tvOSSimulator_arm64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# iOS arm
-
-- ${{ if containsValue(parameters.platforms, 'iOS_arm') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: iOS
-      archType: arm
-      targetRid: ios-arm
-      platform: iOS_arm
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# iOS arm64
-
-- ${{ if containsValue(parameters.platforms, 'iOS_arm64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: iOS
-      archType: arm64
-      targetRid: ios-arm64
-      platform: iOS_arm64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# iOS Simulator x64
-
-- ${{ if containsValue(parameters.platforms, 'iOSSimulator_x64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: iOSSimulator
-      archType: x64
-      targetRid: iossimulator-x64
-      platform: iOSSimulator_x64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# iOS Simulator x86
-
-- ${{ if containsValue(parameters.platforms, 'iOSSimulator_x86') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: iOSSimulator
-      archType: x86
-      targetRid: iossimulator-x86
-      platform: iOSsimulator_x86
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        managedTestBuildOsGroup: OSX
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# iOS Simulator arm64
-
-- ${{ if containsValue(parameters.platforms, 'iOSSimulator_arm64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: iOSSimulator
-      archType: arm64
-      targetRid: iossimulator-arm64
-      platform: iOSSimulator_arm64
-      jobParameters:
-        runtimeFlavor: mono
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# macOS arm64
-
-- ${{ if containsValue(parameters.platforms, 'OSX_arm64') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: OSX
-      archType: arm64
-      targetRid: osx-arm64
-      platform: OSX_arm64
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# macOS x64
-
-- ${{ if or(containsValue(parameters.platforms, 'OSX_x64'), eq(parameters.platformGroup, 'all')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: OSX
-      archType: x64
-      targetRid: osx-x64
-      platform: OSX_x64
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Tizen armel
-
-- ${{ if containsValue(parameters.platforms, 'Tizen_armel') }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: Tizen
-      archType: armel
-      targetRid: tizen-armel
-      platform: Tizen_armel
-      container:
-        image: ubuntu-18.04-cross-armel-tizen-20210719212651-8b02f56
-        registry: mcr
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        crossBuild: true
-        crossrootfsDir: '/crossrootfs/armel'
-        disableClrTest: true
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Windows x64
-
-- ${{ if or(containsValue(parameters.platforms, 'windows_x64'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: windows
-      archType: x64
-      targetRid: win-x64
-      platform: windows_x64
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Windows x86
-
-- ${{ if or(containsValue(parameters.platforms, 'windows_x86'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: windows
-      archType: x86
-      targetRid: win-x86
-      platform: windows_x86
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Windows arm
-- ${{ if or(containsValue(parameters.platforms, 'windows_arm'), eq(parameters.platformGroup, 'all')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: windows
-      archType: arm
-      targetRid: win-arm
-      platform: windows_arm
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
-
-# Windows arm64
-
-- ${{ if or(containsValue(parameters.platforms, 'windows_arm64'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
-  - template: xplat-setup.yml
-    parameters:
-      jobTemplate: ${{ parameters.jobTemplate }}
-      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
-      variables: ${{ parameters.variables }}
-      osGroup: windows
-      archType: arm64
-      targetRid: win-arm64
-      platform: windows_arm64
-      jobParameters:
-        runtimeFlavor: ${{ parameters.runtimeFlavor }}
-        stagedBuild: ${{ parameters.stagedBuild }}
-        buildConfig: ${{ parameters.buildConfig }}
-        ${{ if eq(parameters.passPlatforms, true) }}:
-          platforms: ${{ parameters.platforms }}
-        helixQueueGroup: ${{ parameters.helixQueueGroup }}
-        ${{ insert }}: ${{ parameters.jobParameters }}
+#- ${{ if containsValue(parameters.platforms, 'Browser_wasm_win') }}:
+  #- template: xplat-setup.yml
+    #parameters:
+      #jobTemplate: ${{ parameters.jobTemplate }}
+      #helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
+      #variables: ${{ parameters.variables }}
+      #hostedOs: windows
+      #osGroup: Browser
+      #archType: wasm
+      #targetRid: browser-wasm
+      #platform: Browser_wasm_win
+      #jobParameters:
+        #runtimeFlavor: ${{ parameters.runtimeFlavor }}
+        #stagedBuild: ${{ parameters.stagedBuild }}
+        #buildConfig: ${{ parameters.buildConfig }}
+        #${{ if eq(parameters.passPlatforms, true) }}:
+          #platforms: ${{ parameters.platforms }}
+        #${{ insert }}: ${{ parameters.jobParameters }}
diff --git a/eng/pipelines/libraries/wasm-debugger-tests-then-helix.yml b/eng/pipelines/libraries/wasm-debugger-tests-then-helix.yml
new file mode 100644
index 00000000000000..bd0fd1d06f2e58
--- /dev/null
+++ b/eng/pipelines/libraries/wasm-debugger-tests-then-helix.yml
@@ -0,0 +1,48 @@
+parameters:
+  runtimeFlavor: ''
+  archType: ''
+  buildConfig: ''
+  creator: ''
+  helixQueues: ''
+  osGroup: ''
+  targetRid: ''
+  testRunNamePrefixSuffix: ''
+  testScope: 'innerloop' # innerloop | outerloop | all
+  interpreter: ''
+  condition: always()
+  extraHelixArguments: ''
+  shouldContinueOnError: false
+  scenarios: ''
+
+steps:
+  - script: $(_msbuildCommand) -restore
+            $(Build.SourcesDirectory)/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestSuite.csproj
+            /p:Configuration=Debug
+            /p:RuntimeConfiguration=${{ parameters.buildConfig }} /p:ArchiveTests=true
+            /bl:$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)/Wasm.Debugger.Tests.binlog
+    displayName: Build Wasm.Debugger.Tests
+    condition: and(succeeded(), ${{ parameters.condition }})
+    continueOnError: ${{ eq(parameters.shouldContinueOnError, true) }}
+
+  # Chain to helix
+  - template: /eng/pipelines/libraries/helix.yml
+    parameters:
+      archType: ${{ parameters.archType }}
+      buildConfig: ${{ parameters.buildConfig }}
+      condition: succeeded()
+      creator: ${{ parameters.creator }}
+      extraHelixArguments: ${{ parameters.extraHelixArguments }}
+      helixQueues: ${{ parameters.helixQueues }}
+      interpreter: ${{ parameters.interpreter }}
+      nameSuffix: ${{ parameters.nameSuffix }}
+      osGroup: ${{ parameters.osGroup }}
+      osSubgroup: ${{ parameters.osSubgroup }}
+      pgoType: ${{ parameters.pgoType }}
+      platform: ${{ parameters.platform }}
+      runtimeFlavor: ${{ parameters.runtimeFlavor }}
+      runtimeVariant: ${{ parameters.runtimeVariant }}
+      scenarios: ${{ parameters.scenarios }}
+      shouldContinueOnError: ${{ parameters.shouldContinueOnError }}
+      targetRid: ${{ parameters.targetRid }}
+      testRunNamePrefixSuffix: ${{ parameters.testRunNamePrefixSuffix }}
+      testScope: ${{ parameters.testScope }}
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index af8b9c116dd80c..00c30fce099799 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -279,48 +279,81 @@ jobs:
 #
 # Build the whole product using Mono and run libraries tests, multi-scenario
 #
-- template: /eng/pipelines/common/platform-matrix.yml
-  parameters:
-    jobTemplate: /eng/pipelines/common/global-build-job.yml
-    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
-    buildConfig: Release
-    runtimeFlavor: mono
-    platforms:
-    - Browser_wasm
-    variables:
-      # map dependencies variables to local variables
-      - name: librariesContainsChange
-        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
-      - name: monoContainsChange
-        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
-    jobParameters:
-      testGroup: innerloop
-      nameSuffix: AllSubsets_Mono
-      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
-      timeoutInMinutes: 180
-      condition: >-
-        or(
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
-          eq(variables['isFullMatrix'], true))
-      # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
-      extraStepsParameters:
-        creator: dotnet-bot
-        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
-        scenarios:
-        - normal
-        - wasmtestonbrowser
-        condition: >-
-          or(
-          eq(variables['librariesContainsChange'], true),
-          eq(variables['monoContainsChange'], true),
-          eq(variables['isFullMatrix'], true))
+#- template: /eng/pipelines/common/platform-matrix.yml
+  #parameters:
+    #jobTemplate: /eng/pipelines/common/global-build-job.yml
+    #helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    #buildConfig: Release
+    #runtimeFlavor: mono
+    #platforms:
+    #- Browser_wasm
+    #variables:
+      ## map dependencies variables to local variables
+      #- name: librariesContainsChange
+        #value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+      #- name: monoContainsChange
+        #value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
+    #jobParameters:
+      #testGroup: innerloop
+      #nameSuffix: AllSubsets_Mono
+      #buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
+      #timeoutInMinutes: 180
+      #condition: >-
+        #or(
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
+          #eq(variables['isFullMatrix'], true))
+      ## extra steps, run tests
+      #extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      #extraStepsParameters:
+        #creator: dotnet-bot
+        #testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        #scenarios:
+        #- normal
+        #- wasmtestonbrowser
+        #condition: >-
+          #or(
+          #eq(variables['librariesContainsChange'], true),
+          #eq(variables['monoContainsChange'], true),
+          #eq(variables['isFullMatrix'], true))
 
 #
 # Build the whole product using Mono and run libraries tests, for Wasm.Build.Tests
 #
+#- template: /eng/pipelines/common/platform-matrix.yml
+  #parameters:
+    #jobTemplate: /eng/pipelines/common/global-build-job.yml
+    #helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    #buildConfig: Release
+    #runtimeFlavor: mono
+    #platforms:
+    #- Browser_wasm
+    #variables:
+      ## map dependencies variables to local variables
+      #- name: wasmbuildtestsContainsChange
+        #value: $[ dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'] ]
+    #jobParameters:
+      #testGroup: innerloop
+      #nameSuffix: AllSubsets_Mono_WasmBuildTests
+      #buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:TestWasmBuildTests=true /p:TestAssemblies=false
+      #timeoutInMinutes: 180
+      #condition: >-
+        #or(
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'], true),
+          #eq(variables['isFullMatrix'], true))
+      ## extra steps, run tests
+      #extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      #extraStepsParameters:
+        #creator: dotnet-bot
+        #testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        #scenarios:
+        #- buildwasmapps
+        #condition: >-
+          #or(
+          #eq(variables['wasmbuildtestsContainsChange'], true),
+          #eq(variables['isFullMatrix'], true))
+
 - template: /eng/pipelines/common/platform-matrix.yml
   parameters:
     jobTemplate: /eng/pipelines/common/global-build-job.yml
@@ -335,108 +368,108 @@ jobs:
         value: $[ dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'] ]
     jobParameters:
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_WasmBuildTests
-      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:TestWasmBuildTests=true /p:TestAssemblies=false
+      nameSuffix: WasmDebuggerTests
+      buildArgs: -s mono+libs -c $(_BuildConfig)
       timeoutInMinutes: 180
-      condition: >-
-        or(
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'], true),
-          eq(variables['isFullMatrix'], true))
+      #condition: >-
+        #or(
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'], true),
+          #eq(variables['isFullMatrix'], true))
       # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsTemplate: /eng/pipelines/libraries/wasm-debugger-tests-then-helix.yml
       extraStepsParameters:
         creator: dotnet-bot
         testRunNamePrefixSuffix: Mono_$(_BuildConfig)
         scenarios:
-        - buildwasmapps
-        condition: >-
-          or(
-          eq(variables['wasmbuildtestsContainsChange'], true),
-          eq(variables['isFullMatrix'], true))
+        - wasmdebuggertests
+        #condition: >-
+          #or(
+          #eq(variables['wasmbuildtestsContainsChange'], true),
+          #eq(variables['isFullMatrix'], true))
 
 #
 # Build for Browser/wasm, with EnableAggressiveTrimming=true
 #
-- template: /eng/pipelines/common/platform-matrix.yml
-  parameters:
-    jobTemplate: /eng/pipelines/common/global-build-job.yml
-    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
-    buildConfig: Release
-    runtimeFlavor: mono
-    platforms:
-    - Browser_wasm
-    variables:
-      # map dependencies variables to local variables
-      - name: librariesContainsChange
-        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
-      - name: monoContainsChange
-        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
-    jobParameters:
-      testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_EAT
-      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=false
-      timeoutInMinutes: 180
-      condition: >-
-        or(
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
-          eq(variables['isFullMatrix'], true))
-      # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
-      extraStepsParameters:
-        creator: dotnet-bot
-        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
-        extraHelixArguments: /p:NeedsToBuildWasmAppsOnHelix=true $(_runSmokeTestsOnlyArg)
-        scenarios:
-        - normal
-        condition: >-
-          or(
-          eq(variables['librariesContainsChange'], true),
-          eq(variables['monoContainsChange'], true),
-          eq(variables['isFullMatrix'], true))
+#- template: /eng/pipelines/common/platform-matrix.yml
+  #parameters:
+    #jobTemplate: /eng/pipelines/common/global-build-job.yml
+    #helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    #buildConfig: Release
+    #runtimeFlavor: mono
+    #platforms:
+    #- Browser_wasm
+    #variables:
+      ## map dependencies variables to local variables
+      #- name: librariesContainsChange
+        #value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+      #- name: monoContainsChange
+        #value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
+    #jobParameters:
+      #testGroup: innerloop
+      #nameSuffix: AllSubsets_Mono_EAT
+      #buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=false
+      #timeoutInMinutes: 180
+      #condition: >-
+        #or(
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
+          #eq(variables['isFullMatrix'], true))
+      ## extra steps, run tests
+      #extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      #extraStepsParameters:
+        #creator: dotnet-bot
+        #testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        #extraHelixArguments: /p:NeedsToBuildWasmAppsOnHelix=true $(_runSmokeTestsOnlyArg)
+        #scenarios:
+        #- normal
+        #condition: >-
+          #or(
+          #eq(variables['librariesContainsChange'], true),
+          #eq(variables['monoContainsChange'], true),
+          #eq(variables['isFullMatrix'], true))
 
-#
-# Build for Browser/wasm with RunAOTCompilation=true
-#
-- template: /eng/pipelines/common/platform-matrix.yml
-  parameters:
-    jobTemplate: /eng/pipelines/common/global-build-job.yml
-    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
-    buildConfig: Release
-    runtimeFlavor: mono
-    platforms:
-    - Browser_wasm
-    variables:
-      # map dependencies variables to local variables
-      - name: librariesContainsChange
-        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
-      - name: monoContainsChange
-        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
-    jobParameters:
-      testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_AOT
-      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=true
-      timeoutInMinutes: 180
-      condition: >-
-        or(
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
-          eq(variables['isFullMatrix'], true))
-      # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
-      extraStepsParameters:
-        creator: dotnet-bot
-        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
-        extraHelixArguments: /p:NeedsToBuildWasmAppsOnHelix=true $(_runSmokeTestsOnlyArg)
-        scenarios:
-        - normal
-        condition: >-
-          or(
-          eq(variables['librariesContainsChange'], true),
-          eq(variables['monoContainsChange'], true),
-          eq(variables['isFullMatrix'], true))
+##
+## Build for Browser/wasm with RunAOTCompilation=true
+##
+#- template: /eng/pipelines/common/platform-matrix.yml
+  #parameters:
+    #jobTemplate: /eng/pipelines/common/global-build-job.yml
+    #helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    #buildConfig: Release
+    #runtimeFlavor: mono
+    #platforms:
+    #- Browser_wasm
+    #variables:
+      ## map dependencies variables to local variables
+      #- name: librariesContainsChange
+        #value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+      #- name: monoContainsChange
+        #value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
+    #jobParameters:
+      #testGroup: innerloop
+      #nameSuffix: AllSubsets_Mono_AOT
+      #buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=true
+      #timeoutInMinutes: 180
+      #condition: >-
+        #or(
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
+          #eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
+          #eq(variables['isFullMatrix'], true))
+      ## extra steps, run tests
+      #extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      #extraStepsParameters:
+        #creator: dotnet-bot
+        #testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        #extraHelixArguments: /p:NeedsToBuildWasmAppsOnHelix=true $(_runSmokeTestsOnlyArg)
+        #scenarios:
+        #- normal
+        #condition: >-
+          #or(
+          #eq(variables['librariesContainsChange'], true),
+          #eq(variables['monoContainsChange'], true),
+          #eq(variables['isFullMatrix'], true))
 
 # Build and test libraries under single-file publishing
 - template: /eng/pipelines/common/platform-matrix.yml
@@ -463,38 +496,38 @@ jobs:
 #
 # Build the whole product using Mono and run runtime tests
 #
-- template: /eng/pipelines/common/platform-matrix.yml
-  parameters:
-    jobTemplate: /eng/pipelines/common/global-build-job.yml
-    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
-    buildConfig: Release
-    runtimeFlavor: mono
-    platforms:
-    - Browser_wasm
-    variables:
-      - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
-        - name: _HelixSource
-          value: pr/dotnet/runtime/$(Build.SourceBranch)
-      - ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
-        - name: _HelixSource
-          value: ci/dotnet/runtime/$(Build.SourceBranch)
-      - name: timeoutPerTestInMinutes
-        value: 10
-      - name: timeoutPerTestCollectionInMinutes
-        value: 200
-    jobParameters:
-      testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_RuntimeTests
-      buildArgs: -s mono+libs -c $(_BuildConfig)
-      timeoutInMinutes: 180
-      condition: >-
-        eq(variables['isFullMatrix'], true)
-      # NOTE: Per PR test execution is not recommended for mobile runtime tests
-      # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/common/templates/runtimes/wasm-runtime-and-send-to-helix.yml
-      extraStepsParameters:
-        creator: dotnet-bot
-        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+#- template: /eng/pipelines/common/platform-matrix.yml
+  #parameters:
+    #jobTemplate: /eng/pipelines/common/global-build-job.yml
+    #helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
+    #buildConfig: Release
+    #runtimeFlavor: mono
+    #platforms:
+    #- Browser_wasm
+    #variables:
+      #- ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
+        #- name: _HelixSource
+          #value: pr/dotnet/runtime/$(Build.SourceBranch)
+      #- ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
+        #- name: _HelixSource
+          #value: ci/dotnet/runtime/$(Build.SourceBranch)
+      #- name: timeoutPerTestInMinutes
+        #value: 10
+      #- name: timeoutPerTestCollectionInMinutes
+        #value: 200
+    #jobParameters:
+      #testGroup: innerloop
+      #nameSuffix: AllSubsets_Mono_RuntimeTests
+      #buildArgs: -s mono+libs -c $(_BuildConfig)
+      #timeoutInMinutes: 180
+      #condition: >-
+        #eq(variables['isFullMatrix'], true)
+      ## NOTE: Per PR test execution is not recommended for mobile runtime tests
+      ## extra steps, run tests
+      #extraStepsTemplate: /eng/pipelines/common/templates/runtimes/wasm-runtime-and-send-to-helix.yml
+      #extraStepsParameters:
+        #creator: dotnet-bot
+        #testRunNamePrefixSuffix: Mono_$(_BuildConfig)
 
 #
 # Build the whole product using Mono for Android and run runtime tests with Android emulator
diff --git a/eng/testing/scenarios/WasmDebuggerTestsJobsList.txt b/eng/testing/scenarios/WasmDebuggerTestsJobsList.txt
new file mode 100644
index 00000000000000..d6405c516a4f28
--- /dev/null
+++ b/eng/testing/scenarios/WasmDebuggerTestsJobsList.txt
@@ -0,0 +1,18 @@
+DebuggerTests.ArrayTests
+DebuggerTests.AssignmentTests
+DebuggerTests.AsyncTests
+DebuggerTests.BadHarnessInitTests
+DebuggerTests.BreakpointTests
+DebuggerTests.CallFunctionOnTests
+DebuggerTests.CustomViewTests
+DebuggerTests.DateTimeList
+DebuggerTests.DelegateTests
+DebuggerTests.EvaluateOnCallFrameTests
+DebuggerTests.ExceptionTests
+DebuggerTests.GetPropertiesTests
+DebuggerTests.HarnessTests
+DebuggerTests.MonoJsTests
+DebuggerTests.PointerTests
+DebuggerTests.SetVariableValueTests
+DebuggerTests.SourceList
+DebuggerTests.SteppingTests
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/Diagnostics/Stopwatch.cs b/src/libraries/System.Runtime.Extensions/tests/System/Diagnostics/Stopwatch.cs
index 672e6af2f32acf..77b94ffa04d1e3 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/Diagnostics/Stopwatch.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/Diagnostics/Stopwatch.cs
@@ -11,19 +11,14 @@ public static class StopwatchTests
     {
         private static readonly ManualResetEvent s_sleepEvent = new ManualResetEvent(false);
 
+        // workaround for issue: https://github.com/dotnet/runtime/issues/62021
+        private static readonly int s_defaultSleepTimeMs = PlatformDetection.IsBrowser ? 5 : 1;
+
         [Fact]
         public static void GetTimestamp()
         {
             long ts1 = Stopwatch.GetTimestamp();
-            if (PlatformDetection.IsBrowser)
-            {
-                // workaround for issue: https://github.com/dotnet/runtime/issues/62021
-                Sleep(5);
-            }
-            else
-            {
-                Sleep();
-            }
+            Sleep(s_defaultSleepTimeMs);
             long ts2 = Stopwatch.GetTimestamp();
             Assert.NotEqual(ts1, ts2);
         }
@@ -38,20 +33,20 @@ public static void ConstructStartAndStop()
             Assert.Equal(0, watch.ElapsedMilliseconds);
             watch.Start();
             Assert.True(watch.IsRunning);
-            Sleep();
+            Sleep(s_defaultSleepTimeMs);
             Assert.True(watch.Elapsed > TimeSpan.Zero);
 
             watch.Stop();
             Assert.False(watch.IsRunning);
 
             var e1 = watch.Elapsed;
-            Sleep();
+            Sleep(s_defaultSleepTimeMs);
             var e2 = watch.Elapsed;
             Assert.Equal(e1, e2);
             Assert.Equal((long)e1.TotalMilliseconds, watch.ElapsedMilliseconds);
 
             var t1 = watch.ElapsedTicks;
-            Sleep();
+            Sleep(s_defaultSleepTimeMs);
             var t2 = watch.ElapsedTicks;
             Assert.Equal(t1, t2);
         }
@@ -63,7 +58,7 @@ public static void StartNewAndReset()
             Assert.True(watch.IsRunning);
             watch.Start(); // should be no-op
             Assert.True(watch.IsRunning);
-            Sleep();
+            Sleep(s_defaultSleepTimeMs);
             Assert.True(watch.Elapsed > TimeSpan.Zero);
 
             watch.Reset();
@@ -130,7 +125,7 @@ public static void ElapsedMilliseconds_WithinExpectedWindow()
             Assert.True(false, $"All {AllowedTries} fell outside of {WindowFactor} window of {SleepTime} sleep time: {string.Join(", ", results)}");
         }
 
-        private static void Sleep(int milliseconds = 1)
+        private static void Sleep(int milliseconds)
         {
             s_sleepEvent.WaitOne(milliseconds);
         }
diff --git a/src/libraries/sendtohelixhelp.proj b/src/libraries/sendtohelixhelp.proj
index c3f4fc1549607b..16ebb898f70e9f 100644
--- a/src/libraries/sendtohelixhelp.proj
+++ b/src/libraries/sendtohelixhelp.proj
@@ -32,6 +32,7 @@
     <_workItemTimeout Condition="'$(Scenario)' != '' and '$(_workItemTimeout)' == '' and ('$(TargetArchitecture)' == 'arm64' or '$(TargetArchitecture)' == 'arm')">01:00:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' == 'BuildWasmApps' and '$(_workItemTimeout)' == ''">01:30:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(TargetOS)' == 'Browser' and '$(NeedsToBuildWasmAppsOnHelix)' == 'true'">01:00:00</_workItemTimeout>
+    <_workItemTimeout Condition="'$(Scenario)' == 'wasmdebuggertests'">01:30:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' == '' and '$(_workItemTimeout)' == '' and '$(Outerloop)' == 'true'">00:20:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' == '' and '$(_workItemTimeout)' == ''">00:15:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' != '' and '$(_workItemTimeout)' == ''">00:30:00</_workItemTimeout>
@@ -40,6 +41,7 @@
     <!-- The Helix runtime payload and the tests to run -->
     <!-- TestArchiveRuntimeFile will be passed as a property by the calling project -->
     <HelixCorrelationPayload Condition="'$(HelixCorrelationPayload)' == ''">$(TestArchiveRuntimeFile)</HelixCorrelationPayload>
+    <WorkItemArchiveWildCard Condition="'$(IsWasmDebuggerTests)' == 'true'">$(ArtifactsObjDir)\DebuggerTestSuite.zip</WorkItemArchiveWildCard>
     <WorkItemArchiveWildCard Condition="'$(WorkItemArchiveWildCard)' == ''">$(TestArchiveTestsRoot)**/*.zip</WorkItemArchiveWildCard>
 
     <HelixConfiguration>$(Configuration)</HelixConfiguration>
@@ -55,17 +57,21 @@
     <TestRunNamePrefix Condition="'$(Scenario)' != ''">$(TestRunNamePrefix)$(Scenario)-</TestRunNamePrefix>
 
     <BuildWasmAppsJobsList>$(RepositoryEngineeringDir)\testing\scenarios\BuildWasmAppsJobsList.txt</BuildWasmAppsJobsList>
+    <WasmDebuggerTestsJobsList>$(RepositoryEngineeringDir)\testing\scenarios\WasmDebuggerTestsJobsList.txt</WasmDebuggerTestsJobsList>
+    <DefaultHelixWorkItems Condition="'$(Scenario)' != 'BuildWasmApps' and '$(Scenario)' != 'WasmDebuggerTests'">true</DefaultHelixWorkItems>
 
     <FailOnTestFailure Condition="'$(WaitForWorkItemCompletion)' != ''">$(WaitForWorkItemCompletion)</FailOnTestFailure>
     <NeedsToBuildAppsOnHelix Condition="('$(TargetOS)' == 'iOS' or '$(TargetOS)' == 'iOSSimulator' or '$(TargetOS)' == 'tvOS' or '$(TargetOS)' == 'tvOSSimulator') and '$(NeedsToBuildAppsOnHelix)' == '' and '$(Scenario)' == 'BuildiOSApps'">true</NeedsToBuildAppsOnHelix>
-    
+
     <NeedsiOSSDK Condition="'$(NeedsToBuildAppsOnHelix)' == 'true' and '$(NeedsWorkload)' != 'true'">true</NeedsiOSSDK>
 
     <EMSDK_PATH Condition="$([MSBuild]::IsOSPlatform('WINDOWS')) and '$(EMSDK_PATH)' == ''">$(RepoRoot)src\mono\wasm\emsdk\</EMSDK_PATH>
 
+    <IsWasmDebuggerTests Condition="'$(Scenario)' == 'wasmdebuggertests'">true</IsWasmDebuggerTests>
     <NeedsWorkload Condition="'$(Scenario)' == 'BuildWasmApps'">true</NeedsWorkload>
     <NeedsEMSDK Condition="'$(NeedsToBuildWasmAppsOnHelix)' == 'true' or ('$(Scenario)' == 'BuildWasmApps' and '$(TestUsingWorkloads)' != 'true')">true</NeedsEMSDK>
     <NeedsToRunOnBrowser Condition="'$(TargetOS)' == 'Browser' and ('$(Scenario)' == 'WasmTestOnBrowser' or '$(Scenario)' == 'BuildWasmApps')">true</NeedsToRunOnBrowser>
+    <NeedsToRunOnBrowser Condition="'$(NeedsToRunOnBrowser)' == '' and '$(IsWasmDebuggerTests)' == 'true'">true</NeedsToRunOnBrowser>
 
     <SdkForWorkloadTestingDirName Condition="'$(NeedsWorkload)' == 'true' and '$(TestUsingWorkloads)' == 'true'">dotnet-workload</SdkForWorkloadTestingDirName>
     <SdkForWorkloadTestingDirName Condition="'$(NeedsWorkload)' == 'true' and '$(TestUsingWorkloads)' != 'true'">sdk-no-workload</SdkForWorkloadTestingDirName>
@@ -116,7 +122,7 @@
       We also run some network tests to this server and so, we are running it on both HTTP and HTTPS.
       For the HTTPS endpoint we need development SSL certificate.
     -->
-    <InstallDevCerts Condition="'$(Scenario)' != 'BuildWasmApps'">true</InstallDevCerts>
+    <InstallDevCerts Condition="'$(Scenario)' != 'BuildWasmApps' and '$(Scenario)' != 'WasmDebuggerTests'">true</InstallDevCerts>
 
     <!-- Install SDK so that, we could use `dotnet dev-certs https` -->
     <NeedsDotNetSdk Condition="'$(NeedsWorkload)' != 'true'">true</NeedsDotNetSdk>
@@ -448,6 +454,10 @@
       <Output TaskParameter="Lines" ItemName="BuildWasmApps_PerJobList" />
     </ReadLinesFromFile>
 
+    <ReadLinesFromFile File="$(WasmDebuggerTestsJobsList)" Condition="Exists($(WasmDebuggerTestsJobsList)) and '$(Scenario)' == 'WasmDebuggerTests'">
+      <Output TaskParameter="Lines" ItemName="WasmDebuggerTests_PerJobList" />
+    </ReadLinesFromFile>
+
     <ItemGroup Condition="'$(TargetOS)' != 'Android' and '$(TargetOS)' != 'iOS' and '$(TargetOS)' != 'iOSSimulator' and '$(TargetOS)' != 'tvOS' and '$(TargetOS)' != 'tvOSSimulator' and '$(TargetOS)' != 'MacCatalyst'">
       <HelixCorrelationPayload Include="$(HelixCorrelationPayload)"
                                Condition="'$(IncludeHelixCorrelationPayload)' == 'true' and '$(TargetOS)' != 'Browser' and '$(Scenario)' != 'BuildiOSApps'"
@@ -460,7 +470,7 @@
       <_WorkItem Include="$(TestArchiveRoot)runonly/**/WebAssembly.Browser.*.Test.zip" Condition="'$(TargetOS)' == 'Browser' and '$(Scenario)' == 'WasmTestOnBrowser'" />
       <_WorkItem Include="$(TestArchiveRoot)browseronly/**/*.zip" Condition="'$(TargetOS)' == 'Browser' and '$(Scenario)' == 'WasmTestOnBrowser'" />
 
-      <HelixWorkItem Include="@(_WorkItem -> '$(WorkItemPrefix)%(FileName)')" Condition="'$(Scenario)' != 'BuildWasmApps'">
+      <HelixWorkItem Include="@(_WorkItem -> '$(WorkItemPrefix)%(FileName)')" Condition="'$(DefaultHelixWorkItems)' == 'true'">
         <PayloadArchive>%(Identity)</PayloadArchive>
         <Command>$(HelixCommand)</Command>
         <Timeout>$(_workItemTimeout)</Timeout>
@@ -469,6 +479,7 @@
 
     <PropertyGroup>
       <_BuildWasmAppsPayloadArchive>@(_WorkItem)</_BuildWasmAppsPayloadArchive>
+      <_WasmDebuggerTestsPayloadArchive>@(_WorkItem)</_WasmDebuggerTestsPayloadArchive>
     </PropertyGroup>
 
     <ItemGroup Condition="'$(Scenario)' == 'BuildWasmApps'">
@@ -481,6 +492,18 @@
       </HelixWorkItem>
     </ItemGroup>
 
+    <ItemGroup Condition="'$(Scenario)' == 'WasmDebuggerTests'">
+      <HelixWorkItem Include="@(WasmDebuggerTests_PerJobList)">
+        <PayloadArchive>$(_WasmDebuggerTestsPayloadArchive)</PayloadArchive>
+        <!-- ClassNAme not supported for `dotnet test` for xunit -->
+        <PreCommands>export TEST_FILTER=&quot;--filter FullyQualifiedName~%(Identity)&quot;</PreCommands>
+        <!--<PreCommands Condition="'$(OS)' == 'Windows_NT'">set &quot;HELIX_XUNIT_ARGS=-class %(Identity)&quot;</PreCommands>-->
+        <!--<PreCommands Condition="'$(OS)' != 'Windows_NT'">export &quot;HELIX_XUNIT_ARGS=-class %(Identity)&quot;</PreCommands>-->
+        <Command>$(HelixCommand)</Command>
+        <Timeout>$(_workItemTimeout)</Timeout>
+      </HelixWorkItem>
+    </ItemGroup>
+
     <PropertyGroup Condition="'$(TargetOS)' == 'Browser' and '$(BrowserHost)' != 'windows'">
       <ExecXHarnessCmd>dotnet exec $XHARNESS_CLI_PATH</ExecXHarnessCmd>
       <XHarnessOutput>$HELIX_WORKITEM_UPLOAD_ROOT/xharness-output</XHarnessOutput>
@@ -526,6 +549,10 @@
           ContinueOnError="true"
           IgnoreExitCode="true"
           IgnoreStandardErrorWarningFormat="true" />
+
+    <Message Text="HelixCorrelationPayload: %(HelixCorrelationPayload.Identity)" Condition="'$(HelixDryRun)' == 'true'" Importance="High" />
+    <Message Text="HelixWorkItem: %(HelixWorkItem.Identity), Command: %(HelixWorkItem.Command), PreCommands: %(HelixWorkItem.PreCommands)" Condition="'$(HelixDryRun)' == 'true'" Importance="High" />
+    <Error Text="Stopping the build for dry run" Condition="'$(HelixDryRun)' == 'true'" />
   </Target>
 
   <!-- CI has emscripten provisioned in $(EMSDK_PATH) as `/usr/local/emscripten`. Because helix tasks will
diff --git a/src/mono/wasm/Makefile b/src/mono/wasm/Makefile
index 04828bba7240ce..90c1d77b306a1c 100644
--- a/src/mono/wasm/Makefile
+++ b/src/mono/wasm/Makefile
@@ -164,6 +164,27 @@ run-build-tests:
 run-browser-tests-%:
 	PATH="$(GECKODRIVER):$(CHROMEDRIVER):$(PATH)" XHARNESS_COMMAND="test-browser --browser=$(XHARNESS_BROWSER)" $(DOTNET) build $(TOP)/src/libraries/$*/tests/ /t:Test $(_MSBUILD_WASM_BUILD_ARGS) $(MSBUILD_ARGS)
 
+run-debugger-tests-helix:
+	echo "\n** This will submit all the available test zip files to helix **\n"
+	EMSDK_PATH=$(EMSDK_PATH) BUILD_REASON=wasm-test SYSTEM_TEAMPROJECT=wasm BUILD_REPOSITORY_NAME=dotnet/runtime BUILD_SOURCEBRANCH=main \
+		$(TOP)/eng/common/msbuild.sh --ci -restore $(TOP)/src/libraries/sendtohelix.proj \
+		/p:TestRunNamePrefixSuffix=WasmLocalTestRun /p:HelixBuild=`date "+%Y%m%d.%H%M"` /p:Creator=`whoami` \
+		/bl:$(TOP)/artifacts/log/$(CONFIG)/SendToHelix.binlog -p:HelixTargetQueue=Ubuntu.1804.Amd64.Open \
+		/p:RuntimeFlavor=mono /p:TargetRuntimeIdentifier= /p:MonoForceInterpreter= /p:TestScope=innerloop \
+		/p:_Scenarios=wasmdebuggertests \
+		$(_MSBUILD_WASM_BUILD_ARGS) \
+		$(MSBUILD_ARGS)
+
+run-tests-helix:
+	echo "\n** This will submit all the available test zip files to helix **\n"
+	EMSDK_PATH=$(EMSDK_PATH) BUILD_REASON=wasm-test SYSTEM_TEAMPROJECT=wasm BUILD_REPOSITORY_NAME=dotnet/runtime BUILD_SOURCEBRANCH=main \
+		$(TOP)/eng/common/msbuild.sh --ci -restore $(TOP)/src/libraries/sendtohelix.proj \
+		/p:TestRunNamePrefixSuffix=WasmLocalTestRun /p:HelixBuild=`date "+%Y%m%d.%H%M"` /p:Creator=`whoami` \
+		/bl:$(TOP)/artifacts/log/$(CONFIG)/SendToHelix.binlog -v:n -p:HelixTargetQueue=Ubuntu.1804.Amd64.Open \
+		/p:RuntimeFlavor=mono /p:TargetRuntimeIdentifier= /p:MonoForceInterpreter= /p:TestScope=innerloop \
+		$(_MSBUILD_WASM_BUILD_ARGS) \
+		$(MSBUILD_ARGS)
+
 run-debugger-tests:
 	if [ ! -z "$(TEST_FILTER)" ]; then \
 		$(DOTNET) test  $(TOP)/src/mono/wasm/debugger/DebuggerTestSuite $(MSBUILD_ARGS) --filter FullyQualifiedName~$(TEST_FILTER) $(TEST_ARGS); \
diff --git a/src/mono/wasm/build/WasmApp.targets b/src/mono/wasm/build/WasmApp.targets
index ad4896e09b8310..453058cbc3f6b6 100644
--- a/src/mono/wasm/build/WasmApp.targets
+++ b/src/mono/wasm/build/WasmApp.targets
@@ -208,7 +208,7 @@
     </PropertyGroup>
 
     <Warning Condition="'$(WasmGenerateAppBundle)' == 'true' and $(_MainAssemblyPath) == ''" Text="Could not find %24(AssemblyName)=$(AssemblyName).dll in the assemblies to be bundled." />
-    <Warning Condition="'$(WasmGenerateAppBundle)' == 'true' and $(_WasmRuntimeConfigFilePath) != '' and !Exists($(_WasmRuntimeConfigFilePath))"
+    <Warning Condition="'$(OutputType)' == 'Exe' and '$(WasmGenerateAppBundle)' == 'true' and $(_WasmRuntimeConfigFilePath) != '' and !Exists($(_WasmRuntimeConfigFilePath))"
              Text="Could not find $(_WasmRuntimeConfigFilePath) for $(_MainAssemblyPath)." />
 
     <ItemGroup>
diff --git a/src/mono/wasm/debugger/BrowserDebugHost/Startup.cs b/src/mono/wasm/debugger/BrowserDebugHost/Startup.cs
index f5dc5ecca471b9..074a953b694ae8 100644
--- a/src/mono/wasm/debugger/BrowserDebugHost/Startup.cs
+++ b/src/mono/wasm/debugger/BrowserDebugHost/Startup.cs
@@ -160,7 +160,11 @@ async Task ConnectProxy(HttpContext context)
                     try
                     {
                         using ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
-                            builder.AddSimpleConsole(options => options.SingleLine = true)
+                            builder.AddSimpleConsole(options =>
+                                    {
+                                        options.SingleLine = true;
+                                        options.TimestampFormat = "[HH:mm:ss] ";
+                                    })
                                    .AddFilter(null, LogLevel.Information)
                         );
 
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/ArrayTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/ArrayTests.cs
index 05d3d6cccbf66d..43b0cfdd059170 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/ArrayTests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/ArrayTests.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
-using Microsoft.WebAssembly.Diagnostics;
 using Newtonsoft.Json.Linq;
 using Xunit;
 
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
index 1329e284eb066a..7310a7284a62a8 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
@@ -40,17 +40,23 @@ protected static string DebuggerTestAppPath
 
         static protected string FindTestPath()
         {
-            var asm_dir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            string test_app_path = Environment.GetEnvironmentVariable("DEBUGGER_TEST_PATH");
+
+            if (string.IsNullOrEmpty(test_app_path))
+            {
+                var asm_dir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
 #if DEBUG
-            var config="Debug";
+                var config="Debug";
 #else
-            var config="Release";
-#endif            
-            var test_app_path = Path.Combine(asm_dir, "..", "..", "..", "debugger-test", config, "publish");
+                var config="Release";
+#endif
+                test_app_path = Path.Combine(asm_dir, "..", "..", "..", "debugger-test", config, "publish");
+            }
+
             if (File.Exists(Path.Combine(test_app_path, "debugger-driver.html")))
                 return test_app_path;
 
-            throw new Exception($"Could not figure out debugger-test app path ({test_app_path}) based on the test suite location ({asm_dir})");
+            throw new Exception($"Could not figure out debugger-test app path ({test_app_path})");//based on the test suite location ({asm_dir})");
         }
 
         static string[] PROBE_LIST = {
@@ -63,21 +69,32 @@ static protected string FindTestPath()
         };
         static string chrome_path;
 
-        static string FindChromePath()
+        static string GetChromePath()
         {
-            if (chrome_path != null)
-                return chrome_path;
+            if (string.IsNullOrEmpty(chrome_path))
+            {
+                chrome_path = FindChromePath();
+                if (!string.IsNullOrEmpty(chrome_path))
+                    Console.WriteLine ($"** Using chrome from {chrome_path}");
+                else
+                    throw new Exception("Could not find an installed Chrome to use");
+            }
+
+            return chrome_path;
 
-            foreach (var s in PROBE_LIST)
+            string FindChromePath()
             {
-                if (File.Exists(s))
+                string chrome_path_env_var = Environment.GetEnvironmentVariable("CHROME_PATH_FOR_DEBUGGER_TESTS");
+                if (!string.IsNullOrEmpty(chrome_path_env_var))
                 {
-                    chrome_path = s;
-                    Console.WriteLine($"Using chrome path: ${s}");
-                    return s;
+                    if (File.Exists(chrome_path_env_var))
+                        return chrome_path_env_var;
+
+                    Console.WriteLine ($"warning: Could not find CHROME_PATH_FOR_DEBUGGER_TESTS={chrome_path_env_var}");
                 }
+
+                return PROBE_LIST.FirstOrDefault(p => File.Exists(p));
             }
-            throw new Exception("Could not find an installed Chrome to use");
         }
 
         public DebuggerTestBase(string driver = "debugger-driver.html")
@@ -90,7 +107,7 @@ public DebuggerTestBase(string driver = "debugger-driver.html")
             cli = insp.Client;
             scripts = SubscribeToScripts(insp);
 
-            startTask = TestHarnessProxy.Start(FindChromePath(), DebuggerTestAppPath, driver);
+            startTask = TestHarnessProxy.Start(GetChromePath(), DebuggerTestAppPath, driver);
         }
 
         public virtual async Task InitializeAsync()
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestSuite.csproj b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestSuite.csproj
index a46fd059b01fe9..091a272a33a6d8 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestSuite.csproj
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestSuite.csproj
@@ -19,4 +19,58 @@
     <ProjectReference Include="..\tests\debugger-test\debugger-test.csproj" ReferenceOutputAssembly="false" />
   </ItemGroup>
 
+  <Target Name="CopyAppZipToHelixTestDir"
+          Condition="'$(ArchiveTests)' == 'true'"
+          AfterTargets="Build">
+
+    <PropertyGroup>
+      <WasmHelixTestAppRelativeDir Condition="'$(WasmHelixTestAppRelativeDir)' == ''">$(MSBuildProjectName)</WasmHelixTestAppRelativeDir>
+      <OSPlatformConfig>$(TargetOS).AnyCPU.$(Configuration)</OSPlatformConfig>
+      <HelixArchiveRoot>$([MSBuild]::NormalizeDirectory($(ArtifactsDir), 'helix'))</HelixArchiveRoot>
+      <HelixArchiveRunOnlyRoot>$([MSBuild]::NormalizeDirectory($(HelixArchiveRoot), 'runonly'))</HelixArchiveRunOnlyRoot>
+      <HelixArchiveRunOnlyAppsDir>$([MSBuild]::NormalizeDirectory($(HelixArchiveRunOnlyRoot), $(OSPlatformConfig), $(WasmHelixTestAppRelativeDir)))</HelixArchiveRunOnlyAppsDir>
+
+      <_TmpDebuggerTestsDir>$(ArtifactsObjDir)WasmDebuggerTestsArchive\</_TmpDebuggerTestsDir>
+      <ZippedApp>$(ArtifactsDir)helix\tests\$(AssemblyName).zip</ZippedApp>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <_FilesToCopy Include="$(OutputPath)\**\*" TargetPath="DebuggerTestSuite" />
+      <_FilesToCopy Include="$(ArtifactsBinDir)debugger-test\Debug\publish\**\*" TargetPath="debugger-test" />
+    </ItemGroup>
+
+    <RemoveDir Directories="$(_TmpDebuggerTestsDir)" />
+    <MakeDir Directories="$(_TmpDebuggerTestsDir)" />
+    <MakeDir Directories="$(ArtifactsDir)helix\tests" />
+
+    <Copy SourceFiles="@(_FilesToCopy)" DestinationFiles="$(_TmpDebuggerTestsDir)\%(TargetPath)\%(RecursiveDir)%(FileName)%(Extension)" />
+
+    <ItemGroup Condition="'$(OS)' != 'Windows_NT'">
+      <ScriptCommand Include="#!/usr/bin/env bash" />
+
+      <!-- FIXME: windows -->
+      <!-- FIXME: Use the same setup for local runs.. via RunTEsts.sh -->
+      <ScriptCommand Include="export DEBUGGER_TEST_PATH=$PWD/debugger-test" />
+      <ScriptCommand Include="export CHROME_PATH_FOR_DEBUGGER_TESTS=$HELIX_CORRELATION_PAYLOAD/chrome-linux/chrome" />
+      <ScriptCommand Include="export LOG_PATH=${HELIX_WORKITEM_UPLOAD_ROOT:-.}" />
+
+      <TestCommandArg Include="&quot;-l:trx%3BLogFileName=testResults.xml&quot;" />
+      <TestCommandArg Include="--results-directory &quot;$LOG_PATH&quot;" />
+      <TestCommandArg Include="$TEST_FILTER" />
+      <!--<TestCommandArg Include="filter FullyQualifiedName~InspectPrimitiveTypeArrayLocals" />-->
+    </ItemGroup>
+
+    <PropertyGroup>
+      <TestCommand>dotnet test DebuggerTestSuite/DebuggerTestSuite.dll @(TestCommandArg, ' ')  2&gt;&amp;1 | tee $LOG_PATH/console-output.txt</TestCommand>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ScriptCommand Include="$(TestCommand)" />
+    </ItemGroup>
+
+    <WriteLinesToFile Lines="@(ScriptCommand)" File="$(_TmpDebuggerTestsDir)\RunTests.sh" Overwrite="true" />
+    <Exec Condition="'$(TargetOS)' != 'windows' and '$(OS)' != 'Windows_NT'" Command="chmod +x $(_TmpDebuggerTestsDir)\RunTests.sh" />
+
+    <ZipDirectory SourceDirectory="$(_TmpDebuggerTestsDir)" DestinationFile="$(ZippedApp)" Overwrite="true" />
+  </Target>
 </Project>
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/Inspector.cs b/src/mono/wasm/debugger/DebuggerTestSuite/Inspector.cs
index 826d860c21e4d4..c4685767b7abe2 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/Inspector.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/Inspector.cs
@@ -42,7 +42,11 @@ public Inspector()
             Token = _cancellationTokenSource.Token;
 
             _loggerFactory = LoggerFactory.Create(builder =>
-                    builder.AddSimpleConsole(options => options.SingleLine = true)
+                    builder.AddSimpleConsole(options =>
+                                {
+                                    options.SingleLine = true;
+                                    options.TimestampFormat = "[HH:mm:ss] ";
+                                })
                            .AddFilter(null, LogLevel.Trace));
 
             Client = new InspectorClient(_loggerFactory.CreateLogger<InspectorClient>());
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/TestHarnessProxy.cs b/src/mono/wasm/debugger/DebuggerTestSuite/TestHarnessProxy.cs
index 7a5c30d9cc9e82..0482292875b723 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/TestHarnessProxy.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/TestHarnessProxy.cs
@@ -38,7 +38,11 @@ public static Task Start(string chromePath, string appPath, string pagePath)
                     })
                     .ConfigureLogging(logging =>
                     {
-                        logging.AddSimpleConsole(options => options.SingleLine = true)
+                        logging.AddSimpleConsole(options =>
+                                {
+                                    options.SingleLine = true;
+                                    options.TimestampFormat = "[HH:mm:ss] ";
+                                })
                                .AddFilter(null, LogLevel.Information);
                     })
                     .ConfigureServices((ctx, services) =>
@@ -62,4 +66,4 @@ public static Task Start(string chromePath, string appPath, string pagePath)
             return hostTask;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/appsettings.json b/src/mono/wasm/debugger/DebuggerTestSuite/appsettings.json
index 4d7c82ac0ee05b..61e59678c7c0c2 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/appsettings.json
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/appsettings.json
@@ -6,7 +6,7 @@
       "Microsoft.Hosting.Lifetime": "Information",
       "Microsoft.WebAssembly.Diagnostics.TestHarnessProxy": "Information",
       "Microsoft.WebAssembly.Diagnostics.DevToolsProxy": "Information",
-      "DebuggerTests.Inspector": "Information"
+      "DebuggerTests.Inspector": "Trace"
     }
   }
 }
diff --git a/src/mono/wasm/debugger/tests/debugger-test/debugger-test.csproj b/src/mono/wasm/debugger/tests/debugger-test/debugger-test.csproj
index c3cc1800aad87e..9641163c41dd7b 100644
--- a/src/mono/wasm/debugger/tests/debugger-test/debugger-test.csproj
+++ b/src/mono/wasm/debugger/tests/debugger-test/debugger-test.csproj
@@ -21,7 +21,7 @@
     <ProjectReference Include="..\library-dependency-debugger-test1\library-dependency-debugger-test1.csproj" Private="true"/>
     <ProjectReference Include="..\library-dependency-debugger-test2\library-dependency-debugger-test2.csproj" Private="true"/>
     <ProjectReference Include="..\debugger-test-with-source-link\debugger-test-with-source-link.csproj" Private="true"/>
-    <ProjectReference Include="..\ApplyUpdateReferencedAssembly\ApplyUpdateReferencedAssembly.csproj" />
+    <!--<ProjectReference Include="..\ApplyUpdateReferencedAssembly\ApplyUpdateReferencedAssembly.csproj" />-->
   </ItemGroup>
 
   <Target Name="PrepareForWasmBuildApp" DependsOnTargets="RebuildWasmAppBuilder;Build">
@@ -44,30 +44,32 @@
       <WasmExtraFilesToDeploy Include="@(ReferenceCopyLocalPaths)" />
     </ItemGroup>
   </Target>
-  <Target Name="PreserveEnCAssembliesFromLinking"
-          Condition="'$(TargetOS)' == 'Browser' and '$(EnableAggressiveTrimming)' == 'true'"
-          BeforeTargets="ConfigureTrimming">
-    <ItemGroup>
-      <!-- Don't modify EnC test assemblies -->
-      <TrimmerRootAssembly
-          Condition="$([System.String]::Copy('%(ResolvedFileToPublish.FileName)%(ResolvedFileToPublish.Extension)').EndsWith('ApplyUpdateReferencedAssembly.dll'))"
-          Include="%(ResolvedFileToPublish.FullPath)" />
-    </ItemGroup>
-  </Target>
-  <Target Name="IncludeDeltasInWasmBundle"
-          BeforeTargets="PrepareForWasmBuildApp"
-          Condition="'$(TargetOS)' == 'Browser'">
-    <ItemGroup>
-      <!-- FIXME: this belongs in eng/testing/tests.wasm.targets -->
-      <!-- FIXME: Can we do something on the Content items in the referenced projects themselves to get this for free? -->
-      <WasmFilesToIncludeInFileSystem Include="@(PublishItemsOutputGroupOutputs)"
-                                      Condition="$([System.String]::new('%(PublishItemsOutputGroupOutputs.Identity)').EndsWith('.dmeta'))" />
-      <WasmFilesToIncludeInFileSystem Include="@(PublishItemsOutputGroupOutputs)"
-                                      Condition="$([System.String]::new('%(PublishItemsOutputGroupOutputs.Identity)').EndsWith('.dil'))" />
-      <WasmFilesToIncludeInFileSystem Include="@(PublishItemsOutputGroupOutputs)"
-                                      Condition="$([System.String]::new('%(PublishItemsOutputGroupOutputs.Identity)').EndsWith('.dpdb'))" />
-    </ItemGroup>
-  </Target>
+
+  <!--<Target Name="PreserveEnCAssembliesFromLinking"-->
+          <!--Condition="'$(TargetOS)' == 'Browser' and '$(EnableAggressiveTrimming)' == 'true'"-->
+          <!--BeforeTargets="ConfigureTrimming">-->
+    <!--<ItemGroup>-->
+      <!--[> Don't modify EnC test assemblies <]-->
+      <!--<TrimmerRootAssembly-->
+          <!--Condition="$([System.String]::Copy('%(ResolvedFileToPublish.FileName)%(ResolvedFileToPublish.Extension)').EndsWith('ApplyUpdateReferencedAssembly.dll'))"-->
+          <!--Include="%(ResolvedFileToPublish.FullPath)" />-->
+    <!--</ItemGroup>-->
+  <!--</Target>-->
+
+  <!--<Target Name="IncludeDeltasInWasmBundle"-->
+          <!--BeforeTargets="PrepareForWasmBuildApp"-->
+          <!--Condition="'$(TargetOS)' == 'Browser'">-->
+    <!--<ItemGroup>-->
+      <!--[> FIXME: this belongs in eng/testing/tests.wasm.targets <]-->
+      <!--[> FIXME: Can we do something on the Content items in the referenced projects themselves to get this for free? <]-->
+      <!--<WasmFilesToIncludeInFileSystem Include="@(PublishItemsOutputGroupOutputs)"-->
+                                      <!--Condition="$([System.String]::new('%(PublishItemsOutputGroupOutputs.Identity)').EndsWith('.dmeta'))" />-->
+      <!--<WasmFilesToIncludeInFileSystem Include="@(PublishItemsOutputGroupOutputs)"-->
+                                      <!--Condition="$([System.String]::new('%(PublishItemsOutputGroupOutputs.Identity)').EndsWith('.dil'))" />-->
+      <!--<WasmFilesToIncludeInFileSystem Include="@(PublishItemsOutputGroupOutputs)"-->
+                                      <!--Condition="$([System.String]::new('%(PublishItemsOutputGroupOutputs.Identity)').EndsWith('.dpdb'))" />-->
+    <!--</ItemGroup>-->
+  <!--</Target>-->
 
   <Import Project="$(MonoProjectRoot)\wasm\build\WasmApp.InTree.targets" />
 </Project>