diff --git a/shell/platform/fuchsia/dart_runner/BUILD.gn b/shell/platform/fuchsia/dart_runner/BUILD.gn
index 3d3fad3..be67387 100644
--- a/shell/platform/fuchsia/dart_runner/BUILD.gn
+++ b/shell/platform/fuchsia/dart_runner/BUILD.gn
@@ -34,10 +34,14 @@
       "dart_component_controller_v2.h",
       "dart_runner.cc",
       "dart_runner.h",
+      "dart_test_component_controller_v2.cc",
+      "dart_test_component_controller_v2.h",
       "logging.h",
       "main.cc",
       "service_isolate.cc",
       "service_isolate.h",
+      "string_printf.cc",
+      "string_printf.h",
     ]
 
     defines = extra_defines
@@ -61,6 +65,8 @@
              "//flutter/shell/platform/fuchsia/dart-pkg/fuchsia",
              "//flutter/shell/platform/fuchsia/dart-pkg/zircon",
              "$fuchsia_sdk_root/fidl:fuchsia.component.runner",
+             "$fuchsia_sdk_root/fidl:fuchsia.logger",
+             "$fuchsia_sdk_root/fidl:fuchsia.sys.test",
              "$fuchsia_sdk_root/pkg:async",
              "$fuchsia_sdk_root/pkg:async-cpp",
              "$fuchsia_sdk_root/pkg:async-default",
@@ -70,10 +76,12 @@
              "$fuchsia_sdk_root/pkg:fidl_cpp",
              "$fuchsia_sdk_root/pkg:sys_inspect_cpp",
              "$fuchsia_sdk_root/pkg:sys_cpp",
+             "$fuchsia_sdk_root/pkg:sys_cpp_testing",
              "$fuchsia_sdk_root/pkg:syslog",
              "$fuchsia_sdk_root/pkg:trace",
              "$fuchsia_sdk_root/pkg:trace-provider-so",
              "$fuchsia_sdk_root/pkg:vfs_cpp",
+             "$fuchsia_sdk_root/pkg:zx",
              "//flutter/third_party/tonic",
            ] + dart_deps + extra_deps
   }
diff --git a/shell/platform/fuchsia/dart_runner/dart_runner.cc b/shell/platform/fuchsia/dart_runner/dart_runner.cc
index fba5805..c089f63 100644
--- a/shell/platform/fuchsia/dart_runner/dart_runner.cc
+++ b/shell/platform/fuchsia/dart_runner/dart_runner.cc
@@ -13,25 +13,113 @@
 
 #include <cerrno>
 #include <memory>
+#include <sstream>
 #include <thread>
 #include <utility>
 
 #include "dart_component_controller.h"
 #include "dart_component_controller_v2.h"
+#include "dart_test_component_controller_v2.h"
+#include "flutter/fml/command_line.h"
+#include "flutter/fml/logging.h"
 #include "flutter/fml/trace_event.h"
 #include "logging.h"
 #include "runtime/dart/utils/inlines.h"
+#include "runtime/dart/utils/program_metadata.h"
 #include "runtime/dart/utils/vmservice_object.h"
 #include "service_isolate.h"
 #include "third_party/dart/runtime/include/bin/dart_io_api.h"
 #include "third_party/tonic/dart_microtask_queue.h"
 #include "third_party/tonic/dart_state.h"
 
+// #include "fuchsia_pkg_url.h"
+
 #if defined(AOT_RUNTIME)
 extern "C" uint8_t _kDartVmSnapshotData[];
 extern "C" uint8_t _kDartVmSnapshotInstructions[];
 #endif
 
+namespace {
+struct ComponentArgs {
+  std::string legacy_url;
+  std::shared_ptr<sys::ServiceDirectory> test_component_svc;
+  fidl::InterfaceHandle<fuchsia::io::Directory> component_pkg;
+  std::vector<fuchsia::component::runner::ComponentNamespaceEntry> ns;
+};
+
+// fpromise::result<ComponentArgs, fuchsia::component::Error> GetComponentArgs(
+//     fuchsia::component::runner::ComponentStartInfo& start_info) {
+//   // component::FuchsiaPkgUrl url;
+//   // if (!url.Parse(start_info.resolved_url())) {
+//   //   // FX_LOGS(WARNING) << "cannot run test: " <<
+//   start_info.resolved_url()
+//   //   //                  << ", as we cannot parse url.";
+//   //   return fpromise::error(fuchsia::component::Error::INVALID_ARGUMENTS);
+//   // }
+//   FML_LOG(INFO) << "DART RUNNER : GET COMPONENT ARGS ";
+//   if (!start_info.program().has_entries()) {
+//     FML_LOG(INFO) << "cannot run test: " << start_info.resolved_url()
+//                   << ", as it has no program entry.";
+//     return fpromise::error(fuchsia::component::Error::INVALID_ARGUMENTS);
+//   }
+
+//   auto ns = std::move(*start_info.mutable_ns());
+//   // const std::string& legacy_manifest = it->value->str();
+//   FML_LOG(INFO) << "DART RUNNER : GET COMPONENT ARGS 2";
+
+//   auto pkg_it = std::find_if(
+//       ns.begin(), ns.end(),
+//       [](fuchsia::component::runner::ComponentNamespaceEntry& entry) {
+//         return entry.path() == "/pkg";
+//       });
+//   FML_LOG(INFO) << "DART RUNNER : GET COMPONENT ARGS 3";
+
+//   auto component_pkg = std::move(*pkg_it->mutable_directory());
+//   FML_LOG(INFO) << "DART RUNNER : GET COMPONENT ARGS 4";
+
+//   // auto fd = fsl::OpenChannelAsFileDescriptor(component_pkg.TakeChannel());
+//   // fsl::SizedVmo vmo;
+//   // if (!fsl::VmoFromFilenameAt(fd.get(), legacy_manifest, &vmo)) {
+//   //   FX_LOGS(WARNING) << "cannot run test: " << start_info.resolved_url()
+//   //                    << ", as cannot read legacy manifest file.";
+//   //   return
+//   fpromise::error(fuchsia::component::Error::INSTANCE_CANNOT_START);
+//   // }
+
+//   // const uint64_t size = vmo.size();
+//   // std::string cmx_str(size, ' ');
+//   // auto status = vmo.vmo().read(cmx_str.data(), 0, size);
+//   // if (status != ZX_OK) {
+//   //   FX_LOGS(WARNING) << "cannot run test: " << start_info.resolved_url()
+//   //                    << ", as cannot read legacy manifest file: "
+//   //                    << zx_status_get_string(status) << ".";
+//   //   return
+//   fpromise::error(fuchsia::component::Error::INSTANCE_CANNOT_START);
+//   // }
+//   // auto legacy_url = url.package_path() + "#" + legacy_manifest;
+
+//   auto legacy_url = start_info.resolved_url();
+//   FML_LOG(INFO) << "DART RUNNER : GET COMPONENT ARGS 5";
+//   auto svc_it = std::find_if(
+//       ns.begin(), ns.end(),
+//       [](fuchsia::component::runner::ComponentNamespaceEntry& entry) {
+//         return entry.path() == "/svc";
+//       });
+
+//   FML_LOG(INFO) << "DART RUNNER : GET COMPONENT ARGS 6";
+
+//   auto component_svc = std::make_shared<sys::ServiceDirectory>(
+//       std::move(*svc_it->mutable_directory()));
+//   FML_LOG(INFO) << "DART RUNNER : GET COMPONENT ARGS 7";
+//   return fpromise::ok(
+//       ComponentArgs{.legacy_url = std::move(legacy_url),
+//                     .test_component_svc = std::move(component_svc),
+//                     .component_pkg = std::move(component_pkg),
+//                     .ns = std::move(ns)});
+// }
+
+}  // namespace
+
 namespace dart_runner {
 
 namespace {
@@ -152,6 +240,39 @@
   }
 }
 
+void RunTestApplicationV2(
+    DartRunner* runner,
+    fuchsia::component::runner::ComponentStartInfo start_info,
+    std::shared_ptr<sys::ServiceDirectory> runner_incoming_services,
+    fidl::InterfaceRequest<fuchsia::component::runner::ComponentController>
+        controller,
+    fit::function<void(std::unique_ptr<DartTestComponentControllerV2>)>
+        create_callback,
+    fit::function<void(DartTestComponentControllerV2*)> done_callback) {
+  const int64_t start = Dart_TimelineGetMicros();
+
+  auto test_component = std::make_unique<DartTestComponentControllerV2>(
+      std::move(start_info), runner_incoming_services, std::move(controller),
+      std::move(done_callback));
+
+  // DartTestComponentControllerV2 app(
+  //     std::move(start_info), runner_incoming_services,
+  //     std::move(controller));
+  test_component->SetUp();
+  // const bool success = app.SetUp();
+  FML_LOG(INFO) << "DART COMPONENT SET UP: ";
+  const int64_t end = Dart_TimelineGetMicros();
+  Dart_TimelineEvent("DartTestComponentControllerV2::Setup", start, end,
+                     Dart_Timeline_Event_Duration, 0, NULL, NULL);
+  create_callback(std::move(test_component));
+
+  // app.Run();
+
+  if (Dart_CurrentIsolate()) {
+    Dart_ShutdownIsolate();
+  }
+}
+
 bool EntropySource(uint8_t* buffer, intptr_t count) {
   zx_cprng_draw(buffer, count);
   return true;
@@ -159,6 +280,86 @@
 
 }  // namespace
 
