Fix some CI (windows + nasm, core-macro error) (#2676)

* Moves index.html creation until after wasm creation so the webserver doesn't prematurely serve the page
* sets up nasm for windows builds (to be superseded by Remove Dioxus CLI NASM dependency #2666 #2682)
* puts magnanis-cli-support in a blocking task to prevent threadlocking during sequential builds
* changes order of client/server builds such that the client is built before the server so the webserver doesn't prematurely serve invalid client code
* declobbers "serve" such that each project gets a different dir in the target folder
* uses nest_service instead of fallback so the router doesn't respond with fallback codes
* reincorporates doge's fix from Fix hot-reloading on Windows #2544

packages/cli/src/builder/cargo.rs

@@ -150,11 +150,17 @@ impl BuildRequest {
         // Start Manganis linker intercept.
         let linker_args = vec![format!("{}", self.dioxus_crate.out_dir().display())];
 
-        manganis_cli_support::start_linker_intercept(
-            &LinkCommand::command_name(),
-            cargo_args,
-            Some(linker_args),
-        )?;
+        // Don't block the main thread - magnanis should not be running its own std process but it's
+        // fine to wrap it here at the top
+        tokio::task::spawn_blocking(move || {
+            manganis_cli_support::start_linker_intercept(
+                &LinkCommand::command_name(),
+                cargo_args,
+                Some(linker_args),
+            )
+        })
+        .await
+        .unwrap()?;
 
         let file_name = self.dioxus_crate.executable_name();
 

packages/cli/src/builder/fullstack.rs

@@ -44,8 +44,8 @@ impl BuildRequest {
         serve: bool,
     ) -> Vec<Self> {
         vec![
-            Self::new_server(serve, &config, &build_arguments),
             Self::new_client(serve, &config, &build_arguments),
+            Self::new_server(serve, &config, &build_arguments),
         ]
     }
 

packages/cli/src/builder/web.rs

@@ -120,11 +120,6 @@ impl BuildRequest {
             update: UpdateStage::Start,
         });
 
-        // Create the index.html file
-        let html = self.prepare_html(assets)?;
-        let html_path = self.dioxus_crate.out_dir().join("index.html");
-        std::fs::write(&html_path, html)?;
-
         // Find the wasm file
         let output_location = build_result.executable.clone();
         let input_path = output_location.with_extension("wasm");
@@ -177,6 +172,14 @@ impl BuildRequest {
             .await
             .unwrap()?;
 
+        // Create the index.html file
+        // Note that we do this last since the webserver will attempt to serve the index.html file
+        // If we do this too early, the wasm won't be ready but the index.html will be served, leading
+        // to test failures and broken pages.
+        let html = self.prepare_html(assets)?;
+        let html_path = self.dioxus_crate.out_dir().join("index.html");
+        std::fs::write(html_path, html)?;
+
         Ok(())
     }
 }

packages/cli/src/cli/serve.rs

@@ -68,6 +68,16 @@ impl Serve {
         // Resolve the build arguments
         self.build_arguments.resolve(crate_config)?;
 
+        // Since this is a serve, adjust the outdir to be target/dx-dist/<crate name>
+        let mut dist_dir = crate_config.workspace_dir().join("target").join("dx-dist");
+
+        if crate_config.target.is_example() {
+            dist_dir = dist_dir.join("examples");
+        }
+
+        crate_config.dioxus_config.application.out_dir =
+            dist_dir.join(crate_config.executable_name());
+
         Ok(())
     }
 

packages/cli/src/serve/mod.rs

@@ -45,16 +45,15 @@ use watcher::*;
 /// - I want us to be able to detect a `server_fn` in the project and then upgrade from a static server
 ///   to a dynamic one on the fly.
 pub async fn serve_all(serve: Serve, dioxus_crate: DioxusCrate) -> Result<()> {
-    let mut server = Server::start(&serve, &dioxus_crate);
-    let mut watcher = Watcher::start(&dioxus_crate);
-    let mut screen = Output::start(&serve)
-        .await
-        .expect("Failed to open terminal logger");
     let mut builder = Builder::new(&dioxus_crate, &serve);
 
     // Start the first build
     builder.build();
 
+    let mut server = Server::start(&serve, &dioxus_crate);
+    let mut watcher = Watcher::start(&dioxus_crate);
+    let mut screen = Output::start(&serve).expect("Failed to open terminal logger");
+
     loop {
         // Make sure we don't hog the CPU: these loop { select! {} } blocks can starve the executor
         yield_now().await;

packages/cli/src/serve/output.rs

@@ -86,7 +86,7 @@ enum Tab {
 type TerminalBackend = Terminal<CrosstermBackend<io::Stdout>>;
 
 impl Output {
-    pub async fn start(cfg: &Serve) -> io::Result<Self> {
+    pub fn start(cfg: &Serve) -> io::Result<Self> {
         let interactive = std::io::stdout().is_tty() && cfg.interactive.unwrap_or(true);
 
         let mut events = None;

packages/cli/src/serve/server.rs

@@ -328,13 +328,13 @@ fn setup_router(
     match platform {
         Platform::Web => {
             // Route file service to output the .wasm and assets if this is a web build
-            router = router.fallback(build_serve_dir(serve, config));
+            router = router.nest_service("/", build_serve_dir(serve, config));
         }
         Platform::Fullstack | Platform::StaticGeneration => {
             // For fullstack and static generation, forward all requests to the server
             let address = fullstack_address.unwrap();
 
-            router = router.fallback(super::proxy::proxy_to(
+            router = router.nest_service("/",super::proxy::proxy_to(
                 format!("http://{address}").parse().unwrap(),
                 true,
                 |error| {