@@ -1482,21 +1482,6 @@ void WebGPUGraph::copy_inputs(const std::vector<InputData>& inputs) {
       continue;
     }
 
-    // Require an explicit fp32 host dtype, not merely "not int64": inferring
-    // the narrow from the 2:1 byte ratio alone would silently reinterpret a
-    // same-sized non-fp32 host buffer (e.g. a stale int32) as fp32.
-    if (in.host_is_fp32 && buffer_is_fp16 && in.nbytes == live_nbytes * 2) {
-      const size_t numel = live_nbytes / sizeof(uint16_t);
-      const float* src = static_cast<const float*>(in.data);
-      std::vector<executorch::runtime::etensor::Half> narrowed(numel);
-      for (size_t e = 0; e < numel; e++) {
-        narrowed[e] = executorch::runtime::etensor::Half(src[e]);
-      }
-      wgpuQueueWriteBuffer(
-          queue_, tensor.buffer, 0, narrowed.data(), live_nbytes);
-      continue;
-    }
-
     throw std::runtime_error(
         "WebGPU: unsupported input copy for input " + std::to_string(i) +
         " (host " + std::to_string(in.nbytes) + " bytes" +
@@ -1533,17 +1518,10 @@ constexpr uint32_t kRouteK16CausalBound = 1u << 11;
 constexpr uint32_t kRouteBicolSubgroup = 1u << 12;
 constexpr uint32_t kRouteQwen3Q16K16 = 1u << 13;
 constexpr uint32_t kRouteQwen3Q32K16 = 1u << 14;
-#endif // WGPU_BACKEND_ENABLE_PROFILING
-
-// Bench gate: compiled out unless WGPU_BACKEND_ENABLE_PROFILING; then the
-// WEBGPU_TIMESTAMP_QUERY env var enables per-pass GPU timestamp queries.
 bool should_timestamp_query() {
-#ifdef WGPU_BACKEND_ENABLE_PROFILING
   return std::getenv("WEBGPU_TIMESTAMP_QUERY") != nullptr;
-#else
-  return false;
-#endif
 }
+#endif // WGPU_BACKEND_ENABLE_PROFILING
 } // namespace
 
 #ifdef WGPU_BACKEND_ENABLE_PROFILING
 
@@ -203,98 +203,6 @@ void add_bool_to_float_op(WebGPUGraph& graph, int in_id, int out_id) {
       });
 }
 