+// "data" and "assets" are arguments that are specific to the Flutter runner.
+// They will likely go away if we migrate to the ELF runner.
+constexpr char kDataKey[] = "data";
+constexpr char kAssetsKey[] = "assets";
+
+// "args" are how the component specifies arguments to the runner.
+constexpr char kArgsKey[] = "args";
+constexpr char kOldGenHeapSizeKey[] = "old_gen_heap_size";
+constexpr char kExposeDirsKey[] = "expose_dirs";
+
+// constexpr char kTmpPath[] = "/tmp";
+// constexpr char kServiceRootPath[] = "/svc";
+// constexpr char kRunnerConfigPath[] = "/config/data/flutter_runner_config";
+
+/// Parses the |args| field from the "program" field into
+/// |metadata|.
+void ParseArgs(std::vector<std::string>& args, ProgramMetadata* metadata) {
+  // fml::CommandLine expects the first argument to be the name of the program,
+  // so we prepend a dummy argument so we can use fml::CommandLine to parse the
+  // arguments for us.
+  std::vector<std::string> command_line_args = {""};
+  command_line_args.insert(command_line_args.end(), args.begin(), args.end());
+  fml::CommandLine parsed_args = fml::CommandLineFromIterators(
+      command_line_args.begin(), command_line_args.end());
+
+  std::string is_test;
+  if (parsed_args.GetOptionValue("is_test", &is_test)) {
+    // FML_LOG(INFO) << "HIT";
+    // FML_LOG(INFO) << is_test;
+    metadata->is_test = is_test == "true";
+  }
+
+  std::string old_gen_heap_size_option;
+  if (parsed_args.GetOptionValue(kOldGenHeapSizeKey,
+                                 &old_gen_heap_size_option)) {
+    int64_t specified_old_gen_heap_size = strtol(
+        old_gen_heap_size_option.c_str(), nullptr /* endptr */, 10 /* base */);
+    if (specified_old_gen_heap_size != 0) {
+      metadata->old_gen_heap_size = specified_old_gen_heap_size;
+    } else {
+      // FML_LOG(ERROR) << "Invalid old_gen_heap_size: "
+      //                << old_gen_heap_size_option;
+    }
+  }
+
+  std::string expose_dirs_option;
+  if (parsed_args.GetOptionValue(kExposeDirsKey, &expose_dirs_option)) {
+    // Parse the comma delimited string
+    std::vector<std::string> expose_dirs;
+    std::stringstream s(expose_dirs_option);
+    while (s.good()) {
+      std::string dir;
+      getline(s, dir, ',');  // get first string delimited by comma
+      metadata->expose_dirs.push_back(dir);
+    }
+  }
+}
+
+ProgramMetadata ParseProgramMetadata(
+    const fuchsia::data::Dictionary& program_metadata) {
+  ProgramMetadata result;
+
+  for (const auto& entry : program_metadata.entries()) {
+    if (entry.key.compare(kDataKey) == 0 && entry.value != nullptr) {
+      result.data_path = "pkg/" + entry.value->str();
+    } else if (entry.key.compare(kAssetsKey) == 0 && entry.value != nullptr) {
+      result.assets_path = "pkg/" + entry.value->str();
+    } else if (entry.key.compare(kArgsKey) == 0 && entry.value != nullptr) {
+      ParseArgs(entry.value->str_vec(), &result);
+    }
+  }
+
+  // assets_path defaults to the same as data_path if omitted.
+  if (result.assets_path.empty()) {
+    result.assets_path = result.data_path;
+  }
+
+  return result;
+}
+
 DartRunner::DartRunner(sys::ComponentContext* context) : context_(context) {
   context_->outgoing()->AddPublicService<fuchsia::sys::Runner>(
       [this](fidl::InterfaceRequest<fuchsia::sys::Runner> request) {
@@ -236,6 +437,7 @@
   // move or change, so we make a copy to pass to TRACE_DURATION.
   // TODO(PT-169): Remove this copy when TRACE_DURATION reads string arguments
   // eagerly.
+  FML_LOG(INFO) << "RESOLVED URL V1: " << package.resolved_url;
   std::string url_copy = package.resolved_url;
   TRACE_EVENT1("dart", "StartComponent", "url", url_copy.c_str());
   std::thread thread(RunApplicationV1, this, std::move(package),
@@ -248,11 +450,36 @@
     fuchsia::component::runner::ComponentStartInfo start_info,
     fidl::InterfaceRequest<fuchsia::component::runner::ComponentController>
         controller) {
-  std::string url_copy = start_info.resolved_url();
-  TRACE_EVENT1("dart", "Start", "url", url_copy.c_str());
-  std::thread thread(RunApplicationV2, this, std::move(start_info),
-                     context_->svc(), std::move(controller));
-  thread.detach();
+  ProgramMetadata metadata = ParseProgramMetadata(start_info.program());
+  FML_LOG(INFO) << "RESOLVED URL V2: " << start_info.resolved_url();
+
+  if (metadata.is_test) {
+    FML_LOG(INFO) << "RESOLVED URL: " << start_info.resolved_url();
+
+    std::string url_copy = start_info.resolved_url();
+    TRACE_EVENT1("dart", "Start", "url", url_copy.c_str());
+    std::thread thread(
+        RunTestApplicationV2, this, std::move(start_info), context_->svc(),
+        std::move(controller),
+        [this](std::unique_ptr<DartTestComponentControllerV2> ptr) {
+          FML_LOG(INFO) << "TEST COMPONENT SAVED";
+          test_components_.emplace(ptr.get(), std::move(ptr));
+        },
+        [this](DartTestComponentControllerV2* ptr) {
+          FML_LOG(INFO) << "TEST COMPONENT ERASED";
+          auto it = test_components_.find(ptr);
+          if (it != test_components_.end()) {
+            test_components_.erase(it);
+          }
+        });
+    thread.detach();
+  } else {
+    std::string url_copy = start_info.resolved_url();
+    TRACE_EVENT1("dart", "Start", "url", url_copy.c_str());
+    std::thread thread(RunApplicationV2, this, std::move(start_info),
+                       context_->svc(), std::move(controller));
+    thread.detach();
+  }
 }
 
 }  // namespace dart_runner
diff --git a/shell/platform/fuchsia/dart_runner/dart_runner.h b/shell/platform/fuchsia/dart_runner/dart_runner.h
index ce47eec..5688ca5 100644
--- a/shell/platform/fuchsia/dart_runner/dart_runner.h
+++ b/shell/platform/fuchsia/dart_runner/dart_runner.h
@@ -10,7 +10,9 @@
 #include <lib/fidl/cpp/binding_set.h>
 #include <lib/sys/cpp/component_context.h>
 
+#include "dart_test_component_controller_v2.h"
 #include "runtime/dart/utils/mapped_resource.h"
+// #include "test_component.h"
 
 namespace dart_runner {
 
@@ -33,12 +35,18 @@
       fidl::InterfaceRequest<fuchsia::component::runner::ComponentController>
           controller) override;
 
+  std::map<DartTestComponentControllerV2*,
+           std::shared_ptr<DartTestComponentControllerV2>>
+      test_components_;
+
   // Not owned by DartRunner.
   sys::ComponentContext* context_;
   fidl::BindingSet<fuchsia::sys::Runner> bindings_;
   fidl::BindingSet<fuchsia::component::runner::ComponentRunner>
       component_runner_bindings_;
 
+  std::shared_ptr<sys::ServiceDirectory> svc_;
+
 #if !defined(AOT_RUNTIME)
   dart_utils::MappedResource vm_snapshot_data_;
   dart_utils::MappedResource vm_snapshot_instructions_;
diff --git a/shell/platform/fuchsia/dart_runner/dart_test_component_controller_v2.cc b/shell/platform/fuchsia/dart_runner/dart_test_component_controller_v2.cc
new file mode 100644
index 0000000..30136a7
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/dart_test_component_controller_v2.cc
@@ -0,0 +1,690 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "dart_test_component_controller_v2.h"
+
+#include <fcntl.h>
+#include <fml/logging.h>
+#include <fuchsia/sys/test/cpp/fidl.h>
+#include <lib/async-loop/loop.h>
+#include <lib/async/cpp/task.h>
+#include <lib/async/default.h>
+#include <lib/fdio/directory.h>
+#include <lib/fdio/fd.h>
+#include <lib/fdio/namespace.h>
+#include <lib/fidl/cpp/string.h>
+#include <lib/fpromise/barrier.h>
+#include <lib/sys/cpp/service_directory.h>
+#include <lib/syslog/global.h>
+#include <lib/zx/clock.h>
+#include <lib/zx/thread.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <zircon/status.h>
+
+#include <regex>
+#include <utility>
+
+#include "runtime/dart/utils/files.h"
+#include "runtime/dart/utils/handle_exception.h"
+#include "runtime/dart/utils/inlines.h"
+#include "runtime/dart/utils/tempfs.h"
+#include "third_party/dart/runtime/include/dart_tools_api.h"
+#include "third_party/tonic/converter/dart_converter.h"
+#include "third_party/tonic/dart_message_handler.h"
+#include "third_party/tonic/dart_microtask_queue.h"
+#include "third_party/tonic/dart_state.h"
+#include "third_party/tonic/logging/dart_error.h"
+#include "third_party/tonic/logging/dart_invoke.h"
+
+#include "builtin_libraries.h"
+#include "logging.h"
+
+using tonic::ToDart;
+
+namespace dart_runner {
+
+namespace {
+
+constexpr char kTmpPath[] = "/tmp";
+
+constexpr zx::duration kIdleWaitDuration = zx::sec(2);
+constexpr zx::duration kIdleNotifyDuration = zx::msec(500);
+constexpr zx::duration kIdleSlack = zx::sec(1);
+
+void AfterTask(async_loop_t*, void*) {
+  tonic::DartMicrotaskQueue* queue =
+      tonic::DartMicrotaskQueue::GetForCurrentThread();
+  // Verify that the queue exists, as this method could have been called back as
+  // part of the exit routine, after the destruction of the microtask queue.
+  if (queue) {
+    queue->RunMicrotasks();
+  }
+}
+
+constexpr async_loop_config_t kLoopConfig = {
+    .default_accessors =
+        {
+            .getter = async_get_default_dispatcher,
+            .setter = async_set_default_dispatcher,
+        },
+    .make_default_for_current_thread = true,
+    .epilogue = &AfterTask,
+};
+
+// Find the last path of the component.
+// fuchsia-pkg://fuchsia.com/hello_dart#meta/hello_dart.cmx -> hello_dart.cmx
+std::string GetLabelFromUrl(const std::string& url) {
+  for (size_t i = url.length() - 1; i > 0; i--) {
+    if (url[i] == '/') {
+      return url.substr(i + 1, url.length() - 1);
+    }
+  }
+  return url;
+}
+
+// Find the name of the component.
+// fuchsia-pkg://fuchsia.com/hello_dart#meta/hello_dart.cm -> hello_dart
+std::string GetComponentNameFromUrl(const std::string& url) {
+  const std::string label = GetLabelFromUrl(url);
+  for (size_t i = 0; i < label.length(); ++i) {
+    if (label[i] == '.') {
+      return label.substr(0, i);
+    }
+  }
+  return label;
+}
+
+}  // namespace
+
+DartTestComponentControllerV2::DartTestComponentControllerV2(
+    fuchsia::component::runner::ComponentStartInfo start_info,
+    std::shared_ptr<sys::ServiceDirectory> runner_incoming_services,
+    fidl::InterfaceRequest<fuchsia::component::runner::ComponentController>
+        controller,
+    DoneCallback done_callback)
+    : loop_(new async::Loop(&kLoopConfig)),
+      label_(GetLabelFromUrl(start_info.resolved_url())),
+      url_(std::move(start_info.resolved_url())),
+      runner_incoming_services_(runner_incoming_services),
+      start_info_(std::move(start_info)),
+      binding_(this),
+      done_callback_(std::move(done_callback)) {
+  // TODO(fxb/84537): This data path is configured based how we build Flutter
+  // applications in tree currently, but the way we build the Flutter
+  // application may change. We should avoid assuming the data path and let the
+  // CML file specify this data path instead.
+  const std::string component_name = GetComponentNameFromUrl(url_);
+  FX_LOGF(INFO, LOG_TAG, "Component Name from URL: %s.",
+          component_name.c_str());
+  data_path_ = "pkg/data/" + component_name;
+
+  if (controller.is_valid()) {
+    binding_.Bind(std::move(controller));
+    binding_.set_error_handler([this](zx_status_t status) { Kill(); });
+  } else {
+    FX_LOG(ERROR, LOG_TAG,
+           "Fuchsia component controller endpoint is not valid.");
+  }
+}
+
+DartTestComponentControllerV2::~DartTestComponentControllerV2() {
+  if (namespace_) {
+    fdio_ns_destroy(namespace_);
+    namespace_ = nullptr;
+  }
+  close(stdout_fd_);
+  close(stderr_fd_);
+}
+
+void DartTestComponentControllerV2::SetUp() {
+  // Name the thread after the url of the component being launched.
+  zx::thread::self()->set_property(ZX_PROP_NAME, label_.c_str(), label_.size());
+  Dart_SetThreadName(label_.c_str());
+
+  if (!CreateAndBindNamespace()) {
+    return;
+  }
+
+  if (SetUpFromAppSnapshot()) {
+    FX_LOGF(INFO, LOG_TAG, "%s is running from an app snapshot", url_.c_str());
+  } else if (SetUpFromKernel()) {
+    FX_LOGF(INFO, LOG_TAG, "%s is running from kernel", url_.c_str());
+  } else {
+    FX_LOGF(ERROR, LOG_TAG, "Failed to set up component controller for %s.",
+            url_.c_str());
+    return;
+    // return false;
+  }
+
+  // return true;
+  // suite_ = std::make_unique<Suite>(url_, loop_);
+  suite_context_ = sys::ComponentContext::Create();
+  suite_context_->outgoing()->AddPublicService(
+      suite_bindings_.GetHandler(this, loop_->dispatcher()));
+  suite_context_->outgoing()->Serve(
+      start_info_.mutable_outgoing_dir()->TakeChannel(), loop_->dispatcher());
+}
+
+bool DartTestComponentControllerV2::CreateAndBindNamespace() {
+  if (!start_info_.has_ns()) {
+    FX_LOG(ERROR, LOG_TAG, "Component start info does not have a namespace.");
+    return false;
+  }
+
+  const zx_status_t ns_create_status = fdio_ns_create(&namespace_);
+  if (ns_create_status != ZX_OK) {
+    FX_LOGF(ERROR, LOG_TAG, "Failed to create namespace: %s",
+            zx_status_get_string(ns_create_status));
+  }
+
+  dart_utils::RunnerTemp::SetupComponent(namespace_);
+
+  // Bind each directory in start_info's namespace to the controller's namespace
+  // instance.
+  for (auto& ns_entry : *start_info_.mutable_ns()) {
+    // TODO(akbiggs): Under what circumstances does a namespace entry not
+    // have a path or directory? Should we log an error for these?
+    if (!ns_entry.has_path() || !ns_entry.has_directory()) {
+      continue;
+    }
+
+    if (ns_entry.path() == kTmpPath) {
+      // /tmp is covered by the local memfs.
+      continue;
+    }
+
+    // We move ownership of the directory & path since RAII is used to keep
+    // the handle open.
+    fidl::InterfaceHandle<::fuchsia::io::Directory> dir =
+        std::move(*ns_entry.mutable_directory());
+    const std::string path = std::move(*ns_entry.mutable_path());
+
+    const zx_status_t ns_bind_status =
+        fdio_ns_bind(namespace_, path.c_str(), dir.TakeChannel().release());
+    if (ns_bind_status != ZX_OK) {
+      FX_LOGF(ERROR, LOG_TAG, "Failed to bind %s to namespace: %s",
+              path.c_str(), zx_status_get_string(ns_bind_status));
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool DartTestComponentControllerV2::SetUpFromKernel() {
+  dart_utils::MappedResource manifest;
+  if (!dart_utils::MappedResource::LoadFromNamespace(
+          namespace_, data_path_ + "/app.dilplist", manifest)) {
+    return false;
+  }
+
+  if (!dart_utils::MappedResource::LoadFromNamespace(
+          nullptr, "/pkg/data/isolate_core_snapshot_data.bin",
+          isolate_snapshot_data_)) {
+    return false;
+  }
+  if (!dart_utils::MappedResource::LoadFromNamespace(
+          nullptr, "/pkg/data/isolate_core_snapshot_instructions.bin",
+          isolate_snapshot_instructions_, true /* executable */)) {
+    return false;
+  }
+
+  if (!CreateIsolate(isolate_snapshot_data_.address(),
+                     isolate_snapshot_instructions_.address())) {
+    return false;
+  }
+
+  Dart_EnterScope();
+
+  std::string str(reinterpret_cast<const char*>(manifest.address()),
+                  manifest.size());
+  Dart_Handle library = Dart_Null();
+  for (size_t start = 0; start < manifest.size();) {
+    size_t end = str.find("\n", start);
+    if (end == std::string::npos) {
+      FX_LOG(ERROR, LOG_TAG, "Malformed manifest");
+      Dart_ExitScope();
+      return false;
+    }
+
+    std::string path = data_path_ + "/" + str.substr(start, end - start);
+    start = end + 1;
+
+    dart_utils::MappedResource kernel;
+    if (!dart_utils::MappedResource::LoadFromNamespace(namespace_, path,
+                                                       kernel)) {
+      FX_LOGF(ERROR, LOG_TAG, "Cannot load kernel from namespace: %s",
+              path.c_str());
+      Dart_ExitScope();
+      return false;
+    }
+    library = Dart_LoadLibraryFromKernel(kernel.address(), kernel.size());
+    if (Dart_IsError(library)) {
+      FX_LOGF(ERROR, LOG_TAG, "Cannot load library from kernel: %s",
+              Dart_GetError(library));
+      Dart_ExitScope();
+      return false;
+    }
+
+    kernel_peices_.emplace_back(std::move(kernel));
+  }
+  Dart_SetRootLibrary(library);
+
+  Dart_Handle result = Dart_FinalizeLoading(false);
+  if (Dart_IsError(result)) {
+    FX_LOGF(ERROR, LOG_TAG, "Failed to FinalizeLoading: %s",
+            Dart_GetError(result));
+    Dart_ExitScope();
+    return false;
+  }
+
+  return true;
+}
+
+bool DartTestComponentControllerV2::SetUpFromAppSnapshot() {
+#if !defined(AOT_RUNTIME)
+  return false;
+#else
+  // Load the ELF snapshot as available, and fall back to a blobs snapshot
+  // otherwise.
+  const uint8_t *isolate_data, *isolate_instructions;
+  if (elf_snapshot_.Load(namespace_, data_path_ + "/app_aot_snapshot.so")) {
+    isolate_data = elf_snapshot_.IsolateData();
+    isolate_instructions = elf_snapshot_.IsolateInstrs();
+    if (isolate_data == nullptr || isolate_instructions == nullptr) {
+      return false;
+    }
+  } else {
+    if (!dart_utils::MappedResource::LoadFromNamespace(
+            namespace_, data_path_ + "/isolate_snapshot_data.bin",
+            isolate_snapshot_data_)) {
+      return false;
+    }
+    if (!dart_utils::MappedResource::LoadFromNamespace(
+            namespace_, data_path_ + "/isolate_snapshot_instructions.bin",
+            isolate_snapshot_instructions_, true /* executable */)) {
+      return false;
+    }
+  }
+  return CreateIsolate(isolate_data, isolate_instructions);
+#endif  // defined(AOT_RUNTIME)
+}
+
+bool DartTestComponentControllerV2::CreateIsolate(
+    const uint8_t* isolate_snapshot_data,
+    const uint8_t* isolate_snapshot_instructions) {
+  // Create the isolate from the snapshot.
+  char* error = nullptr;
+
+  // TODO(dart_runner): Pass if we start using tonic's loader.
+  intptr_t namespace_fd = -1;
+
+  // Freed in IsolateShutdownCallback.
+  auto state = new std::shared_ptr<tonic::DartState>(new tonic::DartState(
+      namespace_fd, [this](Dart_Handle result) { MessageEpilogue(result); }));
+
+  isolate_ = Dart_CreateIsolateGroup(
+      url_.c_str(), label_.c_str(), isolate_snapshot_data,
+      isolate_snapshot_instructions, nullptr /* flags */, state, state, &error);
+  if (!isolate_) {
+    FX_LOGF(ERROR, LOG_TAG, "Dart_CreateIsolateGroup failed: %s", error);
+    return false;
+  }
+
+  state->get()->SetIsolate(isolate_);
+
+  tonic::DartMessageHandler::TaskDispatcher dispatcher =
+      [loop = loop_.get()](auto callback) {
+        async::PostTask(loop->dispatcher(), std::move(callback));
+      };
+  state->get()->message_handler().Initialize(dispatcher);
+
+  state->get()->SetReturnCodeCallback(
+      [this](uint32_t return_code) { return_code_ = return_code; });
+
+  return true;
+}
+
+// void DartTestComponentControllerV2::Run() {
+//   async::PostTask(loop_->dispatcher(), [loop = loop_.get(), app = this] {
+//     if (!app->RunDartMain()) {
+//       loop->Quit();
+//     }
+//   });
+//   loop_->Run();
+
+//   if (binding_.is_bound()) {
+//     // From the documentation for ComponentController, ZX_OK should be sent
+//     when
+//     // the ComponentController receives a termination request. However, if
+//     the
+//     // component exited with a non-zero return code, we indicate this by
+//     sending
+//     // an INTERNAL epitaph instead.
+//     //
+//     // TODO(fxb/86666): Communicate return code from the ComponentController
+//     // once v2 has support.
+//     if (return_code_ == 0) {
+//       binding_.Close(ZX_OK);
+//     } else {
+//       FML_LOG(ERROR) << "Component exited with non-zero return code: "
+//                      << return_code_;
+//       binding_.Close(zx_status_t(fuchsia::component::Error::INTERNAL));
+//     }
+//   }
+// }
+
+// |fuchsia::test::Suite|
+DartTestComponentControllerV2::CaseIterator::CaseIterator(
+    fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator> request,
+    async_dispatcher_t* dispatcher,
+    fit::function<void(CaseIterator*)> done_callback)
+    : binding_(this, std::move(request), dispatcher),
+      done_callback_(std::move(done_callback)) {}
+
+static const char kTestCaseName[] = "dart_test";
+void DartTestComponentControllerV2::CaseIterator::GetNext(
+    GetNextCallback callback) {
+  FML_LOG(INFO) << "DartTestComponentControllerV2 GetNext() called";
+  if (get_next_call_count == 0) {
+    fuchsia::sys::test::Case test_case;
+    test_case.set_name(std::string(kTestCaseName));
+    test_case.set_enabled(true);
+    std::vector<fuchsia::sys::test::Case> cases;
+    cases.push_back(std::move(test_case));
+    callback(std::move(cases));
+    get_next_call_count++;
+
+  } else {
+    std::vector<fuchsia::sys::test::Case> cases;
+    callback(std::move(cases));
+    // this would be removed
+    done_callback_(this);
+  }
+}
+
+void DartTestComponentControllerV2::GetTests(
+    fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator> iterator) {
+  FML_LOG(INFO) << "DART RUNNER HIT SUITE GetTests()";
+
+  auto case_iterator =
+      std::make_unique<CaseIterator>(std::move(iterator), loop_->dispatcher(),
+                                     [this](CaseIterator* case_iterator) {
+                                       RemoveCaseInterator(case_iterator);
+                                     });
+  case_iterators_.emplace(case_iterator.get(), std::move(case_iterator));
+}
+
+std::unique_ptr<DartTestComponentControllerV2::CaseIterator>
+DartTestComponentControllerV2::RemoveCaseInterator(
+    CaseIterator* case_iterator) {
+  auto it = case_iterators_.find(case_iterator);
+  std::unique_ptr<DartTestComponentControllerV2::CaseIterator>
+      case_iterator_ptr;
+  if (it != case_iterators_.end()) {
+    case_iterator_ptr = std::move(it->second);
+    case_iterators_.erase(it);
+  }
+  return case_iterator_ptr;
+}
+
+// |fuchsia::test::Suite|
+void DartTestComponentControllerV2::Run(
+    std::vector<fuchsia::sys::test::Invocation> tests,
+    fuchsia::sys::test::RunOptions options,
+    fidl::InterfaceHandle<fuchsia::sys::test::RunListener> listener) {
+  FML_LOG(INFO) << "DART RUNNER HIT SUITE Run()";
+
+  std::vector<std::string> args;
+  if (options.has_arguments()) {
+    args = std::move(*options.mutable_arguments());
+  }
+
+  if (options.has_parallel()) {
+    FML_LOG(WARNING) << "Ignoring 'parallel'. Pass test specific flags, eg: "
+                        "for rust test pass in "
+                        "--test-threads="
+                     << options.parallel();
+  }
+
+  auto listener_proxy = listener.Bind();
+  fpromise::barrier barrier;
+  for (auto it = tests.begin(); it != tests.end(); it++) {
+    auto invocation = std::move(*it);
+    std::string test_case_name;
+    if (invocation.has_name()) {
+      test_case_name = invocation.name();
+    }
+    FML_LOG(INFO) << "DART RUNNER HIT SUITE RUN - TEST CASE: "
+                  << test_case_name;
+    zx::socket out, err, out_client, err_client;
+    auto status = zx::socket::create(0, &out, &out_client);
+    if (status != ZX_OK) {
+      FML_LOG(FATAL) << "cannot create socket: "
+                     << zx_status_get_string(status);
+    }
+    status = zx::socket::create(0, &err, &err_client);
+    if (status != ZX_OK) {
+      FML_LOG(FATAL) << "cannot create socket: "
+                     << zx_status_get_string(status);
+    }
+
+    fidl::InterfacePtr<fuchsia::sys::test::CaseListener> case_listener;
+
+    fuchsia::sys::test::StdHandles std_handles;
+    std_handles.set_err(std::move(err_client));
+    std_handles.set_out(std::move(out_client));
+
+    listener_proxy->OnTestCaseStarted(std::move(invocation),
+                                      std::move(std_handles),
+                                      case_listener.NewRequest());
+
+    async::PostTask(loop_->dispatcher(), [loop = loop_.get(), app = this] {
+      if (!app->RunDartMain()) {
+        loop->Quit();
+      }
+    });
+    loop_->Run();
+
+    auto ret_status = return_code_ == 0 ? fuchsia::sys::test::Status::PASSED
+                                        : fuchsia::sys::test::Status::FAILED;
+    fuchsia::sys::test::Result result;
+    result.set_status(ret_status);
+    FML_LOG(INFO) << "Sending finished event for dart tests";
+    case_listener->Finished(std::move(result));
+  }
+
+  if (binding_.is_bound()) {
+    // From the documentation for ComponentController, ZX_OK should be sent when
+    // the ComponentController receives a termination request. However, if the
+    // component exited with a non-zero return code, we indicate this by sending
+    // an INTERNAL epitaph instead.
+    //
+    // TODO(fxb/86666): Communicate return code from the ComponentController
+    // once v2 has support.
+    if (return_code_ == 0) {
+      binding_.Close(ZX_OK);
+    } else {
+      FML_LOG(ERROR) << "Component exited with non-zero return code: "
+                     << return_code_;
+      binding_.Close(zx_status_t(fuchsia::component::Error::INTERNAL));
+    }
+  }
+}
+
+bool DartTestComponentControllerV2::RunDartMain() {
+  FML_CHECK(namespace_ != nullptr);
+  Dart_EnterScope();
+
+  tonic::DartMicrotaskQueue::StartForCurrentThread();
+
+  // TODO(fxb/88384): Create a file descriptor for each component that is
+  // launched and listen for anything that is written to the component. When
+  // something is written to the component, forward that message along to the
+  // Fuchsia logger and decorate it with the tag that it came from the
+  // component.
+  stdout_fd_ = fileno(stdout);
+  stderr_fd_ = fileno(stderr);
+
+  fidl::InterfaceRequest<fuchsia::io::Directory> outgoing_dir =
+      std::move(*start_info_.mutable_outgoing_dir());
+  FML_LOG(INFO) << "DART TEST COMPONENT CONTROLLER: RUNMAIN()";
+  FML_LOG(INFO) << url_;
+  InitBuiltinLibrariesForIsolate(
+      url_, namespace_, stdout_fd_, stderr_fd_, nullptr /* environment */,
+      outgoing_dir.TakeChannel(), false /* service_isolate */);
+
+  Dart_ExitScope();
+  Dart_ExitIsolate();
+  char* error = Dart_IsolateMakeRunnable(isolate_);
+  if (error != nullptr) {
+    Dart_EnterIsolate(isolate_);
+    Dart_ShutdownIsolate();
+    FX_LOGF(ERROR, LOG_TAG, "Unable to make isolate runnable: %s", error);
+    free(error);
+    return false;
+  }
+  Dart_EnterIsolate(isolate_);
+  Dart_EnterScope();
+
+  // TODO(fxb/88383): Support argument passing.
+  Dart_Handle corelib = Dart_LookupLibrary(ToDart("dart:core"));
+  Dart_Handle string_type =
+      Dart_GetNonNullableType(corelib, ToDart("String"), 0, NULL);
+  Dart_Handle dart_arguments =
+      Dart_NewListOfTypeFilled(string_type, Dart_EmptyString(), 0);
+
+  if (Dart_IsError(dart_arguments)) {
+    FX_LOGF(ERROR, LOG_TAG, "Failed to allocate Dart arguments list: %s",
+            Dart_GetError(dart_arguments));
+    Dart_ExitScope();
+    return false;
+  }
+
+  Dart_Handle user_main = Dart_GetField(Dart_RootLibrary(), ToDart("main"));
+
+  if (Dart_IsError(user_main)) {
+    FX_LOGF(ERROR, LOG_TAG,
+            "Failed to locate user_main in the root library: %s",
+            Dart_GetError(user_main));
+    Dart_ExitScope();
+    return false;
+  }
+
+  Dart_Handle fuchsia_lib = Dart_LookupLibrary(tonic::ToDart("dart:fuchsia"));
+
+  if (Dart_IsError(fuchsia_lib)) {
+    FX_LOGF(ERROR, LOG_TAG, "Failed to locate dart:fuchsia: %s",
+            Dart_GetError(fuchsia_lib));
+    Dart_ExitScope();
+    return false;
+  }
+
+  Dart_Handle main_result = tonic::DartInvokeField(
+      fuchsia_lib, "_runUserMainForDartRunner", {user_main, dart_arguments});
+
+  if (Dart_IsError(main_result)) {
+    auto dart_state = tonic::DartState::Current();
+    if (!dart_state->has_set_return_code()) {
+      // The program hasn't set a return code meaning this exit is unexpected.
+      FX_LOG(ERROR, LOG_TAG, Dart_GetError(main_result));
+      return_code_ = tonic::GetErrorExitCode(main_result);
+
+      dart_utils::HandleIfException(runner_incoming_services_, url_,
+                                    main_result);
+    }
+    Dart_ExitScope();
+    return false;
+  }
+
+  Dart_ExitScope();
+  return true;
+}
+
+void DartTestComponentControllerV2::Kill() {
+  FML_LOG(INFO) << "DartTestComponentControllerV2 KILL CALLED";
+  if (Dart_CurrentIsolate()) {
+    tonic::DartMicrotaskQueue* queue =
+        tonic::DartMicrotaskQueue::GetForCurrentThread();
+    if (queue) {
+      queue->Destroy();
+    }
+
+    loop_->Quit();
+
+    // TODO(rosswang): The docs warn of threading issues if doing this again,
+    // but without this, attempting to shut down the isolate finalizes app
+    // contexts that can't tell a shutdown is in progress and so fatal.
+    Dart_SetMessageNotifyCallback(nullptr);
+
+    Dart_ShutdownIsolate();
+  }
+  done_callback_(this);
+}
+
+void DartTestComponentControllerV2::MessageEpilogue(Dart_Handle result) {
+  auto dart_state = tonic::DartState::Current();
+  // If the Dart program has set a return code, then it is intending to shut
+  // down by way of a fatal error, and so there is no need to override
+  // return_code_.
+  if (dart_state->has_set_return_code()) {
+    Dart_ShutdownIsolate();
+    return;
+  }
+
+  dart_utils::HandleIfException(runner_incoming_services_, url_, result);
+
+  // Otherwise, see if there was any other error.
+  return_code_ = tonic::GetErrorExitCode(result);
+  if (return_code_ != 0) {
+    Dart_ShutdownIsolate();
+    return;
+  }
+
+  idle_start_ = zx::clock::get_monotonic();
+  zx_status_t status =
+      idle_timer_.set(idle_start_ + kIdleWaitDuration, kIdleSlack);
+  if (status != ZX_OK) {
+    FX_LOGF(INFO, LOG_TAG, "Idle timer set failed: %s",
+            zx_status_get_string(status));
+  }
+}
+
+void DartTestComponentControllerV2::Stop() {
+  Kill();
+}
+
+void DartTestComponentControllerV2::OnIdleTimer(
+    async_dispatcher_t* dispatcher,
+    async::WaitBase* wait,
+    zx_status_t status,
+    const zx_packet_signal* signal) {
+  if ((status != ZX_OK) || !(signal->observed & ZX_TIMER_SIGNALED) ||
+      !Dart_CurrentIsolate()) {
+    // Timer closed or isolate shutdown.
+    return;
+  }
+
+  zx::time deadline = idle_start_ + kIdleWaitDuration;
+  zx::time now = zx::clock::get_monotonic();
+  if (now >= deadline) {
+    // No Dart message has been processed for kIdleWaitDuration: assume we'll
+    // stay idle for kIdleNotifyDuration.
+    Dart_NotifyIdle((now + kIdleNotifyDuration).get());
+    idle_start_ = zx::time(0);
+    idle_timer_.cancel();  // De-assert signal.
+  } else {
+    // Early wakeup or message pushed idle time forward: reschedule.
+    zx_status_t status = idle_timer_.set(deadline, kIdleSlack);
+    if (status != ZX_OK) {
+      FX_LOGF(INFO, LOG_TAG, "Idle timer set failed: %s",
+              zx_status_get_string(status));
+    }
+  }
+  wait->Begin(dispatcher);  // ignore errors
+}
+
+}  // namespace dart_runner
diff --git a/shell/platform/fuchsia/dart_runner/dart_test_component_controller_v2.h b/shell/platform/fuchsia/dart_runner/dart_test_component_controller_v2.h
new file mode 100644
index 0000000..c15d498
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/dart_test_component_controller_v2.h
@@ -0,0 +1,166 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_DART_TEST_COMPONENT_CONTROLLER_V2_H_
+#define FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_DART_TEST_COMPONENT_CONTROLLER_V2_H_
+
+#include <memory>
+
+#include <fuchsia/component/runner/cpp/fidl.h>
+#include <fuchsia/sys/cpp/fidl.h>
+#include <fuchsia/sys/test/cpp/fidl.h>
+#include <lib/async-loop/cpp/loop.h>
+#include <lib/async/cpp/wait.h>
+#include <lib/fdio/namespace.h>
+#include <lib/sys/cpp/component_context.h>
+#include <lib/sys/cpp/service_directory.h>
+#include <lib/zx/timer.h>
+
+#include <lib/fidl/cpp/binding_set.h>
+#include "lib/fidl/cpp/binding.h"
+#include "runtime/dart/utils/mapped_resource.h"
+#include "third_party/dart/runtime/include/dart_api.h"
+
+// #include "suite.h"
+namespace dart_runner {
+
+// struct TestComponentArgs {
+//   std::string legacy_url;
+//   zx::channel outgoing_dir;
+//   fuchsia::sys::EnvironmentPtr parent_env;
+//   std::shared_ptr<sys::ServiceDirectory> parent_env_svc;
+//   std::shared_ptr<sys::ServiceDirectory> test_component_svc;
+
+//   async_dispatcher_t* dispatcher;
+// };
+
+/// Starts a Dart component written in CFv2.
+class DartTestComponentControllerV2
+    : public fuchsia::component::runner::ComponentController,
+      public fuchsia::sys::test::Suite {
+  using DoneCallback = fit::function<void(DartTestComponentControllerV2*)>;
+
+ public:
+  DartTestComponentControllerV2(
+      fuchsia::component::runner::ComponentStartInfo start_info,
+      std::shared_ptr<sys::ServiceDirectory> runner_incoming_services,
+      fidl::InterfaceRequest<fuchsia::component::runner::ComponentController>
+          controller,
+      DoneCallback done_callback);
+
+  ~DartTestComponentControllerV2() override;
+
+  /// Sets up the controller.
+  ///
+  /// This should be called before |Run|.
+  void SetUp();
+
+  /// Runs the Dart component in a task, sending the return code back to
+  /// the Fuchsia component controller.
+  ///
+  /// This should be called after |SetUp|.
+  //   void Run();
+
+  /// |Suite| protocol implementation.
+  void GetTests(fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator>
+                    iterator) override;
+
+  /// |Suite| protocol implementation.
+  void Run(
+      std::vector<fuchsia::sys::test::Invocation> tests,
+      fuchsia::sys::test::RunOptions options,
+      fidl::InterfaceHandle<fuchsia::sys::test::RunListener> listener) override;
+
+ private:
+  /// Helper for actually running the Dart main. Returns true if successful,
+  /// false otherwise.
+  bool RunDartMain();
+
+  /// Creates and binds the namespace for this component. Returns true if
+  /// successful, false otherwise.
+  bool CreateAndBindNamespace();
+
+  bool SetUpFromKernel();
+  bool SetUpFromAppSnapshot();
+
+  bool CreateIsolate(const uint8_t* isolate_snapshot_data,
+                     const uint8_t* isolate_snapshot_instructions);
+
+  // |ComponentController|
+  void Kill() override;
+  void Stop() override;
+
+  // Idle notification.
+  void MessageEpilogue(Dart_Handle result);
+  void OnIdleTimer(async_dispatcher_t* dispatcher,
+                   async::WaitBase* wait,
+                   zx_status_t status,
+                   const zx_packet_signal* signal);
+
+  class CaseIterator final : public fuchsia::sys::test::CaseIterator {
+   public:
+    CaseIterator(
+        fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator> request,
+        async_dispatcher_t* dispatcher,
+        fit::function<void(CaseIterator*)> done_callback);
+
+    void GetNext(GetNextCallback callback) override;
+
+   private:
+    int get_next_call_count = 0;
+    fidl::Binding<fuchsia::sys::test::CaseIterator> binding_;
+    fit::function<void(CaseIterator*)> done_callback_;
+  };
+
+  std::unique_ptr<CaseIterator> RemoveCaseInterator(CaseIterator*);
+
+  // |Suite|
+  // async_dispatcher_t* dispatcher_;
+  std::unique_ptr<Suite> suite_;
+  std::map<CaseIterator*, std::unique_ptr<CaseIterator>> case_iterators_;
+  /// Exposes suite protocol on behalf of test component.
+  std::unique_ptr<sys::ComponentContext> suite_context_;
+  fidl::BindingSet<fuchsia::sys::test::Suite> suite_bindings_;
+
+  // The loop must be the first declared member so that it gets destroyed after
+  // binding_ which expects the existence of a loop.
+  std::unique_ptr<async::Loop> loop_;
+
+  std::string label_;
+  std::string url_;
+  std::shared_ptr<sys::ServiceDirectory> runner_incoming_services_;
+  std::string data_path_;
+  std::unique_ptr<sys::ComponentContext> context_;
+
+  fuchsia::component::runner::ComponentStartInfo start_info_;
+  fidl::Binding<fuchsia::component::runner::ComponentController> binding_;
+  DoneCallback done_callback_;
+
+  fdio_ns_t* namespace_ = nullptr;
+  int stdout_fd_ = -1;
+  int stderr_fd_ = -1;
+
+  dart_utils::ElfSnapshot elf_snapshot_;                      // AOT snapshot
+  dart_utils::MappedResource isolate_snapshot_data_;          // JIT snapshot
+  dart_utils::MappedResource isolate_snapshot_instructions_;  // JIT snapshot
+  std::vector<dart_utils::MappedResource> kernel_peices_;
+
+  Dart_Isolate isolate_;
+  int32_t return_code_ = 0;
+
+  zx::time idle_start_{0};
+  zx::timer idle_timer_;
+  async::WaitMethod<DartTestComponentControllerV2,
+                    &DartTestComponentControllerV2::OnIdleTimer>
+      idle_wait_{this};
+
+  // Disallow copy and assignment.
+  DartTestComponentControllerV2(const DartTestComponentControllerV2&) = delete;
+  DartTestComponentControllerV2& operator=(
+      const DartTestComponentControllerV2&) = delete;
+};
+
+}  // namespace dart_runner
+
+#endif  // FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_DART_TEST_COMPONENT_CONTROLLER_V2_H_
diff --git a/shell/platform/fuchsia/dart_runner/fuchsia_pkg_url.cc b/shell/platform/fuchsia/dart_runner/fuchsia_pkg_url.cc
new file mode 100644
index 0000000..8ac5ad2
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/fuchsia_pkg_url.cc
@@ -0,0 +1,122 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "fuchsia_pkg_url.h"
+
+// #include <re2/re2.h>
+#include <regex>
+#include <string>
+#include <string_view>
+
+namespace component {
+
+// Subsitutue functions copied from fxl.
+static std::string SubstituteWithArray(std::string_view format,
+                                       std::string_view* args,
+                                       size_t nargs);
+
+std::string Substitute(std::string_view format, std::string_view arg0) {
+  std::array<std::string_view, 1> arr = {arg0};
+  return SubstituteWithArray(format, arr.data(), arr.size());
+}
+
+std::string Substitute(std::string_view format,
+                       std::string_view arg0,
+                       std::string_view arg1) {
+  std::array<std::string_view, 2> arr = {arg0, arg1};
+  return SubstituteWithArray(format, arr.data(), arr.size());
+}
+
+std::string Substitute(std::string_view format,
+                       std::string_view arg0,
+                       std::string_view arg1,
+                       std::string_view arg2) {
+  std::array<std::string_view, 3> arr = {arg0, arg1, arg2};
+  return SubstituteWithArray(format, arr.data(), arr.size());
+}
+
+static const std::string kFuchsiaPkgPrefix = "fuchsia-pkg://";
+
+// kFuchsiaPkgRexp has the following group matches:
+// 1: user/domain/port/etc (everything after scheme, before path)
+// 2: package name
+// 3: package variant
+// 4: package merkle-root hash
+// 5: resource path
+static const std::regex* kFuchsiaPkgRexp = std::regex(
+    "^fuchsia-pkg://([^/]+)/([^/#?]+)(?:/([^/"
+    "#?]+))?(?:\\?hash=([^&#]+))?(?:#(.+))?$");
+
+// static
+bool FuchsiaPkgUrl::IsFuchsiaPkgScheme(const std::string& url) {
+  return url.compare(0, kFuchsiaPkgPrefix.length(), kFuchsiaPkgPrefix) == 0;
+}
+
+std::string FuchsiaPkgUrl::GetDefaultComponentCmxPath() const {
+  return fxl::Substitute("meta/$0.cmx", package_name());
+}
+
+bool FuchsiaPkgUrl::Parse(const std::string& url) {
+  package_name_.clear();
+  resource_path_.clear();
+
+  // if (!re2::RE2::FullMatch(url, *kFuchsiaPkgRexp, &host_name_,
+  // &package_name_,
+  //                          &variant_, &hash_, &resource_path_)) {
+  //   return false;
+  // }
+
+  char* cstr = new char[url.size()];
+  std::copy(url.begin(), url.end(), cstr);
+
+  std::cmatch cm;
+  bool full_match = std::regex_match(cstr, cm, kFuchsiaPkgRexp);
+  if (!full_match) {
+    return false;
+  }
+
+  host_name_ = cm[1];
+  package_name_ = cm[2];
+  variant_ = cm[3];
+  hash_ = cm[4];
+  resource_path_ = cm[5];
+
+  url_ = url;
+
+  if (variant_.empty()) {
+    // TODO(fxbug.dev/4002): Currently this defaults to "0" if not present, but
+    // variant will eventually be required in fuchsia-pkg URLs.
+    variant_ = "0";
+  }
+
+  return true;
+}
+
+bool FuchsiaPkgUrl::operator==(const FuchsiaPkgUrl& rhs) const {
+  return (this->host_name() == rhs.host_name() &&
+          this->package_name() == rhs.package_name() &&
+          this->variant() == rhs.variant() &&
+          this->resource_path() == rhs.resource_path() &&
+          this->hash() == rhs.hash());
+}
+
+std::string FuchsiaPkgUrl::pkgfs_dir_path() const {
+  return fxl::Substitute("/pkgfs/packages/$0/$1", package_name_, variant_);
+}
+
+std::string FuchsiaPkgUrl::package_path() const {
+  std::string query = "";
+  if (!hash_.empty()) {
+    query = fxl::Substitute("?hash=$0", hash_);
+  }
+
+  return fxl::Substitute("fuchsia-pkg://$0/$1/$2$3", host_name_, package_name_,
+                         variant_, query);
+}
+
+const std::string& FuchsiaPkgUrl::ToString() const {
+  return url_;
+}
+
+}  // namespace component
diff --git a/shell/platform/fuchsia/dart_runner/fuchsia_pkg_url.h b/shell/platform/fuchsia/dart_runner/fuchsia_pkg_url.h
new file mode 100644
index 0000000..8a05ebe
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/fuchsia_pkg_url.h
@@ -0,0 +1,54 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_FUCHSIA_PKG_URL_H_
+#define FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_FUCHSIA_PKG_URL_H_
+
+#include <string>
+
+// #include "src/lib/fxl/macros.h"
+
+namespace component {
+
+class FuchsiaPkgUrl {
+ public:
+  FuchsiaPkgUrl() = default;
+  FuchsiaPkgUrl(const FuchsiaPkgUrl&) = default;
+  FuchsiaPkgUrl& operator=(const FuchsiaPkgUrl&) = default;
+  FuchsiaPkgUrl(FuchsiaPkgUrl&&) = default;
+  FuchsiaPkgUrl& operator=(FuchsiaPkgUrl&&) = default;
+
+  static bool IsFuchsiaPkgScheme(const std::string& url);
+
+  // Returns the default component's .cmx path of this package, i.e.
+  // meta/<package_name>.cmx
+  std::string GetDefaultComponentCmxPath() const;
+
+  bool Parse(const std::string& url);
+
+  bool operator==(const FuchsiaPkgUrl&) const;
+  bool operator!=(const FuchsiaPkgUrl& rhs) const { return !(*this == rhs); }
+
+  const std::string& host_name() const { return host_name_; }
+  const std::string& package_name() const { return package_name_; }
+  const std::string& variant() const { return variant_; }
+  const std::string& hash() const { return hash_; }
+  const std::string& resource_path() const { return resource_path_; }
+  std::string package_path() const;
+  std::string pkgfs_dir_path() const;
+
+  const std::string& ToString() const;
+
+ private:
+  std::string url_;
+  std::string host_name_;
+  std::string package_name_;
+  std::string variant_;
+  std::string hash_;
+  std::string resource_path_;
+};
+
+}  // namespace component
+
+#endif  // FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_FUCHSIA_PKG_URL_H_
diff --git a/shell/platform/fuchsia/dart_runner/meta/dart_jit_runner.cml b/shell/platform/fuchsia/dart_runner/meta/dart_jit_runner.cml
index 2552f7e..545ed80 100644
--- a/shell/platform/fuchsia/dart_runner/meta/dart_jit_runner.cml
+++ b/shell/platform/fuchsia/dart_runner/meta/dart_jit_runner.cml
@@ -17,6 +17,14 @@
             path: "/svc/fuchsia.component.runner.ComponentRunner",
         },
     ],
+    use: [
+        {
+            protocol: [
+                "fuchsia.sys.Environment",
+                "fuchsia.sys.Loader",
+            ],
+        },
+    ],
     expose: [
         {
             runner: "dart_jit_runner",
diff --git a/shell/platform/fuchsia/dart_runner/string_printf.cc b/shell/platform/fuchsia/dart_runner/string_printf.cc
new file mode 100644
index 0000000..801f54e
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/string_printf.cc
@@ -0,0 +1,90 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "string_printf.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include <memory>
+
+namespace fxl {
+namespace {
+
+void StringVAppendfHelper(std::string* dest, const char* format, va_list ap) {
+  // Size of the small stack buffer to use first. This should be kept in sync
+  // with the numbers in StringPrintfTest.StringPrintf_Boundary.
+  constexpr size_t kStackBufferSize = 1024u;
+
+  // First, try with a small buffer on the stack.
+  char stack_buf[kStackBufferSize];
+  // Copy |ap| (which can only be used once), in case we need to retry.
+  va_list ap_copy;
+  va_copy(ap_copy, ap);
+  int result = vsnprintf(stack_buf, kStackBufferSize, format, ap_copy);
+  va_end(ap_copy);
+  if (result < 0) {
+    // As far as I can tell, we'd only get |EOVERFLOW| if the result is so large
+    // that it can't be represented by an |int| (in which case retrying would be
+    // futile), so Chromium's implementation is wrong.
+    return;
+  }
+  // |result| should be the number of characters we need, not including the
+  // terminating null. However, |vsnprintf()| always null-terminates!
+  size_t output_size = static_cast<size_t>(result);
+  // Check if the output fit into our stack buffer. This is "<" not "<=", since
+  // |vsnprintf()| will null-terminate.
+  if (output_size < kStackBufferSize) {
+    // It fit.
+    dest->append(stack_buf, static_cast<size_t>(result));
+    return;
+  }
+
+  // Since we have the required output size, we can just heap allocate that.
+  // (Add 1 because |vsnprintf()| will always null-terminate.)
+  size_t heap_buf_size = output_size + 1u;
+  std::unique_ptr<char[]> heap_buf(new char[heap_buf_size]);
+  result = vsnprintf(heap_buf.get(), heap_buf_size, format, ap);
+  if (result < 0 || static_cast<size_t>(result) > output_size) {
+    assert(false);
+    return;
+  }
+  assert(static_cast<size_t>(result) == output_size);
+  dest->append(heap_buf.get(), static_cast<size_t>(result));
+}
+
+}  // namespace
+
+std::string StringPrintf(const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  std::string rv;
+  StringVAppendf(&rv, format, ap);
+  va_end(ap);
+  return rv;
+}
+
+std::string StringVPrintf(const char* format, va_list ap) {
+  std::string rv;
+  StringVAppendf(&rv, format, ap);
+  return rv;
+}
+
+void StringAppendf(std::string* dest, const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  StringVAppendf(dest, format, ap);
+  va_end(ap);
+}
+
+void StringVAppendf(std::string* dest, const char* format, va_list ap) {
+  int old_errno = errno;
+  StringVAppendfHelper(dest, format, ap);
+  errno = old_errno;
+}
+
+}  // namespace fxl
diff --git a/shell/platform/fuchsia/dart_runner/string_printf.h b/shell/platform/fuchsia/dart_runner/string_printf.h
new file mode 100644
index 0000000..7ec78e9
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/string_printf.h
@@ -0,0 +1,37 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// |printf()|-like formatting functions that output/append to C++ strings.
+
+#ifndef FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_STRING_PRINTF_H_
+#define FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_STRING_PRINTF_H_
+
+#include <stdarg.h>
+
+#include <string>
+
+// #include "src/lib/fxl/fxl_export.h"
+// #include "src/lib/fxl/macros.h"
+
+namespace fxl {
+
+// Formats |printf()|-like input and returns it as an |std::string|.
+[[nodiscard, gnu::format(printf, 1, 2)]] std::string StringPrintf(
+    const char* format,
+    ...);
+
+// Formats |vprintf()|-like input and returns it as an |std::string|.
+[[nodiscard]] std::string StringVPrintf(const char* format, va_list ap);
+
+// Formats |printf()|-like input and appends it to |*dest|.
+[[gnu::format(printf, 2, 3)]] void StringAppendf(std::string* dest,
+                                                 const char* format,
+                                                 ...);
+
+// Formats |vprintf()|-like input and appends it to |*dest|.
+void StringVAppendf(std::string* dest, const char* format, va_list ap);
+
+}  // namespace fxl
+
+#endif  // FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_STRING_PRINTF_H_
diff --git a/shell/platform/fuchsia/dart_runner/suite.cc b/shell/platform/fuchsia/dart_runner/suite.cc
new file mode 100644
index 0000000..0645dbc
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/suite.cc
@@ -0,0 +1,297 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "suite.h"
+
+#include <fuchsia/component/runner/cpp/fidl.h>
+#include <fuchsia/io/cpp/fidl.h>
+#include <fuchsia/logger/cpp/fidl.h>
+#include <fuchsia/sys/cpp/fidl.h>
+#include <fuchsia/sys/test/cpp/fidl.h>
+#include <lib/async/cpp/executor.h>
+#include <lib/async/cpp/task.h>
+#include <lib/async/dispatcher.h>
+#include <lib/fidl/cpp/interface_handle.h>
+#include <lib/fidl/cpp/interface_ptr.h>
+#include <lib/fidl/cpp/interface_request.h>
+#include <lib/fpromise/barrier.h>
+#include <lib/fpromise/bridge.h>
+#include <lib/fpromise/promise.h>
+#include <lib/sys/cpp/service_directory.h>
+#include <lib/sys/cpp/termination_reason.h>
+#include <lib/sys/cpp/testing/enclosing_environment.h>
+// #include <lib/syslog/cpp/macros.h>
+#include <lib/zx/socket.h>
+#include <unistd.h>
+#include <zircon/processargs.h>
+#include <zircon/status.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <utility>
+#include <vector>
+
+#include "flutter/fml/logging.h"
+#include "string_printf.h"
+
+static const char kTestCaseName[] = "dart_test";
+// constexpr char kEnvPrefix[] = "test_env_";
+
+Suite::Suite(std::string legacy_url, async_dispatcher_t* dispatcher)
+    : legacy_url_(std::move(legacy_url)),
+      test_components_(std::make_shared<ComponentMap>()),
+      dispatcher_(dispatcher),
+      executor_(dispatcher) {
+  FML_LOG(INFO) << "SUITE CLASS CREATED";
+}
+
+Suite::~Suite() = default;
+
+Suite::CaseIterator::CaseIterator(
+    fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator> request,
+    async_dispatcher_t* dispatcher,
+    fit::function<void(CaseIterator*)> done_callback)
+    : binding_(this, std::move(request), dispatcher),
+      done_callback_(std::move(done_callback)) {}
+
+void Suite::CaseIterator::GetNext(GetNextCallback callback) {
+  if (get_next_call_count == 0) {
+    fuchsia::sys::test::Case test_case;
+    test_case.set_name(std::string(kTestCaseName));
+    test_case.set_enabled(true);
+    std::vector<fuchsia::sys::test::Case> cases;
+    cases.push_back(std::move(test_case));
+    callback(std::move(cases));
+    get_next_call_count++;
+
+  } else {
+    std::vector<fuchsia::sys::test::Case> cases;
+    callback(std::move(cases));
+    // this would be removed
+    done_callback_(this);
+  }
+}
+
+void Suite::GetTests(
+    fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator> iterator) {
+  FML_LOG(INFO) << "DART RUNNER HIT SUITE GETTESTS";
+  auto case_iterator = std::make_unique<CaseIterator>(
+      std::move(iterator), dispatcher_, [this](CaseIterator* case_iterator) {
+        RemoveCaseInterator(case_iterator);
+      });
+  case_iterators_.emplace(case_iterator.get(), std::move(case_iterator));
+}
+
+std::unique_ptr<Suite::CaseIterator> Suite::RemoveCaseInterator(
+    CaseIterator* case_iterator) {
+  auto it = case_iterators_.find(case_iterator);
+  std::unique_ptr<Suite::CaseIterator> case_iterator_ptr;
+  if (it != case_iterators_.end()) {
+    case_iterator_ptr = std::move(it->second);
+    case_iterators_.erase(it);
+  }
+  return case_iterator_ptr;
+}
+
+void Suite::Run(
+    std::vector<fuchsia::sys::test::Invocation> tests,
+    fuchsia::sys::test::RunOptions options,
+    fidl::InterfaceHandle<fuchsia::sys::test::RunListener> listener) {
+  FML_LOG(INFO) << "DART RUNNER HIT SUITE RUN";
+  auto listener_proxy = listener.Bind();
+  std::vector<std::string> args;
+  if (options.has_arguments()) {
+    args = std::move(*options.mutable_arguments());
+  }
+
+  if (options.has_parallel()) {
+    FML_LOG(WARNING) << "Ignoring 'parallel'. Pass test specific flags, eg: "
+                        "for rust test pass in "
+                        "--test-threads="
+                     << options.parallel();
+  }
+
+  fpromise::barrier barrier;
+  for (auto it = tests.begin(); it != tests.end(); it++) {
+    auto invocation = std::move(*it);
+    std::string test_case_name;
+    if (invocation.has_name()) {
+      test_case_name = invocation.name();
+    }
+    FML_LOG(INFO) << "DART RUNNER HIT SUITE RUN - TEST CASE: "
+                  << test_case_name;
+    zx::socket out, err, out_client, err_client;
+    auto status = zx::socket::create(0, &out, &out_client);
+    if (status != ZX_OK) {
+      FML_LOG(FATAL) << "cannot create socket: "
+                     << zx_status_get_string(status);
+    }
+    status = zx::socket::create(0, &err, &err_client);
+    if (status != ZX_OK) {
+      FML_LOG(FATAL) << "cannot create socket: "
+                     << zx_status_get_string(status);
+    }
+
+    fidl::InterfacePtr<fuchsia::sys::test::CaseListener> case_listener;
+
+    fuchsia::sys::test::StdHandles std_handles;
+    std_handles.set_err(std::move(err_client));
+    std_handles.set_out(std::move(out_client));
+
+    listener_proxy->OnTestCaseStarted(std::move(invocation),
+                                      std::move(std_handles),
+                                      case_listener.NewRequest());
+    // if (test_case_name != kTestCaseName) {
+    //   FML_LOG(INFO) << "TEST CASE: " << test_case_name;
+    //   FML_LOG(INFO) << "kTEST CASE: " << kTestCaseName;
+    //   std::string msg =
+    //       fxl::StringPrintf("Invalid test case, expected: %s, got: %s\n",
+    //                         kTestCaseName, test_case_name.c_str());
+    //   err.write(0, msg.c_str(), msg.length(), nullptr);
+    //   fuchsia::sys::test::Result result;
+    //   result.set_status(fuchsia::sys::test::Status::FAILED);
+    //   case_listener->Finished(std::move(result));
+    // } else {
+    //   auto promise = RunTest(std::move(out), std::move(err), args,
+    //                          std::move(case_listener))
+    //                      .wrap_with(barrier);
+    //   executor_.schedule_task(std::move(promise));
+    // }
+  }
+
+  auto sync_promise =
+      fpromise::make_promise([listener_proxy = std::move(listener_proxy)] {
+        FML_LOG(INFO) << "Sending OnFinished for legacy tests";
+        listener_proxy->OnFinished();
+      });
+  executor_.schedule_task(barrier.sync().and_then(std::move(sync_promise)));
+}
+
+// fpromise::promise<> Suite::RunTest(
+//     zx::socket out,
+//     zx::socket err,
+//     const std::vector<std::string>& arguments,
+//     fidl::InterfacePtr<fuchsia::sys::test::CaseListener> case_listener) {
+//   sys::testing::EnvironmentServices::ParentOverrides parent_overrides;
+//   parent_overrides.debug_data_service_ = std::make_shared<vfs::Service>(
+//       [namespace_services = test_component_svc_](
+//           zx::channel channel, async_dispatcher_t* /*unused*/) {
+//         // namespace_services->Connect(
+//         //     fuchsia::sys::test::DebugData::Name_,
+//         //     std::move(channel));
+//       });
+
+//   auto test_env_services =
+//       sys::testing::EnvironmentServices::CreateWithParentOverrides(
+//           parent_env_, std::move(parent_overrides));
+
+//   // Add these services to the environment if they are not injected and test
+//   // doesn't request sys version of them.
+//   std::set<std::string> services_to_add = {
+//       fuchsia::logger::LogSink::Name_, fuchsia::logger::Log::Name_,
+//       fuchsia::diagnostics::ArchiveAccessor::Name_};
+
+//   // Compute a common random suffix for the environments created to run the
+//   // test.
+//   uint32_t env_rand_suffix;
+//   zx_cprng_draw(&env_rand_suffix, sizeof(env_rand_suffix));
+
+//   for (const auto& service : services_to_add) {
+//     test_env_services->AddService<void>(
+//         [namespace_services = test_component_svc_,
+//          service](fidl::InterfaceRequest<void> request) {
+//           namespace_services->Connect(service, request.TakeChannel());
+//         },
+//         service);
+//   }
+
+//   fuchsia::sys::EnvironmentOptions env_opt;
+//   // std::string env_label = std::format("%s%08x", kEnvPrefix,
+//   // env_rand_suffix);
+//   std::string env_label = kEnvPrefix;
+//   env_opt.delete_storage_on_death = true;
+
+//   auto enclosing_env = sys::testing::EnclosingEnvironment::Create(
+//       env_label, parent_env_, std::move(test_env_services), env_opt);
+
+//   auto launcher = enclosing_env->launcher_ptr();
+
+//   auto info =
+//       fuchsia::sys::LaunchInfo{.url = legacy_url_, .arguments = arguments};
+//   auto out_collector = AddOutputFileDescriptor(STDOUT_FILENO, std::move(out),
+//                                                dispatcher_, &info.out);
+//   auto err_collector = AddOutputFileDescriptor(STDERR_FILENO, std::move(err),
+//                                                dispatcher_, &info.err);
+
+//   auto svc =
+//   sys::ServiceDirectory::CreateWithRequest(&info.directory_request);
+
+//   // fuchsia::component::runner::ComponentControllerPtr contoller;
+//   fuchsia::sys::ComponentControllerPtr contoller;
+//   launcher->CreateComponent(std::move(info), contoller.NewRequest());
+//   auto test_component = std::make_unique<run::Component>(
+//       std::move(out_collector), std::move(err_collector),
+//       std::move(contoller), std::move(svc));
+//   fpromise::bridge<> bridge;
+//   test_component->controller().events().OnTerminated =
+//       [this, url = legacy_url_, enclosing_env = std::move(enclosing_env),
+//        completer = std::move(bridge.completer),
+//        case_listener = std::move(case_listener),
+//        this_ptr = test_component.get()](
+//           int64_t return_code,
+//           fuchsia::sys::TerminationReason termination_reason) mutable {
+//         if (termination_reason != fuchsia::sys::TerminationReason::EXITED) {
+//           FML_LOG(WARNING) << "Test " << url << " failed with "
+//                            << sys::HumanReadableTerminationReason(
+//                                   termination_reason);
+//         }
+
+//         FML_LOG(INFO) << "Legacy test exited with return code " <<
+//         return_code
+//                       << ", collecting stdout";
+
+//         auto status = return_code == 0 ? fuchsia::sys::test::Status::PASSED
+//                                        : fuchsia::sys::test::Status::FAILED;
+
+//         auto output_promise = this_ptr->SignalWhenOutputCollected();
+
+//         FML_LOG(INFO) << "Killing environment for legacy test";
+//         fpromise::bridge<> bridge;
+//         enclosing_env->Kill(bridge.completer.bind());
+//         auto promise = bridge.consumer.promise().and_then(
+//             [enclosing_env = std::move(enclosing_env),
+//              case_listener = std::move(case_listener), status = status,
+//              completer = std::move(completer)]() mutable {
+//               fuchsia::sys::test::Result result;
+//               result.set_status(status);
+//               FML_LOG(INFO) << "Sending finished event for legacy tests";
+//               case_listener->Finished(std::move(result));
+//               completer.complete_ok();
+//             });
+//         this->executor_.schedule_task(output_promise.and_then([this,
+//                                                                this_ptr]() {
+//           FML_LOG(INFO) << "Done collecting standard output for legacy tests
+//           "; RemoveComponent(this_ptr);
+//         }));
+//         this->executor_.schedule_task(std::move(promise));
+//       };
+
+//   test_components_->emplace(test_component.get(), std::move(test_component));
+
+//   return bridge.consumer.promise();
+// }
+
+// std::unique_ptr<run::Component> Suite::RemoveComponent(run::Component* ptr) {
+//   if (!test_components_) {
+//     return nullptr;
+//   }
+//   auto it = test_components_->find(ptr);
+//   std::unique_ptr<run::Component> test_component_ptr;
+//   if (it != test_components_->end()) {
+//     test_component_ptr = std::move(it->second);
+//     test_components_->erase(it);
+//   }
+//   return test_component_ptr;
+// }
diff --git a/shell/platform/fuchsia/dart_runner/suite.h b/shell/platform/fuchsia/dart_runner/suite.h
new file mode 100644
index 0000000..30052e0
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/suite.h
@@ -0,0 +1,84 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_SUITE_H_
+#define FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_SUITE_H_
+
+#include <fuchsia/sys/cpp/fidl.h>
+#include <fuchsia/sys/test/cpp/fidl.h>
+#include <lib/async/cpp/executor.h>
+#include <lib/fidl/cpp/binding.h>
+#include <lib/fidl/cpp/binding_set.h>
+#include <lib/fidl/cpp/interface_request.h>
+#include <lib/fpromise/promise.h>
+#include <lib/sys/cpp/service_directory.h>
+
+#include <map>
+#include <memory>
+#include <vector>
+
+/// Implement and expose Suite protocol on behalf of wrapped legacy dart test
+/// component.
+class Suite final : public fuchsia::sys::test::Suite {
+  using ComponentMap =
+      std::map<run::Component*, std::unique_ptr<run::Component>>;
+
+ public:
+  Suite(std::string legacy_url, std::unique_ptr<async::Loop> loop);
+  ~Suite() override;
+
+  void GetTests(fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator>
+                    iterator) override;
+
+  void Run(
+      std::vector<fuchsia::sys::test::Invocation> tests,
+      fuchsia::sys::test::RunOptions options,
+      fidl::InterfaceHandle<fuchsia::sys::test::RunListener> listener) override;
+
+  fidl::InterfaceRequestHandler<fuchsia::sys::test::Suite> GetHandler() {
+    return bindings_.GetHandler(this, dispatcher_);
+  }
+
+  void AddBinding(zx::channel request) {
+    bindings_.AddBinding(
+        this,
+        fidl::InterfaceRequest<fuchsia::sys::test::Suite>(std::move(request)),
+        dispatcher_);
+  }
+
+ private:
+  fpromise::promise<> RunTest(
+      zx::socket out,
+      zx::socket err,
+      const std::vector<std::string>& arguments,
+      fidl::InterfacePtr<fuchsia::sys::test::CaseListener> case_listener);
+
+  class CaseIterator final : public fuchsia::sys::test::CaseIterator {
+   public:
+    CaseIterator(
+        fidl::InterfaceRequest<fuchsia::sys::test::CaseIterator> request,
+        async_dispatcher_t* dispatcher,
+        fit::function<void(CaseIterator*)> done_callback);
+
+    void GetNext(GetNextCallback callback) override;
+
+   private:
+    int get_next_call_count = 0;
+    fidl::Binding<fuchsia::sys::test::CaseIterator> binding_;
+    fit::function<void(CaseIterator*)> done_callback_;
+  };
+
+  // const std::shared_ptr<sys::ServiceDirectory> test_component_svc_;
+  const std::string legacy_url_;
+  std::shared_ptr<ComponentMap> test_components_;
+  std::map<CaseIterator*, std::unique_ptr<CaseIterator>> case_iterators_;
+  async_dispatcher_t* dispatcher_;
+  fidl::BindingSet<fuchsia::sys::test::Suite> bindings_;
+  async::Executor executor_;
+
+  std::unique_ptr<CaseIterator> RemoveCaseInterator(CaseIterator*);
+  std::unique_ptr<run::Component> RemoveComponent(run::Component* ptr);
+};
+
+#endif  // FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_SUITE_H_
diff --git a/shell/platform/fuchsia/dart_runner/test_component.cc b/shell/platform/fuchsia/dart_runner/test_component.cc
new file mode 100644
index 0000000..0a5660d
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/test_component.cc
@@ -0,0 +1,36 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "test_component.h"
+
+#include <lib/fidl/cpp/interface_request.h>
+#include <lib/sys/cpp/component_context.h>
+
+#include "flutter/fml/logging.h"
+#include "suite.h"
+
+TestComponent::TestComponent(TestComponentArgs args, DoneCallback done_callback)
+    : dispatcher_(args.dispatcher),
+      binding_(this, std::move(args.request), args.dispatcher),
+      done_callback_(std::move(done_callback)) {
+  suite_ = std::make_unique<Suite>(std::move(args.parent_env_svc),
+                                   std::move(args.parent_env),
+                                   std::move(args.test_component_svc),
+                                   std::move(args.legacy_url), dispatcher_);
+  suite_context_ = sys::ComponentContext::Create();
+  suite_context_->outgoing()->AddPublicService(suite_->GetHandler());
+  suite_context_->outgoing()->Serve(std::move(args.outgoing_dir), dispatcher_);
+}
+
+TestComponent::~TestComponent() = default;
+
+void TestComponent::Stop() {
+  Kill();
+}
+
+void TestComponent::Kill() {
+  binding_.Close(ZX_OK);
+  // this object would be killed after this call
+  done_callback_(this);
+}
diff --git a/shell/platform/fuchsia/dart_runner/test_component.h b/shell/platform/fuchsia/dart_runner/test_component.h
new file mode 100644
index 0000000..cf9c0a5
--- /dev/null
+++ b/shell/platform/fuchsia/dart_runner/test_component.h
@@ -0,0 +1,58 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_TEST_COMPONENT_H_
+#define FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_TEST_COMPONENT_H_
+
+#include <fuchsia/component/runner/cpp/fidl.h>
+#include <fuchsia/sys/cpp/fidl.h>
+#include <lib/fidl/cpp/binding.h>
+#include <lib/fidl/cpp/interface_request.h>
+#include <lib/sys/cpp/component_context.h>
+#include <lib/sys/cpp/service_directory.h>
+
+#include <memory>
+
+#include "suite.h"
+
+using ComponentController = fuchsia::component::runner::ComponentController;
+
+struct TestComponentArgs {
+  std::string legacy_url;
+  zx::channel outgoing_dir;
+  fuchsia::sys::EnvironmentPtr parent_env;
+  std::shared_ptr<sys::ServiceDirectory> parent_env_svc;
+  std::shared_ptr<sys::ServiceDirectory> test_component_svc;
+
+  fidl::InterfaceRequest<ComponentController> request;
+  async_dispatcher_t* dispatcher;
+};
+
+/// Implements component controller on behalf of the runner and also
+/// stores/controls running test component.
+class TestComponent final : public ComponentController {
+  using DoneCallback = fit::function<void(TestComponent*)>;
+
+ public:
+  explicit TestComponent(TestComponentArgs args, DoneCallback done_callback);
+  ~TestComponent() override;
+
+  void Stop() override;
+
+  void Kill() override;
+
+ private:
+  async_dispatcher_t* dispatcher_;
+  fidl::Binding<ComponentController> binding_;
+
+  /// For safe keeping while the component is running.
+  std::unique_ptr<Suite> suite_;
+
+  /// Exposes suite protocol on behalf of test component.
+  std::unique_ptr<sys::ComponentContext> suite_context_;
+
+  DoneCallback done_callback_;
+};
+
+#endif  // FLUTTER_SHELL_PLATFORM_FUCHSIA_DART_RUNNER_TEST_COMPONENT_H_
diff --git a/shell/platform/fuchsia/flutter/component_v2.cc b/shell/platform/fuchsia/flutter/component_v2.cc
index b068369..532da61 100644
--- a/shell/platform/fuchsia/flutter/component_v2.cc
+++ b/shell/platform/fuchsia/flutter/component_v2.cc
@@ -116,6 +116,16 @@
       result.assets_path = "pkg/" + entry.value->str();
     } else if (entry.key.compare(kArgsKey) == 0 && entry.value != nullptr) {
       ParseArgs(entry.value->str_vec(), &result);
+      FML_LOG(INFO) << "FLUTTER RUNNER PROGRAM ARGS: ";
+      std::string s;
+      for (const auto& piece : entry.value->str_vec())
+        s += piece;
+      FML_LOG(INFO) << s;
+
+      std::string d;
+      for (const auto& piece : result.expose_dirs)
+        d += piece;
+      FML_LOG(INFO) << d;
     }
   }
 
diff --git a/shell/platform/fuchsia/flutter/runner.cc b/shell/platform/fuchsia/flutter/runner.cc
index 6c59e6c..377ec61 100644
--- a/shell/platform/fuchsia/flutter/runner.cc
+++ b/shell/platform/fuchsia/flutter/runner.cc
@@ -308,6 +308,7 @@
   // change, so we make a copy to pass to TRACE_DURATION.
   // TODO(PT-169): Remove this copy when TRACE_DURATION reads string arguments
   // eagerly.
+  FML_LOG(INFO) << "RESOLVED URL V2: " << start_info.resolved_url();
   const std::string url_copy = start_info.resolved_url();
   TRACE_EVENT1("flutter", "Start", "url", url_copy.c_str());
 
diff --git a/shell/platform/fuchsia/runtime/dart/utils/program_metadata.h b/shell/platform/fuchsia/runtime/dart/utils/program_metadata.h
new file mode 100644
index 0000000..afb2a50
--- /dev/null
+++ b/shell/platform/fuchsia/runtime/dart/utils/program_metadata.h
@@ -0,0 +1,38 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_FUCHSIA_RUNTIME_DART_UTILS_PROGRAM_METADATA_H_
+#define FLUTTER_SHELL_PLATFORM_FUCHSIA_RUNTIME_DART_UTILS_PROGRAM_METADATA_H_
+
+#include <optional>
+#include <string>
+
+namespace dart_runner {
+
+/// The metadata that can be passed by a Flutter component via
+/// the `program` field.
+struct ProgramMetadata {
+  /// The path where data for the Flutter component should
+  /// be stored.
+  std::string data_path = "";
+
+  bool is_test = false;
+
+  /// The path where assets for the Flutter component should
+  /// be stored.
+  ///
+  /// TODO(fxb/89246): No components appear to be using this field. We
+  /// may be able to get rid of this.
+  std::string assets_path = "";
+
+  /// The preferred heap size for the Flutter component in megabytes.
+  std::optional<int64_t> old_gen_heap_size = std::nullopt;
+
+  /// A list of additional directories that we will expose in out/
+  std::vector<std::string> expose_dirs;
+};
+
+}  // namespace dart_runner
+
+#endif  // FLUTTER_SHELL_PLATFORM_FUCHSIA_RUNTIME_DART_UTILS_PROGRAM_METADATA_H_
diff --git a/tools/gn b/tools/gn
index abf2836..8b07b21 100755
--- a/tools/gn
+++ b/tools/gn
@@ -414,7 +414,7 @@
         gn_args['fuchsia_target_api_level'] = int(f.read().strip())
 
     # Impeller flags.
-    gn_args['impeller_enable_playground'] = args.enable_impeller_playground
+    # gn_args['impeller_enable_playground'] = args.enable_impeller_playground
 
     return gn_args
 
@@ -528,8 +528,8 @@
   parser.add_argument('--fuchsia-target-api-level', dest='fuchsia_target_api_level')
 
   # Impeller flags.
-  parser.add_argument('--enable-impeller-playground', default=False, action='store_true',
-                      help='Whether impeller unit tests run in playground mode')
+  # parser.add_argument('--enable-impeller-playground', default=False, action='store_true',
+  #                     help='Whether impeller unit tests run in playground mode')
 
   # Sanitizers.
   parser.add_argument('--asan', default=False, action='store_true')