-// Decode byte-packed bool storage into numeric fp32 values.
-void add_bool_to_float_op(WebGPUGraph& graph, int in_id, int out_id) {
-  WGPUDevice device = graph.device();
-  const auto& in_tensor = graph.get_tensor(in_id);
-  const auto& out_tensor = graph.get_tensor(out_id);
-  if (in_tensor.buffer == nullptr || out_tensor.buffer == nullptr) {
-    throw std::runtime_error("to_copy_bool_to_float: null buffer binding");
-  }
-  if (!in_tensor.is_bool || in_tensor.elem_size != 1 || out_tensor.is_int ||
-      out_tensor.elem_size != sizeof(float) ||
-      out_tensor.nbytes % sizeof(float) != 0 ||
-      out_tensor.nbytes / sizeof(float) != in_tensor.nbytes) {
-    throw std::runtime_error("to_copy_bool_to_float: dtype/numel mismatch");
-  }
-  if (in_tensor.nbytes == 0u ||
-      in_tensor.nbytes > std::numeric_limits<uint32_t>::max()) {
-    throw std::runtime_error(
-        "to_copy_bool_to_float: numel must be nonzero and fit u32");
-  }
-
-  const uint32_t num_elements = static_cast<uint32_t>(in_tensor.nbytes);
-  const uint64_t input_bind_size_u64 =
-      (static_cast<uint64_t>(in_tensor.nbytes) + 3u) & ~uint64_t(3);
-  if (input_bind_size_u64 > std::numeric_limits<size_t>::max()) {
-    throw std::runtime_error(
-        "to_copy_bool_to_float: input binding size overflows");
-  }
-  const size_t input_bind_size = static_cast<size_t>(input_bind_size_u64);
-
-  const uint32_t wg_size =
-      utils::clamp_workgroup_size(device, kToCopyBoolToFloatWorkgroupSizeX);
-  const uint32_t workgroup_count = utils::compute_1d_workgroup_count(
-      device, num_elements, wg_size, "to_copy_bool_to_float");
-
-  WGPUConstantEntry wg_size_constant = {};
-  wg_size_constant.key = {"wg_size", WGPU_STRLEN};
-  wg_size_constant.value = static_cast<double>(wg_size);
-
-  ConvertParams params = {};
-  params.num_elements = num_elements;
-  WGPUBuffer uniform_buffer =
-      utils::make_uniform(device, &params, sizeof(ConvertParams));
-  graph.add_uniform_buffer_bytes(sizeof(ConvertParams));
-
-  utils::ComputePipelineBundle bundle = utils::make_compute_pipeline(
-      device,
-      kToCopyBoolToFloatWGSL,
-      {
-          {0,
-           WGPUBufferBindingType_ReadOnlyStorage,
-           in_tensor.buffer,
-           input_bind_size},
-          {1,
-           WGPUBufferBindingType_Storage,
-           out_tensor.buffer,
-           out_tensor.nbytes},
-          {2,
-           WGPUBufferBindingType_Uniform,
-           uniform_buffer,
-           sizeof(ConvertParams)},
-      },
-      &wg_size_constant,
-      1);
-
-  const size_t dispatch_idx =
-      graph.add_dispatch({bundle.pipeline, bundle.bind_group, workgroup_count});
-
-  WGPUBuffer params_buf = uniform_buffer;
-  graph.add_tensor_resize_hook(
-      in_id,
-      [in_id, out_id, wg_size, dispatch_idx, params_buf](WebGPUGraph& g) {
-        const auto& dims = g.cur_dims(in_id);
-        const uint64_t numel = utils::numel_of(dims);
-        if (numel == 0u || numel > std::numeric_limits<uint32_t>::max()) {
-          throw std::runtime_error(
-              "to_copy_bool_to_float(resize): invalid numel");
-        }
-        g.set_cur_dims(out_id, dims);
-        ConvertParams p = {};
-        p.num_elements = static_cast<uint32_t>(numel);
-        wgpuQueueWriteBuffer(g.queue(), params_buf, 0, &p, sizeof(p));
-        g.dispatch_at(dispatch_idx).workgroup_count_x =
-            utils::compute_1d_workgroup_count(
-                g.device(),
-                static_cast<uint32_t>(numel),
-                wg_size,
-                "to_copy_bool_to_float(resize)");
-      });
-
-  graph.own_uniform_buffer(uniform_buffer);
-}
-
 void to_copy_impl(WebGPUGraph& graph, const std::vector<int>& args) {
   // aten._to_copy.default args: [self, ...kwargs, out]; out = last value id.
   add_to_copy_node(graph, args.at(0), args.at(args.size() - 1));
 
@@ -239,6 +239,67 @@ void build_conv1d_route_graph(
   graph.build(fbb.GetBufferPointer(), nullptr, 0, nullptr);
 }
 
+TEST(WebGPUShaderRegistry, FindsKnownShaderAndRejectsUnknownName) {
+  const WebGPUShaderInfo& sigmoid = get_webgpu_shader_info("sigmoid");
+  EXPECT_EQ(sigmoid.name, "sigmoid");
+  EXPECT_NE(sigmoid.source, nullptr);
+  EXPECT_GT(sigmoid.workgroup_size_x, 0u);
+  EXPECT_THROW(
+      get_webgpu_shader_info("not_a_registered_shader"), std::runtime_error);
+}
+
+TEST(WebGPUQ4RouteSignal, PreservesStaticAndRecordsBothDynamicSignals) {
+  WebGPUGraph static_graph;
+  static_graph.set_device(g_device);
+  build_q4_route_graph(static_graph, Q4RouteSignal::Static);
+  const auto static_dispatches = q4_dispatches(static_graph);
+  ASSERT_EQ(static_dispatches.size(), 1);
+  EXPECT_EQ(static_graph.num_dispatches(), 1);
+  EXPECT_NE(static_dispatches[0]->pipeline, nullptr);
+  EXPECT_NE(static_dispatches[0]->bind_group, nullptr);
+  EXPECT_FALSE(static_graph.has_dynamic_shapes());
+  EXPECT_FALSE(static_graph.config().record_q4gsw_decode_route);
+
+  WebGPUGraph legacy_graph;
+  legacy_graph.set_device(g_device);
+  build_q4_route_graph(legacy_graph, Q4RouteSignal::LegacyGraphMarker);
+  EXPECT_TRUE(legacy_graph.has_dynamic_shapes());
+  EXPECT_FALSE(legacy_graph.config().record_q4gsw_decode_route);
+  EXPECT_EQ(legacy_graph.num_dispatches(), 3);
+  expect_dual_q4_topology(legacy_graph);
+
+  WebGPUGraph explicit_graph;
+  explicit_graph.set_device(g_device);
+  build_q4_route_graph(explicit_graph, Q4RouteSignal::ExplicitOption);
+  EXPECT_FALSE(explicit_graph.has_dynamic_shapes());
+  EXPECT_TRUE(explicit_graph.config().record_q4gsw_decode_route);
+  EXPECT_EQ(explicit_graph.num_dispatches(), 2);
+  expect_dual_q4_topology(explicit_graph);
+}
+
+TEST(WebGPUConv1dRoute, SelectsPointwiseGeneralAndSingleChannelDepthwise) {
+  const Conv1dRouteCase cases[] = {
+      {"pointwise", {1, 4, 8}, {6, 4, 1}, {1, 6, 8}, 1, 0, 1, 1, "conv1d_pw"},
+      {"general", {1, 4, 10}, {6, 4, 3}, {1, 6, 4}, 2, 0, 1, 1, "conv1d"},
+      {"single-channel depthwise",
+       {1, 1, 8},
+       {1, 1, 3},
+       {1, 1, 8},
+       1,
+       1,
+       1,
+       1,
+       "conv1d_dw"},
+  };
+  for (const Conv1dRouteCase& test_case : cases) {
+    SCOPED_TRACE(test_case.name);
+    WebGPUGraph graph;
+    build_conv1d_route_graph(graph, test_case);
+    ASSERT_EQ(graph.num_dispatches(), 1);
+    EXPECT_EQ(graph.dispatch_at(0).kernel_name, test_case.expected_kernel);
+  }
+}
+
 TEST(WebGPUComputeDispatch, PipelineKeyCanonicalizesConstants) {
   WebGPUComputeDispatchDescriptor first;
   first.shader_name = "sigmoid";