Binary patching rust hot-reloading, sub-second rebuilds, independent server/client hot-reload (#3797)

Enable runtime rust hot patching.

* roll back wry to 0.45

* cleanup rustc

* wip

* wip: fix client/server

* get the subsecond cli thing working again

* back to list of builds but with accessors

* migrate some methods to workspace, clean up impl a bit

* pass mode through build context

* use a build context, similar to cargo/rustc

* merge BuildUpdate and HandleUpdate into BuilderUpdate

* Move more resolution of args into runner

* migrate some methods to runner

* hoist out fullstack

* fix build request resolver

* yay request is cleaned up

* fixup resolution a bit

* spawn off the build!

* re-wire android autodetection

* re-wire android autodetection

* wire back up a few more things

* re-wire tooling verification

* I think it's mostly in the right condition for regular app

* add depinfo parser

* yay okay works with regular apps again

* full rebuilds are back

* rewire file wtcher

* wire patch!

* yayyyyyy patching works and is really fast

* yay android works

* clean up stdout piping

* yayyy memap on android so we don't need root

* create a static wasm jump table

* wip: global offset table for wasm

* wip... thinking about making the patches relocatable

* wip: customized relocation

* YESSSSSS RELOCATABLE WASM

* clean up impl a bit

* lil bit more cleanup

* lil bit more

* lil bit more cleanup

* lil bit more cleanup, support 32 bit platforms

* sick, wasm is completely pic

* hmmmm not quite working yet

* woooo, patches loading from rust+wasm

* integrated into the cli 😎

* condense a bit

* cleaned up request a bit

* bust fingerprints

* Make the file diffing logic a bit more sensible

* still working through a few issues, server launches but is acting weird

* fix merge conflict

* more merge issues

* remove stuff we don't want anymore

* revert name change

* wip: server not working anymore :(

* split apart "dioxus fullstack" into "dioxus server" and "dioxus web"

* fixup a few more compile errors

* grrr opening server

* simultaneous frontend and backend patching

* use rustc wrapper

* wip: passing assets to jumptable

* migrate project-like examples

* patchy  patchy server fns!

* rollback some random changes

* unwind the js files

* rollback hash

* no need for patch

* more cleanups

* lil bit more cleanup, remove some old cruft

* allow patching when wasm webpage is closed

* tiny bit more robust

* lil bit of clean up

* clean up ws code

* bit more clean ups

* condense

* undo file moves

* move back other project

* move other project

* migrate out harness and janky CLI

* fix compile

* anonymize some files, heavily document others

* lots more documentation, for posterity!

* ton more docs

* clean up the cli a bit more

* more ws cleanup

* more cleanup

* migrate build id to cli-config

* add command file handling

* random small cleanups

* wip....

* wip....

* fix: use workspace for krate discovery

* fix panic logging on serve by placing it *after* the logs

* reorder logging to be sensible on success

* bring back swc

* ws cruft

* small patches to relocs in loader

* bump krates

* hoist main funcs into the ifunc table, fixing wasm

* fix tui output for long lines

* add more linker logging

* wow, incredible, we build fat binaries, holy heckkkkk

* fix args for frontend/backend

* small cleanups

* properly send along build IDs to clients

* fix workspace compiles

* clean up jump table work a bit

* clean up logging a bit

* open existing

* fixup some commands

* open existing browser integration

* wire up the new dx serve client/server syntax

* fixup `dx run` command

* bring back some old functionality

* fix serverfn feature sets

* remove toast animation and simplify its code a bit

* less intrusive toast

* dont change build status when patching on web

* add proper cache busting to vcomponent

* clean up the patch file a bit

* more lints/checks cleaned up

* go back to TargetArgs but a BuildTargets resolved struct

* clean up more nits

* use an atomicptr for jumptable

* fix interaction with initial web load + suspense

* don't run asset system on wasm/bindgen js in dev

* reduce blast radius of PR

* use profile to determine if we're in release

* cleanup prod html template

* cleanup profiles

* fix feature resolution of fullstack

* if fullstack is explicitly false, don't use it

* light cleanups

* drop carg config2

* pass along linker args properly

* make workspace examples compile with dx again

* fewer unwraps and better error loggign

* bit more error handlign

* small cleanup

* drive-by cleanups

* use queries instead of initialize for aslr stuff

* fix hotpatch with higher opt level

* fix aslr bug from multiple clients

* fix merge conflict

* fix typos

* clippy

* fix miscompile

* fix doctest

* properly rollback wry to 0.45

* fix markdown path issues, other test issues

* fix test in router

* fix release mode test

* fix some more tests, clean up a few more items

* use fnptr instead of typeid

* clean up memozation via subsecond in core

* use "main" as sentinel

* fix imports and re-exports

* get off __rust_alloc for aslr offset detection

* wip

* wip... fixing unoptimized web

* hmmmm mmmm

* close,ish, still missing the wasmbindgen dynaimc imports

* aha! full wasm works now

- disable externref when compilng patch modules
- manually link wasm instrinsics
- displace the __wbindgen_placeholder__ table with the synthesized wbg imports

what an awful pain.

There might be a few items missing, so will test against the docsite shortly

* remove failing test

* hmmmm things aren't perfect

* from what I can tell, relocatable wasm just doesn't work with wasm-bindgen

sad

https://github.com/rustwasm/wasm-bindgen/issues/1420

* AI IS LITERALLY THE WORST

* preserve wasm snippets across compiles

* IT HOTPATCHES THE DOCSITE, WE ARE LIVING IN THE FUTURE

* remove the macos cfg-out

* fix: need to allocate 1 more page

* fix url issue

* properly span props

* properly fill in extra symbols

* light cleanups and good docs

* delete cruft, better docs

* More cleanups and simplifications

* clippy, typos

* remove harnesses

* wasm-bindgen error logging

* clean up deps

* remove cruft

* proper priv/pub

* use ifuncs for all env imports

* cruft

* use par_iter, better output

* implement a cache for the base module

* delete custom sections

* cache the main native module too

* add par iter in a few more places

* clippy, map ident

* better logging and status bars

* wip: some small windows support

* wip more windowss

* fix weird regression

* implement windows jump table

* small fixes for windows

* better windows support

* windows support pt2

* rust lld is not msvc

* whole archive the rlibs

* ignore windows and sys crates

* logging

* ohhhhhh, pop out dlls

* dedupe

* thANK GOD FAT LINKING WORKS ON WINDOWS

* hoist caching

* implement patch based on cache

* fix location for pdb

* pass data symbols, correct object

* add all symbol for windows

* add log

* treat none rva as undefined

* whoops

* handle windows calling convention

* dont use relocated arm64 stub windows

* not all are text?

* WINDOWS FUNCTION PATCHING WORKS

but issue with statics?

* use our own entry

* handle windows imp symbols

* add log

* jump to the real symbol not the layout

* whoops

* hotpatching windows works completely holy heck yay

* drop linker args crate

* disable ssg playwright for now

* light cleanups

* some cleanups / preps:
- bump to serverfn 0.8.2
- fix playwright test
- fix clippy

* use fix from #4042

* bring in other fix for liveview

* hoist some configuration

* use __aslr_reference instead of aslr_reference

* add better errors to patcherror

* fix android

* panic if patching fails

* clean up tomls

* wip: fixing wasm compile for server

* fullstack wasm again

* fix cfg

* fixup feature detection

* fix issue with features

* fix playwright!

* add barebones template test harness

* fix compatibility between the two hotreload engines

* fix preldue of server

* fix check for wasm-opt

* small fixes

.gitignore

@@ -28,3 +28,6 @@ node_modules/
 # ignore the output of tmps
 tmp/
 bundle/
+
+# in debugging we frequently dump wasm to wat with `wasm-tools print`
+*.wat

.vscode/settings.json

@@ -6,14 +6,19 @@
   "[handlebars]": {
     "editor.formatOnSave": false
   },
+  "[javascript]": {
+    "editor.formatOnSave": false
+  },
+  "dioxus.formatOnSave": "disabled",
   // "rust-analyzer.check.workspace": true,
   // "rust-analyzer.check.workspace": false,
   // "rust-analyzer.check.features": "all",
   // "rust-analyzer.cargo.buildScripts.rebuildOnSave": false,
   // "rust-analyzer.check.workspace": false,
+  // "rust-analyzer.check.allTargets": true,
   "rust-analyzer.cargo.features": "all",
   "rust-analyzer.check.features": "all",
-  // "rust-analyzer.check.allTargets": true,
-  // we don't want the formatter to kick in while we're working on dioxus itself
-  "dioxus.formatOnSave": "disabled",
+  "rust-analyzer.cargo.extraArgs": [
+    "--tests"
+  ],
 }

Cargo.lock

@@ -450,7 +450,7 @@ dependencies = [
  "reqwest 0.11.27",
  "ring",
  "rsa",
- "scroll",
+ "scroll 0.12.0",
  "security-framework 2.11.1",
  "security-framework-sys",
  "semver 1.0.26",
@@ -489,7 +489,7 @@ dependencies = [
  "apple-xar",
  "cpio-archive",
  "flate2",
- "scroll",
+ "scroll 0.12.0",
  "serde",
  "serde-xml-rs",
  "thiserror 1.0.69",
@@ -512,7 +512,7 @@ dependencies = [
  "md-5",
  "rand 0.8.5",
  "reqwest 0.11.27",
- "scroll",
+ "scroll 0.12.0",
  "serde",
  "serde-xml-rs",
  "sha1",
@@ -1343,6 +1343,13 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "barebones-template-test"
+version = "0.1.0"
+dependencies = [
+ "dioxus",
+]
+
 [[package]]
 name = "base16"
 version = "0.2.1"
@@ -1811,9 +1818,9 @@ dependencies = [
 
 [[package]]
 name = "built"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c360505aed52b7ec96a3636c3f039d99103c37d1d9b4f7a8c743d3ea9ffcd03b"
+checksum = "56ed6191a7e78c36abdb16ab65341eefd73d64d303fffccdbb00d51e4205967b"
 dependencies = [
  "git2",
 ]
@@ -1983,23 +1990,11 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "cargo-config2"
-version = "0.1.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dc3749a36e0423c991f1e7a3e4ab0c36a1f489658313db4b187d401d79cc461"
-dependencies = [
- "serde",
- "serde_derive",
- "toml_edit 0.22.24",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "cargo-generate"
-version = "0.22.1"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd20c031c5650a045e60c7bc274aa2a20d32fd604b9265e760562ceda4bdbf26"
+checksum = "dd3cea99ecf678f9f12dd63f685f9ae79dca897ebb2a8a0aa1ec4dfb8b64d534"
 dependencies = [
  "anstyle",
  "anyhow",
@@ -2024,7 +2019,6 @@ dependencies = [
  "log",
  "names",
  "paste",
- "path-absolutize",
  "regex",
  "remove_dir_all",
  "rhai",
@@ -2049,15 +2043,15 @@ dependencies = [
 
 [[package]]
 name = "cargo-util-schemas"
-version = "0.7.2"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f905f68f8cb8a8182592d9858a5895360f0a5b08b6901fdb10498fb91829804"
+checksum = "e788664537bc508c6f252ca8b0e64275d89ca3ce11aeb71452a3554f390e3a65"
 dependencies = [
  "semver 1.0.26",
  "serde",
  "serde-untagged",
  "serde-value",
- "thiserror 1.0.69",
+ "thiserror 2.0.12",
  "toml",
  "unicode-xid",
  "url",
@@ -2179,14 +2173,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
 dependencies = [
  "smallvec",
- "target-lexicon",
+ "target-lexicon 0.12.16",
 ]
 
 [[package]]
 name = "cfg-expr"
-version = "0.17.2"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d4ba6e40bd1184518716a6e1a781bf9160e286d219ccdb8ab2612e74cfe4789"
+checksum = "15b9a064fcc3a1cd4077688b2a1951e0884dcc098a06610f21d0413ccd687e67"
 dependencies = [
  "smallvec",
 ]
@@ -2620,9 +2614,9 @@ dependencies = [
 
 [[package]]
 name = "const-str"
-version = "0.5.7"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3618cccc083bb987a415d85c02ca6c9994ea5b44731ec28b9ecf09658655fba9"
+checksum = "9e991226a70654b49d34de5ed064885f0bef0348a8e70018b8ff1ac80aa984a2"
 
 [[package]]
 name = "const-str-proc-macro"
@@ -2676,6 +2670,15 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "convert_case"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "convert_case"
 version = "0.8.0"
@@ -2966,7 +2969,6 @@ checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
 dependencies = [
  "bitflags 2.9.0",
  "crossterm_winapi",
- "futures-core",
  "mio",
  "parking_lot",
  "rustix 0.38.44",
@@ -2975,6 +2977,25 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "crossterm"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
+dependencies = [
+ "bitflags 2.9.0",
+ "crossterm_winapi",
+ "derive_more 2.0.1",
+ "document-features",
+ "futures-core",
+ "mio",
+ "parking_lot",
+ "rustix 1.0.5",
+ "signal-hook",
+ "signal-hook-mio",
+ "winapi",
+]
+
 [[package]]
 name = "crossterm_winapi"
 version = "0.9.1"
@@ -3337,6 +3358,13 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "depinfo"
+version = "0.6.3"
+dependencies = [
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "der"
 version = "0.7.9"
@@ -3419,7 +3447,16 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
 dependencies = [
- "derive_more-impl",
+ "derive_more-impl 1.0.0",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+dependencies = [
+ "derive_more-impl 2.0.1",
 ]
 
 [[package]]
@@ -3434,6 +3471,18 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "derive_more-impl"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+dependencies = [
+ "convert_case 0.7.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
+
 [[package]]
 name = "des"
 version = "0.8.1"
@@ -3503,14 +3552,17 @@ dependencies = [
  "dioxus-mobile",
  "dioxus-native",
  "dioxus-router",
+ "dioxus-server",
  "dioxus-signals",
  "dioxus-ssr",
  "dioxus-web",
+ "dioxus_server_macro",
  "env_logger 0.11.8",
  "futures-util",
  "manganis",
  "rand 0.8.5",
  "serde",
+ "subsecond",
  "thiserror 2.0.12",
  "tokio",
  "tracing",
@@ -3565,12 +3617,13 @@ dependencies = [
  "ansi-to-html",
  "ansi-to-tui",
  "anyhow",
+ "ar",
  "axum 0.8.3",
  "axum-extra",
  "axum-server",
+ "backtrace",
  "brotli",
  "built",
- "cargo-config2",
  "cargo-generate",
  "cargo_metadata",
  "cargo_toml",
@@ -3580,8 +3633,9 @@ dependencies = [
  "console-subscriber",
  "const-serialize",
  "convert_case 0.8.0",
- "crossterm",
+ "crossterm 0.29.0",
  "ctrlc",
+ "depinfo",
  "dioxus-autofmt",
  "dioxus-check",
  "dioxus-cli-config",
@@ -3617,12 +3671,14 @@ dependencies = [
  "log",
  "manganis",
  "manganis-core",
+ "memmap",
  "memoize",
  "notify",
  "object 0.36.7",
  "once_cell",
  "open",
  "path-absolutize",
+ "pdb",
  "plist",
  "prettyplease",
  "proc-macro2",
@@ -3633,9 +3689,12 @@ dependencies = [
  "rustls 0.23.26",
  "serde",
  "serde_json",
+ "shell-words",
  "strum 0.27.1",
+ "subsecond-types",
  "syn 2.0.100",
  "tar",
+ "target-lexicon 0.13.2",
  "tauri-bundler",
  "tauri-utils",
  "tempfile",
@@ -3653,8 +3712,12 @@ dependencies = [
  "unicode-segmentation",
  "uuid",
  "walkdir",
+ "walrus",
+ "wasm-bindgen-externref-xform",
+ "wasm-encoder 0.228.0",
  "wasm-opt",
  "wasm-split-cli",
+ "wasmparser 0.226.0",
  "which 7.0.3",
 ]
 
@@ -3757,6 +3820,7 @@ dependencies = [
  "serde",
  "slab",
  "slotmap",
+ "subsecond",
  "sysinfo",
  "tokio",
  "tracing",
@@ -3850,11 +3914,14 @@ dependencies = [
 name = "dioxus-devtools"
 version = "0.6.3"
 dependencies = [
+ "dioxus-cli-config",
  "dioxus-core",
  "dioxus-devtools-types",
  "dioxus-signals",
  "serde",
  "serde_json",
+ "subsecond",
+ "thiserror 2.0.12",
  "tokio",
  "tracing",
  "tungstenite 0.26.2",
@@ -3867,6 +3934,7 @@ version = "0.6.3"
 dependencies = [
  "dioxus-core",
  "serde",
+ "subsecond-types",
 ]
 
 [[package]]
@@ -3901,14 +3969,13 @@ name = "dioxus-examples"
 version = "0.6.3"
 dependencies = [
  "async-std",
- "axum 0.8.3",
  "base64 0.22.1",
  "ciborium",
  "dioxus",
  "dioxus-ssr",
  "form_urlencoded",
  "futures-util",
- "getrandom 0.3.2",
+ "getrandom 0.2.15",
  "http-range",
  "openssl",
  "ouroboros",
@@ -3956,14 +4023,12 @@ dependencies = [
  "dioxus-lib",
  "dioxus-mobile",
  "dioxus-router",
- "dioxus-ssr",
+ "dioxus-server",
  "dioxus-web",
  "dioxus_server_macro",
  "futures-channel",
  "futures-util",
  "generational-box",
- "http 1.3.1",
- "hyper 1.6.0",
  "hyper-rustls 0.27.5",
  "once_cell",
  "parking_lot",
@@ -3972,7 +4037,6 @@ dependencies = [
  "serde",
  "server_fn",
  "thiserror 2.0.12",
- "tokio",
  "tokio-stream",
  "tokio-util",
  "tower 0.5.2",
@@ -3987,10 +4051,12 @@ dependencies = [
 name = "dioxus-fullstack-hooks"
 version = "0.6.3"
 dependencies = [
+ "dioxus",
  "dioxus-core",
  "dioxus-fullstack",
  "dioxus-fullstack-protocol",
  "dioxus-hooks",
+ "dioxus-lib",
  "dioxus-signals",
  "futures-channel",
  "serde",
@@ -4342,6 +4408,55 @@ dependencies = [
  "syn 2.0.100",
 ]
 
+[[package]]
+name = "dioxus-server"
+version = "0.6.3"
+dependencies = [
+ "async-trait",
+ "aws-lc-rs",
+ "axum 0.8.3",
+ "base64 0.22.1",
+ "bytes",
+ "ciborium",
+ "dashmap 6.1.0",
+ "dioxus",
+ "dioxus-cli-config",
+ "dioxus-devtools",
+ "dioxus-fullstack-hooks",
+ "dioxus-fullstack-protocol",
+ "dioxus-history",
+ "dioxus-interpreter-js",
+ "dioxus-isrg",
+ "dioxus-lib",
+ "dioxus-router",
+ "dioxus-ssr",
+ "futures-channel",
+ "futures-util",
+ "generational-box",
+ "http 1.3.1",
+ "hyper 1.6.0",
+ "hyper-rustls 0.27.5",
+ "hyper-util",
+ "inventory",
+ "once_cell",
+ "parking_lot",
+ "pin-project",
+ "rustls 0.23.26",
+ "serde",
+ "server_fn",
+ "subsecond",
+ "thiserror 2.0.12",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tower 0.5.2",
+ "tower-http",
+ "tower-layer",
+ "tracing",
+ "tracing-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "dioxus-signals"
 version = "0.6.3"
@@ -5008,6 +5123,19 @@ name = "faster-hex"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2a2b11eda1d40935b26cf18f6833c526845ae8c41e58d09af6adeb6f0269183"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "faster-hex"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73"
+dependencies = [
+ "heapless",
+ "serde",
+]
 
 [[package]]
 name = "fastrand"
@@ -5096,6 +5224,12 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
 version = "1.1.1"
@@ -5273,9 +5407,9 @@ dependencies = [
 
 [[package]]
 name = "fs-err"
-version = "3.0.0"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bb60e7409f34ef959985bc9d9c5ee8f5db24ee46ed9775850548021710f807f"
+checksum = "1f89bda4c2a21204059a977ed3bfe746677dfd137b83c339e702b0ac91d482aa"
 dependencies = [
  "autocfg",
  "tokio",
@@ -5768,9 +5902,9 @@ dependencies = [
 
 [[package]]
 name = "git2"
-version = "0.19.0"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b903b73e45dc0c6c596f2d37eccece7c1c8bb6e4407b001096387c63d0d93724"
+checksum = "2deb07a133b1520dc1a5690e9bd08950108873d7ed5de38dcc74d3b5ebffa110"
 dependencies = [
  "bitflags 2.9.0",
  "libc",
@@ -5783,27 +5917,27 @@ dependencies = [
 
 [[package]]
 name = "gix-actor"
-version = "0.32.0"
+version = "0.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc19e312cd45c4a66cd003f909163dc2f8e1623e30a0c0c6df3776e89b308665"
+checksum = "f438c87d4028aca4b82f82ba8d8ab1569823cfb3e5bc5fa8456a71678b2a20e7"
 dependencies = [
  "bstr",
  "gix-date",
  "gix-utils",
  "itoa 1.0.15",
- "thiserror 1.0.69",
- "winnow 0.6.26",
+ "thiserror 2.0.12",
+ "winnow 0.7.6",
 ]
 
 [[package]]
 name = "gix-config"
-version = "0.40.0"
+version = "0.44.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78e797487e6ca3552491de1131b4f72202f282fb33f198b1c34406d765b42bb0"
+checksum = "9c6f830bf746604940261b49abf7f655d2c19cadc9f4142ae9379e3a316e8cfa"
 dependencies = [
  "bstr",
  "gix-config-value",
- "gix-features",
+ "gix-features 0.41.1",
  "gix-glob",
  "gix-path",
  "gix-ref",
@@ -5811,9 +5945,9 @@ dependencies = [
  "memchr",
  "once_cell",
  "smallvec",
- "thiserror 1.0.69",
+ "thiserror 2.0.12",
  "unicode-bom",
- "winnow 0.6.26",
+ "winnow 0.7.6",
 ]
 
 [[package]]
@@ -5843,80 +5977,120 @@ dependencies = [
 
 [[package]]
 name = "gix-features"
-version = "0.38.2"
+version = "0.41.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac7045ac9fe5f9c727f38799d002a7ed3583cd777e3322a7c4b43e3cf437dc69"
+checksum = "016d6050219458d14520fe22bdfdeb9cb71631dec9bc2724767c983f60109634"
 dependencies = [
- "gix-hash",
+ "gix-path",
  "gix-trace",
  "gix-utils",
  "libc",
  "prodash",
- "sha1_smol",
  "walkdir",
 ]
 
+[[package]]
+name = "gix-features"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f4399af6ec4fd9db84dd4cf9656c5c785ab492ab40a7c27ea92b4241923fed"
+dependencies = [
+ "gix-trace",
+ "libc",
+ "prodash",
+]
+
 [[package]]
 name = "gix-fs"
-version = "0.11.3"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2bfe6249cfea6d0c0e0990d5226a4cb36f030444ba9e35e0639275db8f98575"
+checksum = "951e886120dc5fa8cac053e5e5c89443f12368ca36811b2e43d1539081f9c111"
 dependencies = [
+ "bstr",
  "fastrand",
- "gix-features",
+ "gix-features 0.41.1",
+ "gix-path",
  "gix-utils",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
 name = "gix-glob"
-version = "0.16.5"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74908b4bbc0a0a40852737e5d7889f676f081e340d5451a16e5b4c50d592f111"
+checksum = "20972499c03473e773a2099e5fd0c695b9b72465837797a51a43391a1635a030"
 dependencies = [
  "bitflags 2.9.0",
  "bstr",
- "gix-features",
+ "gix-features 0.41.1",
  "gix-path",
 ]
 
 [[package]]
 name = "gix-hash"
-version = "0.14.2"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93d7df7366121b5018f947a04d37f034717e113dcf9ccd85c34b58e57a74d5e"
+checksum = "834e79722063958b03342edaa1e17595cd2939bb2b3306b3225d0815566dcb49"
 dependencies = [
- "faster-hex",
- "thiserror 1.0.69",
+ "faster-hex 0.9.0",
+ "gix-features 0.41.1",
+ "sha1-checked",
+ "thiserror 2.0.12",
+]
+
+[[package]]
+name = "gix-hash"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d4900562c662852a6b42e2ef03442eccebf24f047d8eab4f23bc12ef0d785d8"
+dependencies = [
+ "faster-hex 0.10.0",
+ "gix-features 0.42.1",
+ "sha1-checked",
+ "thiserror 2.0.12",
+]
+
+[[package]]
+name = "gix-hashtable"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b5cb3c308b4144f2612ff64e32130e641279fcf1a84d8d40dad843b4f64904"
+dependencies = [
+ "gix-hash 0.18.0",
+ "hashbrown 0.14.5",
+ "parking_lot",
 ]
 
 [[package]]
 name = "gix-lock"
-version = "14.0.0"
+version = "17.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3bc7fe297f1f4614774989c00ec8b1add59571dc9b024b4c00acb7dedd4e19d"
+checksum = "df47b8f11c34520db5541bc5fc9fbc8e4b0bdfcec3736af89ccb1a5728a0126f"
 dependencies = [
  "gix-tempfile",
  "gix-utils",
- "thiserror 1.0.69",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
 name = "gix-object"
-version = "0.44.0"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f5b801834f1de7640731820c2df6ba88d95480dc4ab166a5882f8ff12b88efa"
+checksum = "4943fcdae6ffc135920c9ea71e0362ed539182924ab7a85dd9dac8d89b0dd69a"
 dependencies = [
  "bstr",
  "gix-actor",
  "gix-date",
- "gix-features",
- "gix-hash",
+ "gix-features 0.41.1",
+ "gix-hash 0.17.0",
+ "gix-hashtable",
+ "gix-path",
  "gix-utils",
  "gix-validate",
  "itoa 1.0.15",
  "smallvec",
- "thiserror 1.0.69",
- "winnow 0.6.26",
+ "thiserror 2.0.12",
+ "winnow 0.7.6",
 ]
 
 [[package]]
@@ -5934,14 +6108,14 @@ dependencies = [
 
 [[package]]
 name = "gix-ref"
-version = "0.47.0"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae0d8406ebf9aaa91f55a57f053c5a1ad1a39f60fdf0303142b7be7ea44311e5"
+checksum = "b2e1f7eb6b7ce82d2d19961f74bd637bab3ea79b1bc7bfb23dbefc67b0415d8b"
 dependencies = [
  "gix-actor",
- "gix-features",
+ "gix-features 0.41.1",
  "gix-fs",
- "gix-hash",
+ "gix-hash 0.17.0",
  "gix-lock",
  "gix-object",
  "gix-path",
@@ -5949,8 +6123,8 @@ dependencies = [
  "gix-utils",
  "gix-validate",
  "memmap2",
- "thiserror 1.0.69",
- "winnow 0.6.26",
+ "thiserror 2.0.12",
+ "winnow 0.7.6",
 ]
 
 [[package]]
@@ -5967,9 +6141,9 @@ dependencies = [
 
 [[package]]
 name = "gix-tempfile"
-version = "14.0.2"
+version = "17.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "046b4927969fa816a150a0cda2e62c80016fe11fb3c3184e4dddf4e542f108aa"
+checksum = "3d6de439bbb9a5d3550c9c7fab0e16d2d637d120fcbe0dfbc538772a187f099b"
 dependencies = [
  "gix-fs",
  "libc",
@@ -5986,9 +6160,9 @@ checksum = "7c396a2036920c69695f760a65e7f2677267ccf483f25046977d87e4cb2665f7"
 
 [[package]]
 name = "gix-utils"
-version = "0.1.14"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff08f24e03ac8916c478c8419d7d3c33393da9bb41fa4c24455d5406aeefd35f"
+checksum = "189f8724cf903e7fd57cfe0b7bc209db255cacdcb22c781a022f52c3a774f8d0"
 dependencies = [
  "fastrand",
  "unicode-normalization",
@@ -6214,7 +6388,7 @@ checksum = "1b363a30c165f666402fe6a3024d3bec7ebc898f96a4a23bd1c99f8dbf3f4f47"
 dependencies = [
  "log",
  "plain",
- "scroll",
+ "scroll 0.12.0",
 ]
 
 [[package]]
@@ -6469,6 +6643,15 @@ dependencies = [
  "thiserror 2.0.12",
 ]
 
+[[package]]
+name = "hash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -6571,6 +6754,16 @@ dependencies = [
  "http 1.3.1",
 ]
 
+[[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "heck"
 version = "0.4.1"
@@ -7765,13 +7958,13 @@ dependencies = [
 
 [[package]]
 name = "krates"
-version = "0.17.5"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd5bdd9794c39f6eb77da784fdcd065cc730a95fd0ca7d88ec945ed26c3c5109"
+checksum = "c0e4748d9ac5a5c1e557d716a86d1a121caa7dee44c8a3848932c0bdebff075e"
 dependencies = [
  "camino",
- "cfg-expr 0.17.2",
- "petgraph",
+ "cfg-expr 0.19.0",
+ "petgraph 0.7.1",
  "semver 1.0.26",
  "serde",
  "serde_json",
@@ -7853,6 +8046,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "lebe"
 version = "0.5.2"
@@ -7901,9 +8100,9 @@ dependencies = [
 
 [[package]]
 name = "libgit2-sys"
-version = "0.17.0+1.8.1"
+version = "0.18.1+1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10472326a8a6477c3c20a64547b0059e4b0d086869eee31e6d7da728a8eb7224"
+checksum = "e1dcb20f84ffcdd825c7a311ae347cce604a6f084a767dec4a4929829645290e"
 dependencies = [
  "cc",
  "libc",
@@ -8401,6 +8600,25 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "memfd"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2cffa4ad52c6f791f4f8b15f0c05f9824b2ced1160e88cc393d64fff9a8ac64"
+dependencies = [
+ "rustix 0.38.44",
+]
+
+[[package]]
+name = "memmap"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "memmap2"
 version = "0.9.5"
@@ -9083,7 +9301,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3531f65190d9cff863b77a99857e74c314dd16bf56c538c4b57c7cbc3f3a6e59"
 dependencies = [
  "objc2-encode",
- "objc2-exception-helper",
 ]
 
 [[package]]
@@ -9211,15 +9428,6 @@ version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
 
-[[package]]
-name = "objc2-exception-helper"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "objc2-foundation"
 version = "0.2.2"
@@ -9313,18 +9521,6 @@ dependencies = [
  "objc2-user-notifications",
 ]
 
-[[package]]
-name = "objc2-ui-kit"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "777a571be14a42a3990d4ebedaeb8b54cd17377ec21b92e8200ac03797b3bee1"
-dependencies = [
- "bitflags 2.9.0",
- "objc2 0.6.0",
- "objc2-core-foundation",
- "objc2-foundation 0.3.0",
-]
-
 [[package]]
 name = "objc2-uniform-type-identifiers"
 version = "0.2.2"
@@ -9349,20 +9545,6 @@ dependencies = [
  "objc2-foundation 0.2.2",
 ]
 
-[[package]]
-name = "objc2-web-kit"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b717127e4014b0f9f3e8bba3d3f2acec81f1bde01f656823036e823ed2c94dce"
-dependencies = [
- "bitflags 2.9.0",
- "block2 0.6.0",
- "objc2 0.6.0",
- "objc2-app-kit 0.3.0",
- "objc2-core-foundation",
- "objc2-foundation 0.3.0",
-]
-
 [[package]]
 name = "objc_exception"
 version = "0.1.2"
@@ -9401,7 +9583,10 @@ version = "0.36.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
 dependencies = [
+ "crc32fast",
  "flate2",
+ "hashbrown 0.15.2",
+ "indexmap 2.9.0",
  "memchr",
  "ruzstd 0.7.3",
  "wasmparser 0.222.1",
@@ -9823,6 +10008,17 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
 
+[[package]]
+name = "pdb"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82040a392923abe6279c00ab4aff62d5250d1c8555dc780e4b02783a7aa74863"
+dependencies = [
+ "fallible-iterator",
+ "scroll 0.11.0",
+ "uuid",
+]
+
 [[package]]
 name = "pear"
 version = "0.2.9"
@@ -9933,7 +10129,17 @@ version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
- "fixedbitset",
+ "fixedbitset 0.4.2",
+ "indexmap 2.9.0",
+]
+
+[[package]]
+name = "petgraph"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
+dependencies = [
+ "fixedbitset 0.5.7",
  "indexmap 2.9.0",
 ]
 
@@ -10458,9 +10664,9 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -10480,9 +10686,13 @@ dependencies = [
 
 [[package]]
 name = "prodash"
-version = "28.0.0"
+version = "29.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744a264d26b88a6a7e37cbad97953fa233b94d585236310bcbc88474b4092d79"
+checksum = "f04bb108f648884c23b98a0e940ebc2c93c0c3b89f04dbaf7eb8256ce617d1bc"
+dependencies = [
+ "log",
+ "parking_lot",
+]
 
 [[package]]
 name = "profiling"
@@ -10872,7 +11082,7 @@ dependencies = [
  "bitflags 2.9.0",
  "cassowary",
  "compact_str",
- "crossterm",
+ "crossterm 0.28.1",
  "indoc",
  "instability",
  "itertools 0.13.0",
@@ -11077,9 +11287,9 @@ checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
 
 [[package]]
 name = "remove_dir_all"
-version = "0.8.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a694f9e0eb3104451127f6cc1e5de55f59d3b1fc8c5ddfaeb6f1e716479ceb4a"
+checksum = "808cc0b475acf76adf36f08ca49429b12aad9f678cb56143d5b3cb49b9a1dd08"
 dependencies = [
  "cfg-if",
  "cvt",
@@ -11244,9 +11454,9 @@ dependencies = [
 
 [[package]]
 name = "rhai"
-version = "1.20.1"
+version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0277a46f29fe3b3eb10821ca2c65a4751b686b6c84422aae31695ba167b0fbc"
+checksum = "ce4d759a4729a655ddfdbb3ff6e77fb9eadd902dae12319455557796e435d2a6"
 dependencies = [
  "ahash 0.8.11",
  "bitflags 2.9.0",
@@ -11671,11 +11881,10 @@ dependencies = [
 
 [[package]]
 name = "sanitize-filename"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ed72fbaf78e6f2d41744923916966c4fbe3d7c74e3037a8ee482f1115572603"
+checksum = "bc984f4f9ceb736a7bb755c3e3bd17dc56370af2600c9780dcc48c66453da34d"
 dependencies = [
- "lazy_static",
  "regex",
 ]
 
@@ -11706,6 +11915,12 @@ version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f6280af86e5f559536da57a45ebc84948833b3bee313a7dd25232e09c878a52"
 
+[[package]]
+name = "scroll"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04c565b551bafbef4157586fa379538366e4385d42082f255bfd96e4fe8519da"
+
 [[package]]
 name = "scroll"
 version = "0.12.0"
@@ -11973,13 +12188,13 @@ dependencies = [
 
 [[package]]
 name = "serde_qs"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd34f36fe4c5ba9654417139a9b3a20d2e1de6012ee678ad14d240c22c78d8d6"
+checksum = "8b417bedc008acbdf6d6b4bc482d29859924114bbe2650b7921fb68a261d0aa6"
 dependencies = [
  "percent-encoding",
  "serde",
- "thiserror 1.0.69",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
@@ -12059,14 +12274,14 @@ dependencies = [
 
 [[package]]
 name = "server_fn"
-version = "0.8.0-rc1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b279618eba9bf2298336a6b5f72c84bee46a5a76ad048a5763b552d69393988"
+checksum = "09b0f92b9d3a62c73f238ac21f7a09f15bad335a9d1651514d9da80d2eaf8d4c"
 dependencies = [
  "axum 0.8.3",
  "base64 0.22.1",
  "bytes",
- "const-str 0.5.7",
+ "const-str 0.6.2",
  "const_format",
  "dashmap 6.1.0",
  "futures",
@@ -12079,6 +12294,7 @@ dependencies = [
  "once_cell",
  "pin-project-lite",
  "reqwest 0.12.15",
+ "rustc_version 0.4.1",
  "rustversion",
  "send_wrapper",
  "serde",
@@ -12101,12 +12317,12 @@ dependencies = [
 
 [[package]]
 name = "server_fn_macro"
-version = "0.8.0-rc1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40c805d4055915c94d1b168bec37afc9fadcfd7c17798c63259e303667076a67"
+checksum = "341dd1087afe9f3e546c5979a4f0b6d55ac072e1201313f86e7fe364223835ac"
 dependencies = [
  "const_format",
- "convert_case 0.6.0",
+ "convert_case 0.8.0",
  "proc-macro2",
  "quote",
  "rustc_version 0.4.1",
@@ -12116,9 +12332,9 @@ dependencies = [
 
 [[package]]
 name = "server_fn_macro_default"
-version = "0.8.0-rc1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e63085deb77b447034fd865a7a054c0a234bd1ce93c9cf13dd02e0138773930f"
+checksum = "bc5ab934f581482a66da82f2b57b15390ad67c9ab85bd9a6c54bb65060fb1380"
 dependencies = [
  "server_fn_macro",
  "syn 2.0.100",
@@ -12560,9 +12776,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14e22987355fbf8cfb813a0cf8cd97b1b4ec834b94dbd759a9e8679d41fabe83"
+checksum = "f3c3a85280daca669cfd3bcb68a337882a8bc57ec882f72c5d13a430613a738e"
 dependencies = [
  "sqlx-core",
  "sqlx-macros",
@@ -12573,9 +12789,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-core"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55c4720d7d4cd3d5b00f61d03751c685ad09c33ae8290c8a2c11335e0604300b"
+checksum = "f743f2a3cea30a58cd479013f75550e879009e3a02f616f18ca699335aa248c3"
 dependencies = [
  "base64 0.22.1",
  "bigdecimal",
@@ -12620,9 +12836,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "175147fcb75f353ac7675509bc58abb2cb291caf0fd24a3623b8f7e3eb0a754b"
+checksum = "7f4200e0fde19834956d4252347c12a083bdcb237d7a1a1446bffd8768417dce"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -12633,9 +12849,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros-core"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cde983058e53bfa75998e1982086c5efe3c370f3250bf0357e344fa3352e32b"
+checksum = "882ceaa29cade31beca7129b6beeb05737f44f82dbe2a9806ecea5a7093d00b7"
 dependencies = [
  "dotenvy",
  "either",
@@ -12659,9 +12875,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-mysql"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "847d2e5393a4f39e47e4f36cab419709bc2b83cbe4223c60e86e1471655be333"
+checksum = "0afdd3aa7a629683c2d750c2df343025545087081ab5942593a5288855b1b7a7"
 dependencies = [
  "atoi",
  "base64 0.22.1",
@@ -12706,9 +12922,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-postgres"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc35947a541b9e0a2e3d85da444f1c4137c13040267141b208395a0d0ca4659f"
+checksum = "a0bedbe1bbb5e2615ef347a5e9d8cd7680fb63e77d9dafc0f29be15e53f1ebe6"
 dependencies = [
  "atoi",
  "base64 0.22.1",
@@ -12753,9 +12969,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-sqlite"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c48291dac4e5ed32da0927a0b981788be65674aeb62666d19873ab4289febde"
+checksum = "c26083e9a520e8eb87a06b12347679b142dc2ea29e6e409f805644a7a979a5bc"
 dependencies = [
  "atoi",
  "chrono",
@@ -13105,6 +13321,30 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "subsecond"
+version = "0.6.3"
+dependencies = [
+ "js-sys",
+ "libc",
+ "libloading 0.8.6",
+ "memfd",
+ "memmap2",
+ "serde",
+ "subsecond-types",
+ "thiserror 2.0.12",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "subsecond-types"
+version = "0.6.3"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -13203,7 +13443,7 @@ dependencies = [
  "is-macro",
  "once_cell",
  "parking_lot",
- "petgraph",
+ "petgraph 0.6.5",
  "radix_fmt",
  "relative-path",
  "swc_atoms",
@@ -13464,7 +13704,7 @@ dependencies = [
  "dashmap 5.5.3",
  "indexmap 2.9.0",
  "once_cell",
- "petgraph",
+ "petgraph 0.6.5",
  "rustc-hash 1.1.0",
  "serde_json",
  "swc_atoms",
@@ -13549,7 +13789,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c22e0a0478b1b06610453a97c8371cafa742e371a79aff860ccfbabe1ab160a7"
 dependencies = [
  "indexmap 2.9.0",
- "petgraph",
+ "petgraph 0.6.5",
  "rustc-hash 1.1.0",
  "swc_common",
 ]
@@ -13561,7 +13801,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "79b9841af596d2ddb37e56defca81387b60a14863e251cede839d1e349e6209d"
 dependencies = [
  "auto_impl",
- "petgraph",
+ "petgraph 0.6.5",
  "swc_common",
  "swc_fast_graph",
  "tracing",
@@ -13762,9 +14002,9 @@ dependencies = [
 
 [[package]]
 name = "tao"
-version = "0.32.8"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63c8b1020610b9138dd7b1e06cf259ae91aa05c30f3bd0d6b42a03997b92dec1"
+checksum = "1e59c1f38e657351a2e822eadf40d6a2ad4627b9c25557bc1180ec1b3295ef82"
 dependencies = [
  "bitflags 2.9.0",
  "core-foundation 0.10.0",
@@ -13794,8 +14034,8 @@ dependencies = [
  "tao-macros",
  "unicode-segmentation",
  "url",
- "windows 0.60.0",
- "windows-core 0.60.1",
+ "windows 0.61.1",
+ "windows-core 0.61.0",
  "windows-version",
  "x11-dl",
 ]
@@ -13834,6 +14074,15 @@ version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
+[[package]]
+name = "target-lexicon"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "target-triple"
 version = "0.1.4"
@@ -13952,14 +14201,14 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.13.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
+checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
 dependencies = [
- "cfg-if",
  "fastrand",
+ "getrandom 0.3.2",
  "once_cell",
- "rustix 0.38.44",
+ "rustix 1.0.5",
  "windows-sys 0.59.0",
 ]
 
@@ -15242,7 +15491,7 @@ dependencies = [
  "log",
  "rayon",
  "walrus-macro",
- "wasm-encoder",
+ "wasm-encoder 0.214.0",
  "wasmparser 0.214.0",
 ]
 
@@ -15342,6 +15591,17 @@ dependencies = [
  "wasm-bindgen-shared",
 ]
 
+[[package]]
+name = "wasm-bindgen-externref-xform"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940542c5cdbe96c35f98b5da5c65fb9d18df55a0cb1d81fc5ca4acc4fda4d61c"
+dependencies = [
+ "anyhow",
+ "walrus",
+ "wasm-bindgen-wasm-conventions",
+]
+
 [[package]]
 name = "wasm-bindgen-futures"
 version = "0.4.50"
@@ -15411,6 +15671,19 @@ dependencies = [
  "syn 2.0.100",
 ]
 
+[[package]]
+name = "wasm-bindgen-wasm-conventions"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1c24fcaa34d2d84407122cfb1d3f37c3586756cf462be18e049b49245a16c08"
+dependencies = [
+ "anyhow",
+ "leb128",
+ "log",
+ "walrus",
+ "wasmparser 0.214.0",
+]
+
 [[package]]
 name = "wasm-encoder"
 version = "0.214.0"
@@ -15420,6 +15693,16 @@ dependencies = [
  "leb128",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.228.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05d30290541f2d4242a162bbda76b8f2d8b1ac59eab3568ed6f2327d52c9b2c4"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.228.0",
+]
+
 [[package]]
 name = "wasm-opt"
 version = "0.116.1"
@@ -15493,7 +15776,7 @@ dependencies = [
  "dioxus",
  "dioxus-router",
  "futures",
- "getrandom 0.3.2",
+ "getrandom 0.2.15",
  "js-sys",
  "once_cell",
  "reqwest 0.12.15",
@@ -15572,6 +15855,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "wasmparser"
+version = "0.228.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4abf1132c1fdf747d56bbc1bb52152400c70f336870f968b85e89ea422198ae3"
+dependencies = [
+ "bitflags 2.9.0",
+ "indexmap 2.9.0",
+ "semver 1.0.26",
+]
+
 [[package]]
 name = "wayland-backend"
 version = "0.3.8"
@@ -15779,16 +16073,16 @@ dependencies = [
 
 [[package]]
 name = "webview2-com"
-version = "0.36.0"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0d606f600e5272b514dbb66539dd068211cc20155be8d3958201b4b5bd79ed3"
+checksum = "6f61ff3d9d0ee4efcb461b14eb3acfda2702d10dc329f339303fc3e57215ae2c"
 dependencies = [
  "webview2-com-macros",
  "webview2-com-sys",
- "windows 0.60.0",
- "windows-core 0.60.1",
- "windows-implement 0.59.0",
- "windows-interface 0.59.1",
+ "windows 0.58.0",
+ "windows-core 0.58.0",
+ "windows-implement 0.58.0",
+ "windows-interface 0.58.0",
 ]
 
 [[package]]
@@ -15804,13 +16098,13 @@ dependencies = [
 
 [[package]]
 name = "webview2-com-sys"
-version = "0.36.0"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfb27fccd3c27f68e9a6af1bcf48c2d82534b8675b83608a4d81446d095a17ac"
+checksum = "a3a3e2eeb58f82361c93f9777014668eb3d07e7d174ee4c819575a9208011886"
 dependencies = [
- "thiserror 2.0.12",
- "windows 0.60.0",
- "windows-core 0.60.1",
+ "thiserror 1.0.69",
+ "windows 0.58.0",
+ "windows-core 0.58.0",
 ]
 
 [[package]]
@@ -16156,12 +16450,12 @@ dependencies = [
 
 [[package]]
 name = "windows"
-version = "0.60.0"
+version = "0.61.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddf874e74c7a99773e62b1c671427abf01a425e77c3d3fb9fb1e4883ea934529"
+checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
 dependencies = [
  "windows-collections",
- "windows-core 0.60.1",
+ "windows-core 0.61.0",
  "windows-future",
  "windows-link",
  "windows-numerics",
@@ -16169,11 +16463,11 @@ dependencies = [
 
 [[package]]
 name = "windows-collections"
-version = "0.1.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5467f79cc1ba3f52ebb2ed41dbb459b8e7db636cc3429458d9a852e15bc24dec"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
- "windows-core 0.60.1",
+ "windows-core 0.61.0",
 ]
 
 [[package]]
@@ -16210,19 +16504,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-core"
-version = "0.60.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca21a92a9cae9bf4ccae5cf8368dce0837100ddf6e6d57936749e85f152f6247"
-dependencies = [
- "windows-implement 0.59.0",
- "windows-interface 0.59.1",
- "windows-link",
- "windows-result 0.3.2",
- "windows-strings 0.3.1",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.61.0"
@@ -16238,11 +16519,11 @@ dependencies = [
 
 [[package]]
 name = "windows-future"
-version = "0.1.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a787db4595e7eb80239b74ce8babfb1363d8e343ab072f2ffe901400c03349f0"
+checksum = "7a1d6bbefcb7b60acd19828e1bc965da6fcf18a7e39490c5f8be71e54a19ba32"
 dependencies = [
- "windows-core 0.60.1",
+ "windows-core 0.61.0",
  "windows-link",
 ]
 
@@ -16268,17 +16549,6 @@ dependencies = [
  "syn 2.0.100",
 ]
 
-[[package]]
-name = "windows-implement"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83577b051e2f49a058c308f17f273b570a6a758386fc291b5f6a934dd84e48c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "windows-implement"
 version = "0.60.0"
@@ -16331,11 +16601,11 @@ checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
 
 [[package]]
 name = "windows-numerics"
-version = "0.1.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "005dea54e2f6499f2cee279b8f703b3cf3b5734a2d8d21867c8f44003182eeed"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 dependencies = [
- "windows-core 0.60.1",
+ "windows-core 0.61.0",
  "windows-link",
 ]
 
@@ -16729,7 +16999,7 @@ dependencies = [
  "objc2 0.5.2",
  "objc2-app-kit 0.2.2",
  "objc2-foundation 0.2.2",
- "objc2-ui-kit 0.2.2",
+ "objc2-ui-kit",
  "orbclient",
  "percent-encoding",
  "pin-project",
@@ -16764,15 +17034,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "winnow"
-version = "0.6.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e90edd2ac1aa278a5c4599b1d89cf03074b610800f866d4026dc199d7929a28"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "winnow"
 version = "0.7.6"
@@ -16821,13 +17082,14 @@ checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
 
 [[package]]
 name = "wry"
-version = "0.50.5"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b19b78efae8b853c6c817e8752fc1dbf9cab8a8ffe9c30f399bd750ccf0f0730"
+checksum = "ac0099a336829fbf54c26b5f620c68980ebbe37196772aeaf6118df4931b5cb0"
 dependencies = [
  "base64 0.22.1",
- "block2 0.6.0",
- "cookie",
+ "block",
+ "cocoa 0.26.0",
+ "core-graphics 0.24.0",
  "crossbeam-channel",
  "dpi",
  "dunce",
@@ -16840,25 +17102,20 @@ dependencies = [
  "kuchikiki",
  "libc",
  "ndk",
- "objc2 0.6.0",
- "objc2-app-kit 0.3.0",
- "objc2-core-foundation",
- "objc2-foundation 0.3.0",
- "objc2-ui-kit 0.3.0",
- "objc2-web-kit",
+ "objc",
+ "objc_id",
  "once_cell",
  "percent-encoding",
  "raw-window-handle 0.6.2",
  "sha2",
  "soup3",
  "tao-macros",
- "thiserror 2.0.12",
- "url",
+ "thiserror 1.0.69",
  "webkit2gtk",
  "webkit2gtk-sys",
  "webview2-com",
- "windows 0.60.0",
- "windows-core 0.60.1",
+ "windows 0.58.0",
+ "windows-core 0.58.0",
  "windows-version",
  "x11-dl",
 ]

Cargo.toml

@@ -70,6 +70,8 @@ members = [
     "packages/config-macros",
     "packages/native",
     "packages/asset-resolver",
+    "packages/depinfo",
+    "packages/server",
 
     # Playwright tests
     "packages/playwright-tests/liveview",
@@ -89,6 +91,10 @@ members = [
     "packages/wasm-split/wasm-split-cli",
     "packages/wasm-split/wasm-used",
 
+    # subsecond
+    "packages/subsecond/subsecond",
+    "packages/subsecond/subsecond-types",
+
     # Full project examples
     "example-projects/fullstack-hackernews",
     "example-projects/ecommerce-site",
@@ -107,6 +113,7 @@ members = [
     # Playwright tests
     "packages/playwright-tests/liveview",
     "packages/playwright-tests/web",
+    "packages/playwright-tests/barebones-template",
     "packages/playwright-tests/fullstack",
     "packages/playwright-tests/fullstack-mounted",
     "packages/playwright-tests/fullstack-routing",
@@ -114,7 +121,7 @@ members = [
     "packages/playwright-tests/nested-suspense",
     "packages/playwright-tests/cli-optimization",
     "packages/playwright-tests/wasm-split-harness",
-    "packages/playwright-tests/default-features-disabled"
+    "packages/playwright-tests/default-features-disabled",
 ]
 
 [workspace.package]
@@ -152,6 +159,7 @@ dioxus-cli-config = { path = "packages/cli-config", version = "0.6.2" }
 dioxus-cli-opt = { path = "packages/cli-opt", version = "0.6.2" }
 dioxus-devtools = { path = "packages/devtools", version = "0.6.2" }
 dioxus-devtools-types = { path = "packages/devtools-types", version = "0.6.2" }
+dioxus-server = { path = "packages/server", version = "0.6.2" }
 dioxus-fullstack = { path = "packages/fullstack", version = "0.6.2" }
 dioxus-fullstack-hooks = { path = "packages/fullstack-hooks", version = "0.6.3" }
 dioxus-fullstack-protocol = { path = "packages/fullstack-protocol", version = "0.6.3" }
@@ -166,16 +174,22 @@ const-serialize-macro = { path = "packages/const-serialize-macro", version = "0.
 generational-box = { path = "packages/generational-box", version = "0.6.2" }
 lazy-js-bundle = { path = "packages/lazy-js-bundle", version = "0.6.2" }
 
+# subsecond
+subsecond-types = { path = "packages/subsecond/subsecond-types", version = "0.6.3" }
+subsecond = { path = "packages/subsecond/subsecond", version = "0.6.3" }
 
+# manganis
 manganis = { path = "packages/manganis/manganis", version = "0.6.2" }
 manganis-core = { path = "packages/manganis/manganis-core", version = "0.6.2" }
 manganis-macro = { path = "packages/manganis/manganis-macro", version = "0.6.2" }
 
+# wasm-split
 wasm-split = { path = "packages/wasm-split/wasm-split", version = "0.1.0" }
 wasm-split-macro = { path = "packages/wasm-split/wasm-split-macro", version = "0.1.0" }
 wasm-split-cli = { path = "packages/wasm-split/wasm-split-cli", version = "0.1.0" }
 wasm-split-harness = { path = "packages/playwright-tests/wasm-split-harness", version = "0.1.0" }
 
+depinfo = { path = "packages/depinfo", version = "0.6.3" }
 warnings = { version = "0.2.1" }
 
 # a fork of pretty please for tests - let's get off of this if we can!
@@ -209,8 +223,10 @@ tauri-utils = { version = "2.2.0" }
 tauri-bundler = { version = "2.2.4" }
 lru = "0.13.0"
 async-trait = "0.1.87"
-axum = "0.8.1"
+axum = { version = "0.8.1", default-features = false }
 axum-server = { version = "0.7.1", default-features = false }
+server_fn = { version = "0.8.2", default-features = false }
+server_fn_macro = { version = "0.8.2" }
 tower = "0.5.2"
 http = "1.2.0"
 notify = { version = "8.0.0" }
@@ -268,11 +284,14 @@ sha2 = "0.10.8"
 walrus = { version = "0.23.3", features = ["parallel"] }
 id-arena = "2.2.1"
 async-compression = { version = "0.4.20", features = ["futures-io", "gzip", "brotli"] }
-getrandom = { version = "0.3.1" }
+getrandom = { version = "0.2.0" }
 async-once-cell = { version = "0.5.4" }
 rayon = "1.10.0"
 wasmparser = "0.226.0"
 itertools = "0.14.0"
+object = { version = "0.36.0" }
+bincode = "1.3.3"
+inventory = { version = "0.3.5" }
 macro-string = "0.1.4"
 walkdir = "2.5.0"
 url = "2.3.1"
@@ -280,10 +299,15 @@ separator = "0.4.1"
 pretty_assertions = "1.4.0"
 serde_repr = "0.1"
 hyper-util = "0.1.10"
+krates = { version = "0.19.0" }
+libloading = "0.8.6"
+libc = "0.2.170"
+memmap2 = "0.9.5"
+memfd = "0.6.4"
 
 # desktop
-wry = { version = "0.50.3", default-features = false }
-tao = { version = "0.32.6", features = ["rwh_05"] }
+wry = { version = "0.45.0", default-features = false }
+tao = { version = "0.33.0", features = ["rwh_05"] }
 webbrowser = "1.0.3"
 infer = "0.19.0"
 dunce = "1.0.5"
@@ -301,13 +325,20 @@ open = "5.1.2"
 # web
 gloo-dialogs = "0.2.0"
 
+# tui stuff
+ansi-to-tui = "7.0"
+ansi-to-html = "0.2.1"
+path-absolutize = "3.1"
+crossterm = { version = "0.29.0" }
+ratatui = { version = "0.29.0" }
+shell-words = "1.1.0"
+color-eyre = "0.6.3"
+
 # native
 keyboard-types = { version = "0.7", default-features = false }
 winit = { version = "0.30.2", features = ["rwh_06"] }
 
-# disable debug symbols in dev builds - shouldn't matter for downstream crates but makes our binaries (examples, cli, etc) build faster
 [profile.dev]
-debug = 0
 
 # our release profile should be fast to compile and fast to run
 # when we ship our CI builds, we turn on LTO which improves perf leftover by turning on incremental
@@ -315,7 +346,7 @@ debug = 0
 incremental = true
 
 # crank up the opt level for wasm-split-cli in dev mode
-# important here that lto is on and the debug symbols are presenta (since they're used by wasm-opt)a
+# important here that lto is on and the debug symbols are present (since they're used by wasm-opt)a
 [profile.wasm-split-release]
 inherits = "release"
 opt-level = 'z'
@@ -386,13 +417,12 @@ separator = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 rand = { workspace = true, features = ["small_rng"] }
-form_urlencoded = "1.2.1"
-async-std = "1.13.0"
+form_urlencoded = "1.2.0"
+async-std = "1.12.0"
 web-time = "1.1.0"
-axum = { workspace = true, default-features = true }
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
-getrandom = { workspace = true }
+getrandom = { workspace = true, features = ["js"] }
 tokio = { version = "1.43", default-features = false, features = ["sync", "macros", "io-util", "rt", "time"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]

examples/fullstack-auth/Cargo.toml

@@ -48,17 +48,17 @@ optional = true
 [features]
 default = []
 server = [
-    "dioxus-cli-config",
-    "axum",
-    "tokio",
-    "dioxus-fullstack/axum",
-    "tower-http",
-    "async-trait",
-    "sqlx",
-    "axum_session",
-    "axum_session_auth",
-    "axum_session_sqlx",
-    "http",
-    "tower",
+    "dioxus-fullstack/server",
+    "dep:dioxus-cli-config",
+    "dep:axum",
+    "dep:tokio",
+    "dep:tower-http",
+    "dep:async-trait",
+    "dep:sqlx",
+    "dep:axum_session",
+    "dep:axum_session_auth",
+    "dep:axum_session_sqlx",
+    "dep:http",
+    "dep:tower",
 ]
-web = ["dioxus/web", "dioxus-web"]
+web = ["dioxus/web", "dep:dioxus-web"]

packages/cli-config/src/lib.rs

@@ -69,6 +69,7 @@ pub const APP_TITLE_ENV: &str = "DIOXUS_APP_TITLE";
 #[doc(hidden)]
 pub const OUT_DIR: &str = "DIOXUS_OUT_DIR";
 pub const SESSION_CACHE_DIR: &str = "DIOXUS_SESSION_CACHE_DIR";
+pub const BUILD_ID: &str = "DIOXUS_BUILD_ID";
 
 /// Reads an environment variable at runtime in debug mode or at compile time in
 /// release mode. When bundling in release mode, we will not be running under the
@@ -306,3 +307,20 @@ pub fn session_cache_dir() -> Option<PathBuf> {
 pub fn android_session_cache_dir() -> PathBuf {
     PathBuf::from("/data/local/tmp/dx/")
 }
+
+/// The unique build id for this application, used to disambiguate between different builds of the same
+/// application.
+pub fn build_id() -> u64 {
+    #[cfg(target_arch = "wasm32")]
+    {
+        0
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        std::env::var(BUILD_ID)
+            .ok()
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(0)
+    }
+}

packages/cli-opt/Cargo.toml

@@ -13,7 +13,7 @@ keywords = ["dom", "ui", "gui", "react"]
 anyhow = { workspace = true }
 manganis = { workspace = true }
 manganis-core = { workspace = true }
-object = {version="0.36.7", features=["wasm"]}
+object = { workspace = true, features = ["wasm"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 const-serialize = { workspace = true, features = ["serde"] }

packages/cli/Cargo.toml

@@ -24,6 +24,8 @@ dioxus-cli-opt = { workspace = true }
 dioxus-fullstack = { workspace = true }
 dioxus-dx-wire-format = { workspace = true }
 wasm-split-cli = { workspace = true }
+depinfo = { workspace = true }
+subsecond-types = { workspace = true }
 
 clap = { workspace = true, features = ["derive", "cargo"] }
 convert_case = { workspace = true }
@@ -32,7 +34,7 @@ uuid = { workspace = true, features = ["v4"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 toml = { workspace = true }
-cargo_toml = { workspace = true }
+cargo_toml = { workspace = true, features = ["features"] }
 futures-util = { workspace = true, features = ["async-await-macro"] }
 notify = { workspace = true, features = ["serde"] }
 html_parser = { workspace = true }
@@ -47,8 +49,8 @@ hyper-rustls = { workspace = true }
 rustls = { workspace = true }
 rayon = { workspace = true }
 futures-channel = { workspace = true }
-cargo-config2 = { workspace = true, optional = true }
-krates = { version = "0.17.5" }
+target-lexicon = { version = "0.13.2", features = ["serde", "serde_support"] }
+krates = { workspace = true }
 regex = "1.11.1"
 console = "0.15.11"
 ctrlc = "3.4.5"
@@ -75,7 +77,7 @@ which = { version = "7.0.2" }
 
 # plugin packages
 open = { workspace = true }
-cargo-generate = "0.22.1"
+cargo-generate = "0.23.3"
 toml_edit = "0.22.24"
 
 # formatting
@@ -92,11 +94,12 @@ tracing-subscriber = { version = "0.3.19", features = ["std", "env-filter", "jso
 console-subscriber = { version = "0.4.1", optional = true }
 tracing = { workspace = true }
 wasm-opt = { version = "0.116.1", optional = true }
-crossterm = { version = "0.28.1", features = ["event-stream"] }
-ansi-to-tui = "7.0.0"
-ansi-to-html = "0.2.2"
-path-absolutize = "3.1"
-ratatui = { version = "0.29.0", features = ["crossterm", "unstable"] }
+ansi-to-tui = { workspace = true }
+ansi-to-html = { workspace = true }
+path-absolutize = { workspace = true }
+crossterm = { workspace = true, features = ["event-stream"] }
+ratatui = { workspace = true, features = ["crossterm", "unstable"] }
+shell-words = { workspace = true }
 
 # disable `log` entirely since `walrus` uses it and is *much* slower with it enableda
 log = { version = "0.4", features = ["max_level_off", "release_max_level_off"] }
@@ -107,13 +110,16 @@ manganis = { workspace = true }
 manganis-core = { workspace = true }
 
 # Extracting data from an executable
-object = { version = "0.36.7", features = ["wasm"] }
+object = { workspace = true, features = ["all"] }
 tokio-util = { workspace = true, features = ["full"] }
 itertools = { workspace = true }
 throbber-widgets-tui = "0.8.0"
 unicode-segmentation = "1.12.0"
 handlebars = "6.3.1"
 strum = { version = "0.27.1", features = ["derive"] }
+memmap = "0.7.0"
+walrus = { workspace = true, features = ["parallel"]}
+wasmparser = { workspace = true }
 
 tauri-utils = { workspace = true }
 tauri-bundler = { workspace = true }
@@ -124,6 +130,11 @@ local-ip-address = "0.6.3"
 dircpy = "0.3.19"
 plist = "1.7.0"
 memoize = "0.5.1"
+wasm-encoder = "0.228.0"
+backtrace = "0.3.74"
+ar = "0.9.0"
+wasm-bindgen-externref-xform = "0.2.100"
+pdb = "0.8.0"
 
 [build-dependencies]
 built = { version = "0.7.5", features = ["git2"] }

packages/cli/assets/android/gen/app/src/main/AndroidManifest.xml.hbs

@@ -3,6 +3,8 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <application android:hasCode="true" android:supportsRtl="true" android:icon="@mipmap/ic_launcher"
+        android:extractNativeLibs="true"
+        android:allowNativeHeapPointerTagging="false"
         android:label="@string/app_name" android:theme="@style/AppTheme">
         <activity android:configChanges="orientation|screenLayout|screenSize|keyboardHidden" android:exported="true"
             android:label="@string/app_name" android:name="dev.dioxus.main.MainActivity">

packages/cli/assets/web/dev.index.html

@@ -0,0 +1,184 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>{app_title}</title>
+        <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <meta charset="UTF-8">
+        <style>
+            /* Inter Font */
+            @import url('https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap');
+
+            #dx-toast-template {
+                display: none;
+                visibility: hidden;
+            }
+
+            .dx-toast {
+                position: absolute;
+                top: 10px;
+                right: 0;
+                padding-right: 10px;
+                user-select: none;
+                /* transition: transform 0.2s ease; */
+                z-index: 2147483647;
+            }
+
+            .dx-toast .dx-toast-inner {
+                /* transition: right 0.2s ease-out; */
+                position: fixed;
+
+                background-color: #181B20;
+                color: #ffffff;
+                font-family: "Inter", sans-serif;
+
+                display: grid;
+                grid-template-columns: auto auto;
+                max-width: 400px;
+                min-height: 56px;
+                border-radius: 5px;
+            }
+
+            .dx-toast .dx-toast-inner {
+                cursor: pointer;
+                margin-right: 10px;
+            }
+
+            .dx-toast .dx-toast-level-bar-container {
+                height: 100%;
+                width: 6px;
+            }
+
+            .dx-toast .dx-toast-level-bar-container .dx-toast-level-bar {
+                width: 100%;
+                height: 100%;
+                border-radius: 5px 0px 0px 5px;
+            }
+
+            .dx-toast .dx-toast-content {
+                padding: 8px;
+            }
+
+            .dx-toast .dx-toast-header {
+                display: flex;
+                flex-direction: row;
+                justify-content: start;
+                align-items: end;
+                margin-bottom: 10px;
+            }
+
+            .dx-toast .dx-toast-header>svg {
+                height: 18px;
+                margin-right: 5px;
+            }
+
+            .dx-toast .dx-toast-header .dx-toast-header-text {
+                font-size: 14px;
+                font-weight: 700;
+                padding: 0;
+                margin: 0;
+            }
+
+            .dx-toast .dx-toast-msg {
+                font-size: 11px;
+                font-weight: 400;
+                padding: 0;
+                margin: 0;
+            }
+
+            .dx-toast-level-bar.info {
+                background-color: #428EFF;
+            }
+
+            .dx-toast-level-bar.success {
+                background-color: #42FF65;
+            }
+
+            .dx-toast-level-bar.error {
+                background-color: #FF4242;
+            }
+        </style>
+        <script>
+            const STORAGE_KEY = "SCHEDULED-DX-TOAST";
+            let currentTimeout = null;
+            let currentToastId = 0;
+
+            // Show a toast, removing the previous one.
+            function showDXToast(headerText, message, progressLevel, durationMs) {
+                document.getElementById("__dx-toast-decor").className = `dx-toast-level-bar ${progressLevel}`;
+                document.getElementById("__dx-toast-text").innerText = headerText;
+                document.getElementById("__dx-toast-msg").innerText = message;
+                document.getElementById("__dx-toast-inner").style.right = "0";
+                document.getElementById("__dx-toast").addEventListener("click", closeDXToast);
+
+
+                // Wait a bit of time so animation plays correctly.
+                setTimeout(
+                    () => {
+                        let ourToastId = currentToastId;
+                        currentTimeout = setTimeout(() => {
+                            if (ourToastId == currentToastId) {
+                                closeDXToast();
+                            }
+                        }, durationMs);
+                    },
+                    100
+                );
+
+                currentToastId += 1;
+            }
+
+            // Schedule a toast to be displayed after reload.
+            function scheduleDXToast(headerText, message, level, durationMs) {
+                let data = {
+                    headerText,
+                    message,
+                    level,
+                    durationMs,
+                };
+
+                let jsonData = JSON.stringify(data);
+                sessionStorage.setItem(STORAGE_KEY, jsonData);
+            }
+
+            // Close the current toast.
+            function closeDXToast() {
+                document.getElementById("__dx-toast-inner").style.right = "-1000px";
+                clearTimeout(currentTimeout);
+            }
+
+            // Handle any scheduled toasts after reload.
+            let potentialData = sessionStorage.getItem(STORAGE_KEY);
+            if (potentialData) {
+                sessionStorage.removeItem(STORAGE_KEY);
+                let data = JSON.parse(potentialData);
+                showDXToast(data.headerText, data.message, data.level, data.durationMs);
+            }
+
+            window.scheduleDXToast = scheduleDXToast;
+            window.showDXToast = showDXToast;
+            window.closeDXToast = closeDXToast;
+        </script>
+    </head>
+    <body>
+        <div id="__dx-toast" class="dx-toast">
+            <div id="__dx-toast-inner" class="dx-toast-inner" style="right:-1000px;">
+                <div class="dx-toast-level-bar-container">
+                    <div id="__dx-toast-decor" class="dx-toast-level-bar __info"></div>
+                </div>
+                <div class="dx-toast-content">
+                    <div class="dx-toast-header">
+                        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" preserveAspectRatio="none">
+                            <path d="M22.158 1.783c0 3.077-.851 5.482-2.215 7.377s-3.32 3.557-5.447 5.33-4.425 3.657-6.252 6.195-3.102 5.515-3.102 9.532h4.699c0-3.077.853-5.377 2.217-7.272s3.32-3.557 5.447-5.33 4.425-3.657 6.252-6.195 3.102-5.62 3.102-9.637z" fill="#e96020"/>
+                            <path d="M9.531 25.927c-.635 0-1.021.515-1.02 1.15s.385 1.151 1.02 1.15H22.47a1.151 1.151 0 1 0 0-2.301zm1.361-4.076c-.608 0-.954.558-.953 1.166s.346 1.035.953 1.035h10.217a1.101 1.101 0 1 0 0-2.201zm0-13.594a1.101 1.101 0 1 0 0 2.201h10.217c.607 0 .953-.598.953-1.205s-.345-.996-.953-.996zM9.531 4.021A1.15 1.15 0 0 0 8.38 5.17a1.15 1.15 0 0 0 1.15 1.15h12.94c.635 0 1.021-.498 1.02-1.133s-.386-1.166-1.02-1.166z" fill="#2d323b"/>
+                            <path d="M5.142 1.783c0 4.016 1.275 7.099 3.102 9.637s4.125 4.422 6.252 6.195 4.083 3.656 5.447 5.551 2.215 3.974 2.215 7.051h4.701c0-4.016-1.275-7.038-3.102-9.576s-4.125-4.422-6.252-6.195-4.083-3.435-5.447-5.33S9.841 4.86 9.841 1.783z" fill="#00a8d6"/>
+                        </svg>
+                        <h3 id="__dx-toast-text" class="dx-toast-header-text">Your app is being rebuilt.</h3>
+                    </div>
+                    <p id="__dx-toast-msg" class="dx-toast-msg">A non-hot-reloadable change occurred and we must rebuild.</p>
+                </div>
+            </div>
+        </div>
+        <div id="main"></div>
+    </body>
+</html>

packages/cli/assets/web/index.html

@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>{app_title}</title>
-    <meta content="text/html;charset=utf-8" http-equiv="Content-Type" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta charset="UTF-8" />
-  </head>
-  <body>
-    <div id="main"></div>
-  </body>
-</html>

packages/cli/assets/web/prod.index.html

@@ -0,0 +1,11 @@
+<html>
+    <head>
+        <title>{app_title}</title>
+        <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <meta charset="UTF-8">
+    </head>
+    <body>
+        <div id="main"></div>
+    </body>
+</html>

packages/cli/assets/web/toast.html

@@ -1,207 +0,0 @@
-<style>
-  /* Inter Font */
-  @import url('https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap');
-
-  #dx-toast-template {
-    display: none;
-    visibility: hidden;
-  }
-
-  .dx-toast {
-    position: absolute;
-    top: 10px;
-    right: 0;
-    padding-right: 10px;
-    user-select: none;
-    transition: transform 0.2s ease;
-    z-index: 2147483647;
-  }
-
-  .dx-toast .dx-toast-inner {
-    transition: right 0.2s ease-out;
-    position: fixed;
-
-    background-color: #181B20;
-    color: #ffffff;
-    font-family: "Inter", sans-serif;
-
-    display: grid;
-    grid-template-columns: auto auto;
-    min-width: 280px;
-    min-height: 92px;
-    width: min-content;
-    border-radius: 5px;
-
-  }
-
-  .dx-toast:hover {
-    cursor: pointer;
-    transform: translateX(-5px);
-  }
-
-  .dx-toast .dx-toast-level-bar-container {
-    height: 100%;
-    width: 6px;
-  }
-
-  .dx-toast .dx-toast-level-bar-container .dx-toast-level-bar {
-    width: 100%;
-    height: 100%;
-    border-radius: 5px 0px 0px 5px;
-  }
-
-  .dx-toast .dx-toast-content {
-    padding: 13px;
-  }
-
-  .dx-toast .dx-toast-header {
-    display: flex;
-    flex-direction: row;
-    justify-content: start;
-    align-items: end;
-    margin-bottom: 13px;
-  }
-
-  .dx-toast .dx-toast-header>svg {
-    height: 22px;
-    margin-right: 5px;
-  }
-
-  .dx-toast .dx-toast-header .dx-toast-header-text {
-    font-size: 16px;
-    font-weight: 700;
-    padding: 0;
-    margin: 0;
-  }
-
-  .dx-toast .dx-toast-msg {
-    font-size: 14px;
-    font-weight: 400;
-    padding: 0;
-    margin: 0;
-  }
-
-  .dx-toast-level-bar.info {
-    background-color: #428EFF;
-  }
-
-  .dx-toast-level-bar.success {
-    background-color: #42FF65;
-  }
-
-  .dx-toast-level-bar.error {
-    background-color: #FF4242;
-  }
-</style>
-
-<div id="dx-toast-template" class="dx-toast" hidden>
-  <div class="dx-toast-inner" style="right:-300px;">
-    <!-- Level/Color decor -->
-    <div class="dx-toast-level-bar-container">
-      <div class="dx-toast-level-bar info"></div>
-    </div>
-
-    <!-- Content -->
-    <div class="dx-toast-content">
-      <!-- Header -->
-      <div class="dx-toast-header">
-        <!-- Dioxus Logo -->
-        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" preserveAspectRatio="none">
-          <path
-            d="M22.158 1.783c0 3.077-.851 5.482-2.215 7.377s-3.32 3.557-5.447 5.33-4.425 3.657-6.252 6.195-3.102 5.515-3.102 9.532h4.699c0-3.077.853-5.377 2.217-7.272s3.32-3.557 5.447-5.33 4.425-3.657 6.252-6.195 3.102-5.62 3.102-9.637z"
-            fill="#e96020" />
-          <path
-            d="M9.531 25.927c-.635 0-1.021.515-1.02 1.15s.385 1.151 1.02 1.15H22.47a1.151 1.151 0 1 0 0-2.301zm1.361-4.076c-.608 0-.954.558-.953 1.166s.346 1.035.953 1.035h10.217a1.101 1.101 0 1 0 0-2.201zm0-13.594a1.101 1.101 0 1 0 0 2.201h10.217c.607 0 .953-.598.953-1.205s-.345-.996-.953-.996zM9.531 4.021A1.15 1.15 0 0 0 8.38 5.17a1.15 1.15 0 0 0 1.15 1.15h12.94c.635 0 1.021-.498 1.02-1.133s-.386-1.166-1.02-1.166z"
-            fill="#2d323b" />
-          <path
-            d="M5.142 1.783c0 4.016 1.275 7.099 3.102 9.637s4.125 4.422 6.252 6.195 4.083 3.656 5.447 5.551 2.215 3.974 2.215 7.051h4.701c0-4.016-1.275-7.038-3.102-9.576s-4.125-4.422-6.252-6.195-4.083-3.435-5.447-5.33S9.841 4.86 9.841 1.783z"
-            fill="#00a8d6" />
-        </svg>
-        <!-- Toast Title Text -->
-        <h3 class="dx-toast-header-text">Your app is being rebuilt.</h3>
-      </div>
-
-      <!-- Message -->
-      <p class="dx-toast-msg">A non-hot-reloadable change occurred and we must rebuild.</p>
-    </div>
-  </div>
-</div>
-
-<script>
-  const STORAGE_KEY = "SCHEDULED-DX-TOAST";
-  let currentToast = null;
-  let currentTimeout = null;
-
-  // Show a toast, removing the previous one.
-  function showDXToast(headerText, message, progressLevel, durationMs) {
-    // Close current toast if exists.
-    closeDXToast();
-
-    // Clone template and add unique id.
-    let toastTemplate = document.getElementById("dx-toast-template");
-    let cloned = toastTemplate.cloneNode(true);
-    let toastId = `dx-toast`;
-    cloned.id = toastId;
-    currentToast = cloned;
-
-    let innerElem = currentToast.querySelector(`#${toastId} .dx-toast-inner`);
-
-    // Set the progress level
-    let progressBarElem = innerElem.querySelector(".dx-toast-inner .dx-toast-level-bar-container .dx-toast-level-bar");
-    progressBarElem.className = `dx-toast-level-bar ${progressLevel}`;
-
-    // Set header text
-    let headerTextElem = innerElem.querySelector(".dx-toast-inner .dx-toast-header .dx-toast-header-text");
-    headerTextElem.innerText = headerText;
-
-    // Set message
-    let messageElem = innerElem.querySelector(".dx-toast-inner .dx-toast-msg");
-    messageElem.innerText = message;
-
-    currentToast.removeAttribute("hidden");
-    document.body.appendChild(currentToast);
-
-    // Add listener to close toasts when clicked.
-    // Safety: Calling `closeToast` removes the element and all event listeners with it.
-    currentToast.addEventListener("click", closeDXToast);
-
-    // Wait a bit of time so animation plays correctly.
-    setTimeout(() => {
-      innerElem.style.right = "0";
-
-      currentTimeout = setTimeout(() => {
-        closeDXToast();
-      }, durationMs);
-    }, 100);
-  }
-
-  // Schedule a toast to be displayed after reload.
-  function scheduleDXToast(headerText, message, level, durationMs) {
-    let data = {
-      headerText,
-      message,
-      level,
-      durationMs,
-    };
-
-    let jsonData = JSON.stringify(data);
-    sessionStorage.setItem(STORAGE_KEY, jsonData);
-  }
-
-  // Close the current toast.
-  function closeDXToast() {
-    if (currentToast) {
-      currentToast.remove();
-    }
-    clearTimeout(currentTimeout);
-  }
-
-  // Handle any scheduled toasts after reload.
-  let potentialData = sessionStorage.getItem(STORAGE_KEY);
-  if (potentialData) {
-    sessionStorage.removeItem(STORAGE_KEY);
-    let data = JSON.parse(potentialData);
-    showDXToast(data.headerText, data.message, data.level, data.durationMs);
-  }
-
-</script>

packages/cli/src/build/builder.rs

@@ -1,10 +1,29 @@
 use crate::{
-    AppBundle, BuildArgs, BuildRequest, BuildStage, BuildUpdate, DioxusCrate, ProgressRx,
-    ProgressTx, Result, StructuredOutput,
+    BuildArtifacts, BuildRequest, BuildStage, BuilderUpdate, Platform, ProgressRx, ProgressTx,
+    Result, StructuredOutput,
 };
-use std::time::{Duration, Instant};
+use anyhow::Context;
+use dioxus_cli_opt::process_file_to;
+use futures_util::future::OptionFuture;
+use std::{
+    env,
+    time::{Duration, Instant, SystemTime},
+};
+use std::{
+    net::SocketAddr,
+    path::{Path, PathBuf},
+    process::Stdio,
+};
+use subsecond_types::JumpTable;
+use tokio::{
+    io::{AsyncBufReadExt, BufReader, Lines},
+    process::{Child, ChildStderr, ChildStdout, Command},
+    task::JoinHandle,
+};
+
+use super::{BuildContext, BuildId, BuildMode, HotpatchModuleCache};
 
-/// The component of the serve engine that watches ongoing builds and manages their state, handle,
+/// The component of the serve engine that watches ongoing builds and manages their state, open handle,
 /// and progress.
 ///
 /// Previously, the builder allowed multiple apps to be built simultaneously, but this newer design
@@ -12,82 +31,173 @@ use std::time::{Duration, Instant};
 ///
 /// Here, we track the number of crates being compiled, assets copied, the times of these events, and
 /// other metadata that gives us useful indicators for the UI.
-pub(crate) struct Builder {
-    // Components of the build
-    pub krate: DioxusCrate,
-    pub request: BuildRequest,
-    pub build: tokio::task::JoinHandle<Result<AppBundle>>,
+///
+/// A handle to a running app.
+///
+/// The actual child processes might not be present (web) or running (died/killed).
+///
+/// The purpose of this struct is to accumulate state about the running app and its server, like
+/// any runtime information needed to hotreload the app or send it messages.
+///
+/// We might want to bring in websockets here too, so we know the exact channels the app is using to
+/// communicate with the devserver. Currently that's a broadcast-type system, so this struct isn't super
+/// duper useful.
+///
+/// todo: restructure this such that "open" is a running task instead of blocking the main thread
+pub(crate) struct AppBuilder {
     pub tx: ProgressTx,
     pub rx: ProgressRx,
 
+    // The original request with access to its build directory
+    pub build: BuildRequest,
+
+    // Ongoing build task, if any
+    pub build_task: JoinHandle<Result<BuildArtifacts>>,
+
+    // If a build has already finished, we'll have its artifacts (rustc, link args, etc) to work with
+    pub artifacts: Option<BuildArtifacts>,
+
+    /// The aslr offset of this running app
+    pub aslr_reference: Option<u64>,
+
+    /// The list of patches applied to the app, used to know which ones to reapply and/or iterate from.
+    pub patches: Vec<JumpTable>,
+    pub patch_cache: Option<HotpatchModuleCache>,
+
+    /// The virtual directory that assets will be served from
+    /// Used mostly for apk/ipa builds since they live in simulator
+    pub runtime_asset_dir: Option<PathBuf>,
+
+    // These might be None if the app died or the user did not specify a server
+    pub child: Option<Child>,
+
+    // stdio for the app so we can read its stdout/stderr
+    // we don't map stdin today (todo) but most apps don't need it
+    pub stdout: Option<Lines<BufReader<ChildStdout>>>,
+    pub stderr: Option<Lines<BufReader<ChildStderr>>>,
+
+    /// The executables but with some extra entropy in their name so we can run two instances of the
+    /// same app without causing collisions on the filesystem.
+    pub entropy_app_exe: Option<PathBuf>,
+    pub builds_opened: usize,
+
     // Metadata about the build that needs to be managed by watching build updates
     // used to render the TUI
     pub stage: BuildStage,
     pub compiled_crates: usize,
-    pub compiled_crates_server: usize,
     pub expected_crates: usize,
-    pub expected_crates_server: usize,
     pub bundling_progress: f64,
     pub compile_start: Option<Instant>,
     pub compile_end: Option<Instant>,
-    pub compile_end_server: Option<Instant>,
     pub bundle_start: Option<Instant>,
     pub bundle_end: Option<Instant>,
 }
 
-impl Builder {
-    /// Create a new builder and immediately start a build
-    pub(crate) fn start(krate: &DioxusCrate, args: BuildArgs) -> Result<Self> {
+impl AppBuilder {
+    /// Create a new `AppBuilder` and immediately start a build process.
+    ///
+    /// This method initializes the builder with the provided `BuildRequest` and spawns an asynchronous
+    /// task (`build_task`) to handle the build process. The build process involves several stages:
+    ///
+    /// 1. **Tooling Verification**: Ensures that the necessary tools are available for the build.
+    /// 2. **Build Directory Preparation**: Sets up the directory structure required for the build.
+    /// 3. **Build Execution**: Executes the build process asynchronously.
+    /// 4. **Bundling**: Packages the built artifacts into a final bundle.
+    ///
+    /// The `build_task` is a Tokio task that runs the build process in the background. It uses a
+    /// `BuildContext` to manage the build state and communicate progress or errors via a message
+    /// channel (`tx`).
+    ///
+    /// The builder is initialized with default values for various fields, such as the build stage,
+    /// progress metrics, and optional runtime configurations.
+    ///
+    /// # Notes
+    ///
+    /// - The `build_task` is immediately spawned and will run independently of the caller.
+    /// - The caller can use other methods on the `AppBuilder` to monitor the build progress or handle
+    ///   updates (e.g., `wait`, `finish_build`).
+    /// - The build process is designed to be cancellable and restartable using methods like `abort_all`
+    ///   or `rebuild`.
+    pub(crate) fn start(request: &BuildRequest, mode: BuildMode) -> Result<Self> {
         let (tx, rx) = futures_channel::mpsc::unbounded();
-        let request = BuildRequest::new(krate.clone(), args, tx.clone());
 
         Ok(Self {
-            krate: krate.clone(),
-            request: request.clone(),
+            build: request.clone(),
             stage: BuildStage::Initializing,
-            build: tokio::spawn(async move {
-                // On the first build, we want to verify the tooling
-                // We wont bother verifying on subsequent builds
-                request.verify_tooling().await?;
-
-                request.build_all().await
+            build_task: tokio::spawn({
+                let request = request.clone();
+                let tx = tx.clone();
+                async move {
+                    let ctx = BuildContext {
+                        mode,
+                        tx: tx.clone(),
+                    };
+                    request.verify_tooling(&ctx).await?;
+                    request.prepare_build_dir()?;
+                    request.build(&ctx).await
+                }
             }),
             tx,
             rx,
+            patches: vec![],
             compiled_crates: 0,
             expected_crates: 1,
-            expected_crates_server: 1,
-            compiled_crates_server: 0,
             bundling_progress: 0.0,
+            builds_opened: 0,
             compile_start: Some(Instant::now()),
+            aslr_reference: None,
             compile_end: None,
-            compile_end_server: None,
             bundle_start: None,
             bundle_end: None,
+            runtime_asset_dir: None,
+            child: None,
+            stderr: None,
+            stdout: None,
+            entropy_app_exe: None,
+            artifacts: None,
+            patch_cache: None,
         })
     }
 
     /// Wait for any new updates to the builder - either it completed or gave us a message etc
-    pub(crate) async fn wait(&mut self) -> BuildUpdate {
+    pub(crate) async fn wait(&mut self) -> BuilderUpdate {
         use futures_util::StreamExt;
+        use BuilderUpdate::*;
 
         // Wait for the build to finish or for it to emit a status message
         let update = tokio::select! {
             Some(progress) = self.rx.next() => progress,
-            bundle = (&mut self.build) => {
+            bundle = (&mut self.build_task) => {
                 // Replace the build with an infinitely pending task so we can select it again without worrying about deadlocks/spins
-                self.build = tokio::task::spawn(std::future::pending());
+                self.build_task = tokio::task::spawn(std::future::pending());
                 match bundle {
-                    Ok(Ok(bundle)) => BuildUpdate::BuildReady { bundle },
-                    Ok(Err(err)) => BuildUpdate::BuildFailed { err },
-                    Err(err) => BuildUpdate::BuildFailed { err: crate::Error::Runtime(format!("Build panicked! {:?}", err)) },
+                    Ok(Ok(bundle)) => BuilderUpdate::BuildReady { bundle },
+                    Ok(Err(err)) => BuilderUpdate::BuildFailed { err },
+                    Err(err) => BuilderUpdate::BuildFailed { err: crate::Error::Runtime(format!("Build panicked! {:#?}", err)) },
                 }
             },
+            Some(Ok(Some(msg))) = OptionFuture::from(self.stdout.as_mut().map(|f| f.next_line())) => {
+                StdoutReceived {  msg }
+            },
+            Some(Ok(Some(msg))) = OptionFuture::from(self.stderr.as_mut().map(|f| f.next_line())) => {
+                StderrReceived {  msg }
+            },
+            Some(status) = OptionFuture::from(self.child.as_mut().map(|f| f.wait())) => {
+                // Panicking here is on purpose. If the task crashes due to a JoinError (a panic),
+                // we want to propagate that panic up to the serve controller.
+                let status = status.unwrap();
+                self.child = None;
+
+                ProcessExited { status }
+            }
         };
 
         // Update the internal stage of the build so the UI can render it
+        // *VERY IMPORTANT* - DO NOT AWAIT HERE
+        // doing so will cause the changes to be lost since this wait call is called under a cancellable task
+        // todo - move this handling to a separate function that won't be cancelled
         match &update {
-            BuildUpdate::Progress { stage } => {
+            BuilderUpdate::Progress { stage } => {
                 // Prevent updates from flowing in after the build has already finished
                 if !self.is_finished() {
                     self.stage = stage.clone();
@@ -95,33 +205,15 @@ impl Builder {
                     match stage {
                         BuildStage::Initializing => {
                             self.compiled_crates = 0;
-                            self.compiled_crates_server = 0;
                             self.bundling_progress = 0.0;
                         }
-                        BuildStage::Starting {
-                            crate_count,
-                            is_server,
-                        } => {
-                            if *is_server {
-                                self.expected_crates_server = *crate_count;
-                            } else {
-                                self.expected_crates = *crate_count;
-                            }
+                        BuildStage::Starting { crate_count, .. } => {
+                            self.expected_crates = *crate_count;
                         }
                         BuildStage::InstallingTooling => {}
-                        BuildStage::Compiling {
-                            current,
-                            total,
-                            is_server,
-                            ..
-                        } => {
-                            if *is_server {
-                                self.compiled_crates_server = *current;
-                                self.expected_crates_server = *total;
-                            } else {
-                                self.compiled_crates = *current;
-                                self.expected_crates = *total;
-                            }
+                        BuildStage::Compiling { current, total, .. } => {
+                            self.compiled_crates = *current;
+                            self.expected_crates = *total;
 
                             if self.compile_start.is_none() {
                                 self.compile_start = Some(Instant::now());
@@ -138,18 +230,15 @@ impl Builder {
                         }
                         BuildStage::Success => {
                             self.compiled_crates = self.expected_crates;
-                            self.compiled_crates_server = self.expected_crates_server;
                             self.bundling_progress = 1.0;
                         }
                         BuildStage::Failed => {
                             self.compiled_crates = self.expected_crates;
-                            self.compiled_crates_server = self.expected_crates_server;
                             self.bundling_progress = 1.0;
                         }
                         BuildStage::Aborted => {}
                         BuildStage::Restarting => {
                             self.compiled_crates = 0;
-                            self.compiled_crates_server = 0;
                             self.expected_crates = 1;
                             self.bundling_progress = 0.0;
                         }
@@ -158,53 +247,100 @@ impl Builder {
                     }
                 }
             }
-            BuildUpdate::CompilerMessage { .. } => {}
-            BuildUpdate::BuildReady { .. } => {
+            BuilderUpdate::CompilerMessage { .. } => {}
+            BuilderUpdate::BuildReady { .. } => {
                 self.compiled_crates = self.expected_crates;
-                self.compiled_crates_server = self.expected_crates_server;
                 self.bundling_progress = 1.0;
                 self.stage = BuildStage::Success;
 
                 self.complete_compile();
                 self.bundle_end = Some(Instant::now());
             }
-            BuildUpdate::BuildFailed { .. } => {
+            BuilderUpdate::BuildFailed { .. } => {
                 tracing::debug!("Setting builder to failed state");
                 self.stage = BuildStage::Failed;
             }
+            StdoutReceived { .. } => {}
+            StderrReceived { .. } => {}
+            ProcessExited { .. } => {}
         }
 
         update
     }
 
-    /// Restart this builder with new build arguments.
-    pub(crate) fn rebuild(&mut self, args: BuildArgs) {
+    pub(crate) fn patch_rebuild(&mut self, changed_files: Vec<PathBuf>) {
+        // We need the rustc args from the original build to pass to the new build
+        let Some(artifacts) = self.artifacts.as_ref().cloned() else {
+            tracing::warn!("Ignoring patch rebuild since there is no existing build.");
+            return;
+        };
+
+        // On web, our patches are fully relocatable, so we don't need to worry about ASLR, but
+        // for all other platforms, we need to use the ASLR reference to know where to insert the patch.
+        let aslr_reference = match self.aslr_reference {
+            Some(val) => val,
+            None if self.build.platform == Platform::Web => 0,
+            None => {
+                tracing::warn!(
+                    "Ignoring hotpatch since there is no ASLR reference. Is the client connected?"
+                );
+                return;
+            }
+        };
+
+        let cache = artifacts
+            .patch_cache
+            .clone()
+            .context("Failed to get patch cache")
+            .unwrap();
+
         // Abort all the ongoing builds, cleaning up any loose artifacts and waiting to cleanly exit
-        self.abort_all();
+        self.abort_all(BuildStage::Restarting);
+        self.build_task = tokio::spawn({
+            let request = self.build.clone();
+            let ctx = BuildContext {
+                tx: self.tx.clone(),
+                mode: BuildMode::Thin {
+                    changed_files,
+                    rustc_args: artifacts.direct_rustc,
+                    aslr_reference,
+                    cache,
+                },
+            };
+            async move { request.build(&ctx).await }
+        });
+    }
 
+    /// Restart this builder with new build arguments.
+    pub(crate) fn start_rebuild(&mut self, mode: BuildMode) {
+        // Abort all the ongoing builds, cleaning up any loose artifacts and waiting to cleanly exit
         // And then start a new build, resetting our progress/stage to the beginning and replacing the old tokio task
-        let request = BuildRequest::new(self.krate.clone(), args, self.tx.clone());
-        self.request = request.clone();
-        self.stage = BuildStage::Restarting;
-
-        // This build doesn't have any extra special logging - rebuilds would get pretty noisy
-        self.build = tokio::spawn(async move { request.build_all().await });
+        self.abort_all(BuildStage::Restarting);
+        self.artifacts.take();
+        self.patch_cache.take();
+        self.build_task = tokio::spawn({
+            let request = self.build.clone();
+            let ctx = BuildContext {
+                tx: self.tx.clone(),
+                mode,
+            };
+            async move { request.build(&ctx).await }
+        });
     }
 
     /// Shutdown the current build process
     ///
     /// todo: might want to use a cancellation token here to allow cleaner shutdowns
-    pub(crate) fn abort_all(&mut self) {
-        self.build.abort();
-        self.stage = BuildStage::Aborted;
+    pub(crate) fn abort_all(&mut self, stage: BuildStage) {
+        self.stage = stage;
         self.compiled_crates = 0;
-        self.compiled_crates_server = 0;
         self.expected_crates = 1;
         self.bundling_progress = 0.0;
         self.compile_start = None;
         self.bundle_start = None;
         self.bundle_end = None;
         self.compile_end = None;
+        self.build_task.abort();
     }
 
     /// Wait for the build to finish, returning the final bundle
@@ -212,10 +348,10 @@ impl Builder {
     ///
     /// todo(jon): maybe we want to do some logging here? The build/bundle/run screens could be made to
     /// use the TUI output for prettier outputs.
-    pub(crate) async fn finish(&mut self) -> Result<AppBundle> {
+    pub(crate) async fn finish_build(&mut self) -> Result<BuildArtifacts> {
         loop {
             match self.wait().await {
-                BuildUpdate::Progress { stage } => {
+                BuilderUpdate::Progress { stage } => {
                     match &stage {
                         BuildStage::Compiling {
                             current,
@@ -239,19 +375,19 @@ impl Builder {
 
                     tracing::info!(json = ?StructuredOutput::BuildUpdate { stage: stage.clone() });
                 }
-                BuildUpdate::CompilerMessage { message } => {
+                BuilderUpdate::CompilerMessage { message } => {
                     tracing::info!(json = ?StructuredOutput::CargoOutput { message: message.clone() }, %message);
                 }
-                BuildUpdate::BuildReady { bundle } => {
+                BuilderUpdate::BuildReady { bundle } => {
                     tracing::debug!(json = ?StructuredOutput::BuildFinished {
-                        path: bundle.build.root_dir(),
+                        path: self.build.root_dir(),
                     });
                     return Ok(bundle);
                 }
-                BuildUpdate::BuildFailed { err } => {
+                BuilderUpdate::BuildFailed { err } => {
                     // Flush remaining compiler messages
                     while let Ok(Some(msg)) = self.rx.try_next() {
-                        if let BuildUpdate::CompilerMessage { message } = msg {
+                        if let BuilderUpdate::CompilerMessage { message } = msg {
                             tracing::info!(json = ?StructuredOutput::CargoOutput { message: message.clone() }, %message);
                         }
                     }
@@ -259,15 +395,872 @@ impl Builder {
                     tracing::error!(?err, json = ?StructuredOutput::Error { message: err.to_string() });
                     return Err(err);
                 }
+                BuilderUpdate::StdoutReceived { .. } => {}
+                BuilderUpdate::StderrReceived { .. } => {}
+                BuilderUpdate::ProcessExited { .. } => {}
+            }
+        }
+    }
+
+    pub(crate) async fn open(
+        &mut self,
+        devserver_ip: SocketAddr,
+        open_address: Option<SocketAddr>,
+        start_fullstack_on_address: Option<SocketAddr>,
+        open_browser: bool,
+        always_on_top: bool,
+        build_id: BuildId,
+    ) -> Result<()> {
+        let krate = &self.build;
+
+        // Set the env vars that the clients will expect
+        // These need to be stable within a release version (ie 0.6.0)
+        let mut envs = vec![
+            (dioxus_cli_config::CLI_ENABLED_ENV, "true".to_string()),
+            (
+                dioxus_cli_config::DEVSERVER_IP_ENV,
+                devserver_ip.ip().to_string(),
+            ),
+            (
+                dioxus_cli_config::DEVSERVER_PORT_ENV,
+                devserver_ip.port().to_string(),
+            ),
+            (
+                dioxus_cli_config::APP_TITLE_ENV,
+                krate.config.web.app.title.clone(),
+            ),
+            (
+                dioxus_cli_config::SESSION_CACHE_DIR,
+                self.build.session_cache_dir().display().to_string(),
+            ),
+            (dioxus_cli_config::BUILD_ID, build_id.0.to_string()),
+            (
+                dioxus_cli_config::ALWAYS_ON_TOP_ENV,
+                always_on_top.to_string(),
+            ),
+            // unset the cargo dirs in the event we're running `dx` locally
+            // since the child process will inherit the env vars, we don't want to confuse the downstream process
+            ("CARGO_MANIFEST_DIR", "".to_string()),
+            ("RUST_BACKTRACE", "1".to_string()),
+        ];
+
+        if let Some(base_path) = &krate.config.web.app.base_path {
+            envs.push((dioxus_cli_config::ASSET_ROOT_ENV, base_path.clone()));
+        }
+
+        if let Some(env_filter) = env::var_os("RUST_LOG").and_then(|e| e.into_string().ok()) {
+            envs.push(("RUST_LOG", env_filter));
+        }
+
+        // Launch the server if we were given an address to start it on, and the build includes a server. After we
+        // start the server, consume its stdout/stderr.
+        if let Some(addr) = start_fullstack_on_address {
+            envs.push((dioxus_cli_config::SERVER_IP_ENV, addr.ip().to_string()));
+            envs.push((dioxus_cli_config::SERVER_PORT_ENV, addr.port().to_string()));
+        }
+
+        // We try to use stdin/stdout to communicate with the app
+        let running_process = match self.build.platform {
+            // Unfortunately web won't let us get a proc handle to it (to read its stdout/stderr) so instead
+            // use use the websocket to communicate with it. I wish we could merge the concepts here,
+            // like say, opening the socket as a subprocess, but alas, it's simpler to do that somewhere else.
+            Platform::Web => {
+                // Only the first build we open the web app, after that the user knows it's running
+                if open_browser {
+                    self.open_web(open_address.unwrap_or(devserver_ip));
+                }
+
+                None
             }
+
+            Platform::Ios => Some(self.open_ios_sim(envs).await?),
+
+            Platform::Android => {
+                self.open_android_sim(false, devserver_ip, envs).await?;
+                None
+            }
+
+            // These are all just basically running the main exe, but with slightly different resource dir paths
+            Platform::Server
+            | Platform::MacOS
+            | Platform::Windows
+            | Platform::Linux
+            | Platform::Liveview => Some(self.open_with_main_exe(envs)?),
+        };
+
+        // If we have a running process, we need to attach to it and wait for its outputs
+        if let Some(mut child) = running_process {
+            let stdout = BufReader::new(child.stdout.take().unwrap());
+            let stderr = BufReader::new(child.stderr.take().unwrap());
+            self.stdout = Some(stdout.lines());
+            self.stderr = Some(stderr.lines());
+            self.child = Some(child);
+        }
+
+        self.builds_opened += 1;
+
+        Ok(())
+    }
+
+    /// Gracefully kill the process and all of its children
+    ///
+    /// Uses the `SIGTERM` signal on unix and `taskkill` on windows.
+    /// This complex logic is necessary for things like window state preservation to work properly.
+    ///
+    /// Also wipes away the entropy executables if they exist.
+    pub(crate) async fn soft_kill(&mut self) {
+        use futures_util::FutureExt;
+
+        // Kill any running executables on Windows
+        let Some(mut process) = self.child.take() else {
+            return;
+        };
+
+        let Some(pid) = process.id() else {
+            _ = process.kill().await;
+            return;
+        };
+
+        // on unix, we can send a signal to the process to shut down
+        #[cfg(unix)]
+        {
+            _ = Command::new("kill")
+                .args(["-s", "TERM", &pid.to_string()])
+                .spawn();
+        }
+
+        // on windows, use the `taskkill` command
+        #[cfg(windows)]
+        {
+            _ = Command::new("taskkill")
+                .args(["/F", "/PID", &pid.to_string()])
+                .spawn();
+        }
+
+        // join the wait with a 100ms timeout
+        futures_util::select! {
+            _ = process.wait().fuse() => {}
+            _ = tokio::time::sleep(std::time::Duration::from_millis(1000)).fuse() => {}
+        };
+
+        // Wipe out the entropy executables if they exist
+        if let Some(entropy_app_exe) = self.entropy_app_exe.take() {
+            _ = std::fs::remove_file(entropy_app_exe);
         }
     }
 
+    pub(crate) async fn hotpatch(
+        &mut self,
+        res: &BuildArtifacts,
+        cache: &HotpatchModuleCache,
+    ) -> Result<JumpTable> {
+        let original = self.build.main_exe();
+        let new = self.build.patch_exe(res.time_start);
+        let triple = self.build.triple.clone();
+        let original_artifacts = self.artifacts.as_ref().unwrap();
+        let asset_dir = self.build.asset_dir();
+
+        for (k, bundled) in res.assets.assets.iter() {
+            let k = dunce::canonicalize(k)?;
+            if original_artifacts.assets.assets.contains_key(k.as_path()) {
+                continue;
+            }
+
+            let from = k.clone();
+            let to = asset_dir.join(bundled.bundled_path());
+
+            tracing::debug!("Copying asset from patch: {}", k.display());
+            if let Err(e) = dioxus_cli_opt::process_file_to(bundled.options(), &from, &to) {
+                tracing::error!("Failed to copy asset: {e}");
+                continue;
+            }
+
+            // If the emulator is android, we need to copy the asset to the device with `adb push asset /data/local/tmp/dx/assets/filename.ext`
+            if self.build.platform == Platform::Android {
+                let changed_file = dunce::canonicalize(k).inspect_err(|e| {
+                    tracing::debug!("Failed to canonicalize hotreloaded asset: {e}")
+                })?;
+                let bundled_name = PathBuf::from(bundled.bundled_path());
+                _ = self
+                    .copy_file_to_android_tmp(&changed_file, &bundled_name)
+                    .await;
+            }
+        }
+
+        tracing::debug!("Patching {} -> {}", original.display(), new.display());
+
+        let mut jump_table = crate::build::create_jump_table(&new, &triple, cache)?;
+
+        // If it's android, we need to copy the assets to the device and then change the location of the patch
+        if self.build.platform == Platform::Android {
+            jump_table.lib = self
+                .copy_file_to_android_tmp(&new, &(PathBuf::from(new.file_name().unwrap())))
+                .await?;
+        }
+
+        // Rebase the wasm binary to be relocatable once the jump table is generated
+        if triple.architecture == target_lexicon::Architecture::Wasm32 {
+            // Make sure we use the dir relative to the public dir, so the web can load it as a proper URL
+            //
+            // ie we would've shipped `/Users/foo/Projects/dioxus/target/dx/project/debug/web/public/wasm/lib.wasm`
+            //    but we want to ship `/wasm/lib.wasm`
+            jump_table.lib =
+                PathBuf::from("/").join(jump_table.lib.strip_prefix(self.build.root_dir()).unwrap())
+        }
+
+        let changed_files = match &res.mode {
+            BuildMode::Thin { changed_files, .. } => changed_files.clone(),
+            _ => vec![],
+        };
+
+        let changed_file = changed_files.first().unwrap();
+        tracing::info!(
+            "Hot-patching: {} took {:?}ms",
+            changed_file
+                .strip_prefix(std::env::current_dir().unwrap())
+                .unwrap_or(changed_file.as_path())
+                .display(),
+            SystemTime::now()
+                .duration_since(res.time_start)
+                .unwrap()
+                .as_millis()
+        );
+
+        self.patches.push(jump_table.clone());
+
+        Ok(jump_table)
+    }
+
+    /// Hotreload an asset in the running app.
+    ///
+    /// This will modify the build dir in place! Be careful! We generally assume you want all bundles
+    /// to reflect the latest changes, so we will modify the bundle.
+    ///
+    /// However, not all platforms work like this, so we might also need to update a separate asset
+    /// dir that the system simulator might be providing. We know this is the case for ios simulators
+    /// and haven't yet checked for android.
+    ///
+    /// This will return the bundled name of the asset such that we can send it to the clients letting
+    /// them know what to reload. It's not super important that this is robust since most clients will
+    /// kick all stylsheets without necessarily checking the name.
+    pub(crate) async fn hotreload_bundled_asset(&self, changed_file: &PathBuf) -> Option<PathBuf> {
+        let artifacts = self.artifacts.as_ref()?;
+
+        // Use the build dir if there's no runtime asset dir as the override. For the case of ios apps,
+        // we won't actually be using the build dir.
+        let asset_dir = match self.runtime_asset_dir.as_ref() {
+            Some(dir) => dir.to_path_buf().join("assets/"),
+            None => self.build.asset_dir(),
+        };
+
+        tracing::debug!("Hotreloading asset {changed_file:?} in target {asset_dir:?}");
+
+        // Canonicalize the path as Windows may use long-form paths "\\\\?\\C:\\".
+        let changed_file = dunce::canonicalize(changed_file)
+            .inspect_err(|e| tracing::debug!("Failed to canonicalize hotreloaded asset: {e}"))
+            .ok()?;
+
+        // The asset might've been renamed thanks to the manifest, let's attempt to reload that too
+        let resource = artifacts.assets.assets.get(&changed_file)?;
+        let output_path = asset_dir.join(resource.bundled_path());
+
+        // Remove the old asset if it exists
+        _ = std::fs::remove_file(&output_path);
+
+        // And then process the asset with the options into the **old** asset location. If we recompiled,
+        // the asset would be in a new location because the contents and hash have changed. Since we are
+        // hotreloading, we need to use the old asset location it was originally written to.
+        let options = *resource.options();
+        let res = process_file_to(&options, &changed_file, &output_path);
+        let bundled_name = PathBuf::from(resource.bundled_path());
+        if let Err(e) = res {
+            tracing::debug!("Failed to hotreload asset {e}");
+        }
+
+        // If the emulator is android, we need to copy the asset to the device with `adb push asset /data/local/tmp/dx/assets/filename.ext`
+        if self.build.platform == Platform::Android {
+            _ = self
+                .copy_file_to_android_tmp(&changed_file, &bundled_name)
+                .await;
+        }
+
+        Some(bundled_name)
+    }
+
+    /// Copy this file to the tmp folder on the android device, returning the path to the copied file
+    ///
+    /// When we push patches (.so), the runtime will dlopen the file from the tmp folder by first copying
+    /// it to shared memory. This is a workaround since not all android devices will be rooted and we
+    /// can't drop the file into the `/data/data/com.org.app/lib/` directory.
+    pub(crate) async fn copy_file_to_android_tmp(
+        &self,
+        changed_file: &Path,
+        bundled_name: &Path,
+    ) -> Result<PathBuf> {
+        let target = dioxus_cli_config::android_session_cache_dir().join(bundled_name);
+        tracing::debug!("Pushing asset to device: {target:?}");
+
+        let res = tokio::process::Command::new(&self.build.workspace.android_tools()?.adb)
+            .arg("push")
+            .arg(changed_file)
+            .arg(&target)
+            .output()
+            .await
+            .context("Failed to push asset to device");
+
+        if let Err(e) = res {
+            tracing::debug!("Failed to push asset to device: {e}");
+        }
+
+        Ok(target)
+    }
+
+    /// Open the native app simply by running its main exe
+    ///
+    /// Eventually, for mac, we want to run the `.app` with `open` to fix issues with `dylib` paths,
+    /// but for now, we just run the exe directly. Very few users should be caring about `dylib` search
+    /// paths right now, but they will when we start to enable things like swift integration.
+    ///
+    /// Server/liveview/desktop are all basically the same, though
+    fn open_with_main_exe(&mut self, envs: Vec<(&str, String)>) -> Result<Child> {
+        let main_exe = self.app_exe();
+
+        tracing::debug!("Opening app with main exe: {main_exe:?}");
+
+        let child = Command::new(main_exe)
+            .envs(envs)
+            .stderr(Stdio::piped())
+            .stdout(Stdio::piped())
+            .kill_on_drop(true)
+            .spawn()?;
+
+        Ok(child)
+    }
+
+    /// Open the web app by opening the browser to the given address.
+    /// Check if we need to use https or not, and if so, add the protocol.
+    /// Go to the basepath if that's set too.
+    fn open_web(&self, address: SocketAddr) {
+        let base_path = self.build.config.web.app.base_path.clone();
+        let https = self.build.config.web.https.enabled.unwrap_or_default();
+        let protocol = if https { "https" } else { "http" };
+        let base_path = match base_path.as_deref() {
+            Some(base_path) => format!("/{}", base_path.trim_matches('/')),
+            None => "".to_owned(),
+        };
+        _ = open::that_detached(format!("{protocol}://{address}{base_path}"));
+    }
+
+    /// Use `xcrun` to install the app to the simulator
+    /// With simulators, we're free to basically do anything, so we don't need to do any fancy codesigning
+    /// or entitlements, or anything like that.
+    ///
+    /// However, if there's no simulator running, this *might* fail.
+    ///
+    /// TODO(jon): we should probably check if there's a simulator running before trying to install,
+    /// and open the simulator if we have to.
+    async fn open_ios_sim(&mut self, envs: Vec<(&str, String)>) -> Result<Child> {
+        tracing::debug!("Installing app to simulator {:?}", self.build.root_dir());
+
+        let res = Command::new("xcrun")
+            .arg("simctl")
+            .arg("install")
+            .arg("booted")
+            .arg(self.build.root_dir())
+            .output()
+            .await?;
+
+        tracing::debug!("Installed app to simulator with exit code: {res:?}");
+
+        // Remap the envs to the correct simctl env vars
+        // iOS sim lets you pass env vars but they need to be in the format "SIMCTL_CHILD_XXX=XXX"
+        let ios_envs = envs
+            .iter()
+            .map(|(k, v)| (format!("SIMCTL_CHILD_{k}"), v.clone()));
+
+        let child = Command::new("xcrun")
+            .arg("simctl")
+            .arg("launch")
+            .arg("--console")
+            .arg("booted")
+            .arg(self.build.bundle_identifier())
+            .envs(ios_envs)
+            .stderr(Stdio::piped())
+            .stdout(Stdio::piped())
+            .kill_on_drop(true)
+            .spawn()?;
+
+        Ok(child)
+    }
+
+    /// We have this whole thing figured out, but we don't actually use it yet.
+    ///
+    /// Launching on devices is more complicated and requires us to codesign the app, which we don't
+    /// currently do.
+    ///
+    /// Converting these commands shouldn't be too hard, but device support would imply we need
+    /// better support for codesigning and entitlements.
+    #[allow(unused)]
+    async fn open_ios_device(&self) -> Result<()> {
+        use serde_json::Value;
+        let app_path = self.build.root_dir();
+
+        install_app(&app_path).await?;
+
+        // 2. Determine which device the app was installed to
+        let device_uuid = get_device_uuid().await?;
+
+        // 3. Get the installation URL of the app
+        let installation_url = get_installation_url(&device_uuid, &app_path).await?;
+
+        // 4. Launch the app into the background, paused
+        launch_app_paused(&device_uuid, &installation_url).await?;
+
+        // 5. Pick up the paused app and resume it
+        resume_app(&device_uuid).await?;
+
+        async fn install_app(app_path: &PathBuf) -> Result<()> {
+            let output = Command::new("xcrun")
+                .args(["simctl", "install", "booted"])
+                .arg(app_path)
+                .output()
+                .await?;
+
+            if !output.status.success() {
+                return Err(format!("Failed to install app: {:?}", output).into());
+            }
+
+            Ok(())
+        }
+
+        async fn get_device_uuid() -> Result<String> {
+            let output = Command::new("xcrun")
+                .args([
+                    "devicectl",
+                    "list",
+                    "devices",
+                    "--json-output",
+                    "target/deviceid.json",
+                ])
+                .output()
+                .await?;
+
+            let json: Value =
+                serde_json::from_str(&std::fs::read_to_string("target/deviceid.json")?)
+                    .context("Failed to parse xcrun output")?;
+            let device_uuid = json["result"]["devices"][0]["identifier"]
+                .as_str()
+                .ok_or("Failed to extract device UUID")?
+                .to_string();
+
+            Ok(device_uuid)
+        }
+
+        async fn get_installation_url(device_uuid: &str, app_path: &Path) -> Result<String> {
+            // xcrun devicectl device install app --device <uuid> --path <path> --json-output
+            let output = Command::new("xcrun")
+                .args([
+                    "devicectl",
+                    "device",
+                    "install",
+                    "app",
+                    "--device",
+                    device_uuid,
+                    &app_path.display().to_string(),
+                    "--json-output",
+                    "target/xcrun.json",
+                ])
+                .output()
+                .await?;
+
+            if !output.status.success() {
+                return Err(format!("Failed to install app: {:?}", output).into());
+            }
+
+            let json: Value = serde_json::from_str(&std::fs::read_to_string("target/xcrun.json")?)
+                .context("Failed to parse xcrun output")?;
+            let installation_url = json["result"]["installedApplications"][0]["installationURL"]
+                .as_str()
+                .ok_or("Failed to extract installation URL")?
+                .to_string();
+
+            Ok(installation_url)
+        }
+
+        async fn launch_app_paused(device_uuid: &str, installation_url: &str) -> Result<()> {
+            let output = Command::new("xcrun")
+                .args([
+                    "devicectl",
+                    "device",
+                    "process",
+                    "launch",
+                    "--no-activate",
+                    "--verbose",
+                    "--device",
+                    device_uuid,
+                    installation_url,
+                    "--json-output",
+                    "target/launch.json",
+                ])
+                .output()
+                .await?;
+
+            if !output.status.success() {
+                return Err(format!("Failed to launch app: {:?}", output).into());
+            }
+
+            Ok(())
+        }
+
+        async fn resume_app(device_uuid: &str) -> Result<()> {
+            let json: Value = serde_json::from_str(&std::fs::read_to_string("target/launch.json")?)
+                .context("Failed to parse xcrun output")?;
+
+            let status_pid = json["result"]["process"]["processIdentifier"]
+                .as_u64()
+                .ok_or("Failed to extract process identifier")?;
+
+            let output = Command::new("xcrun")
+                .args([
+                    "devicectl",
+                    "device",
+                    "process",
+                    "resume",
+                    "--device",
+                    device_uuid,
+                    "--pid",
+                    &status_pid.to_string(),
+                ])
+                .output()
+                .await?;
+
+            if !output.status.success() {
+                return Err(format!("Failed to resume app: {:?}", output).into());
+            }
+
+            Ok(())
+        }
+
+        unimplemented!("dioxus-cli doesn't support ios devices yet.")
+    }
+
+    #[allow(unused)]
+    async fn codesign_ios(&self) -> Result<()> {
+        const CODESIGN_ERROR: &str = r#"This is likely because you haven't
+- Created a provisioning profile before
+- Accepted the Apple Developer Program License Agreement
+
+The agreement changes frequently and might need to be accepted again.
+To accept the agreement, go to https://developer.apple.com/account
+
+To create a provisioning profile, follow the instructions here:
+https://developer.apple.com/documentation/xcode/sharing-your-teams-signing-certificates"#;
+
+        let profiles_folder = dirs::home_dir()
+            .context("Your machine has no home-dir")?
+            .join("Library/MobileDevice/Provisioning Profiles");
+
+        if !profiles_folder.exists() || profiles_folder.read_dir()?.next().is_none() {
+            tracing::error!(
+                r#"No provisioning profiles found when trying to codesign the app.
+We checked the folder: {}
+
+{CODESIGN_ERROR}
+"#,
+                profiles_folder.display()
+            )
+        }
+
+        let identities = Command::new("security")
+            .args(["find-identity", "-v", "-p", "codesigning"])
+            .output()
+            .await
+            .context("Failed to run `security find-identity -v -p codesigning`")
+            .map(|e| {
+                String::from_utf8(e.stdout)
+                    .context("Failed to parse `security find-identity -v -p codesigning`")
+            })??;
+
+        // Parsing this:
+        // 1231231231231asdasdads123123 "Apple Development: foo@gmail.com (XYZYZY)"
+        let app_dev_name = regex::Regex::new(r#""Apple Development: (.+)""#)
+            .unwrap()
+            .captures(&identities)
+            .and_then(|caps| caps.get(1))
+            .map(|m| m.as_str())
+            .context(
+                "Failed to find Apple Development in `security find-identity -v -p codesigning`",
+            )?;
+
+        // Acquire the provision file
+        let provision_file = profiles_folder
+            .read_dir()?
+            .flatten()
+            .find(|entry| {
+                entry
+                    .file_name()
+                    .to_str()
+                    .map(|s| s.contains("mobileprovision"))
+                    .unwrap_or_default()
+            })
+            .context("Failed to find a provisioning profile. \n\n{CODESIGN_ERROR}")?;
+
+        // The .mobileprovision file has some random binary thrown into into, but it's still basically a plist
+        // Let's use the plist markers to find the start and end of the plist
+        fn cut_plist(bytes: &[u8], byte_match: &[u8]) -> Option<usize> {
+            bytes
+                .windows(byte_match.len())
+                .enumerate()
+                .rev()
+                .find(|(_, slice)| *slice == byte_match)
+                .map(|(i, _)| i + byte_match.len())
+        }
+        let bytes = std::fs::read(provision_file.path())?;
+        let cut1 = cut_plist(&bytes, b"<plist").context("Failed to parse .mobileprovision file")?;
+        let cut2 = cut_plist(&bytes, r#"</dict>"#.as_bytes())
+            .context("Failed to parse .mobileprovision file")?;
+        let sub_bytes = &bytes[(cut1 - 6)..cut2];
+        let mbfile: ProvisioningProfile =
+            plist::from_bytes(sub_bytes).context("Failed to parse .mobileprovision file")?;
+
+        #[derive(serde::Deserialize, Debug)]
+        struct ProvisioningProfile {
+            #[serde(rename = "TeamIdentifier")]
+            team_identifier: Vec<String>,
+            #[serde(rename = "ApplicationIdentifierPrefix")]
+            application_identifier_prefix: Vec<String>,
+            #[serde(rename = "Entitlements")]
+            entitlements: Entitlements,
+        }
+
+        #[derive(serde::Deserialize, Debug)]
+        struct Entitlements {
+            #[serde(rename = "application-identifier")]
+            application_identifier: String,
+            #[serde(rename = "keychain-access-groups")]
+            keychain_access_groups: Vec<String>,
+        }
+
+        let entielements_xml = format!(
+            r#"
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+    <key>application-identifier</key>
+    <string>{APPLICATION_IDENTIFIER}</string>
+    <key>keychain-access-groups</key>
+    <array>
+        <string>{APP_ID_ACCESS_GROUP}.*</string>
+    </array>
+    <key>get-task-allow</key>
+    <true/>
+    <key>com.apple.developer.team-identifier</key>
+    <string>{TEAM_IDENTIFIER}</string>
+</dict></plist>
+        "#,
+            APPLICATION_IDENTIFIER = mbfile.entitlements.application_identifier,
+            APP_ID_ACCESS_GROUP = mbfile.entitlements.keychain_access_groups[0],
+            TEAM_IDENTIFIER = mbfile.team_identifier[0],
+        );
+
+        // write to a temp file
+        let temp_file = tempfile::NamedTempFile::new()?;
+        std::fs::write(temp_file.path(), entielements_xml)?;
+
+        // codesign the app
+        let output = Command::new("codesign")
+            .args([
+                "--force",
+                "--entitlements",
+                temp_file.path().to_str().unwrap(),
+                "--sign",
+                app_dev_name,
+            ])
+            .arg(self.build.root_dir())
+            .output()
+            .await
+            .context("Failed to codesign the app")?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8(output.stderr).unwrap_or_default();
+            return Err(format!("Failed to codesign the app: {stderr}").into());
+        }
+
+        Ok(())
+    }
+
+    /// Launch the Android simulator and deploy the application.
+    ///
+    /// This function handles the process of starting the Android simulator, installing the APK,
+    /// forwarding the development server port, and launching the application on the simulator.
+    ///
+    /// The following `adb` commands are executed:
+    ///
+    /// 1. **Enable Root Access**:
+    ///    - `adb root`: Enables root access on the Android simulator, allowing for advanced operations like pushing files to restricted directories.
+    ///
+    /// 2. **Port Forwarding**:
+    ///    - `adb reverse tcp:<port> tcp:<port>`: Forwards the development server port from the host
+    ///      machine to the Android simulator, enabling communication between the app and the dev server.
+    ///
+    /// 3. **APK Installation**:
+    ///    - `adb install -r <apk_path>`: Installs the APK onto the Android simulator. The `-r` flag
+    ///      ensures that any existing installation of the app is replaced.
+    ///
+    /// 4. **Environment Variables**:
+    ///    - Writes environment variables to a `.env` file in the session cache directory.
+    ///    - `adb push <local_env_file> <device_env_file>`: Pushes the `.env` file to the Android device
+    ///      to configure runtime environment variables for the app.
+    ///
+    /// 5. **App Launch**:
+    ///    - `adb shell am start -n <package_name>/<activity_name>`: Launches the app on the Android
+    ///      simulator. The `<package_name>` and `<activity_name>` are derived from the app's configuration.
+    ///
+    /// # Notes
+    ///
+    /// - This function is asynchronous and spawns a background task to handle the simulator setup and app launch.
+    /// - The Android tools (`adb`) must be available in the system's PATH for this function to work.
+    /// - If the app fails to launch, errors are logged for debugging purposes.
+    ///
+    /// # Resources:
+    /// - https://developer.android.com/studio/run/emulator-commandline
+    async fn open_android_sim(
+        &self,
+        root: bool,
+        devserver_socket: SocketAddr,
+        envs: Vec<(&'static str, String)>,
+    ) -> Result<()> {
+        let apk_path = self.build.debug_apk_path();
+        let session_cache = self.build.session_cache_dir();
+        let full_mobile_app_name = self.build.full_mobile_app_name();
+        let adb = self.build.workspace.android_tools()?.adb.clone();
+
+        // Start backgrounded since .open() is called while in the arm of the top-level match
+        tokio::task::spawn(async move {
+            // call `adb root` so we can push patches to the device
+            if root {
+                if let Err(e) = Command::new(&adb).arg("root").output().await {
+                    tracing::error!("Failed to run `adb root`: {e}");
+                }
+            }
+
+            let port = devserver_socket.port();
+            if let Err(e) = Command::new(&adb)
+                .arg("reverse")
+                .arg(format!("tcp:{}", port))
+                .arg(format!("tcp:{}", port))
+                .output()
+                .await
+            {
+                tracing::error!("failed to forward port {port}: {e}");
+            }
+
+            // Install
+            // adb install -r app-debug.apk
+            if let Err(e) = Command::new(&adb)
+                .arg("install")
+                .arg("-r")
+                .arg(apk_path)
+                .output()
+                .await
+            {
+                tracing::error!("Failed to install apk with `adb`: {e}");
+            };
+
+            // Write the env vars to a .env file in our session cache
+            let env_file = session_cache.join(".env");
+            let contents: String = envs
+                .iter()
+                .map(|(key, value)| format!("{key}={value}"))
+                .collect::<Vec<_>>()
+                .join("\n");
+            _ = std::fs::write(&env_file, contents);
+
+            // Push the env file to the device
+            if let Err(e) = tokio::process::Command::new(&adb)
+                .arg("push")
+                .arg(env_file)
+                .arg(dioxus_cli_config::android_session_cache_dir().join(".env"))
+                .output()
+                .await
+                .context("Failed to push asset to device")
+            {
+                tracing::error!("Failed to push .env file to device: {e}");
+            }
+
+            // eventually, use the user's MainActivity, not our MainActivity
+            // adb shell am start -n dev.dioxus.main/dev.dioxus.main.MainActivity
+            let activity_name = format!("{}/dev.dioxus.main.MainActivity", full_mobile_app_name,);
+
+            if let Err(e) = Command::new(&adb)
+                .arg("shell")
+                .arg("am")
+                .arg("start")
+                .arg("-n")
+                .arg(activity_name)
+                .output()
+                .await
+            {
+                tracing::error!("Failed to start app with `adb`: {e}");
+            };
+        });
+
+        Ok(())
+    }
+
+    fn make_entropy_path(exe: &PathBuf) -> PathBuf {
+        let id = uuid::Uuid::new_v4();
+        let name = id.to_string();
+        let some_entropy = name.split('-').next().unwrap();
+
+        // Make a copy of the server exe with a new name
+        let entropy_server_exe = exe.with_file_name(format!(
+            "{}-{}",
+            exe.file_name().unwrap().to_str().unwrap(),
+            some_entropy
+        ));
+
+        std::fs::copy(exe, &entropy_server_exe).unwrap();
+
+        entropy_server_exe
+    }
+
+    fn app_exe(&mut self) -> PathBuf {
+        let mut main_exe = self.build.main_exe();
+
+        // The requirement here is based on the platform, not necessarily our current architecture.
+        let requires_entropy = match self.build.platform {
+            // When running "bundled", we don't need entropy
+            Platform::Web => false,
+            Platform::MacOS => false,
+            Platform::Ios => false,
+            Platform::Android => false,
+
+            // But on platforms that aren't running as "bundled", we do.
+            Platform::Windows => true,
+            Platform::Linux => true,
+            Platform::Server => true,
+            Platform::Liveview => true,
+        };
+
+        if requires_entropy || crate::devcfg::should_force_entropy() {
+            // If we already have an entropy app exe, return it - this is useful for re-opening the same app
+            if let Some(existing_app_exe) = self.entropy_app_exe.clone() {
+                return existing_app_exe;
+            }
+
+            let entropy_app_exe = Self::make_entropy_path(&main_exe);
+            self.entropy_app_exe = Some(entropy_app_exe.clone());
+            main_exe = entropy_app_exe;
+        }
+
+        main_exe
+    }
+
     fn complete_compile(&mut self) {
         if self.compile_end.is_none() {
             self.compiled_crates = self.expected_crates;
             self.compile_end = Some(Instant::now());
-            self.compile_end_server = Some(Instant::now());
         }
     }
 
@@ -297,11 +1290,6 @@ impl Builder {
         self.compiled_crates as f64 / self.expected_crates as f64
     }
 
-    /// Return a number between 0 and 1 representing the progress of the server build
-    pub(crate) fn server_compile_progress(&self) -> f64 {
-        self.compiled_crates_server as f64 / self.expected_crates_server as f64
-    }
-
     pub(crate) fn bundle_progress(&self) -> f64 {
         self.bundling_progress
     }

packages/cli/src/build/bundle.rs

@@ -1,955 +0,0 @@
-use super::prerender::pre_render_static_routes;
-use super::templates::InfoPlistData;
-use crate::{BuildRequest, Platform, WasmOptConfig};
-use crate::{Result, TraceSrc};
-use anyhow::Context;
-use dioxus_cli_opt::{process_file_to, AssetManifest};
-use manganis::{AssetOptions, JsAssetOptions};
-use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
-use std::future::Future;
-use std::path::{Path, PathBuf};
-use std::pin::Pin;
-use std::sync::atomic::Ordering;
-use std::{collections::HashSet, io::Write};
-use std::{sync::atomic::AtomicUsize, time::Duration};
-use tokio::process::Command;
-
-/// The end result of a build.
-///
-/// Contains the final asset manifest, the executables, and the workdir.
-///
-/// Every dioxus app can have an optional server executable which will influence the final bundle.
-/// This is built in parallel with the app executable during the `build` phase and the progres/status
-/// of the build is aggregated.
-///
-/// The server will *always* be dropped into the `web` folder since it is considered "web" in nature,
-/// and will likely need to be combined with the public dir to be useful.
-///
-/// We do our best to assemble read-to-go bundles here, such that the "bundle" step for each platform
-/// can just use the build dir
-///
-/// When we write the AppBundle to a folder, it'll contain each bundle for each platform under the app's name:
-/// ```
-/// dog-app/
-///   build/
-///       web/
-///         server.exe
-///         assets/
-///           some-secret-asset.txt (a server-side asset)
-///         public/
-///           index.html
-///           assets/
-///             logo.png
-///       desktop/
-///          App.app
-///          App.appimage
-///          App.exe
-///          server/
-///              server
-///              assets/
-///                some-secret-asset.txt (a server-side asset)
-///       ios/
-///          App.app
-///          App.ipa
-///       android/
-///          App.apk
-///   bundle/
-///       build.json
-///       Desktop.app
-///       Mobile_x64.ipa
-///       Mobile_arm64.ipa
-///       Mobile_rosetta.ipa
-///       web.appimage
-///       web/
-///         server.exe
-///         assets/
-///             some-secret-asset.txt
-///         public/
-///             index.html
-///             assets/
-///                 logo.png
-///                 style.css
-/// ```
-///
-/// When deploying, the build.json file will provide all the metadata that dx-deploy will use to
-/// push the app to stores, set up infra, manage versions, etc.
-///
-/// The format of each build will follow the name plus some metadata such that when distributing you
-/// can easily trim off the metadata.
-///
-/// The idea here is that we can run any of the programs in the same way that they're deployed.
-///
-///
-/// ## Bundle structure links
-/// - apple: https://developer.apple.com/documentation/bundleresources/placing_content_in_a_bundle
-/// - appimage: https://docs.appimage.org/packaging-guide/manual.html#ref-manual
-///
-/// ## Extra links
-/// - xbuild: https://github.com/rust-mobile/xbuild/blob/master/xbuild/src/command/build.rs
-#[derive(Debug)]
-pub(crate) struct AppBundle {
-    pub(crate) build: BuildRequest,
-    pub(crate) app: BuildArtifacts,
-    pub(crate) server: Option<BuildArtifacts>,
-}
-
-#[derive(Debug)]
-pub struct BuildArtifacts {
-    pub(crate) exe: PathBuf,
-    pub(crate) assets: AssetManifest,
-    pub(crate) time_taken: Duration,
-}
-
-impl AppBundle {
-    /// ## Web:
-    /// Create a folder that is somewhat similar to an app-image (exe + asset)
-    /// The server is dropped into the `web` folder, even if there's no `public` folder.
-    /// If there's no server (SPA), we still use the `web` folder, but it only contains the
-    /// public folder.
-    /// ```
-    /// web/
-    ///     server
-    ///     assets/
-    ///     public/
-    ///         index.html
-    ///         wasm/
-    ///            app.wasm
-    ///            glue.js
-    ///            snippets/
-    ///                ...
-    ///         assets/
-    ///            logo.png
-    /// ```
-    ///
-    /// ## Linux:
-    /// https://docs.appimage.org/reference/appdir.html#ref-appdir
-    /// current_exe.join("Assets")
-    /// ```
-    /// app.appimage/
-    ///     AppRun
-    ///     app.desktop
-    ///     package.json
-    ///     assets/
-    ///         logo.png
-    /// ```
-    ///
-    /// ## Macos
-    /// We simply use the macos format where binaries are in `Contents/MacOS` and assets are in `Contents/Resources`
-    /// We put assets in an assets dir such that it generally matches every other platform and we can
-    /// output `/assets/blah` from manganis.
-    /// ```
-    /// App.app/
-    ///     Contents/
-    ///         Info.plist
-    ///         MacOS/
-    ///             Frameworks/
-    ///         Resources/
-    ///             assets/
-    ///                 blah.icns
-    ///                 blah.png
-    ///         CodeResources
-    ///         _CodeSignature/
-    /// ```
-    ///
-    /// ## iOS
-    /// Not the same as mac! ios apps are a bit "flattened" in comparison. simpler format, presumably
-    /// since most ios apps don't ship frameworks/plugins and such.
-    ///
-    /// todo(jon): include the signing and entitlements in this format diagram.
-    /// ```
-    /// App.app/
-    ///     main
-    ///     assets/
-    /// ```
-    ///
-    /// ## Android:
-    ///
-    /// Currently we need to generate a `src` type structure, not a pre-packaged apk structure, since
-    /// we need to compile kotlin and java. This pushes us into using gradle and following a structure
-    /// similar to that of cargo mobile2. Eventually I'd like to slim this down (drop buildSrc) and
-    /// drive the kotlin build ourselves. This would let us drop gradle (yay! no plugins!) but requires
-    /// us to manage dependencies (like kotlinc) ourselves (yuck!).
-    ///
-    /// https://github.com/WanghongLin/miscellaneous/blob/master/tools/build-apk-manually.sh
-    ///
-    /// Unfortunately, it seems that while we can drop the `android` build plugin, we still will need
-    /// gradle since kotlin is basically gradle-only.
-    ///
-    /// Pre-build:
-    /// ```
-    /// app.apk/
-    ///     .gradle
-    ///     app/
-    ///         src/
-    ///             main/
-    ///                 assets/
-    ///                 jniLibs/
-    ///                 java/
-    ///                 kotlin/
-    ///                 res/
-    ///                 AndroidManifest.xml
-    ///             build.gradle.kts
-    ///             proguard-rules.pro
-    ///         buildSrc/
-    ///             build.gradle.kts
-    ///             src/
-    ///                 main/
-    ///                     kotlin/
-    ///                          BuildTask.kt
-    ///     build.gradle.kts
-    ///     gradle.properties
-    ///     gradlew
-    ///     gradlew.bat
-    ///     settings.gradle
-    /// ```
-    ///
-    /// Final build:
-    /// ```
-    /// app.apk/
-    ///   AndroidManifest.xml
-    ///   classes.dex
-    ///   assets/
-    ///       logo.png
-    ///   lib/
-    ///       armeabi-v7a/
-    ///           libmyapp.so
-    ///       arm64-v8a/
-    ///           libmyapp.so
-    /// ```
-    /// Notice that we *could* feasibly build this ourselves :)
-    ///
-    /// ## Windows:
-    /// https://superuser.com/questions/749447/creating-a-single-file-executable-from-a-directory-in-windows
-    /// Windows does not provide an AppImage format, so instead we're going build the same folder
-    /// structure as an AppImage, but when distributing, we'll create a .exe that embeds the resources
-    /// as an embedded .zip file. When the app runs, it will implicitly unzip its resources into the
-    /// Program Files folder. Any subsequent launches of the parent .exe will simply call the AppRun.exe
-    /// entrypoint in the associated Program Files folder.
-    ///
-    /// This is, in essence, the same as an installer, so we might eventually just support something like msi/msix
-    /// which functionally do the same thing but with a sleeker UI.
-    ///
-    /// This means no installers are required and we can bake an updater into the host exe.
-    ///
-    /// ## Handling asset lookups:
-    /// current_exe.join("assets")
-    /// ```
-    /// app.appimage/
-    ///     main.exe
-    ///     main.desktop
-    ///     package.json
-    ///     assets/
-    ///         logo.png
-    /// ```
-    ///
-    /// Since we support just a few locations, we could just search for the first that exists
-    /// - usr
-    /// - ../Resources
-    /// - assets
-    /// - Assets
-    /// - $cwd/assets
-    ///
-    /// ```
-    /// assets::root() ->
-    ///     mac -> ../Resources/
-    ///     ios -> ../Resources/
-    ///     android -> assets/
-    ///     server -> assets/
-    ///     liveview -> assets/
-    ///     web -> /assets/
-    /// root().join(bundled)
-    /// ```
-    pub(crate) async fn new(
-        build: BuildRequest,
-        app: BuildArtifacts,
-        server: Option<BuildArtifacts>,
-    ) -> Result<Self> {
-        let mut bundle = Self { app, server, build };
-
-        tracing::debug!("Assembling app bundle");
-
-        bundle.build.status_start_bundle();
-        /*
-            assume the build dir is already created by BuildRequest
-            todo(jon): maybe refactor this a bit to force AppBundle to be created before it can be filled in
-        */
-        bundle
-            .write_main_executable()
-            .await
-            .context("Failed to write main executable")?;
-        bundle.write_server_executable().await?;
-        bundle
-            .write_assets()
-            .await
-            .context("Failed to write assets")?;
-        bundle.write_metadata().await?;
-        bundle.optimize().await?;
-        bundle.pre_render_ssg_routes().await?;
-        bundle
-            .assemble()
-            .await
-            .context("Failed to assemble app bundle")?;
-
-        tracing::debug!("Bundle created at {}", bundle.build.root_dir().display());
-
-        Ok(bundle)
-    }
-
-    /// Take the output of rustc and make it into the main exe of the bundle
-    ///
-    /// For wasm, we'll want to run `wasm-bindgen` to make it a wasm binary along with some other optimizations
-    /// Other platforms we might do some stripping or other optimizations
-    /// Move the executable to the workdir
-    async fn write_main_executable(&mut self) -> Result<()> {
-        match self.build.build.platform() {
-            // Run wasm-bindgen on the wasm binary and set its output to be in the bundle folder
-            // Also run wasm-opt on the wasm binary, and sets the index.html since that's also the "executable".
-            //
-            // The wasm stuff will be in a folder called "wasm" in the workdir.
-            //
-            // Final output format:
-            // ```
-            // dx/
-            //     app/
-            //         web/
-            //             bundle/
-            //             build/
-            //                 public/
-            //                     index.html
-            //                     wasm/
-            //                        app.wasm
-            //                        glue.js
-            //                        snippets/
-            //                            ...
-            //                     assets/
-            //                        logo.png
-            // ```
-            Platform::Web => {
-                self.bundle_web().await?;
-            }
-
-            // this will require some extra oomf to get the multi architecture builds...
-            // for now, we just copy the exe into the current arch (which, sorry, is hardcoded for my m1)
-            // we'll want to do multi-arch builds in the future, so there won't be *one* exe dir to worry about
-            // eventually `exe_dir` and `main_exe` will need to take in an arch and return the right exe path
-            //
-            // todo(jon): maybe just symlink this rather than copy it?
-            Platform::Android => {
-                self.copy_android_exe(&self.app.exe, &self.main_exe())
-                    .await?;
-            }
-
-            // These are all super simple, just copy the exe into the folder
-            // eventually, perhaps, maybe strip + encrypt the exe?
-            Platform::MacOS
-            | Platform::Windows
-            | Platform::Linux
-            | Platform::Ios
-            | Platform::Liveview
-            | Platform::Server => {
-                std::fs::copy(&self.app.exe, self.main_exe())?;
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Copy the assets out of the manifest and into the target location
-    ///
-    /// Should be the same on all platforms - just copy over the assets from the manifest into the output directory
-    async fn write_assets(&self) -> Result<()> {
-        // Server doesn't need assets - web will provide them
-        if self.build.build.platform() == Platform::Server {
-            return Ok(());
-        }
-
-        let asset_dir = self.build.asset_dir();
-
-        // First, clear the asset dir of any files that don't exist in the new manifest
-        _ = tokio::fs::create_dir_all(&asset_dir).await;
-        // Create a set of all the paths that new files will be bundled to
-        let mut keep_bundled_output_paths: HashSet<_> = self
-            .app
-            .assets
-            .assets
-            .values()
-            .map(|a| asset_dir.join(a.bundled_path()))
-            .collect();
-        // The CLI creates a .version file in the asset dir to keep track of what version of the optimizer
-        // the asset was processed. If that version doesn't match the CLI version, we need to re-optimize
-        // all assets.
-        let version_file = self.build.asset_optimizer_version_file();
-        let clear_cache = std::fs::read_to_string(&version_file)
-            .ok()
-            .filter(|s| s == crate::VERSION.as_str())
-            .is_none();
-        if clear_cache {
-            keep_bundled_output_paths.clear();
-        }
-
-        // one possible implementation of walking a directory only visiting files
-        fn remove_old_assets<'a>(
-            path: &'a Path,
-            keep_bundled_output_paths: &'a HashSet<PathBuf>,
-        ) -> Pin<Box<dyn Future<Output = std::io::Result<()>> + Send + 'a>> {
-            Box::pin(async move {
-                // If this asset is in the manifest, we don't need to remove it
-                let canon_path = dunce::canonicalize(path)?;
-                if keep_bundled_output_paths.contains(canon_path.as_path()) {
-                    return Ok(());
-                }
-
-                // Otherwise, if it is a directory, we need to walk it and remove child files
-                if path.is_dir() {
-                    for entry in std::fs::read_dir(path)?.flatten() {
-                        let path = entry.path();
-                        remove_old_assets(&path, keep_bundled_output_paths).await?;
-                    }
-                    if path.read_dir()?.next().is_none() {
-                        // If the directory is empty, remove it
-                        tokio::fs::remove_dir(path).await?;
-                    }
-                } else {
-                    // If it is a file, remove it
-                    tokio::fs::remove_file(path).await?;
-                }
-
-                Ok(())
-            })
-        }
-
-        tracing::debug!("Removing old assets");
-        tracing::trace!(
-            "Keeping bundled output paths: {:#?}",
-            keep_bundled_output_paths
-        );
-        remove_old_assets(&asset_dir, &keep_bundled_output_paths).await?;
-
-        // todo(jon): we also want to eventually include options for each asset's optimization and compression, which we currently aren't
-        let mut assets_to_transfer = vec![];
-
-        // Queue the bundled assets
-        for (asset, bundled) in &self.app.assets.assets {
-            let from = asset.clone();
-            let to = asset_dir.join(bundled.bundled_path());
-
-            // prefer to log using a shorter path relative to the workspace dir by trimming the workspace dir
-            let from_ = from
-                .strip_prefix(self.build.krate.workspace_dir())
-                .unwrap_or(from.as_path());
-            let to_ = from
-                .strip_prefix(self.build.krate.workspace_dir())
-                .unwrap_or(to.as_path());
-
-            tracing::debug!("Copying asset {from_:?} to {to_:?}");
-            assets_to_transfer.push((from, to, *bundled.options()));
-        }
-
-        // And then queue the legacy assets
-        // ideally, one day, we can just check the rsx!{} calls for references to assets
-        for from in self.build.krate.legacy_asset_dir_files() {
-            let to = asset_dir.join(from.file_name().unwrap());
-            tracing::debug!("Copying legacy asset {from:?} to {to:?}");
-            assets_to_transfer.push((from, to, AssetOptions::Unknown));
-        }
-
-        let asset_count = assets_to_transfer.len();
-        let started_processing = AtomicUsize::new(0);
-        let copied = AtomicUsize::new(0);
-
-        // Parallel Copy over the assets and keep track of progress with an atomic counter
-        let progress = self.build.progress.clone();
-        let ws_dir = self.build.krate.workspace_dir();
-        // Optimizing assets is expensive and blocking, so we do it in a tokio spawn blocking task
-        tokio::task::spawn_blocking(move || {
-            assets_to_transfer
-                .par_iter()
-                .try_for_each(|(from, to, options)| {
-                    let processing = started_processing.fetch_add(1, Ordering::SeqCst);
-                    let from_ = from.strip_prefix(&ws_dir).unwrap_or(from);
-                    tracing::trace!(
-                        "Starting asset copy {processing}/{asset_count} from {from_:?}"
-                    );
-
-                    let res = process_file_to(options, from, to);
-                    if let Err(err) = res.as_ref() {
-                        tracing::error!("Failed to copy asset {from:?}: {err}");
-                    }
-
-                    let finished = copied.fetch_add(1, Ordering::SeqCst);
-                    BuildRequest::status_copied_asset(
-                        &progress,
-                        finished,
-                        asset_count,
-                        from.to_path_buf(),
-                    );
-
-                    res.map(|_| ())
-                })
-        })
-        .await
-        .map_err(|e| anyhow::anyhow!("A task failed while trying to copy assets: {e}"))??;
-
-        // // Remove the wasm bindgen output directory if it exists
-        // _ = std::fs::remove_dir_all(self.build.wasm_bindgen_out_dir());
-
-        // Write the version file so we know what version of the optimizer we used
-        std::fs::write(
-            self.build.asset_optimizer_version_file(),
-            crate::VERSION.as_str(),
-        )?;
-
-        Ok(())
-    }
-
-    /// The item that we'll try to run directly if we need to.
-    ///
-    /// todo(jon): we should name the app properly instead of making up the exe name. It's kinda okay for dev mode, but def not okay for prod
-    pub fn main_exe(&self) -> PathBuf {
-        self.build.exe_dir().join(self.build.platform_exe_name())
-    }
-
-    /// We always put the server in the `web` folder!
-    /// Only the `web` target will generate a `public` folder though
-    async fn write_server_executable(&self) -> Result<()> {
-        if let Some(server) = &self.server {
-            let to = self
-                .server_exe()
-                .expect("server should be set if we're building a server");
-
-            std::fs::create_dir_all(self.server_exe().unwrap().parent().unwrap())?;
-
-            tracing::debug!("Copying server executable to: {to:?} {server:#?}");
-
-            // Remove the old server executable if it exists, since copying might corrupt it :(
-            // todo(jon): do this in more places, I think
-            _ = std::fs::remove_file(&to);
-            std::fs::copy(&server.exe, to)?;
-        }
-
-        Ok(())
-    }
-
-    /// todo(jon): use handlebars templates instead of these prebaked templates
-    async fn write_metadata(&self) -> Result<()> {
-        // write the Info.plist file
-        match self.build.build.platform() {
-            Platform::MacOS => {
-                let dest = self.build.root_dir().join("Contents").join("Info.plist");
-                let plist = self.macos_plist_contents()?;
-                std::fs::write(dest, plist)?;
-            }
-
-            Platform::Ios => {
-                let dest = self.build.root_dir().join("Info.plist");
-                let plist = self.ios_plist_contents()?;
-                std::fs::write(dest, plist)?;
-            }
-
-            // AndroidManifest.xml
-            // er.... maybe even all the kotlin/java/gradle stuff?
-            Platform::Android => {}
-
-            // Probably some custom format or a plist file (haha)
-            // When we do the proper bundle, we'll need to do something with wix templates, I think?
-            Platform::Windows => {}
-
-            // eventually we'll create the .appimage file, I guess?
-            Platform::Linux => {}
-
-            // These are served as folders, not appimages, so we don't need to do anything special (I think?)
-            // Eventually maybe write some secrets/.env files for the server?
-            // We could also distribute them as a deb/rpm for linux and msi for windows
-            Platform::Web => {}
-            Platform::Server => {}
-            Platform::Liveview => {}
-        }
-
-        Ok(())
-    }
-
-    /// Run the optimizers, obfuscators, minimizers, signers, etc
-    pub(crate) async fn optimize(&self) -> Result<()> {
-        match self.build.build.platform() {
-            Platform::Web => {
-                // Compress the asset dir
-                // If pre-compressing is enabled, we can pre_compress the wasm-bindgen output
-                let pre_compress = self
-                    .build
-                    .krate
-                    .should_pre_compress_web_assets(self.build.build.release);
-
-                self.build.status_compressing_assets();
-                let asset_dir = self.build.asset_dir();
-                tokio::task::spawn_blocking(move || {
-                    crate::fastfs::pre_compress_folder(&asset_dir, pre_compress)
-                })
-                .await
-                .unwrap()?;
-            }
-            Platform::MacOS => {}
-            Platform::Windows => {}
-            Platform::Linux => {}
-            Platform::Ios => {}
-            Platform::Android => {}
-            Platform::Server => {}
-            Platform::Liveview => {}
-        }
-
-        Ok(())
-    }
-
-    pub(crate) fn server_exe(&self) -> Option<PathBuf> {
-        if let Some(_server) = &self.server {
-            let mut path = self
-                .build
-                .krate
-                .build_dir(Platform::Server, self.build.build.release);
-
-            if cfg!(windows) {
-                path.push("server.exe");
-            } else {
-                path.push("server");
-            }
-
-            return Some(path);
-        }
-
-        None
-    }
-
-    /// Bundle the web app
-    /// - Run wasm-bindgen
-    /// - Bundle split
-    /// - Run wasm-opt
-    /// - Register the .wasm and .js files with the asset system
-    async fn bundle_web(&mut self) -> Result<()> {
-        use crate::{wasm_bindgen::WasmBindgen, wasm_opt};
-        use std::fmt::Write;
-
-        // Locate the output of the build files and the bindgen output
-        // We'll fill these in a second if they don't already exist
-        let bindgen_outdir = self.build.wasm_bindgen_out_dir();
-        let prebindgen = self.app.exe.clone();
-        let post_bindgen_wasm = self.build.wasm_bindgen_wasm_output_file();
-        let should_bundle_split = self.build.build.experimental_wasm_split;
-        let rustc_exe = self.app.exe.with_extension("wasm");
-        let bindgen_version = self
-            .build
-            .krate
-            .wasm_bindgen_version()
-            .expect("this should have been checked by tool verification");
-
-        // Prepare any work dirs
-        std::fs::create_dir_all(&bindgen_outdir)?;
-
-        // Prepare our configuration
-        //
-        // we turn off debug symbols in dev mode but leave them on in release mode (weird!) since
-        // wasm-opt and wasm-split need them to do better optimizations.
-        //
-        // We leave demangling to false since it's faster and these tools seem to prefer the raw symbols.
-        // todo(jon): investigate if the chrome extension needs them demangled or demangles them automatically.
-        let will_wasm_opt = (self.build.build.release || self.build.build.experimental_wasm_split)
-            && crate::wasm_opt::wasm_opt_available();
-        let keep_debug = self.build.krate.config.web.wasm_opt.debug
-            || self.build.build.debug_symbols
-            || self.build.build.experimental_wasm_split
-            || !self.build.build.release
-            || will_wasm_opt;
-        let demangle = false;
-        let wasm_opt_options = WasmOptConfig {
-            memory_packing: self.build.build.experimental_wasm_split,
-            debug: self.build.build.debug_symbols,
-            ..self.build.krate.config.web.wasm_opt.clone()
-        };
-
-        // Run wasm-bindgen. Some of the options are not "optimal" but will be fixed up by wasm-opt
-        //
-        // There's performance implications here. Running with --debug is slower than without
-        // We're keeping around lld sections and names but wasm-opt will fix them
-        // todo(jon): investigate a good balance of wiping debug symbols during dev (or doing a double build?)
-        self.build.status_wasm_bindgen_start();
-        tracing::debug!(dx_src = ?TraceSrc::Bundle, "Running wasm-bindgen");
-        let start = std::time::Instant::now();
-        WasmBindgen::new(&bindgen_version)
-            .input_path(&rustc_exe)
-            .target("web")
-            .debug(keep_debug)
-            .demangle(demangle)
-            .keep_debug(keep_debug)
-            .keep_lld_sections(true)
-            .out_name(self.build.krate.executable_name())
-            .out_dir(&bindgen_outdir)
-            .remove_name_section(!will_wasm_opt)
-            .remove_producers_section(!will_wasm_opt)
-            .run()
-            .await
-            .context("Failed to generate wasm-bindgen bindings")?;
-        tracing::debug!(dx_src = ?TraceSrc::Bundle, "wasm-bindgen complete in {:?}", start.elapsed());
-
-        // Run bundle splitting if the user has requested it
-        // It's pretty expensive but because of rayon should be running separate threads, hopefully
-        // not blocking this thread. Dunno if that's true
-        if should_bundle_split {
-            self.build.status_splitting_bundle();
-
-            if !will_wasm_opt {
-                return Err(anyhow::anyhow!(
-                    "Bundle splitting requires wasm-opt to be installed or the CLI to be built with `--features optimizations`. Please install wasm-opt and try again."
-                )
-                .into());
-            }
-
-            // Load the contents of these binaries since we need both of them
-            // We're going to use the default makeLoad glue from wasm-split
-            let original = std::fs::read(&prebindgen)?;
-            let bindgened = std::fs::read(&post_bindgen_wasm)?;
-            let mut glue = wasm_split_cli::MAKE_LOAD_JS.to_string();
-
-            // Run the emitter
-            let splitter = wasm_split_cli::Splitter::new(&original, &bindgened);
-            let modules = splitter
-                .context("Failed to parse wasm for splitter")?
-                .emit()
-                .context("Failed to emit wasm split modules")?;
-
-            // Write the chunks that contain shared imports
-            // These will be in the format of chunk_0_modulename.wasm - this is hardcoded in wasm-split
-            tracing::debug!("Writing split chunks to disk");
-            for (idx, chunk) in modules.chunks.iter().enumerate() {
-                let path = bindgen_outdir.join(format!("chunk_{}_{}.wasm", idx, chunk.module_name));
-                wasm_opt::write_wasm(&chunk.bytes, &path, &wasm_opt_options).await?;
-                writeln!(
-                    glue, "export const __wasm_split_load_chunk_{idx} = makeLoad(\"/assets/{url}\", [], fusedImports);",
-                    url = self
-                        .app
-                        .assets
-                        .register_asset(&path, AssetOptions::Unknown)?.bundled_path(),
-                )?;
-            }
-
-            // Write the modules that contain the entrypoints
-            tracing::debug!("Writing split modules to disk");
-            for (idx, module) in modules.modules.iter().enumerate() {
-                let comp_name = module
-                    .component_name
-                    .as_ref()
-                    .context("generated bindgen module has no name?")?;
-
-                let path = bindgen_outdir.join(format!("module_{}_{}.wasm", idx, comp_name));
-                wasm_opt::write_wasm(&module.bytes, &path, &wasm_opt_options).await?;
-
-                let hash_id = module.hash_id.as_ref().unwrap();
-
-                writeln!(
-                    glue,
-                    "export const __wasm_split_load_{module}_{hash_id}_{comp_name} = makeLoad(\"/assets/{url}\", [{deps}], fusedImports);",
-                    module = module.module_name,
-
-
-                    // Again, register this wasm with the asset system
-                    url = self
-                        .app
-                        .assets
-                        .register_asset(&path, AssetOptions::Unknown)?.bundled_path(),
-
-                    // This time, make sure to write the dependencies of this chunk
-                    // The names here are again, hardcoded in wasm-split - fix this eventually.
-                    deps = module
-                        .relies_on_chunks
-                        .iter()
-                        .map(|idx| format!("__wasm_split_load_chunk_{idx}"))
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )?;
-            }
-
-            // Write the js binding
-            // It's not registered as an asset since it will get included in the main.js file
-            let js_output_path = bindgen_outdir.join("__wasm_split.js");
-            std::fs::write(&js_output_path, &glue)?;
-
-            // Make sure to write some entropy to the main.js file so it gets a new hash
-            // If we don't do this, the main.js file will be cached and never pick up the chunk names
-            let uuid = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_URL, glue.as_bytes());
-            std::fs::OpenOptions::new()
-                .append(true)
-                .open(self.build.wasm_bindgen_js_output_file())
-                .context("Failed to open main.js file")?
-                .write_all(format!("/*{uuid}*/").as_bytes())?;
-
-            // Write the main wasm_bindgen file and register it with the asset system
-            // This will overwrite the file in place
-            // We will wasm-opt it in just a second...
-            std::fs::write(&post_bindgen_wasm, modules.main.bytes)?;
-        }
-
-        // Make sure to optimize the main wasm file if requested or if bundle splitting
-        if should_bundle_split || self.build.build.release {
-            self.build.status_optimizing_wasm();
-            wasm_opt::optimize(&post_bindgen_wasm, &post_bindgen_wasm, &wasm_opt_options).await?;
-        }
-
-        // Make sure to register the main wasm file with the asset system
-        self.app
-            .assets
-            .register_asset(&post_bindgen_wasm, AssetOptions::Unknown)?;
-
-        // Register the main.js with the asset system so it bundles in the snippets and optimizes
-        self.app.assets.register_asset(
-            &self.build.wasm_bindgen_js_output_file(),
-            AssetOptions::Js(JsAssetOptions::new().with_minify(true).with_preload(true)),
-        )?;
-
-        // Write the index.html file with the pre-configured contents we got from pre-rendering
-        std::fs::write(
-            self.build.root_dir().join("index.html"),
-            self.prepare_html()?,
-        )?;
-
-        Ok(())
-    }
-
-    async fn pre_render_ssg_routes(&self) -> Result<()> {
-        // Run SSG and cache static routes
-        if !self.build.build.ssg {
-            return Ok(());
-        }
-        self.build.status_prerendering_routes();
-        pre_render_static_routes(
-            &self
-                .server_exe()
-                .context("Failed to find server executable")?,
-        )
-        .await?;
-        Ok(())
-    }
-
-    fn macos_plist_contents(&self) -> Result<String> {
-        handlebars::Handlebars::new()
-            .render_template(
-                include_str!("../../assets/macos/mac.plist.hbs"),
-                &InfoPlistData {
-                    display_name: self.build.krate.bundled_app_name(),
-                    bundle_name: self.build.krate.bundled_app_name(),
-                    executable_name: self.build.platform_exe_name(),
-                    bundle_identifier: self.build.krate.bundle_identifier(),
-                },
-            )
-            .map_err(|e| e.into())
-    }
-
-    fn ios_plist_contents(&self) -> Result<String> {
-        handlebars::Handlebars::new()
-            .render_template(
-                include_str!("../../assets/ios/ios.plist.hbs"),
-                &InfoPlistData {
-                    display_name: self.build.krate.bundled_app_name(),
-                    bundle_name: self.build.krate.bundled_app_name(),
-                    executable_name: self.build.platform_exe_name(),
-                    bundle_identifier: self.build.krate.bundle_identifier(),
-                },
-            )
-            .map_err(|e| e.into())
-    }
-
-    /// Run any final tools to produce apks or other artifacts we might need.
-    async fn assemble(&self) -> Result<()> {
-        if let Platform::Android = self.build.build.platform() {
-            self.build.status_running_gradle();
-
-            let output = Command::new(self.gradle_exe()?)
-                .arg("assembleDebug")
-                .current_dir(self.build.root_dir())
-                .stderr(std::process::Stdio::piped())
-                .stdout(std::process::Stdio::piped())
-                .output()
-                .await?;
-
-            if !output.status.success() {
-                return Err(anyhow::anyhow!("Failed to assemble apk: {output:?}").into());
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Run bundleRelease and return the path to the `.aab` file
-    ///
-    /// https://stackoverflow.com/questions/57072558/whats-the-difference-between-gradlewassemblerelease-gradlewinstallrelease-and
-    pub(crate) async fn android_gradle_bundle(&self) -> Result<PathBuf> {
-        let output = Command::new(self.gradle_exe()?)
-            .arg("bundleRelease")
-            .current_dir(self.build.root_dir())
-            .output()
-            .await
-            .context("Failed to run gradle bundleRelease")?;
-
-        if !output.status.success() {
-            return Err(anyhow::anyhow!("Failed to bundleRelease: {output:?}").into());
-        }
-
-        let app_release = self
-            .build
-            .root_dir()
-            .join("app")
-            .join("build")
-            .join("outputs")
-            .join("bundle")
-            .join("release");
-
-        // Rename it to Name-arch.aab
-        let from = app_release.join("app-release.aab");
-        let to = app_release.join(format!(
-            "{}-{}.aab",
-            self.build.krate.bundled_app_name(),
-            self.build.build.target_args.arch()
-        ));
-
-        std::fs::rename(from, &to).context("Failed to rename aab")?;
-
-        Ok(to)
-    }
-
-    fn gradle_exe(&self) -> Result<PathBuf> {
-        // make sure we can execute the gradlew script
-        #[cfg(unix)]
-        {
-            use std::os::unix::prelude::PermissionsExt;
-            std::fs::set_permissions(
-                self.build.root_dir().join("gradlew"),
-                std::fs::Permissions::from_mode(0o755),
-            )?;
-        }
-
-        let gradle_exec_name = match cfg!(windows) {
-            true => "gradlew.bat",
-            false => "gradlew",
-        };
-
-        Ok(self.build.root_dir().join(gradle_exec_name))
-    }
-
-    pub(crate) fn apk_path(&self) -> PathBuf {
-        self.build
-            .root_dir()
-            .join("app")
-            .join("build")
-            .join("outputs")
-            .join("apk")
-            .join("debug")
-            .join("app-debug.apk")
-    }
-
-    /// Copy the Android executable to the target directory, and rename the hardcoded com_hardcoded_dioxuslabs entries
-    /// to the user's app name.
-    async fn copy_android_exe(&self, source: &Path, destination: &Path) -> Result<()> {
-        // we might want to eventually use the objcopy logic to handle this
-        //
-        // https://github.com/rust-mobile/xbuild/blob/master/xbuild/template/lib.rs
-        // https://github.com/rust-mobile/xbuild/blob/master/apk/src/lib.rs#L19
-        std::fs::copy(source, destination)?;
-        Ok(())
-    }
-}

packages/cli/src/build/context.rs

@@ -0,0 +1,177 @@
+//! Report progress about the build to the user. We use channels to report progress back to the CLI.
+
+use super::BuildMode;
+use crate::{BuildArtifacts, BuildStage, Error, TraceSrc};
+use cargo_metadata::CompilerMessage;
+use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
+use serde::{Deserialize, Serialize};
+use std::{path::PathBuf, process::ExitStatus};
+
+/// The context of the build process. While the BuildRequest is a "plan" for the build, the BuildContext
+/// provides some dynamic configuration that is only known at runtime. For example, the Progress channel
+/// and the BuildMode can change while serving.
+///
+/// The structure of this is roughly taken from cargo itself which uses a similar pattern.
+#[derive(Debug, Clone)]
+pub struct BuildContext {
+    pub tx: ProgressTx,
+    pub mode: BuildMode,
+}
+
+pub type ProgressTx = UnboundedSender<BuilderUpdate>;
+pub type ProgressRx = UnboundedReceiver<BuilderUpdate>;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
+pub struct BuildId(pub(crate) usize);
+impl BuildId {
+    pub const CLIENT: Self = Self(0);
+    pub const SERVER: Self = Self(1);
+}
+
+#[allow(clippy::large_enum_variant)]
+pub enum BuilderUpdate {
+    Progress {
+        stage: BuildStage,
+    },
+
+    CompilerMessage {
+        message: CompilerMessage,
+    },
+
+    BuildReady {
+        bundle: BuildArtifacts,
+    },
+
+    BuildFailed {
+        err: Error,
+    },
+
+    /// A running process has received a stdout.
+    /// May or may not be a complete line - do not treat it as a line. It will include a line if it is a complete line.
+    ///
+    /// We will poll lines and any content in a 50ms interval
+    StdoutReceived {
+        msg: String,
+    },
+
+    /// A running process has received a stderr.
+    /// May or may not be a complete line - do not treat it as a line. It will include a line if it is a complete line.
+    ///
+    /// We will poll lines and any content in a 50ms interval
+    StderrReceived {
+        msg: String,
+    },
+
+    ProcessExited {
+        status: ExitStatus,
+    },
+}
+
+impl BuildContext {
+    pub(crate) fn status_wasm_bindgen_start(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::RunningBindgen,
+        });
+    }
+
+    pub(crate) fn status_splitting_bundle(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::SplittingBundle,
+        });
+    }
+
+    pub(crate) fn status_start_bundle(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::Bundling,
+        });
+    }
+
+    pub(crate) fn status_running_gradle(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::RunningGradle,
+        })
+    }
+
+    pub(crate) fn status_build_diagnostic(&self, message: CompilerMessage) {
+        _ = self
+            .tx
+            .unbounded_send(BuilderUpdate::CompilerMessage { message });
+    }
+
+    pub(crate) fn status_build_error(&self, line: String) {
+        tracing::error!(dx_src = ?TraceSrc::Cargo, "{line}");
+    }
+
+    pub(crate) fn status_build_message(&self, line: String) {
+        tracing::trace!(dx_src = ?TraceSrc::Cargo, "{line}");
+    }
+
+    pub(crate) fn status_build_progress(&self, count: usize, total: usize, name: String) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::Compiling {
+                current: count,
+                total,
+                krate: name,
+            },
+        });
+    }
+
+    pub(crate) fn status_starting_build(&self, crate_count: usize) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::Starting {
+                patch: matches!(self.mode, BuildMode::Thin { .. }),
+                crate_count,
+            },
+        });
+    }
+
+    pub(crate) fn status_starting_link(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::Linking,
+        });
+    }
+
+    pub(crate) fn status_copied_asset(
+        progress: &UnboundedSender<BuilderUpdate>,
+        current: usize,
+        total: usize,
+        path: PathBuf,
+    ) {
+        _ = progress.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::CopyingAssets {
+                current,
+                total,
+                path,
+            },
+        });
+    }
+
+    pub(crate) fn status_optimizing_wasm(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::OptimizingWasm,
+        });
+    }
+
+    pub(crate) fn status_hotpatching(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::Hotpatching,
+        });
+    }
+
+    pub(crate) fn status_installing_tooling(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::InstallingTooling,
+        });
+    }
+
+    pub(crate) fn status_compressing_assets(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::CompressingAssets,
+        });
+    }
+    pub(crate) fn status_extracting_assets(&self) {
+        _ = self.tx.unbounded_send(BuilderUpdate::Progress {
+            stage: BuildStage::ExtractingAssets,
+        });
+    }
+}

packages/cli/src/build/mod.rs

@@ -1,20 +1,21 @@
-//! The primary entrypoint for our build + optimize + bundle engine
+//! The core build module for `dx`, enabling building, bundling, and runtime hot-patching of Rust
+//! applications. This module defines the entire end-to-end build process, including bundling for
+//! all major platforms including Mac, Windows, Linux, iOS, Android, and WebAssembly.
 //!
-//! Handles multiple ongoing tasks and allows you to queue up builds from interactive and non-interactive contexts
-//!
-//! Uses a request -> response architecture that allows you to monitor the progress with an optional message
-//! receiver.
+//! The bulk of the builder code is contained within the [`request`] module which establishes the
+//! arguments and flow of the build process. The [`context`] module contains the context for the build
+//! including status updates and build customization. The [`patch`] module contains the logic for
+//! hot-patching Rust code through binary analysis and a custom linker. The [`builder`] module contains
+//! the management of the ongoing build and methods to open the build as a running app.
 
 mod builder;
-mod bundle;
-mod prerender;
-mod progress;
+mod context;
+mod patch;
 mod request;
-mod templates;
-mod verify;
-mod web;
+mod tools;
 
 pub(crate) use builder::*;
-pub(crate) use bundle::*;
-pub(crate) use progress::*;
+pub(crate) use context::*;
+pub(crate) use patch::*;
 pub(crate) use request::*;
+pub(crate) use tools::*;

packages/cli/src/build/patch.rs

@@ -0,0 +1,1369 @@
+use anyhow::Context;
+use itertools::Itertools;
+use object::{
+    macho::{self},
+    read::File,
+    write::{MachOBuildVersion, StandardSection, Symbol, SymbolSection},
+    Endianness, Object, ObjectSymbol, SymbolKind, SymbolScope,
+};
+use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
+use std::{
+    collections::{BTreeMap, HashMap, HashSet},
+    ops::{Deref, Range},
+    path::Path,
+    path::PathBuf,
+    sync::{Arc, RwLock},
+};
+use subsecond_types::{AddressMap, JumpTable};
+use target_lexicon::{Architecture, OperatingSystem, Triple};
+use thiserror::Error;
+use walrus::{
+    ConstExpr, DataKind, ElementItems, ElementKind, FunctionBuilder, FunctionId, FunctionKind,
+    ImportKind, Module, ModuleConfig, TableId,
+};
+use wasmparser::{
+    BinaryReader, BinaryReaderError, Linking, LinkingSectionReader, Payload, SymbolInfo,
+};
+
+type Result<T, E = PatchError> = std::result::Result<T, E>;
+
+#[derive(Debug, Error)]
+pub enum PatchError {
+    #[error("Failed to read file: {0}")]
+    ReadFs(#[from] std::io::Error),
+
+    #[error("No debug symbols in the patch output. Check your profile's `opt-level` and debug symbols config.")]
+    MissingSymbols,
+
+    #[error("Failed to parse wasm section: {0}")]
+    ParseSection(#[from] wasmparser::BinaryReaderError),
+
+    #[error("Failed to parse object file, {0}")]
+    ParseObjectFile(#[from] object::read::Error),
+
+    #[error("Failed to write object file: {0}")]
+    WriteObjectFIle(#[from] object::write::Error),
+
+    #[error("Failed to emit module: {0}")]
+    RuntimeError(#[from] anyhow::Error),
+
+    #[error("Failed to read module's PDB file: {0}")]
+    PdbLoadError(#[from] pdb::Error),
+
+    #[error("{0}")]
+    InvalidModule(String),
+
+    #[error("Unsupported platform: {0}")]
+    UnsupportedPlatform(String),
+}
+
+/// A cache for the hotpatching engine that stores the original module's parsed symbol table.
+/// For large projects, this can shave up to 50% off the total patching time. Since we compile the base
+/// module with every symbol in it, it can be quite large (hundreds of MB), so storing this here lets
+/// us avoid re-parsing the module every time we want to patch it.
+///
+/// On the Dioxus Docsite, it dropped the patch time from 3s to 1.1s (!)
+#[derive(Default)]
+pub struct HotpatchModuleCache {
+    pub path: PathBuf,
+
+    // .... wasm stuff
+    pub symbol_ifunc_map: HashMap<String, i32>,
+    pub old_wasm: Module,
+    pub old_bytes: Vec<u8>,
+    pub old_exports: HashSet<String>,
+    pub old_imports: HashSet<String>,
+
+    // ... native stuff
+    pub symbol_table: HashMap<String, CachedSymbol>,
+}
+
+pub struct CachedSymbol {
+    pub address: u64,
+    pub kind: SymbolKind,
+    pub is_undefined: bool,
+    pub is_weak: bool,
+}
+
+impl PartialEq for HotpatchModuleCache {
+    fn eq(&self, other: &Self) -> bool {
+        self.path == other.path
+    }
+}
+
+impl std::fmt::Debug for HotpatchModuleCache {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HotpatchModuleCache")
+            .field("_path", &self.path)
+            .finish()
+    }
+}
+
+impl HotpatchModuleCache {
+    /// This caching step is crucial for performance on large projects. The original module can be
+    /// quite large (hundreds of MB), so this step drastically speeds it up.
+    pub fn new(original: &Path, triple: &Triple) -> Result<Self> {
+        let cache = match triple.operating_system {
+            OperatingSystem::Windows => {
+                use pdb::FallibleIterator;
+
+                // due to lifetimes, this code is unfortunately duplicated.
+                // the pdb crate doesn't bind the lifetime of the items in the iterator to the symbol table,
+                // so we're stuck with local lifetime.s
+                let old_pdb_file = original.with_extension("pdb");
+                let old_pdb_file_handle = std::fs::File::open(old_pdb_file)?;
+                let mut pdb_file = pdb::PDB::open(old_pdb_file_handle)?;
+                let global_symbols = pdb_file.global_symbols()?;
+                let address_map = pdb_file.address_map()?;
+                let mut symbol_table = HashMap::new();
+                let mut symbols = global_symbols.iter();
+                while let Ok(Some(symbol)) = symbols.next() {
+                    match symbol.parse() {
+                        Ok(pdb::SymbolData::Public(data)) => {
+                            let rva = data.offset.to_rva(&address_map);
+                            let is_undefined = rva.is_none();
+
+                            // treat undefined symbols as 0 to match macho/elf
+                            let rva = rva.unwrap_or_default();
+
+                            symbol_table.insert(
+                                data.name.to_string().to_string(),
+                                CachedSymbol {
+                                    address: rva.0 as u64,
+                                    kind: if data.function {
+                                        SymbolKind::Text
+                                    } else {
+                                        SymbolKind::Data
+                                    },
+                                    is_undefined,
+                                    is_weak: false,
+                                },
+                            );
+                        }
+
+                        Ok(pdb::SymbolData::Data(data)) => {
+                            let rva = data.offset.to_rva(&address_map);
+                            let is_undefined = rva.is_none();
+
+                            // treat undefined symbols as 0 to match macho/elf
+                            let rva = rva.unwrap_or_default();
+
+                            symbol_table.insert(
+                                data.name.to_string().to_string(),
+                                CachedSymbol {
+                                    address: rva.0 as u64,
+                                    kind: SymbolKind::Data,
+                                    is_undefined,
+                                    is_weak: false,
+                                },
+                            );
+                        }
+
+                        _ => {}
+                    }
+                }
+
+                HotpatchModuleCache {
+                    symbol_table,
+                    path: original.to_path_buf(),
+                    ..Default::default()
+                }
+            }
+
+            // We need to load the ifunc table from the original module since that gives us the map
+            // of name to address (since ifunc entries are also pointers in wasm - ie 0x30 is the 30th
+            // entry in the ifunc table)
+            //
+            // One detail here is that with high optimization levels, the names of functions in the ifunc
+            // table will be smaller than the total number of functions in the module. This is because
+            // in high opt-levels, functions are merged. Fortunately, the symbol table remains intact
+            // and functions with different names point to the same function index (not to be confused
+            // with the function index in the module!).
+            //
+            // We need to take an extra step to account for merged functions by mapping function index
+            // to a set of functions that point to the same index.
+            _ if triple.architecture == Architecture::Wasm32 => {
+                let bytes = std::fs::read(original)?;
+                let ParsedModule {
+                    module, symbols, ..
+                } = parse_module_with_ids(&bytes)?;
+
+                if symbols.symbols.is_empty() {
+                    return Err(PatchError::MissingSymbols);
+                }
+
+                let name_to_ifunc_old = collect_func_ifuncs(&module);
+
+                // These are the "real" bindings for functions in the module
+                // Basically a map between a function's index and its real name
+                let func_to_index = module
+                    .funcs
+                    .par_iter()
+                    .filter_map(|f| {
+                        let name = f.name.as_deref()?;
+                        Some((*symbols.code_symbol_map.get(name)?, name))
+                    })
+                    .collect::<HashMap<usize, &str>>();
+
+                // Find the corresponding function that shares the same index, but in the ifunc table
+                let name_to_ifunc_old: HashMap<_, _> = symbols
+                    .code_symbol_map
+                    .par_iter()
+                    .filter_map(|(name, idx)| {
+                        let new_modules_unified_function = func_to_index.get(idx)?;
+                        let offset = name_to_ifunc_old.get(new_modules_unified_function)?;
+                        Some((*name, *offset))
+                    })
+                    .collect();
+
+                let symbol_ifunc_map = name_to_ifunc_old
+                    .par_iter()
+                    .map(|(name, idx)| (name.to_string(), *idx))
+                    .collect::<HashMap<_, _>>();
+
+                let old_exports = module
+                    .exports
+                    .iter()
+                    .map(|e| e.name.to_string())
+                    .collect::<HashSet<_>>();
+
+                let old_imports = module
+                    .imports
+                    .iter()
+                    .map(|i| i.name.to_string())
+                    .collect::<HashSet<_>>();
+
+                HotpatchModuleCache {
+                    path: original.to_path_buf(),
+                    old_bytes: bytes,
+                    symbol_ifunc_map,
+                    old_exports,
+                    old_imports,
+                    old_wasm: module,
+                    ..Default::default()
+                }
+            }
+            _ => {
+                let old_bytes = std::fs::read(original)?;
+                let obj = File::parse(&old_bytes as &[u8])?;
+                let symbol_table = obj
+                    .symbols()
+                    .filter_map(|s| {
+                        Some((
+                            s.name().ok()?.to_string(),
+                            CachedSymbol {
+                                address: s.address(),
+                                is_undefined: s.is_undefined(),
+                                is_weak: s.is_weak(),
+                                kind: s.kind(),
+                            },
+                        ))
+                    })
+                    .collect::<HashMap<_, _>>();
+                HotpatchModuleCache {
+                    symbol_table,
+                    path: original.to_path_buf(),
+                    old_bytes,
+                    ..Default::default()
+                }
+            }
+        };
+
+        Ok(cache)
+    }
+}
+
+/// Create a jump table for the given original and patch files.
+pub fn create_jump_table(
+    patch: &Path,
+    triple: &Triple,
+    cache: &HotpatchModuleCache,
+) -> Result<JumpTable> {
+    // Symbols are stored differently based on the platform, so we need to handle them differently.
+    // - Wasm requires the walrus crate and actually modifies the patch file
+    // - windows requires the pdb crate and pdb files
+    // - nix requires the object crate
+    match triple.operating_system {
+        OperatingSystem::Windows => create_windows_jump_table(patch, cache),
+        _ if triple.architecture == Architecture::Wasm32 => create_wasm_jump_table(patch, cache),
+        _ => create_native_jump_table(patch, triple, cache),
+    }
+}
+
+fn create_windows_jump_table(patch: &Path, cache: &HotpatchModuleCache) -> Result<JumpTable> {
+    use pdb::FallibleIterator;
+    let old_name_to_addr = &cache.symbol_table;
+
+    let mut new_name_to_addr = HashMap::new();
+    let new_pdb_file_handle = std::fs::File::open(patch.with_extension("pdb"))?;
+    let mut pdb_file = pdb::PDB::open(new_pdb_file_handle)?;
+    let symbol_table = pdb_file.global_symbols()?;
+    let address_map = pdb_file.address_map()?;
+    let mut symbol_iter = symbol_table.iter();
+    while let Ok(Some(symbol)) = symbol_iter.next() {
+        if let Ok(pdb::SymbolData::Public(data)) = symbol.parse() {
+            let rva = data.offset.to_rva(&address_map);
+            if let Some(rva) = rva {
+                new_name_to_addr.insert(data.name.to_string(), rva.0 as u64);
+            }
+        }
+    }
+
+    let mut map = AddressMap::default();
+    for (new_name, new_addr) in new_name_to_addr.iter() {
+        if let Some(old_addr) = old_name_to_addr.get(new_name.as_ref()) {
+            map.insert(old_addr.address, *new_addr);
+        }
+    }
+
+    let new_base_address = new_name_to_addr
+        .get("main")
+        .cloned()
+        .context("failed to find 'main' symbol in patch")?;
+
+    let aslr_reference = old_name_to_addr
+        .get("__aslr_reference")
+        .map(|s| s.address)
+        .context("failed to find '_aslr_reference' symbol in original module")?;
+
+    Ok(JumpTable {
+        lib: patch.to_path_buf(),
+        map,
+        new_base_address,
+        aslr_reference,
+        ifunc_count: 0,
+    })
+}
+
+/// Assemble a jump table for "nix" architectures. This uses the `object` crate to parse both
+/// executable's symbol tables and then creates a mapping between the two. Unlike windows, the symbol
+/// tables are stored within the binary itself, so we can use the `object` crate to parse them.
+///
+/// We use the `_aslr_reference` as a reference point in the base program to calculate the aslr slide
+/// both at compile time and at runtime.
+///
+/// This does not work for WASM since the `object` crate does not support emitting the WASM format,
+/// and because WASM requires more logic to handle the wasm-bindgen transformations.
+fn create_native_jump_table(
+    patch: &Path,
+    triple: &Triple,
+    cache: &HotpatchModuleCache,
+) -> Result<JumpTable> {
+    let old_name_to_addr = &cache.symbol_table;
+    let obj2_bytes = std::fs::read(patch)?;
+    let obj2 = File::parse(&obj2_bytes as &[u8])?;
+    let mut map = AddressMap::default();
+    let new_syms = obj2.symbol_map();
+
+    let new_name_to_addr = new_syms
+        .symbols()
+        .par_iter()
+        .map(|s| (s.name(), s.address()))
+        .collect::<HashMap<_, _>>();
+
+    for (new_name, new_addr) in new_name_to_addr.iter() {
+        if let Some(old_addr) = old_name_to_addr.get(*new_name) {
+            map.insert(old_addr.address, *new_addr);
+        }
+    }
+
+    let new_base_address = match triple.operating_system {
+        // The symbol in the symtab is called "_main" but in the dysymtab it is called "main"
+        OperatingSystem::MacOSX(_) | OperatingSystem::Darwin(_) | OperatingSystem::IOS(_) => {
+            *new_name_to_addr
+                .get("_main")
+                .context("failed to find '_main' symbol in patch")?
+        }
+
+        // No distincation between the two on these platforms
+        OperatingSystem::Freebsd
+        | OperatingSystem::Openbsd
+        | OperatingSystem::Linux
+        | OperatingSystem::Windows => *new_name_to_addr
+            .get("main")
+            .context("failed to find 'main' symbol in patch")?,
+
+        // On wasm, it doesn't matter what the address is since the binary is PIC
+        _ => 0,
+    };
+
+    let aslr_reference = old_name_to_addr
+        .get("___aslr_reference")
+        .or_else(|| old_name_to_addr.get("__aslr_reference"))
+        .map(|s| s.address)
+        .context("failed to find '___aslr_reference' symbol in original module")?;
+
+    Ok(JumpTable {
+        lib: patch.to_path_buf(),
+        map,
+        new_base_address,
+        aslr_reference,
+        ifunc_count: 0,
+    })
+}
+
+/// In the web, our patchable functions are actually ifuncs
+///
+/// We need to line up the ifuncs from the main module to the ifuncs in the patch.
+///
+/// According to the dylink spec, there will be two sets of entries:
+///
+/// - got.func: functions in the indirect function table
+/// - got.mem: data objects in the data segments
+///
+/// It doesn't seem like we can compile the base module to export these, sadly, so we're going
+/// to manually satisfy them here, removing their need to be imported.
+///
+/// https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
+fn create_wasm_jump_table(patch: &Path, cache: &HotpatchModuleCache) -> Result<JumpTable> {
+    let name_to_ifunc_old = &cache.symbol_ifunc_map;
+    let old = &cache.old_wasm;
+    let old_symbols =
+        parse_bytes_to_data_segment(&cache.old_bytes).context("Failed to parse data segment")?;
+    let new_bytes = std::fs::read(patch).context("Could not read patch file")?;
+
+    let mut new = Module::from_buffer(&new_bytes)?;
+    let mut got_mems = vec![];
+    let mut got_funcs = vec![];
+    let mut wbg_funcs = vec![];
+    let mut env_funcs = vec![];
+
+    // Collect all the GOT entries from the new module.
+    // The GOT imports come from the wasm-ld implementation of the dynamic linking spec
+    //
+    // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md#imports
+    //
+    // Normally, the base module would synthesize these as exports, but we're not compiling the base
+    // module with `--pie` (nor does wasm-bindgen support it yet), so we need to manually satisfy them.
+    //
+    // One thing to watch out for here is that GOT.func entries have no visibility to any de-duplication
+    // or merging, so we need to take great care in the base module to export *every* symbol even if
+    // they point to the same function.
+    //
+    // The other thing to watch out for here is the __wbindgen_placeholder__ entries. These are meant
+    // to be satisfied by wasm-bindgen via manual code generation, but we can't run wasm-bindgen on the
+    // patch, so we need to do it ourselves. This involves preventing their elimination in the base module
+    // by prefixing them with `__saved_wbg_`. When handling the imports here, we need modify the imported
+    // name to match the prefixed export name in the base module.
+    for import in new.imports.iter() {
+        match import.module.as_str() {
+            "GOT.func" => {
+                let Some(entry) = name_to_ifunc_old.get(import.name.as_str()).cloned() else {
+                    return Err(PatchError::InvalidModule(format!(
+                        "Expected to find GOT.func entry in ifunc table: {}",
+                        import.name.as_str()
+                    )));
+                };
+                got_funcs.push((import.id(), entry));
+            }
+            "GOT.mem" => got_mems.push(import.id()),
+            "env" => env_funcs.push(import.id()),
+            "__wbindgen_placeholder__" => wbg_funcs.push(import.id()),
+            m => tracing::trace!("Unknown import: {m}:{}", import.name),
+        }
+    }
+
+    // We need to satisfy the GOT.func imports of this side module. The GOT imports come from the wasm-ld
+    // implementation of the dynamic linking spec
+    //
+    // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md#imports
+    //
+    // Most importantly, these functions are functions meant to be called indirectly. In normal wasm
+    // code generation, only functions that Rust code references via pointers are given a slot in
+    // the indirection function table. The optimization here traditionally meaning that if a function
+    // can be called directly, then it doesn't need to be referenced indirectly and potentially inlined
+    // or dissolved during LTO.
+    //
+    // In our "fat build" setup, we aggregated all symbols from dependencies into a `dependencies.ar` file.
+    // By promoting these functions to the dynamic scope, we also prevent their inlining because the
+    // linker can still expect some form of interposition to happen, requiring the symbol *actually*
+    // exists.
+    //
+    // Our technique here takes advantage of that and the [`prepare_wasm_base_module`] function promotes
+    // every possible function to the indirect function table. This means that the GOT imports that
+    // `relocation-model=pic` synthesizes can reference the functions via the indirect function table
+    // even if they are not normally synthesized in regular wasm code generation.
+    //
+    // Normally, the dynaic linker setup would resolve GOT.func against the same GOT.func export in
+    // the main module, but we don't have that. Instead, we simply re-parse the main module, aggregate
+    // its ifunc table, and then resolve directly to the index in that table.
+    for (import_id, ifunc_index) in got_funcs {
+        let import = new.imports.get(import_id);
+        let ImportKind::Global(id) = import.kind else {
+            return Err(PatchError::InvalidModule(format!(
+                "Expected GOT.func import to be a global: {}",
+                import.name
+            )));
+        };
+
+        // "satisfying" the import means removing it from the import table and replacing its target
+        // value with a local global.
+        new.imports.delete(import_id);
+        new.globals.get_mut(id).kind =
+            walrus::GlobalKind::Local(ConstExpr::Value(walrus::ir::Value::I32(ifunc_index)));
+    }
+
+    // We need to satisfy the GOT.mem imports of this side module. The GOT.mem imports come from the wasm-ld
+    // implementation of the dynamic linking spec
+    //
+    // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md#imports
+    //
+    // Unlike the ifunc table, the GOT.mem imports do not need any additional post-processing of the
+    // base module to satisfy. Since our patching approach works but leveraging the experimental dynamic
+    // PIC support in rustc[wasm] and wasm-ld, we are using the GOT.mem imports as a way of identifying
+    // data segments that are present in the base module.
+    //
+    // Normally, the dynamic linker would synthesize corresponding GOT.mem exports in the main module,
+    // but since we're patching on-the-fly, this table will always be out-of-date.
+    //
+    // Instead, we use the symbol table from the base module to find the corresponding data symbols
+    // and then resolve the offset of the data segment in the main module. Using the symbol table
+    // can be somewhat finicky if the user compiled the code with a high-enough opt level that nukes
+    // the names of the data segments, but otherwise this system works well.
+    //
+    // We simply use the name of the import as a key into the symbol table and then its offset into
+    // its data segment as the value within the global.
+    for mem in got_mems {
+        let import = new.imports.get(mem);
+        let data_symbol_idx = *old_symbols
+            .data_symbol_map
+            .get(import.name.as_str())
+            .with_context(|| {
+                format!("Failed to find GOT.mem import by its name: {}", import.name)
+            })?;
+        let data_symbol = old_symbols
+            .data_symbols
+            .get(&data_symbol_idx)
+            .context("Failed to find data symbol by its index")?;
+        let data = old
+            .data
+            .iter()
+            .nth(data_symbol.which_data_segment)
+            .context("Missing data segment in the main module")?;
+
+        let offset = match data.kind {
+            DataKind::Active {
+                offset: ConstExpr::Value(walrus::ir::Value::I32(idx)),
+                ..
+            } => idx,
+            DataKind::Active {
+                offset: ConstExpr::Value(walrus::ir::Value::I64(idx)),
+                ..
+            } => idx as i32,
+            _ => {
+                return Err(PatchError::InvalidModule(format!(
+                    "Data segment of invalid table: {:?}",
+                    data.kind
+                )));
+            }
+        };
+
+        let ImportKind::Global(global_id) = import.kind else {
+            return Err(PatchError::InvalidModule(
+                "Expected GOT.mem import to be a global".to_string(),
+            ));
+        };
+
+        // "satisfying" the import means removing it from the import table and replacing its target
+        // value with a local global.
+        new.imports.delete(mem);
+        new.globals.get_mut(global_id).kind = walrus::GlobalKind::Local(ConstExpr::Value(
+            walrus::ir::Value::I32(offset + data_symbol.segment_offset as i32),
+        ));
+    }
+
+    // wasm-bindgen has a limit on the number of exports a module can have, so we need to call the main
+    // module's functions indirectly. This is done by dropping the env import and replacing it with a
+    // local function that calls the indirect function from the table.
+    //
+    // https://github.com/emscripten-core/emscripten/issues/22863
+    let ifunc_table_initializer = new
+        .elements
+        .iter()
+        .find_map(|e| match e.kind {
+            ElementKind::Active { table, .. } => Some(table),
+            _ => None,
+        })
+        .context("Missing ifunc table")?;
+    for env_func_import in env_funcs {
+        let import = new.imports.get(env_func_import);
+        let ImportKind::Function(func_id) = import.kind else {
+            continue;
+        };
+
+        if cache.old_exports.contains(import.name.as_str())
+            || cache.old_imports.contains(import.name.as_str())
+        {
+            continue;
+        }
+
+        if let Some(table_idx) = name_to_ifunc_old.get(import.name.as_str()) {
+            let name = import.name.as_str().to_string();
+            new.imports.delete(env_func_import);
+            convert_import_to_ifunc_call(
+                &mut new,
+                ifunc_table_initializer,
+                func_id,
+                *table_idx,
+                name,
+            );
+        }
+    }
+
+    // Wire up the preserved intrinsic functions that we saved before running wasm-bindgen to the expected
+    // imports from the patch.
+    for import_id in wbg_funcs {
+        let import = new.imports.get_mut(import_id);
+        import.module = "env".into();
+        import.name = format!("__saved_wbg_{}", import.name);
+    }
+
+    // Wipe away the unnecessary sections
+    let customs = new.customs.iter().map(|f| f.0).collect::<Vec<_>>();
+    for custom_id in customs {
+        if let Some(custom) = new.customs.get_mut(custom_id) {
+            if custom.name().contains("manganis") || custom.name().contains("__wasm_bindgen") {
+                new.customs.delete(custom_id);
+            }
+        }
+    }
+
+    // Clear the start function from the patch - we don't want any code automatically running!
+    new.start = None;
+
+    // Update the wasm module on the filesystem to use the newly lifted version
+    let lib = patch.to_path_buf();
+    std::fs::write(&lib, new.emit_wasm())?;
+
+    // And now assemble the jump table by mapping the old ifunc table to the new one, by name
+    //
+    // The ifunc_count will be passed to the dynamic loader so it can allocate the right amount of space
+    // in the indirect function table when loading the patch.
+    let name_to_ifunc_new = collect_func_ifuncs(&new);
+    let ifunc_count = name_to_ifunc_new.len() as u64;
+    let mut map = AddressMap::default();
+    for (name, idx) in name_to_ifunc_new.iter() {
+        if let Some(old_idx) = name_to_ifunc_old.get(*name) {
+            map.insert(*old_idx as u64, *idx as u64);
+        }
+    }
+
+    Ok(JumpTable {
+        map,
+        lib,
+        ifunc_count,
+        aslr_reference: 0,
+        new_base_address: 0,
+    })
+}
+
+fn convert_import_to_ifunc_call(
+    new: &mut Module,
+    ifunc_table_initializer: TableId,
+    func_id: FunctionId,
+    table_idx: i32,
+    name: String,
+) {
+    use walrus::ir;
+
+    let func = new.funcs.get_mut(func_id);
+    let ty_id = func.ty();
+
+    // Convert the import function to a local function that calls the indirect function from the table
+    let ty = new.types.get(ty_id);
+    let params = ty.params().to_vec();
+    let results = ty.results().to_vec();
+    let locals: Vec<_> = params.iter().map(|ty| new.locals.add(*ty)).collect();
+
+    // New function that calls the indirect function
+    let mut builder = FunctionBuilder::new(&mut new.types, &params, &results);
+    let mut body = builder.name(name).func_body();
+
+    // Push the params onto the stack
+    for arg in locals.iter() {
+        body.local_get(*arg);
+    }
+
+    // And then the address of the indirect function
+    body.instr(ir::Instr::Const(ir::Const {
+        value: ir::Value::I32(table_idx),
+    }));
+
+    // And call it
+    body.instr(ir::Instr::CallIndirect(ir::CallIndirect {
+        ty: ty_id,
+        table: ifunc_table_initializer,
+    }));
+
+    new.funcs.get_mut(func_id).kind = FunctionKind::Local(builder.local_func(locals));
+}
+
+fn collect_func_ifuncs(m: &Module) -> HashMap<&str, i32> {
+    // Collect all the functions in the module that are ifuncs
+    let mut func_to_offset = HashMap::new();
+    for el in m.elements.iter() {
+        let ElementKind::Active { offset, .. } = &el.kind else {
+            continue;
+        };
+
+        let offset = match offset {
+            // Handle explicit offsets
+            ConstExpr::Value(value) => match value {
+                walrus::ir::Value::I32(idx) => *idx,
+                walrus::ir::Value::I64(idx) => *idx as i32,
+                _ => continue,
+            },
+
+            // Globals are usually imports and thus don't add a specific offset
+            // ie the ifunc table is offset by a global, so we don't need to push the offset out
+            ConstExpr::Global(_) => 0,
+            _ => continue,
+        };
+
+        match &el.items {
+            ElementItems::Functions(ids) => {
+                for (idx, id) in ids.iter().enumerate() {
+                    if let Some(name) = m.funcs.get(*id).name.as_deref() {
+                        func_to_offset.insert(name, offset + idx as i32);
+                    }
+                }
+            }
+            ElementItems::Expressions(_ref_type, _const_exprs) => {}
+        }
+    }
+
+    func_to_offset
+}
+
+/// Resolve the undefined symbols in the incrementals against the original binary, returning an object
+/// file that can be linked along the incrementals.
+///
+/// This makes it possible to dlopen the resulting object file and use the original binary's symbols
+/// bypassing the dynamic linker.
+///
+/// This is very similar to malware :) but it's not!
+///
+/// Note - this function is not defined to run on WASM binaries. The `object` crate does not
+///
+/// todo... we need to wire up the cache
+pub fn create_undefined_symbol_stub(
+    cache: &HotpatchModuleCache,
+    incrementals: &[PathBuf],
+    triple: &Triple,
+    aslr_reference: u64,
+) -> Result<Vec<u8>> {
+    let sorted: Vec<_> = incrementals.iter().sorted().collect();
+
+    // Find all the undefined symbols in the incrementals
+    let mut undefined_symbols = HashSet::new();
+    let mut defined_symbols = HashSet::new();
+
+    for path in sorted {
+        let bytes = std::fs::read(path).with_context(|| format!("failed to read {:?}", path))?;
+        let file = File::parse(bytes.deref() as &[u8])?;
+        for symbol in file.symbols() {
+            if symbol.is_undefined() {
+                undefined_symbols.insert(symbol.name()?.to_string());
+            } else if symbol.is_global() {
+                defined_symbols.insert(symbol.name()?.to_string());
+            }
+        }
+    }
+    let undefined_symbols: Vec<_> = undefined_symbols
+        .difference(&defined_symbols)
+        .cloned()
+        .collect();
+
+    tracing::trace!("Undefined symbols: {:#?}", undefined_symbols);
+
+    // Create a new object file (architecture doesn't matter much for our purposes)
+    let mut obj = object::write::Object::new(
+        match triple.binary_format {
+            target_lexicon::BinaryFormat::Elf => object::BinaryFormat::Elf,
+            target_lexicon::BinaryFormat::Macho => object::BinaryFormat::MachO,
+            target_lexicon::BinaryFormat::Coff => object::BinaryFormat::Coff,
+            target_lexicon::BinaryFormat::Wasm => object::BinaryFormat::Wasm,
+            target_lexicon::BinaryFormat::Xcoff => object::BinaryFormat::Xcoff,
+            _ => return Err(PatchError::UnsupportedPlatform(triple.to_string())),
+        },
+        match triple.architecture {
+            Architecture::Aarch64(_) => object::Architecture::Aarch64,
+            Architecture::Wasm32 => object::Architecture::Wasm32,
+            Architecture::X86_64 => object::Architecture::X86_64,
+            _ => return Err(PatchError::UnsupportedPlatform(triple.to_string())),
+        },
+        match triple.endianness() {
+            Ok(target_lexicon::Endianness::Little) => Endianness::Little,
+            Ok(target_lexicon::Endianness::Big) => Endianness::Big,
+            _ => Endianness::Little,
+        },
+    );
+
+    // Write the headers so we load properly in ios/macos
+    #[allow(clippy::identity_op)]
+    match triple.operating_system {
+        OperatingSystem::Darwin(_) => {
+            obj.set_macho_build_version({
+                let mut build_version = MachOBuildVersion::default();
+                build_version.platform = macho::PLATFORM_MACOS;
+                build_version.minos = (11 << 16) | (0 << 8) | 0; // 11.0.0
+                build_version.sdk = (11 << 16) | (0 << 8) | 0; // SDK 11.0.0
+                build_version
+            });
+        }
+        OperatingSystem::IOS(_) => {
+            obj.set_macho_build_version({
+                let mut build_version = MachOBuildVersion::default();
+                build_version.platform = match triple.environment {
+                    target_lexicon::Environment::Sim => macho::PLATFORM_IOSSIMULATOR,
+                    _ => macho::PLATFORM_IOS,
+                };
+                build_version.minos = (14 << 16) | (0 << 8) | 0; // 14.0.0
+                build_version.sdk = (14 << 16) | (0 << 8) | 0; // SDK 14.0.0
+                build_version
+            });
+        }
+
+        _ => {}
+    }
+
+    let symbol_table = &cache.symbol_table;
+
+    // Get the offset from the main module and adjust the addresses by the slide
+    let aslr_ref_address = symbol_table
+        .get("___aslr_reference")
+        .or_else(|| symbol_table.get("__aslr_reference"))
+        .map(|s| s.address)
+        .context("Failed to find ___aslr_reference symbol")?;
+    let aslr_offset = aslr_reference - aslr_ref_address;
+
+    // we need to assemble a PLT/GOT so direct calls to the patch symbols work
+    // for each symbol we either write the address directly (as a symbol) or create a PLT/GOT entry
+    let text_section = obj.section_id(StandardSection::Text);
+    for name in undefined_symbols {
+        let Some(sym) = symbol_table.get(name.as_str().trim_start_matches("__imp_")) else {
+            tracing::error!("Symbol not found: {}", name);
+            continue;
+        };
+
+        // Undefined symbols tend to be import symbols (darwin gives them an address of 0 until defined).
+        // If we fail to skip these, then we end up with stuff like alloc at 0x0 which is quite bad!
+        if sym.is_undefined {
+            continue;
+        }
+
+        // ld64 likes to prefix symbols in intermediate object files with an underscore, but our symbol
+        // table doesn't, so we need to strip it off.
+        let name_offset = match triple.operating_system {
+            OperatingSystem::MacOSX(_) | OperatingSystem::Darwin(_) | OperatingSystem::IOS(_) => 1,
+            _ => 0,
+        };
+
+        let abs_addr = sym.address + aslr_offset;
+
+        match sym.kind {
+            // Handle synthesized window linker cross-dll statics.
+            //
+            // The `__imp_` prefix is a rather poorly documented feature of link.exe that makes it possible
+            // to reference statics in DLLs via text sections. The linker will synthesize a function
+            // that returns the address of the static, so calling that function will return the address.
+            // We want to satisfy it by creating a data symbol with the contents of the *actual* symbol
+            // in the original binary.
+            //
+            // We ca't use the `__imp_` from the original binary because it was not properly compiled
+            // with this in mind. Instead we have to create the new symbol.
+            //
+            // This is currently only implemented for 64bit architectures (haven't tested 32bit yet).
+            //
+            // https://stackoverflow.com/questions/5159353/how-can-i-get-rid-of-the-imp-prefix-in-the-linker-in-vc
+            _ if name.starts_with("__imp_") => {
+                let data_section = obj.section_id(StandardSection::Data);
+
+                // Add a pointer to the resolved address
+                let offset = obj.append_section_data(
+                    data_section,
+                    &abs_addr.to_le_bytes(),
+                    8, // Use proper alignment
+                );
+
+                // Add the symbol as a data symbol in our data section
+                obj.add_symbol(Symbol {
+                    name: name.as_bytes().to_vec(),
+                    value: offset, // Offset within the data section
+                    size: 8,       // Size of pointer
+                    scope: SymbolScope::Linkage,
+                    kind: SymbolKind::Data, // Always Data for IAT entries
+                    weak: false,
+                    section: SymbolSection::Section(data_section),
+                    flags: object::SymbolFlags::None,
+                });
+            }
+
+            // Text symbols are normal code symbols. We need to assemble stubs that resolve the undefined
+            // symbols and jump to the original address in the original binary.
+            //
+            // Unfortunately this isn't simply cross-platform, so we need to handle Unix and Windows
+            // calling conventions separately. It also depends on the architecture, making it even more
+            // complicated.
+            SymbolKind::Text => {
+                let jump_asm = match triple.operating_system {
+                    // The windows ABI and calling convention is different than the SystemV ABI.
+                    OperatingSystem::Windows => match triple.architecture {
+                        Architecture::X86_64 => {
+                            // Windows x64 has specific requirements for alignment and position-independent code
+                            let mut code = vec![
+                                0x48, 0xB8, // movabs RAX, imm64 (move 64-bit immediate to RAX)
+                            ];
+                            // Append the absolute 64-bit address
+                            code.extend_from_slice(&abs_addr.to_le_bytes());
+                            // jmp RAX (jump to the address in RAX)
+                            code.extend_from_slice(&[0xFF, 0xE0]);
+                            code
+                        }
+                        Architecture::X86_32(_) => {
+                            // On Windows 32-bit, we can use direct jump but need proper alignment
+                            let mut code = vec![
+                                0xB8, // mov EAX, imm32 (move immediate value to EAX)
+                            ];
+                            // Append the absolute 32-bit address
+                            code.extend_from_slice(&(abs_addr as u32).to_le_bytes());
+                            // jmp EAX (jump to the address in EAX)
+                            code.extend_from_slice(&[0xFF, 0xE0]);
+                            code
+                        }
+                        Architecture::Aarch64(_) => {
+                            // Use MOV/MOVK sequence to load 64-bit address into X16
+                            // This is more reliable than ADRP+LDR for direct hotpatching
+                            let mut code = Vec::new();
+
+                            // MOVZ X16, #imm16_0 (bits 0-15 of address)
+                            let imm16_0 = (abs_addr & 0xFFFF) as u16;
+                            let movz = 0xD2800010u32 | ((imm16_0 as u32) << 5);
+                            code.extend_from_slice(&movz.to_le_bytes());
+
+                            // MOVK X16, #imm16_1, LSL #16 (bits 16-31 of address)
+                            let imm16_1 = ((abs_addr >> 16) & 0xFFFF) as u16;
+                            let movk1 = 0xF2A00010u32 | ((imm16_1 as u32) << 5);
+                            code.extend_from_slice(&movk1.to_le_bytes());
+
+                            // MOVK X16, #imm16_2, LSL #32 (bits 32-47 of address)
+                            let imm16_2 = ((abs_addr >> 32) & 0xFFFF) as u16;
+                            let movk2 = 0xF2C00010u32 | ((imm16_2 as u32) << 5);
+                            code.extend_from_slice(&movk2.to_le_bytes());
+
+                            // MOVK X16, #imm16_3, LSL #48 (bits 48-63 of address)
+                            let imm16_3 = ((abs_addr >> 48) & 0xFFFF) as u16;
+                            let movk3 = 0xF2E00010u32 | ((imm16_3 as u32) << 5);
+                            code.extend_from_slice(&movk3.to_le_bytes());
+
+                            // BR X16 (Branch to address in X16)
+                            code.extend_from_slice(&[0x00, 0x02, 0x1F, 0xD6]);
+
+                            code
+                        }
+                        Architecture::Arm(_) => {
+                            // For Windows 32-bit ARM, we need a different approach
+                            let mut code = Vec::new();
+                            // LDR r12, [pc, #8] ; Load the address into r12
+                            code.extend_from_slice(&[0x08, 0xC0, 0x9F, 0xE5]);
+                            // BX r12 ; Branch to the address in r12
+                            code.extend_from_slice(&[0x1C, 0xFF, 0x2F, 0xE1]);
+                            // 4-byte alignment padding
+                            code.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]);
+                            // Store the 32-bit address - 4-byte aligned
+                            code.extend_from_slice(&(abs_addr as u32).to_le_bytes());
+                            code
+                        }
+                        _ => return Err(PatchError::UnsupportedPlatform(triple.to_string())),
+                    },
+                    _ => match triple.architecture {
+                        Architecture::X86_64 => {
+                            // Use JMP instruction to absolute address: FF 25 followed by 32-bit offset
+                            // Then the 64-bit absolute address
+                            let mut code = vec![0xFF, 0x25, 0x00, 0x00, 0x00, 0x00]; // jmp [rip+0]
+                                                                                     // Append the 64-bit address
+                            code.extend_from_slice(&abs_addr.to_le_bytes());
+                            code
+                        }
+                        Architecture::X86_32(_) => {
+                            // For 32-bit Intel, use JMP instruction with absolute address
+                            let mut code = vec![0xE9]; // jmp rel32
+                            let rel_addr = abs_addr as i32 - 5; // Relative address (offset from next instruction)
+                            code.extend_from_slice(&rel_addr.to_le_bytes());
+                            code
+                        }
+                        Architecture::Aarch64(_) => {
+                            // For ARM64, we load the address into a register and branch
+                            let mut code = Vec::new();
+                            // LDR X16, [PC, #0]  ; Load from the next instruction
+                            code.extend_from_slice(&[0x50, 0x00, 0x00, 0x58]);
+                            // BR X16            ; Branch to the address in X16
+                            code.extend_from_slice(&[0x00, 0x02, 0x1F, 0xD6]);
+                            // Store the 64-bit address
+                            code.extend_from_slice(&abs_addr.to_le_bytes());
+                            code
+                        }
+                        Architecture::Arm(_) => {
+                            // For 32-bit ARM, use LDR PC, [PC, #-4] to load the address and branch
+                            let mut code = Vec::new();
+                            // LDR PC, [PC, #-4] ; Load the address into PC (branching to it)
+                            code.extend_from_slice(&[0x04, 0xF0, 0x1F, 0xE5]);
+                            // Store the 32-bit address
+                            code.extend_from_slice(&(abs_addr as u32).to_le_bytes());
+                            code
+                        }
+                        _ => return Err(PatchError::UnsupportedPlatform(triple.to_string())),
+                    },
+                };
+
+                let offset = obj.append_section_data(text_section, &jump_asm, 8);
+                obj.add_symbol(Symbol {
+                    name: name.as_bytes()[name_offset..].to_vec(),
+                    value: offset,
+                    size: jump_asm.len() as u64,
+                    scope: SymbolScope::Linkage,
+                    kind: SymbolKind::Text,
+                    weak: false,
+                    section: SymbolSection::Section(text_section),
+                    flags: object::SymbolFlags::None,
+                });
+            }
+
+            // We just assume all non-text symbols are data (globals, statics, etc)
+            _ => {
+                // darwin statics show up as "unknown" symbols even though they are data symbols.
+                let kind = match sym.kind {
+                    SymbolKind::Unknown => SymbolKind::Data,
+                    k => k,
+                };
+                obj.add_symbol(Symbol {
+                    name: name.as_bytes()[name_offset..].to_vec(),
+                    value: abs_addr,
+                    size: 0,
+                    scope: SymbolScope::Linkage,
+                    kind,
+                    weak: sym.is_weak,
+                    section: SymbolSection::Absolute,
+                    flags: object::SymbolFlags::None,
+                });
+            }
+        }
+    }
+
+    Ok(obj.write()?)
+}
+
+/// Prepares the base module before running wasm-bindgen.
+///
+/// This tries to work around how wasm-bindgen works by intelligently promoting non-wasm-bindgen functions
+/// to the export table.
+///
+/// It also moves all functions and memories to be callable indirectly.
+pub fn prepare_wasm_base_module(bytes: &[u8]) -> Result<Vec<u8>> {
+    let ParsedModule {
+        mut module,
+        ids,
+        symbols,
+        ..
+    } = parse_module_with_ids(bytes)?;
+
+    // Due to monomorphizations, functions will get merged and multiple names will point to the same function.
+    // Walrus loses this information, so we need to manually parse the names table to get the indices
+    // and names of these functions.
+    //
+    // Unfortunately, the indices it gives us ARE NOT VALID.
+    // We need to work around it by using the FunctionId from the module as a link between the merged function names.
+    let ifunc_map = collect_func_ifuncs(&module);
+    let ifuncs = module
+        .funcs
+        .par_iter()
+        .filter_map(|f| ifunc_map.get(f.name.as_deref()?).map(|_| f.id()))
+        .collect::<HashSet<_>>();
+
+    let imported_funcs = module
+        .imports
+        .iter()
+        .filter_map(|i| match i.kind {
+            ImportKind::Function(id) => Some((id, i.id())),
+            _ => None,
+        })
+        .collect::<HashMap<_, _>>();
+
+    // Wasm-bindgen will synthesize imports to satisfy its external calls. This facilitates things
+    // like inline-js, snippets, and literally the `#[wasm_bindgen]` macro. All calls to JS are
+    // just `extern "wbg"` blocks!
+    //
+    // However, wasm-bindgen will run a GC pass on the module, removing any unused imports.
+    let mut make_indirect = vec![];
+    for (imported_func, importid) in imported_funcs {
+        let import = module.imports.get(importid);
+        let name_is_wbg =
+            import.name.starts_with("__wbindgen") || import.name.starts_with("__wbg_");
+
+        if name_is_wbg && !name_is_bindgen_symbol(import.name.as_str()) {
+            let func = module.funcs.get(imported_func);
+
+            let ty = module.types.get(func.ty());
+            let params = ty.params().to_vec();
+            let results = ty.results().to_vec();
+
+            let mut builder = FunctionBuilder::new(&mut module.types, &params, &results);
+            let mut body = builder
+                .name(format!("__saved_wbg_{}", import.name))
+                .func_body();
+
+            let locals = params
+                .iter()
+                .map(|ty| module.locals.add(*ty))
+                .collect::<Vec<_>>();
+
+            for l in locals.iter() {
+                body.local_get(*l);
+            }
+
+            body.call(imported_func);
+
+            let new_func_id = module.funcs.add_local(builder.local_func(locals));
+
+            module
+                .exports
+                .add(&format!("__saved_wbg_{}", import.name), new_func_id);
+
+            make_indirect.push(new_func_id);
+        }
+    }
+
+    for (name, index) in symbols.code_symbol_map.iter() {
+        if name_is_bindgen_symbol(name) {
+            continue;
+        }
+
+        let func = module.funcs.get(ids[*index]);
+
+        // We want to preserve the intrinsics from getting gc-ed out.
+        //
+        // These will create corresponding shim functions in the main module, that the patches will
+        // then call. Wasm-bindgen doesn't actually check if anyone uses the `__wbindgen` exports and
+        // forcefully deletes them literally by checking for symbols that start with `__wbindgen`. We
+        // preserve these symbols by naming them `__saved_wbg_<name>` and then exporting them.
+        //
+        // When wasm-bindgen runs, it will wrap these intrinsics with an `externref shim`, but we
+        // want to preserve the actual underlying function so side modules can call them directly.
+        //
+        // https://github.com/rustwasm/wasm-bindgen/blob/c35cc9369d5e0dc418986f7811a0dd702fb33ef9/crates/cli-support/src/wit/mod.rs#L1505
+        if name.starts_with("__wbindgen") {
+            module
+                .exports
+                .add(&format!("__saved_wbg_{name}"), func.id());
+        }
+
+        // This is basically `--export-all` but designed to work around wasm-bindgen not properly gc-ing
+        // imports like __wbindgen_placeholder__ and __wbindgen_externref__
+        //
+        // We only export local functions, and then make sure they can be accessible indirectly.
+        // If we weren't dealing with PIC code, then we could just create local ifuncs in the patch that
+        // call the original function directly. Unfortunately, this would require adding a new relocation
+        // to corresponding GOT.func entry, which we don't want to deal with.
+        //
+        // Note that we don't export via the export table, but rather the ifunc table. This is to work
+        // around issues on large projects where we hit the maximum number of exports.
+        //
+        // https://github.com/emscripten-core/emscripten/issues/22863
+        if let FunctionKind::Local(_) = &func.kind {
+            if !ifuncs.contains(&func.id()) {
+                make_indirect.push(func.id());
+            }
+        }
+    }
+
+    // Now we need to make sure to add the new ifuncs to the ifunc segment initializer.
+    // We just assume the last segment is the safest one we can add to which is common practice.
+    let segment = module
+        .elements
+        .iter_mut()
+        .last()
+        .context("Missing ifunc table")?;
+    let make_indirect_count = make_indirect.len() as u64;
+    let ElementItems::Functions(segment_ids) = &mut segment.items else {
+        return Err(PatchError::InvalidModule(
+            "Expected ifunc table to be a function table".into(),
+        ));
+    };
+
+    for func in make_indirect {
+        segment_ids.push(func);
+    }
+
+    if let ElementKind::Active { table, .. } = segment.kind {
+        let table = module.tables.get_mut(table);
+        table.initial += make_indirect_count;
+        if let Some(max) = table.maximum {
+            table.maximum = Some(max + make_indirect_count);
+        }
+    }
+
+    Ok(module.emit_wasm())
+}
+
+/// Check if the name is a wasm-bindgen symbol
+///
+/// todo(jon): I believe we can just look at all the functions the wasm_bindgen describe export references.
+/// this is kinda hacky on slow.
+///
+/// Uses the heuristics from the wasm-bindgen source code itself:
+///
+/// https://github.com/rustwasm/wasm-bindgen/blob/c35cc9369d5e0dc418986f7811a0dd702fb33ef9/crates/cli-support/src/wit/mod.rs#L1165
+fn name_is_bindgen_symbol(name: &str) -> bool {
+    name.contains("__wbindgen_describe")
+        || name.contains("__wbindgen_externref")
+        || name.contains("wasm_bindgen8describe6inform")
+        || name.contains("wasm_bindgen..describe..WasmDescribe")
+        || name.contains("wasm_bindgen..closure..WasmClosure$GT$8describe")
+        || name.contains("wasm_bindgen7closure16Closure$LT$T$GT$4wrap8describe")
+}
+
+/// Manually parse the data section from a wasm module
+///
+/// We need to do this for data symbols because walrus doesn't provide the right range and offset
+/// information for data segments. Fortunately, it provides it for code sections, so we only need to
+/// do a small amount extra of parsing here.
+fn parse_bytes_to_data_segment(bytes: &[u8]) -> Result<RawDataSection> {
+    let parser = wasmparser::Parser::new(0);
+    let mut parser = parser.parse_all(bytes);
+    let mut segments = vec![];
+    let mut data_range = 0..0;
+    let mut symbols = vec![];
+
+    // Process the payloads in the raw wasm file so we can extract the specific sections we need
+    while let Some(Ok(payload)) = parser.next() {
+        match payload {
+            Payload::DataSection(section) => {
+                data_range = section.range();
+                segments = section
+                    .into_iter()
+                    .collect::<Result<Vec<_>, BinaryReaderError>>()?
+            }
+            Payload::CustomSection(section) if section.name() == "linking" => {
+                let reader = BinaryReader::new(section.data(), 0);
+                let reader = LinkingSectionReader::new(reader)?;
+                for subsection in reader.subsections() {
+                    if let Linking::SymbolTable(map) = subsection? {
+                        symbols = map.into_iter().collect::<Result<Vec<_>, _>>()?;
+                    }
+                }
+            }
+            Payload::CustomSection(section) => {
+                tracing::trace!("Skipping Custom section: {:?}", section.name());
+            }
+            _ => {}
+        }
+    }
+
+    // Accumulate the data symbols into a btreemap for later use
+    let mut data_symbols = BTreeMap::new();
+    let mut data_symbol_map = HashMap::new();
+    let mut code_symbol_map = BTreeMap::new();
+    for (index, symbol) in symbols.iter().enumerate() {
+        if let SymbolInfo::Func { name, index, .. } = symbol {
+            if let Some(name) = name {
+                code_symbol_map.insert(*name, *index as usize);
+            }
+            continue;
+        }
+
+        let SymbolInfo::Data {
+            symbol: Some(symbol),
+            name,
+            ..
+        } = symbol
+        else {
+            continue;
+        };
+
+        data_symbol_map.insert(*name, index);
+
+        if symbol.size == 0 {
+            continue;
+        }
+
+        let data_segment = segments
+            .get(symbol.index as usize)
+            .context("Failed to find data segment")?;
+        let offset: usize =
+            data_segment.range.end - data_segment.data.len() + (symbol.offset as usize);
+        let range = offset..(offset + symbol.size as usize);
+
+        data_symbols.insert(
+            index,
+            DataSymbol {
+                _index: index,
+                _range: range,
+                segment_offset: symbol.offset as usize,
+                _symbol_size: symbol.size as usize,
+                which_data_segment: symbol.index as usize,
+            },
+        );
+    }
+
+    Ok(RawDataSection {
+        _data_range: data_range,
+        symbols,
+        data_symbols,
+        data_symbol_map,
+        code_symbol_map,
+    })
+}
+
+struct RawDataSection<'a> {
+    _data_range: Range<usize>,
+    symbols: Vec<SymbolInfo<'a>>,
+    code_symbol_map: BTreeMap<&'a str, usize>,
+    data_symbols: BTreeMap<usize, DataSymbol>,
+    data_symbol_map: HashMap<&'a str, usize>,
+}
+
+#[derive(Debug)]
+struct DataSymbol {
+    _index: usize,
+    _range: Range<usize>,
+    segment_offset: usize,
+    _symbol_size: usize,
+    which_data_segment: usize,
+}
+
+struct ParsedModule<'a> {
+    module: Module,
+    ids: Vec<FunctionId>,
+    symbols: RawDataSection<'a>,
+}
+
+/// Parse a module and return the mapping of index to FunctionID.
+/// We'll use this mapping to remap ModuleIDs
+fn parse_module_with_ids(bindgened: &[u8]) -> Result<ParsedModule> {
+    let ids = Arc::new(RwLock::new(Vec::new()));
+    let ids_ = ids.clone();
+    let module = Module::from_buffer_with_config(
+        bindgened,
+        ModuleConfig::new().on_parse(move |_m, our_ids| {
+            let mut ids = ids_.write().expect("No shared writers");
+            let mut idx = 0;
+            while let Ok(entry) = our_ids.get_func(idx) {
+                ids.push(entry);
+                idx += 1;
+            }
+
+            Ok(())
+        }),
+    )?;
+    let mut ids_ = ids.write().expect("No shared writers");
+    let mut ids = vec![];
+    std::mem::swap(&mut ids, &mut *ids_);
+
+    let symbols = parse_bytes_to_data_segment(bindgened).context("Failed to parse data segment")?;
+
+    Ok(ParsedModule {
+        module,
+        ids,
+        symbols,
+    })
+}

packages/cli/src/build/prerender.rs

@@ -1,125 +0,0 @@
-use anyhow::Context;
-use dioxus_cli_config::{server_ip, server_port};
-use futures_util::stream::FuturesUnordered;
-use futures_util::StreamExt;
-use std::{
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-    path::Path,
-    time::Duration,
-};
-use tokio::process::Command;
-
-pub(crate) async fn pre_render_static_routes(server_exe: &Path) -> anyhow::Result<()> {
-    // Use the address passed in through environment variables or default to localhost:9999. We need
-    // to default to a value that is different than the CLI default address to avoid conflicts
-    let ip = server_ip().unwrap_or_else(|| IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
-    let port = server_port().unwrap_or(9999);
-    let fullstack_address = SocketAddr::new(ip, port);
-    let address = fullstack_address.ip().to_string();
-    let port = fullstack_address.port().to_string();
-    // Borrow port and address so we can easily moe them into multiple tasks below
-    let address = &address;
-    let port = &port;
-
-    tracing::info!("Running SSG at http://{address}:{port} for {server_exe:?}");
-
-    // Run the server executable
-    let _child = Command::new(server_exe)
-        .env(dioxus_cli_config::SERVER_PORT_ENV, port)
-        .env(dioxus_cli_config::SERVER_IP_ENV, address)
-        .current_dir(server_exe.parent().unwrap())
-        .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .kill_on_drop(true)
-        .spawn()?;
-
-    // Borrow reqwest_client so we only move the reference into the futures
-    let reqwest_client = reqwest::Client::new();
-    let reqwest_client = &reqwest_client;
-
-    // Get the routes from the `/static_routes` endpoint
-    let mut routes = None;
-
-    // The server may take a few seconds to start up. Try fetching the route up to 5 times with a one second delay
-    const RETRY_ATTEMPTS: usize = 5;
-    for i in 0..=RETRY_ATTEMPTS {
-        tracing::debug!(
-            "Attempting to get static routes from server. Attempt {i} of {RETRY_ATTEMPTS}"
-        );
-
-        let request = reqwest_client
-            .post(format!("http://{address}:{port}/api/static_routes"))
-            .body("{}".to_string())
-            .send()
-            .await;
-        match request {
-            Ok(request) => {
-                routes = Some(request
-                    .json::<Vec<String>>()
-                    .await
-                    .inspect(|text| tracing::debug!("Got static routes: {text:?}"))
-                    .context("Failed to parse static routes from the server. Make sure your server function returns Vec<String> with the (default) json encoding")?);
-                break;
-            }
-            Err(err) => {
-                // If the request fails, try  up to 5 times with a one second delay
-                // If it fails 5 times, return the error
-                if i == RETRY_ATTEMPTS {
-                    return Err(err).context("Failed to get static routes from server. Make sure you have a server function at the `/api/static_routes` endpoint that returns Vec<String> of static routes.");
-                }
-                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-            }
-        }
-    }
-
-    let routes = routes.expect(
-        "static routes should exist or an error should have been returned on the last attempt",
-    );
-
-    // Create a pool of futures that cache each route
-    let mut resolved_routes = routes
-        .into_iter()
-        .map(|route| async move {
-            tracing::info!("Rendering {route} for SSG");
-
-            // For each route, ping the server to force it to cache the response for ssg
-            let request = reqwest_client
-                .get(format!("http://{address}:{port}{route}"))
-                .header("Accept", "text/html")
-                .send()
-                .await?;
-
-            // If it takes longer than 30 seconds to resolve the route, log a warning
-            let warning_task = tokio::spawn({
-                let route = route.clone();
-                async move {
-                    tokio::time::sleep(Duration::from_secs(30)).await;
-                    tracing::warn!("Route {route} has been rendering for 30 seconds");
-                }
-            });
-
-            // Wait for the streaming response to completely finish before continuing. We don't use the html it returns directly
-            // because it may contain artifacts of intermediate streaming steps while the page is loading. The SSG app should write
-            // the final clean HTML to the disk automatically after the request completes.
-            let _html = request.text().await?;
-
-            // Cancel the warning task if it hasn't already run
-            warning_task.abort();
-
-            Ok::<_, reqwest::Error>(route)
-        })
-        .collect::<FuturesUnordered<_>>();
-
-    while let Some(route) = resolved_routes.next().await {
-        match route {
-            Ok(route) => tracing::debug!("ssg success: {route:?}"),
-            Err(err) => tracing::error!("ssg error: {err:?}"),
-        }
-    }
-
-    tracing::info!("SSG complete");
-
-    drop(_child);
-
-    Ok(())
-}

packages/cli/src/build/progress.rs

@@ -1,120 +0,0 @@
-//! Report progress about the build to the user. We use channels to report progress back to the CLI.
-use crate::{AppBundle, BuildRequest, BuildStage, Platform, TraceSrc};
-use cargo_metadata::CompilerMessage;
-use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
-use std::path::PathBuf;
-
-pub(crate) type ProgressTx = UnboundedSender<BuildUpdate>;
-pub(crate) type ProgressRx = UnboundedReceiver<BuildUpdate>;
-
-#[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
-pub(crate) enum BuildUpdate {
-    Progress { stage: BuildStage },
-    CompilerMessage { message: CompilerMessage },
-    BuildReady { bundle: AppBundle },
-    BuildFailed { err: crate::Error },
-}
-
-impl BuildRequest {
-    pub(crate) fn status_wasm_bindgen_start(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::RunningBindgen {},
-        });
-    }
-
-    pub(crate) fn status_splitting_bundle(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::SplittingBundle,
-        });
-    }
-
-    pub(crate) fn status_start_bundle(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::Bundling {},
-        });
-    }
-
-    pub(crate) fn status_running_gradle(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::RunningGradle,
-        })
-    }
-
-    pub(crate) fn status_build_diagnostic(&self, message: CompilerMessage) {
-        _ = self
-            .progress
-            .unbounded_send(BuildUpdate::CompilerMessage { message });
-    }
-
-    pub(crate) fn status_build_error(&self, line: String) {
-        tracing::error!(dx_src = ?TraceSrc::Cargo, "{line}");
-    }
-
-    pub(crate) fn status_build_message(&self, line: String) {
-        tracing::trace!(dx_src = ?TraceSrc::Cargo, "{line}");
-    }
-
-    pub(crate) fn status_build_progress(&self, count: usize, total: usize, name: String) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::Compiling {
-                current: count,
-                total,
-                krate: name,
-                is_server: self.is_server(),
-            },
-        });
-    }
-
-    pub(crate) fn status_starting_build(&self, crate_count: usize) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::Starting {
-                is_server: self.build.platform() == Platform::Server,
-                crate_count,
-            },
-        });
-    }
-
-    pub(crate) fn status_copied_asset(
-        progress: &UnboundedSender<BuildUpdate>,
-        current: usize,
-        total: usize,
-        path: PathBuf,
-    ) {
-        _ = progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::CopyingAssets {
-                current,
-                total,
-                path,
-            },
-        });
-    }
-
-    pub(crate) fn status_optimizing_wasm(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::OptimizingWasm {},
-        });
-    }
-
-    pub(crate) fn status_prerendering_routes(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::PrerenderingRoutes {},
-        });
-    }
-
-    pub(crate) fn status_installing_tooling(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::InstallingTooling {},
-        });
-    }
-
-    pub(crate) fn status_compressing_assets(&self) {
-        _ = self.progress.unbounded_send(BuildUpdate::Progress {
-            stage: BuildStage::CompressingAssets,
-        });
-    }
-
-    pub(crate) fn is_server(&self) -> bool {
-        self.build.platform() == Platform::Server
-    }
-}

packages/cli/src/build/request.rs

@@ -1,155 +1,775 @@
-use super::{progress::ProgressTx, BuildArtifacts};
-use crate::dioxus_crate::DioxusCrate;
-use crate::{link::LinkAction, BuildArgs};
-use crate::{AppBundle, Platform, Result, TraceSrc};
+//! # [`BuildRequest`] - the core of the build process
+//!
+//! The [`BuildRequest`] object is the core of the build process. It contains all the resolved arguments
+//! flowing in from the CLI, dioxus.toml, env vars, and the workspace.
+//!
+//! Every BuildRequest is tied to a given workspace and BuildArgs. For simplicity's sake, the BuildArgs
+//! struct is used to represent the CLI arguments and all other configuration is basically just
+//! extra CLI arguments, but in a configuration format.
+//!
+//! When [`BuildRequest::build`] is called, it will prepare its work directory in the target folder
+//! and then start running the build process. A [`BuildContext`] is required to customize this
+//! build process, containing a channel for progress updates and the build mode.
+//!
+//! The [`BuildMode`] is extremely important since it influences how the build is performed. Most
+//! "normal" builds just use [`BuildMode::Base`], but we also support [`BuildMode::Fat`] and
+//! [`BuildMode::Thin`]. These builds are used together to power the hot-patching and fast-linking
+//! engine.
+//! - BuildMode::Base: A normal build generated using `cargo rustc`
+//! - BuildMode::Fat: A "fat" build where all dependency rlibs are merged into a static library
+//! - BuildMode::Thin: A "thin" build that dynamically links against the artifacts produced by the "fat" build
+//!
+//! The BuildRequest is also responsible for writing the final build artifacts to disk. This includes
+//!
+//! - Writing the executable
+//! - Processing assets from the artifact
+//! - Writing any metadata or configuration files (Info.plist, AndroidManifest.xml)
+//! - Bundle splitting (for wasm) and wasm-bindgen
+//!
+//! In some cases, the BuildRequest also handles the linking of the final executable. Specifically,
+//! - For Android, we use `dx` as an opaque linker to dynamically find the true android linker
+//! - For hotpatching, the CLI manually links the final executable with a stub file
+//!
+//! ## Build formats:
+//!
+//! We support building for the most popular platforms:
+//! - Web via wasm-bindgen
+//! - macOS via app-bundle
+//! - iOS via app-bundle
+//! - Android via gradle
+//! - Linux via app-image
+//! - Windows via exe, msi/msix
+//!
+//! Note that we are missing some setups that we *should* support:
+//! - PWAs, WebWorkers, ServiceWorkers
+//! - Web Extensions
+//! - Linux via flatpak/snap
+//!
+//! There are some less popular formats that we might want to support eventually:
+//! - TVOS, watchOS
+//! - OpenHarmony
+//!
+//! Also, some deploy platforms have their own bespoke formats:
+//! - Cloudflare workers
+//! - AWS Lambda
+//!
+//! Currently, we defer most of our deploy-based bundling to Tauri bundle, though we should migrate
+//! to just bundling everything ourselves. This would require us to implement code-signing which
+//! is a bit of a pain, but fortunately a solved process (https://github.com/rust-mobile/xbuild).
+//!
+//! ## Build Structure
+//!
+//! Builds generally follow the same structure everywhere:
+//! - A main executable
+//! - Sidecars (alternate entrypoints, framewrok plugins, etc)
+//! - Assets (images, fonts, etc)
+//! - Metadata (Info.plist, AndroidManifest.xml)
+//! - Glue code (java, kotlin, javascript etc)
+//! - Entitlements for code-signing and verification
+//!
+//! We need to be careful to not try and put a "round peg in a square hole," but most platforms follow
+//! the same pattern.
+//!
+//! As such, we try to assemble a build directory that's somewhat sensible:
+//! - A main "staging" dir for a given app
+//! - Per-profile dirs (debug/release)
+//! - A platform dir (ie web/desktop/android/ios)
+//! - The "bundle" dir which is basically the `.app` format or `wwww` dir.
+//! - The "executable" dir where the main exe is housed
+//! - The "assets" dir where the assets are housed
+//! - The "meta" dir where stuff like Info.plist, AndroidManifest.xml, etc are housed
+//!
+//! There's also some "quirky" folders that need to be stable between builds but don't influence the
+//! bundle itself:
+//! - session_cache_dir which stores stuff like window position
+//!
+//! ### Web:
+//!
+//! Create a folder that is somewhat similar to an app-image (exe + asset)
+//! The server is dropped into the `web` folder, even if there's no `public` folder.
+//! If there's no server (SPA), we still use the `web` folder, but it only contains the
+//! public folder.
+//!
+//! ```
+//! web/
+//!     server
+//!     assets/
+//!     public/
+//!         index.html
+//!         wasm/
+//!            app.wasm
+//!            glue.js
+//!            snippets/
+//!                ...
+//!         assets/
+//!            logo.png
+//! ```
+//!
+//! ### Linux:
+//!
+//! https://docs.appimage.org/reference/appdir.html#ref-appdir
+//! current_exe.join("Assets")
+//! ```
+//! app.appimage/
+//!     AppRun
+//!     app.desktop
+//!     package.json
+//!     assets/
+//!         logo.png
+//! ```
+//!
+//! ### Macos
+//!
+//! We simply use the macos format where binaries are in `Contents/MacOS` and assets are in `Contents/Resources`
+//! We put assets in an assets dir such that it generally matches every other platform and we can
+//! output `/assets/blah` from manganis.
+//! ```
+//! App.app/
+//!     Contents/
+//!         Info.plist
+//!         MacOS/
+//!             Frameworks/
+//!         Resources/
+//!             assets/
+//!                 blah.icns
+//!                 blah.png
+//!         CodeResources
+//!         _CodeSignature/
+//! ```
+//!
+//! ### iOS
+//!
+//! Not the same as mac! ios apps are a bit "flattened" in comparison. simpler format, presumably
+//! since most ios apps don't ship frameworks/plugins and such.
+//!
+//! todo(jon): include the signing and entitlements in this format diagram.
+//! ```
+//! App.app/
+//!     main
+//!     assets/
+//! ```
+//!
+//! ### Android:
+//!
+//! Currently we need to generate a `src` type structure, not a pre-packaged apk structure, since
+//! we need to compile kotlin and java. This pushes us into using gradle and following a structure
+//! similar to that of cargo mobile2. Eventually I'd like to slim this down (drop buildSrc) and
+//! drive the kotlin build ourselves. This would let us drop gradle (yay! no plugins!) but requires
+//! us to manage dependencies (like kotlinc) ourselves (yuck!).
+//!
+//! https://github.com/WanghongLin/miscellaneous/blob/master/tools/build-apk-manually.sh
+//!
+//! Unfortunately, it seems that while we can drop the `android` build plugin, we still will need
+//! gradle since kotlin is basically gradle-only.
+//!
+//! Pre-build:
+//! ```
+//! app.apk/
+//!     .gradle
+//!     app/
+//!         src/
+//!             main/
+//!                 assets/
+//!                 jniLibs/
+//!                 java/
+//!                 kotlin/
+//!                 res/
+//!                 AndroidManifest.xml
+//!             build.gradle.kts
+//!             proguard-rules.pro
+//!         buildSrc/
+//!             build.gradle.kts
+//!             src/
+//!                 main/
+//!                     kotlin/
+//!                          BuildTask.kt
+//!     build.gradle.kts
+//!     gradle.properties
+//!     gradlew
+//!     gradlew.bat
+//!     settings.gradle
+//! ```
+//!
+//! Final build:
+//! ```
+//! app.apk/
+//!   AndroidManifest.xml
+//!   classes.dex
+//!   assets/
+//!       logo.png
+//!   lib/
+//!       armeabi-v7a/
+//!           libmyapp.so
+//!       arm64-v8a/
+//!           libmyapp.so
+//! ```
+//! Notice that we *could* feasibly build this ourselves :)
+//!
+//! ### Windows:
+//! <https://superuser.com/questions/749447/creating-a-single-file-executable-from-a-directory-in-windows>
+//! Windows does not provide an AppImage format, so instead we're going build the same folder
+//! structure as an AppImage, but when distributing, we'll create a .exe that embeds the resources
+//! as an embedded .zip file. When the app runs, it will implicitly unzip its resources into the
+//! Program Files folder. Any subsequent launches of the parent .exe will simply call the AppRun.exe
+//! entrypoint in the associated Program Files folder.
+//!
+//! This is, in essence, the same as an installer, so we might eventually just support something like msi/msix
+//! which functionally do the same thing but with a sleeker UI.
+//!
+//! This means no installers are required and we can bake an updater into the host exe.
+//!
+//! ## Handling asset lookups:
+//! current_exe.join("assets")
+//! ```
+//! app.appimage/
+//!     main.exe
+//!     main.desktop
+//!     package.json
+//!     assets/
+//!         logo.png
+//! ```
+//!
+//! Since we support just a few locations, we could just search for the first that exists
+//! - usr
+//! - ../Resources
+//! - assets
+//! - Assets
+//! - $cwd/assets
+//!
+//! ```
+//! assets::root() ->
+//!     mac -> ../Resources/
+//!     ios -> ../Resources/
+//!     android -> assets/
+//!     server -> assets/
+//!     liveview -> assets/
+//!     web -> /assets/
+//! root().join(bundled)
+//! ```
+//!
+//! Every dioxus app can have an optional server executable which will influence the final bundle.
+//! This is built in parallel with the app executable during the `build` phase and the progres/status
+//! of the build is aggregated.
+//!
+//! The server will *always* be dropped into the `web` folder since it is considered "web" in nature,
+//! and will likely need to be combined with the public dir to be useful.
+//!
+//! We do our best to assemble read-to-go bundles here, such that the "bundle" step for each platform
+//! can just use the build dir
+//!
+//! When we write the AppBundle to a folder, it'll contain each bundle for each platform under the app's name:
+//! ```
+//! dog-app/
+//!   build/
+//!       web/
+//!         server.exe
+//!         assets/
+//!           some-secret-asset.txt (a server-side asset)
+//!         public/
+//!           index.html
+//!           assets/
+//!             logo.png
+//!       desktop/
+//!          App.app
+//!          App.appimage
+//!          App.exe
+//!          server/
+//!              server
+//!              assets/
+//!                some-secret-asset.txt (a server-side asset)
+//!       ios/
+//!          App.app
+//!          App.ipa
+//!       android/
+//!          App.apk
+//!   bundle/
+//!       build.json
+//!       Desktop.app
+//!       Mobile_x64.ipa
+//!       Mobile_arm64.ipa
+//!       Mobile_rosetta.ipa
+//!       web.appimage
+//!       web/
+//!         server.exe
+//!         assets/
+//!             some-secret-asset.txt
+//!         public/
+//!             index.html
+//!             assets/
+//!                 logo.png
+//!                 style.css
+//! ```
+//!
+//! When deploying, the build.json file will provide all the metadata that dx-deploy will use to
+//! push the app to stores, set up infra, manage versions, etc.
+//!
+//! The format of each build will follow the name plus some metadata such that when distributing you
+//! can easily trim off the metadata.
+//!
+//! The idea here is that we can run any of the programs in the same way that they're deployed.
+//!
+//! ## Bundle structure links
+//! - apple: <https>://developer.apple.com/documentation/bundleresources/placing_content_in_a_bundle>
+//! - appimage: <https>://docs.appimage.org/packaging-guide/manual.html#ref-manual>
+//!
+//! ## Extra links
+//! - xbuild: <https://github.com/rust-mobile/xbuild/blob/master/xbuild/src/command/build.rs>
+
+use crate::{
+    AndroidTools, BuildContext, DioxusConfig, Error, LinkAction, Platform, Result, RustcArgs,
+    TargetArgs, TraceSrc, WasmBindgen, WasmOptConfig, Workspace, DX_RUSTC_WRAPPER_ENV_VAR,
+};
 use anyhow::Context;
+use dioxus_cli_config::format_base_path_meta_element;
 use dioxus_cli_config::{APP_TITLE_ENV, ASSET_ROOT_ENV};
-use dioxus_cli_opt::AssetManifest;
-use serde::Deserialize;
+use dioxus_cli_opt::{process_file_to, AssetManifest};
+use itertools::Itertools;
+use krates::{cm::TargetKind, NodeId};
+use manganis::{AssetOptions, JsAssetOptions};
+use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
+use serde::{Deserialize, Serialize};
 use std::{
+    collections::HashSet,
+    io::Write,
     path::{Path, PathBuf},
     process::Stdio,
-    time::Instant,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+    time::{SystemTime, UNIX_EPOCH},
 };
+use target_lexicon::{OperatingSystem, Triple};
+use tempfile::{NamedTempFile, TempDir};
 use tokio::{io::AsyncBufReadExt, process::Command};
-
-#[derive(Clone, Debug)]
+use toml_edit::Item;
+use uuid::Uuid;
+
+use super::HotpatchModuleCache;
+
+/// This struct is used to plan the build process.
+///
+/// The point here is to be able to take in the user's config from the CLI without modifying the
+/// arguments in place. Creating a buildplan "resolves" their config into a build plan that can be
+/// introspected. For example, the users might not specify a "Triple" in the CLI but the triple will
+/// be guaranteed to be resolved here.
+///
+/// Creating a buildplan also lets us introspect build requests and modularize our build process.
+/// This will, however, lead to duplicate fields between the CLI and the build engine. This is fine
+/// since we have the freedom to evolve the schema internally without breaking the API.
+///
+/// All updates from the build will be sent on a global "BuildProgress" channel.
+#[derive(Clone)]
 pub(crate) struct BuildRequest {
-    /// The configuration for the crate we are building
-    pub(crate) krate: DioxusCrate,
-
-    /// The arguments for the build
-    pub(crate) build: BuildArgs,
+    pub(crate) workspace: Arc<Workspace>,
+    pub(crate) config: DioxusConfig,
+    pub(crate) crate_package: NodeId,
+    pub(crate) crate_target: krates::cm::Target,
+    pub(crate) profile: String,
+    pub(crate) release: bool,
+    pub(crate) platform: Platform,
+    pub(crate) enabled_platforms: Vec<Platform>,
+    pub(crate) triple: Triple,
+    pub(crate) _device: bool,
+    pub(crate) package: String,
+    pub(crate) features: Vec<String>,
+    pub(crate) extra_cargo_args: Vec<String>,
+    pub(crate) extra_rustc_args: Vec<String>,
+    pub(crate) no_default_features: bool,
+    pub(crate) custom_target_dir: Option<PathBuf>,
+    pub(crate) skip_assets: bool,
+    pub(crate) wasm_split: bool,
+    pub(crate) debug_symbols: bool,
+    pub(crate) inject_loading_scripts: bool,
+    pub(crate) custom_linker: Option<PathBuf>,
+    pub(crate) session_cache_dir: Arc<TempDir>,
+    pub(crate) link_args_file: Arc<NamedTempFile>,
+    pub(crate) link_err_file: Arc<NamedTempFile>,
+    pub(crate) rustc_wrapper_args_file: Arc<NamedTempFile>,
+}
 
-    /// Status channel to send our progress updates to
-    pub(crate) progress: ProgressTx,
+/// dx can produce different "modes" of a build. A "regular" build is a "base" build. The Fat and Thin
+/// modes are used together to achieve binary patching and linking.
+///
+/// Guide:
+/// ----------
+/// - Base: A normal build generated using `cargo rustc`, intended for production use cases
+///
+/// - Fat: A "fat" build with -Wl,-all_load and no_dead_strip, keeping *every* symbol in the binary.
+///        Intended for development for larger up-front builds with faster link times and the ability
+///        to binary patch the final binary. On WASM, this also forces wasm-bindgen to generate all
+///        JS-WASM bindings, saving us the need to re-wasmbindgen the final binary.
+///
+/// - Thin: A "thin" build that dynamically links against the dependencies produced by the "fat" build.
+///         This is generated by calling rustc *directly* and might be more fragile to construct, but
+///         generates *much* faster than a regular base or fat build.
+#[derive(Clone, Debug, PartialEq)]
+pub enum BuildMode {
+    /// A normal build generated using `cargo rustc`
+    Base,
+
+    /// A "Fat" build generated with cargo rustc and dx as a custom linker without -Wl,-dead-strip
+    Fat,
+
+    /// A "thin" build generated with `rustc` directly and dx as a custom linker
+    Thin {
+        rustc_args: RustcArgs,
+        changed_files: Vec<PathBuf>,
+        aslr_reference: u64,
+        cache: Arc<HotpatchModuleCache>,
+    },
+}
 
-    /// The target directory for the build
-    pub(crate) custom_target_dir: Option<PathBuf>,
+/// The end result of a build.
+///
+/// Contains the final asset manifest, the executable, and metadata about the build.
+/// Note that the `exe` might be stale and/or overwritten by the time you read it!
+///
+/// The patch cache is only populated on fat builds and then used for thin builds (see `BuildMode::Thin`).
+#[derive(Clone, Debug)]
+pub struct BuildArtifacts {
+    pub(crate) platform: Platform,
+    pub(crate) exe: PathBuf,
+    pub(crate) direct_rustc: RustcArgs,
+    pub(crate) time_start: SystemTime,
+    pub(crate) time_end: SystemTime,
+    pub(crate) assets: AssetManifest,
+    pub(crate) mode: BuildMode,
+    pub(crate) patch_cache: Option<Arc<HotpatchModuleCache>>,
 }
 
-impl BuildRequest {
-    pub fn new(krate: DioxusCrate, build: BuildArgs, progress: ProgressTx) -> Self {
-        Self {
-            build,
-            krate,
-            progress,
-            custom_target_dir: None,
-        }
-    }
+pub(crate) static PROFILE_WASM: &str = "wasm-dev";
+pub(crate) static PROFILE_ANDROID: &str = "android-dev";
+pub(crate) static PROFILE_SERVER: &str = "server-dev";
 
-    /// Run the build command with a pretty loader, returning the executable output location
+impl BuildRequest {
+    /// Create a new build request.
     ///
-    /// This will also run the fullstack build. Note that fullstack is handled separately within this
-    /// code flow rather than outside of it.
-    pub(crate) async fn build_all(self) -> Result<AppBundle> {
-        tracing::debug!(
-            "Running build command... {}",
-            if self.build.force_sequential {
-                "(sequentially)"
-            } else {
-                ""
-            }
-        );
+    /// This method consolidates various inputs into a single source of truth. It combines:
+    /// - Command-line arguments provided by the user.
+    /// - The crate's `Cargo.toml`.
+    /// - The `dioxus.toml` configuration file.
+    /// - User-specific CLI settings.
+    /// - The workspace metadata.
+    /// - Host-specific details (e.g., Android tools, installed frameworks).
+    /// - The intended target platform.
+    ///
+    /// Fields may be duplicated from the inputs to allow for autodetection and resolution.
+    ///
+    /// Autodetection is performed for unspecified fields where possible.
+    ///
+    /// Note: Build requests are typically created only when the CLI is invoked or when significant
+    /// changes are detected in the `Cargo.toml` (e.g., features added or removed).
+    pub(crate) async fn new(args: &TargetArgs, workspace: Arc<Workspace>) -> Result<Self> {
+        let crate_package = workspace.find_main_package(args.package.clone())?;
+
+        let config = workspace
+            .load_dioxus_config(crate_package)?
+            .unwrap_or_default();
+
+        let target_kind = match args.example.is_some() {
+            true => TargetKind::Example,
+            false => TargetKind::Bin,
+        };
+
+        let main_package = &workspace.krates[crate_package];
+
+        let target_name = args
+            .example
+            .clone()
+            .or(args.bin.clone())
+            .or_else(|| {
+                if let Some(default_run) = &main_package.default_run {
+                    return Some(default_run.to_string());
+                }
+
+                let bin_count = main_package
+                    .targets
+                    .iter()
+                    .filter(|x| x.kind.contains(&target_kind))
+                    .count();
+
+                if bin_count != 1 {
+                    return None;
+                }
+
+                main_package.targets.iter().find_map(|x| {
+                    if x.kind.contains(&target_kind) {
+                        Some(x.name.clone())
+                    } else {
+                        None
+                    }
+                })
+            })
+            .unwrap_or(workspace.krates[crate_package].name.clone());
+
+        let crate_target = main_package
+            .targets
+            .iter()
+            .find(|target| {
+                target_name == target.name.as_str() && target.kind.contains(&target_kind)
+            })
+            .with_context(|| {
+                let target_of_kind = |kind|-> String {
+                    let filtered_packages = main_package
+                .targets
+                .iter()
+                .filter_map(|target| {
+                    target.kind.contains(kind).then_some(target.name.as_str())
+                }).collect::<Vec<_>>();
+                filtered_packages.join(", ")};
+                if let Some(example) = &args.example {
+                    let examples = target_of_kind(&TargetKind::Example);
+                    format!("Failed to find example {example}. \nAvailable examples are:\n{}", examples)
+                } else if let Some(bin) = &args.bin {
+                    let binaries = target_of_kind(&TargetKind::Bin);
+                    format!("Failed to find binary {bin}. \nAvailable binaries are:\n{}", binaries)
+                } else {
+                    format!("Failed to find target {target_name}. \nIt looks like you are trying to build dioxus in a library crate. \
+                    You either need to run dx from inside a binary crate or build a specific example with the `--example` flag. \
+                    Available examples are:\n{}", target_of_kind(&TargetKind::Example))
+                }
+            })?
+            .clone();
+
+        // The crate might enable multiple platforms or no platforms at
+        // We collect all the platforms it enables first and then select based on the --platform arg
+        let enabled_platforms =
+            Self::enabled_cargo_toml_platforms(main_package, args.no_default_features);
+
+        let mut features = args.features.clone();
+        let mut no_default_features = args.no_default_features;
+
+        let platform: Platform = match args.platform {
+            Some(platform) => match enabled_platforms.len() {
+                0 => platform,
+
+                // The user passed --platform XYZ but already has `default = ["ABC"]` in their Cargo.toml or dioxus = { features = ["abc"] }
+                // We want to strip out the default platform and use the one they passed, setting no-default-features
+                _ => {
+                    features.extend(Self::platformless_features(main_package));
+                    no_default_features = true;
+                    platform
+                }
+            },
+            None => match enabled_platforms.len() {
+                0 => return Err(anyhow::anyhow!("No platform specified and no platform marked as default in Cargo.toml. Try specifying a platform with `--platform`").into()),
+                1 => enabled_platforms[0],
+                _ => {
+                    return Err(anyhow::anyhow!(
+                        "Multiple platforms enabled in Cargo.toml. Please specify a platform with `--platform` or set a default platform in Cargo.toml"
+                    )
+                    .into())
+                }
+            },
+        };
 
-        let (app, server) = match self.build.force_sequential {
-            true => self.build_sequential().await?,
-            false => self.build_concurrent().await?,
+        // Add any features required to turn on the client
+        features.push(Self::feature_for_platform(main_package, platform));
+
+        // Set the profile of the build if it's not already set
+        // This is mostly used for isolation of builds (preventing thrashing) but also useful to have multiple performance profiles
+        // We might want to move some of these profiles into dioxus.toml and make them "virtual".
+        let profile = match args.profile.clone() {
+            Some(profile) => profile,
+            None if args.release => "release".to_string(),
+            None => match platform {
+                Platform::Android => PROFILE_ANDROID.to_string(),
+                Platform::Web => PROFILE_WASM.to_string(),
+                Platform::Server => PROFILE_SERVER.to_string(),
+                _ => "dev".to_string(),
+            },
         };
 
-        AppBundle::new(self, app, server).await
-    }
+        // Determining release mode is based on the profile, actually, so we need to check that
+        let release = workspace.is_release_profile(&profile);
+
+        // Determine the --package we'll pass to cargo.
+        // todo: I think this might be wrong - we don't want to use main_package necessarily...
+        let package = args
+            .package
+            .clone()
+            .unwrap_or_else(|| main_package.name.clone());
+
+        // We usually use the simulator unless --device is passed *or* a device is detected by probing.
+        // For now, though, since we don't have probing, it just defaults to false
+        // Tools like xcrun/adb can detect devices
+        let device = args.device.unwrap_or(false);
+
+        // We want a real triple to build with, so we'll autodetect it if it's not provided
+        // The triple ends up being a source of truth for us later hence all this work to figure it out
+        let triple = match args.target.clone() {
+            Some(target) => target,
+            None => match platform {
+                // Generally just use the host's triple for native executables unless specified otherwise
+                Platform::MacOS
+                | Platform::Windows
+                | Platform::Linux
+                | Platform::Server
+                | Platform::Liveview => target_lexicon::HOST,
+
+                // We currently assume unknown-unknown for web, but we might want to eventually
+                // support emscripten
+                Platform::Web => "wasm32-unknown-unknown".parse().unwrap(),
+
+                // For iOS we should prefer the actual architecture for the simulator, but in lieu of actually
+                // figuring that out, we'll assume aarch64 on m-series and x86_64 otherwise
+                Platform::Ios => {
+                    // use the host's architecture and sim if --device is passed
+                    use target_lexicon::{Architecture, HOST};
+                    match HOST.architecture {
+                        Architecture::Aarch64(_) if device => "aarch64-apple-ios".parse().unwrap(),
+                        Architecture::Aarch64(_) => "aarch64-apple-ios-sim".parse().unwrap(),
+                        _ if device => "x86_64-apple-ios".parse().unwrap(),
+                        _ => "x86_64-apple-ios-sim".parse().unwrap(),
+                    }
+                }
 
-    /// Run the build command with a pretty loader, returning the executable output location
-    async fn build_concurrent(&self) -> Result<(BuildArtifacts, Option<BuildArtifacts>)> {
-        let (app, server) =
-            futures_util::future::try_join(self.build_app(), self.build_server()).await?;
+                // Same idea with android but we figure out the connected device using adb
+                Platform::Android => {
+                    workspace
+                        .android_tools()?
+                        .autodetect_android_device_triple()
+                        .await
+                }
+            },
+        };
 
-        Ok((app, server))
-    }
+        let custom_linker = if platform == Platform::Android {
+            Some(workspace.android_tools()?.android_cc(&triple))
+        } else {
+            None
+        };
 
-    async fn build_sequential(&self) -> Result<(BuildArtifacts, Option<BuildArtifacts>)> {
-        let app = self.build_app().await?;
-        let server = self.build_server().await?;
-        Ok((app, server))
-    }
+        // Set up some tempfiles so we can do some IPC between us and the linker/rustc wrapper (which is occasionally us!)
+        let link_args_file = Arc::new(
+            NamedTempFile::with_suffix(".txt")
+                .context("Failed to create temporary file for linker args")?,
+        );
+        let link_err_file = Arc::new(
+            NamedTempFile::with_suffix(".txt")
+                .context("Failed to create temporary file for linker args")?,
+        );
+        let rustc_wrapper_args_file = Arc::new(
+            NamedTempFile::with_suffix(".json")
+                .context("Failed to create temporary file for rustc wrapper args")?,
+        );
+        let session_cache_dir = Arc::new(
+            TempDir::new().context("Failed to create temporary directory for session cache")?,
+        );
 
-    pub(crate) async fn build_app(&self) -> Result<BuildArtifacts> {
-        tracing::debug!("Building app...");
+        let extra_rustc_args = shell_words::split(&args.rustc_args.clone().unwrap_or_default())
+            .context("Failed to parse rustc args")?;
 
-        let start = Instant::now();
-        self.prepare_build_dir()?;
-        let exe = self.build_cargo().await?;
-        let assets = self.collect_assets(&exe).await?;
+        let extra_cargo_args = shell_words::split(&args.cargo_args.clone().unwrap_or_default())
+            .context("Failed to parse cargo args")?;
 
-        Ok(BuildArtifacts {
-            exe,
-            assets,
-            time_taken: start.elapsed(),
+        tracing::debug!(
+            r#"Log Files:
+link_args_file: {},
+link_err_file: {},
+rustc_wrapper_args_file: {},
+session_cache_dir: {}"#,
+            link_args_file.path().display(),
+            link_err_file.path().display(),
+            rustc_wrapper_args_file.path().display(),
+            session_cache_dir.path().display(),
+        );
+
+        Ok(Self {
+            platform,
+            features,
+            no_default_features,
+            crate_package,
+            crate_target,
+            profile,
+            triple,
+            _device: device,
+            workspace,
+            config,
+            enabled_platforms,
+            custom_target_dir: None,
+            custom_linker,
+            link_args_file,
+            link_err_file,
+            session_cache_dir,
+            rustc_wrapper_args_file,
+            extra_rustc_args,
+            extra_cargo_args,
+            release,
+            package,
+            skip_assets: args.skip_assets,
+            wasm_split: args.wasm_split,
+            debug_symbols: args.debug_symbols,
+            inject_loading_scripts: args.inject_loading_scripts,
         })
     }
 
-    pub(crate) async fn build_server(&self) -> Result<Option<BuildArtifacts>> {
-        tracing::debug!("Building server...");
+    pub(crate) async fn build(&self, ctx: &BuildContext) -> Result<BuildArtifacts> {
+        // If we forget to do this, then we won't get the linker args since rust skips the full build
+        // We need to make sure to not react to this though, so the filemap must cache it
+        _ = self.bust_fingerprint(ctx);
+
+        // Run the cargo build to produce our artifacts
+        let mut artifacts = self.cargo_build(ctx).await?;
+
+        // Write the build artifacts to the bundle on the disk
+        match &ctx.mode {
+            BuildMode::Thin {
+                aslr_reference,
+                cache,
+                ..
+            } => {
+                self.write_patch(ctx, *aslr_reference, &mut artifacts, cache)
+                    .await?;
+            }
+
+            BuildMode::Base | BuildMode::Fat => {
+                ctx.status_start_bundle();
+
+                self.write_executable(ctx, &artifacts.exe, &mut artifacts.assets)
+                    .await
+                    .context("Failed to write main executable")?;
+                self.write_assets(ctx, &artifacts.assets)
+                    .await
+                    .context("Failed to write assets")?;
+                self.write_metadata().await?;
+                self.optimize(ctx).await?;
+                self.assemble(ctx)
+                    .await
+                    .context("Failed to assemble app bundle")?;
+
+                tracing::debug!("Bundle created at {}", self.root_dir().display());
+            }
+        }
 
-        if !self.build.fullstack() {
-            return Ok(None);
+        // Populate the patch cache if we're in fat mode
+        if matches!(ctx.mode, BuildMode::Fat) {
+            artifacts.patch_cache = Some(Arc::new(self.create_patch_cache(&artifacts.exe).await?));
         }
 
-        let mut cloned = self.clone();
-        cloned.build.platform = Some(Platform::Server);
-        Ok(Some(cloned.build_app().await?))
+        Ok(artifacts)
     }
 
-    /// Run `cargo`, returning the location of the final executable
+    /// Run the cargo build by assembling the build command and executing it.
     ///
-    /// todo: add some stats here, like timing reports, crate-graph optimizations, etc
-    pub(crate) async fn build_cargo(&self) -> Result<PathBuf> {
-        tracing::debug!("Executing cargo...");
+    /// This method needs to be very careful with processing output since errors being swallowed will
+    /// be very confusing to the user.
+    async fn cargo_build(&self, ctx: &BuildContext) -> Result<BuildArtifacts> {
+        let time_start = SystemTime::now();
 
         // Extract the unit count of the crate graph so build_cargo has more accurate data
-        let crate_count = self.get_unit_count_estimate().await;
+        // "Thin" builds only build the final exe, so we only need to build one crate
+        let crate_count = match ctx.mode {
+            BuildMode::Thin { .. } => 1,
+            _ => self.get_unit_count_estimate(ctx).await,
+        };
 
         // Update the status to show that we're starting the build and how many crates we expect to build
-        self.status_starting_build(crate_count);
-
-        let mut cmd = Command::new("cargo");
-
-        cmd.arg("rustc")
-            .current_dir(self.krate.crate_dir())
-            .arg("--message-format")
-            .arg("json-diagnostic-rendered-ansi")
-            .args(self.build_arguments())
-            .envs(self.env_vars()?);
-
-        if let Some(target_dir) = self.custom_target_dir.as_ref() {
-            cmd.env("CARGO_TARGET_DIR", target_dir);
-        }
-
-        // Android needs a special linker since the linker is actually tied to the android toolchain.
-        // For the sake of simplicity, we're going to pass the linker here using ourselves as the linker,
-        // but in reality we could simply use the android toolchain's linker as the path.
-        //
-        // We don't want to overwrite the user's .cargo/config.toml since that gets committed to git
-        // and we want everyone's install to be the same.
-        if self.build.platform() == Platform::Android {
-            let ndk = self
-                .krate
-                .android_ndk()
-                .context("Could not autodetect android linker")?;
-            let arch = self.build.target_args.arch();
-            let linker = arch.android_linker(&ndk);
-
-            let link_action = LinkAction::LinkAndroid {
-                linker,
-                extra_flags: vec![],
-            }
-            .to_json();
-
-            cmd.env(LinkAction::ENV_VAR_NAME, link_action);
-        }
+        ctx.status_starting_build(crate_count);
 
-        tracing::trace!(dx_src = ?TraceSrc::Build, "Rust cargo args: {:#?}", cmd);
+        let mut cmd = self.build_command(ctx)?;
+        tracing::debug!(dx_src = ?TraceSrc::Build, "Executing cargo for {} using {}", self.platform, self.triple);
 
         let mut child = cmd
             .stdout(Stdio::piped())
@@ -159,7 +779,7 @@ impl BuildRequest {
 
         let stdout = tokio::io::BufReader::new(child.stdout.take().unwrap());
         let stderr = tokio::io::BufReader::new(child.stderr.take().unwrap());
-        let mut output_location = None;
+        let mut output_location: Option<PathBuf> = None;
         let mut stdout = stdout.lines();
         let mut stderr = stderr.lines();
         let mut units_compiled = 0;
@@ -180,33 +800,60 @@ impl BuildRequest {
 
             match message {
                 Message::BuildScriptExecuted(_) => units_compiled += 1,
+                Message::CompilerMessage(msg) => ctx.status_build_diagnostic(msg),
                 Message::TextLine(line) => {
+                    // Handle the case where we're getting lines directly from rustc.
+                    // These are in a different format than the normal cargo output, though I imagine
+                    // this parsing code is quite fragile/sensitive to changes in cargo, cargo_metadata, rustc, etc.
+                    #[derive(Deserialize)]
+                    struct RustcArtifact {
+                        artifact: PathBuf,
+                        emit: String,
+                    }
+
+                    // These outputs look something like:
+                    //
+                    // { "artifact":"target/debug/deps/libdioxus_core-4f2a0b3c1e5f8b7c.rlib", "emit":"link" }
+                    //
+                    // There are other outputs like depinfo that we might be interested in in the future.
+                    if let Ok(artifact) = serde_json::from_str::<RustcArtifact>(&line) {
+                        if artifact.emit == "link" {
+                            output_location = Some(artifact.artifact);
+                        }
+                    }
+
                     // For whatever reason, if there's an error while building, we still receive the TextLine
                     // instead of an "error" message. However, the following messages *also* tend to
                     // be the error message, and don't start with "error:". So we'll check if we've already
                     // emitted an error message and if so, we'll emit all following messages as errors too.
+                    //
+                    // todo: This can lead to some really ugly output though, so we might want to look
+                    // into a more reliable way to detect errors propagating out of the compiler. If
+                    // we always wrapped rustc, then we could store this data somewhere in a much more
+                    // reliable format.
                     if line.trim_start().starts_with("error:") {
                         emitting_error = true;
                     }
 
-                    if emitting_error {
-                        self.status_build_error(line);
-                    } else {
-                        self.status_build_message(line)
+                    // Note that previous text lines might have set emitting_error to true
+                    match emitting_error {
+                        true => ctx.status_build_error(line),
+                        false => ctx.status_build_message(line),
                     }
                 }
-                Message::CompilerMessage(msg) => self.status_build_diagnostic(msg),
                 Message::CompilerArtifact(artifact) => {
                     units_compiled += 1;
                     match artifact.executable {
                         Some(executable) => output_location = Some(executable.into()),
-                        None => self.status_build_progress(
+                        None => ctx.status_build_progress(
                             units_compiled,
                             crate_count,
                             artifact.target.name,
                         ),
                     }
                 }
+                // todo: this can occasionally swallow errors, so we should figure out what exactly is going wrong
+                //       since that is a really bad user experience.
                 Message::BuildFinished(finished) => {
                     if !finished.success {
                         return Err(anyhow::anyhow!(
@@ -219,604 +866,1425 @@ impl BuildRequest {
             }
         }
 
-        if output_location.is_none() {
-            tracing::error!("Cargo build failed - no output location. Toggle tracing mode (press `t`) for more information.");
+        let exe = output_location.context("Cargo build failed - no output location. Toggle tracing mode (press `t`) for more information.")?;
+
+        // Accumulate the rustc args from the wrapper, if they exist and can be parsed.
+        let mut direct_rustc = RustcArgs::default();
+        if let Ok(res) = std::fs::read_to_string(self.rustc_wrapper_args_file.path()) {
+            if let Ok(res) = serde_json::from_str(&res) {
+                direct_rustc = res;
+            }
+        }
+
+        // If there's any warnings from the linker, we should print them out
+        if let Ok(linker_warnings) = std::fs::read_to_string(self.link_err_file.path()) {
+            if !linker_warnings.is_empty() {
+                tracing::warn!("Linker warnings: {}", linker_warnings);
+            }
         }
 
-        let out_location = output_location.context("Build did not return an executable")?;
+        // Fat builds need to be linked with the fat linker. Would also like to link here for thin builds
+        if matches!(ctx.mode, BuildMode::Fat) {
+            self.run_fat_link(ctx, &exe).await?;
+        }
 
-        tracing::debug!(
-            "Build completed successfully - output location: {:?}",
-            out_location
-        );
+        let assets = self.collect_assets(&exe, ctx)?;
+        let time_end = SystemTime::now();
+        let mode = ctx.mode.clone();
+        let platform = self.platform;
+        tracing::debug!("Build completed successfully - output location: {:?}", exe);
 
-        Ok(out_location)
+        Ok(BuildArtifacts {
+            time_end,
+            platform,
+            exe,
+            direct_rustc,
+            time_start,
+            assets,
+            mode,
+            patch_cache: None,
+        })
     }
 
     /// Traverse the target directory and collect all assets from the incremental cache
     ///
     /// This uses "known paths" that have stayed relatively stable during cargo's lifetime.
     /// One day this system might break and we might need to go back to using the linker approach.
-    pub(crate) async fn collect_assets(&self, exe: &Path) -> Result<AssetManifest> {
-        tracing::debug!("Collecting assets ...");
-
-        if self.build.skip_assets {
-            return Ok(AssetManifest::default());
-        }
-
-        // Experimental feature for testing - if the env var is set, we'll use the deeplinker
-        if std::env::var("DEEPLINK").is_ok() {
-            tracing::debug!("Using deeplinker instead of incremental cache");
-            return self.deep_linker_asset_extract().await;
-        }
+    fn collect_assets(&self, exe: &Path, ctx: &BuildContext) -> Result<AssetManifest> {
+        tracing::debug!("Collecting assets from exe at {} ...", exe.display());
 
         // walk every file in the incremental cache dir, reading and inserting items into the manifest.
         let mut manifest = AssetManifest::default();
 
         // And then add from the exe directly, just in case it's LTO compiled and has no incremental cache
-        _ = manifest.add_from_object_path(exe);
+        if !self.skip_assets {
+            ctx.status_extracting_assets();
+            _ = manifest.add_from_object_path(exe);
+        }
 
         Ok(manifest)
     }
 
-    /// Create a list of arguments for cargo builds
-    pub(crate) fn build_arguments(&self) -> Vec<String> {
-        let mut cargo_args = Vec::new();
-
-        // Set the target, profile and features that vary between the app and server builds
-        if self.build.platform() == Platform::Server {
-            cargo_args.push("--profile".to_string());
-            match self.build.release {
-                true => cargo_args.push("release".to_string()),
-                false => cargo_args.push(self.build.server_profile.to_string()),
-            };
-
-            // If the user provided a server target, use it, otherwise use the default host target.
-            if let Some(target) = self.build.target_args.server_target.as_deref() {
-                cargo_args.push("--target".to_string());
-                cargo_args.push(target.to_string());
-            }
-        } else {
-            // Add required profile flags. --release overrides any custom profiles.
-            let custom_profile = &self.build.profile.as_ref();
-            if custom_profile.is_some() || self.build.release {
-                cargo_args.push("--profile".to_string());
-                match self.build.release {
-                    true => cargo_args.push("release".to_string()),
-                    false => {
-                        cargo_args.push(
-                            custom_profile
-                                .expect("custom_profile should have been checked by is_some")
-                                .to_string(),
-                        );
-                    }
-                };
-            }
-
-            // todo: use the right arch based on the current arch
-            let custom_target = match self.build.platform() {
-                Platform::Web => Some("wasm32-unknown-unknown"),
-                Platform::Ios => match self.build.target_args.device {
-                    Some(true) => Some("aarch64-apple-ios"),
-                    _ => Some("aarch64-apple-ios-sim"),
-                },
-                Platform::Android => Some(self.build.target_args.arch().android_target_triplet()),
-                Platform::Server => None,
-                // we're assuming we're building for the native platform for now... if you're cross-compiling
-                // the targets here might be different
-                Platform::MacOS => None,
-                Platform::Windows => None,
-                Platform::Linux => None,
-                Platform::Liveview => None,
-            };
-
-            if let Some(target) = custom_target.or(self.build.target_args.target.as_deref()) {
-                cargo_args.push("--target".to_string());
-                cargo_args.push(target.to_string());
+    /// Take the output of rustc and make it into the main exe of the bundle
+    ///
+    /// For wasm, we'll want to run `wasm-bindgen` to make it a wasm binary along with some other optimizations
+    /// Other platforms we might do some stripping or other optimizations
+    /// Move the executable to the workdir
+    async fn write_executable(
+        &self,
+        ctx: &BuildContext,
+        exe: &Path,
+        assets: &mut AssetManifest,
+    ) -> Result<()> {
+        match self.platform {
+            // Run wasm-bindgen on the wasm binary and set its output to be in the bundle folder
+            // Also run wasm-opt on the wasm binary, and sets the index.html since that's also the "executable".
+            //
+            // The wasm stuff will be in a folder called "wasm" in the workdir.
+            //
+            // Final output format:
+            // ```
+            // dx/
+            //     app/
+            //         web/
+            //             bundle/
+            //             build/
+            //                 server.exe
+            //                 public/
+            //                     index.html
+            //                     wasm/
+            //                        app.wasm
+            //                        glue.js
+            //                        snippets/
+            //                            ...
+            //                     assets/
+            //                        logo.png
+            // ```
+            Platform::Web => {
+                self.bundle_web(ctx, exe, assets).await?;
             }
-        }
 
-        // We always run in verbose since the CLI itself is the one doing the presentation
-        cargo_args.push("--verbose".to_string());
+            // this will require some extra oomf to get the multi architecture builds...
+            // for now, we just copy the exe into the current arch (which, sorry, is hardcoded for my m1)
+            // we'll want to do multi-arch builds in the future, so there won't be *one* exe dir to worry about
+            // eventually `exe_dir` and `main_exe` will need to take in an arch and return the right exe path
+            //
+            // todo(jon): maybe just symlink this rather than copy it?
+            // we might want to eventually use the objcopy logic to handle this
+            //
+            // https://github.com/rust-mobile/xbuild/blob/master/xbuild/template/lib.rs
+            // https://github.com/rust-mobile/xbuild/blob/master/apk/src/lib.rs#L19
+            //
+            // These are all super simple, just copy the exe into the folder
+            // eventually, perhaps, maybe strip + encrypt the exe?
+            Platform::Android
+            | Platform::MacOS
+            | Platform::Windows
+            | Platform::Linux
+            | Platform::Ios
+            | Platform::Liveview
+            | Platform::Server => {
+                // We wipe away the dir completely, which is not great behavior :/
+                // Don't wipe server since web will need this folder too.
+                if self.platform != Platform::Server {
+                    _ = std::fs::remove_dir_all(self.exe_dir());
+                }
 
-        if self.build.target_args.no_default_features {
-            cargo_args.push("--no-default-features".to_string());
+                std::fs::create_dir_all(self.exe_dir())?;
+                std::fs::copy(exe, self.main_exe())?;
+            }
         }
 
-        let features = self.target_features();
+        Ok(())
+    }
 
-        if !features.is_empty() {
-            cargo_args.push("--features".to_string());
-            cargo_args.push(features.join(" "));
+    /// Copy the assets out of the manifest and into the target location
+    ///
+    /// Should be the same on all platforms - just copy over the assets from the manifest into the output directory
+    async fn write_assets(&self, ctx: &BuildContext, assets: &AssetManifest) -> Result<()> {
+        // Server doesn't need assets - web will provide them
+        if self.platform == Platform::Server {
+            return Ok(());
         }
 
-        if let Some(ref package) = self.build.target_args.package {
-            cargo_args.push(String::from("-p"));
-            cargo_args.push(package.clone());
+        let asset_dir = self.asset_dir();
+
+        // First, clear the asset dir of any files that don't exist in the new manifest
+        _ = std::fs::create_dir_all(&asset_dir);
+
+        // Create a set of all the paths that new files will be bundled to
+        let mut keep_bundled_output_paths: HashSet<_> = assets
+            .assets
+            .values()
+            .map(|a| asset_dir.join(a.bundled_path()))
+            .collect();
+
+        // The CLI creates a .version file in the asset dir to keep track of what version of the optimizer
+        // the asset was processed. If that version doesn't match the CLI version, we need to re-optimize
+        // all assets.
+        let version_file = self.asset_optimizer_version_file();
+        let clear_cache = std::fs::read_to_string(&version_file)
+            .ok()
+            .filter(|s| s == crate::VERSION.as_str())
+            .is_none();
+        if clear_cache {
+            keep_bundled_output_paths.clear();
         }
 
-        cargo_args.append(&mut self.build.cargo_args.clone());
-
-        match self.krate.executable_type() {
-            krates::cm::TargetKind::Bin => cargo_args.push("--bin".to_string()),
-            krates::cm::TargetKind::Lib => cargo_args.push("--lib".to_string()),
-            krates::cm::TargetKind::Example => cargo_args.push("--example".to_string()),
-            _ => {}
-        };
-
-        cargo_args.push(self.krate.executable_name().to_string());
+        tracing::trace!(
+            "Keeping bundled output paths: {:#?}",
+            keep_bundled_output_paths
+        );
 
-        // the bundle splitter needs relocation data
-        // we'll trim these out if we don't need them during the bundling process
-        // todo(jon): for wasm binary patching we might want to leave these on all the time.
-        if self.build.platform() == Platform::Web && self.build.experimental_wasm_split {
-            cargo_args.push("--".to_string());
-            cargo_args.push("-Clink-args=--emit-relocs".to_string());
+        // use walkdir::WalkDir;
+        // for item in WalkDir::new(&asset_dir).into_iter().flatten() {
+        //     // If this asset is in the manifest, we don't need to remove it
+        //     let canonicalized = dunce::canonicalize(item.path())?;
+        //     if !keep_bundled_output_paths.contains(canonicalized.as_path()) {
+        //         // Remove empty dirs, remove files not in the manifest
+        //         if item.file_type().is_dir() && item.path().read_dir()?.next().is_none() {
+        //             std::fs::remove_dir(item.path())?;
+        //         } else {
+        //             std::fs::remove_file(item.path())?;
+        //         }
+        //     }
+        // }
+
+        // todo(jon): we also want to eventually include options for each asset's optimization and compression, which we currently aren't
+        let mut assets_to_transfer = vec![];
+
+        // Queue the bundled assets
+        for (asset, bundled) in &assets.assets {
+            let from = asset.clone();
+            let to = asset_dir.join(bundled.bundled_path());
+
+            // prefer to log using a shorter path relative to the workspace dir by trimming the workspace dir
+            let from_ = from
+                .strip_prefix(self.workspace_dir())
+                .unwrap_or(from.as_path());
+            let to_ = from
+                .strip_prefix(self.workspace_dir())
+                .unwrap_or(to.as_path());
+
+            tracing::debug!("Copying asset {from_:?} to {to_:?}");
+            assets_to_transfer.push((from, to, *bundled.options()));
         }
 
-        tracing::debug!(dx_src = ?TraceSrc::Build, "cargo args: {:?}", cargo_args);
+        let asset_count = assets_to_transfer.len();
+        let started_processing = AtomicUsize::new(0);
+        let copied = AtomicUsize::new(0);
+
+        // Parallel Copy over the assets and keep track of progress with an atomic counter
+        let progress = ctx.tx.clone();
+        let ws_dir = self.workspace_dir();
+
+        // Optimizing assets is expensive and blocking, so we do it in a tokio spawn blocking task
+        tokio::task::spawn_blocking(move || {
+            assets_to_transfer
+                .par_iter()
+                .try_for_each(|(from, to, options)| {
+                    let processing = started_processing.fetch_add(1, Ordering::SeqCst);
+                    let from_ = from.strip_prefix(&ws_dir).unwrap_or(from);
+                    tracing::trace!(
+                        "Starting asset copy {processing}/{asset_count} from {from_:?}"
+                    );
+
+                    let res = process_file_to(options, from, to);
+                    if let Err(err) = res.as_ref() {
+                        tracing::error!("Failed to copy asset {from:?}: {err}");
+                    }
+
+                    let finished = copied.fetch_add(1, Ordering::SeqCst);
+                    BuildContext::status_copied_asset(
+                        &progress,
+                        finished,
+                        asset_count,
+                        from.to_path_buf(),
+                    );
 
-        cargo_args
-    }
+                    res.map(|_| ())
+                })
+        })
+        .await
+        .map_err(|e| anyhow::anyhow!("A task failed while trying to copy assets: {e}"))??;
 
-    #[allow(dead_code)]
-    pub(crate) fn android_rust_flags(&self) -> String {
-        let mut rust_flags = std::env::var("RUSTFLAGS").unwrap_or_default();
+        // // Remove the wasm bindgen output directory if it exists
+        // _ = std::fs::remove_dir_all(self.wasm_bindgen_out_dir());
 
-        // todo(jon): maybe we can make the symbol aliasing logic here instead of using llvm-objcopy
-        if self.build.platform() == Platform::Android {
-            let cur_exe = std::env::current_exe().unwrap();
-            rust_flags.push_str(format!(" -Clinker={}", cur_exe.display()).as_str());
-            rust_flags.push_str(" -Clink-arg=-landroid");
-            rust_flags.push_str(" -Clink-arg=-llog");
-            rust_flags.push_str(" -Clink-arg=-lOpenSLES");
-            rust_flags.push_str(" -Clink-arg=-Wl,--export-dynamic");
-        }
+        // Write the version file so we know what version of the optimizer we used
+        std::fs::write(self.asset_optimizer_version_file(), crate::VERSION.as_str())?;
 
-        rust_flags
+        Ok(())
     }
 
-    /// Create the list of features we need to pass to cargo to build the app by merging together
-    /// either the client or server features depending on if we're building a server or not.
-    pub(crate) fn target_features(&self) -> Vec<String> {
-        let mut features = self.build.target_args.features.clone();
-
-        if self.build.platform() == Platform::Server {
-            features.extend(self.build.target_args.server_features.clone());
-        } else {
-            features.extend(self.build.target_args.client_features.clone());
-        }
+    /// Run our custom linker setup to generate a patch file in the right location
+    ///
+    /// This should be the only case where the cargo output is a "dummy" file and requires us to
+    /// manually do any linking.
+    ///
+    /// We also run some post processing steps here, like extracting out any new assets.
+    async fn write_patch(
+        &self,
+        ctx: &BuildContext,
+        aslr_reference: u64,
+        artifacts: &mut BuildArtifacts,
+        cache: &Arc<HotpatchModuleCache>,
+    ) -> Result<()> {
+        ctx.status_hotpatching();
 
-        features
-    }
+        tracing::debug!(
+            "Original builds for patch: {}",
+            self.link_args_file.path().display()
+        );
+        let raw_args = std::fs::read_to_string(self.link_args_file.path())
+            .context("Failed to read link args from file")?;
+        let args = raw_args.lines().collect::<Vec<_>>();
 
-    pub(crate) fn all_target_features(&self) -> Vec<String> {
-        let mut features = self.target_features();
+        // Extract out the incremental object files.
+        //
+        // This is sadly somewhat of a hack, but it might be a moderately reliable hack.
+        //
+        // When rustc links your project, it passes the args as how a linker would expect, but with
+        // a somewhat reliable ordering. These are all internal details to cargo/rustc, so we can't
+        // rely on them *too* much, but the *are* fundamental to how rust compiles your projects, and
+        // linker interfaces probably won't change drastically for another 40 years.
+        //
+        // We need to tear apart this command and only pass the args that are relevant to our thin link.
+        // Mainly, we don't want any rlibs to be linked. Occasionally some libraries like objc_exception
+        // export a folder with their artifacts - unsure if we actually need to include them. Generally
+        // you can err on the side that most *libraries* don't need to be linked here since dlopen
+        // satisfies those symbols anyways when the binary is loaded.
+        //
+        // Many args are passed twice, too, which can be confusing, but generally don't have any real
+        // effect. Note that on macos/ios, there's a special macho header that needs to be set, otherwise
+        // dyld will complain.a
+        //
+        // Also, some flags in darwin land might become deprecated, need to be super conservative:
+        // - https://developer.apple.com/forums/thread/773907
+        //
+        // The format of this command roughly follows:
+        // ```
+        // clang
+        //     /dioxus/target/debug/subsecond-cli
+        //     /var/folders/zs/gvrfkj8x33d39cvw2p06yc700000gn/T/rustcAqQ4p2/symbols.o
+        //     /dioxus/target/subsecond-dev/deps/subsecond_harness-acfb69cb29ffb8fa.05stnb4bovskp7a00wyyf7l9s.rcgu.o
+        //     /dioxus/target/subsecond-dev/deps/subsecond_harness-acfb69cb29ffb8fa.08rgcutgrtj2mxoogjg3ufs0g.rcgu.o
+        //     /dioxus/target/subsecond-dev/deps/subsecond_harness-acfb69cb29ffb8fa.0941bd8fa2bydcv9hfmgzzne9.rcgu.o
+        //     /dioxus/target/subsecond-dev/deps/libbincode-c215feeb7886f81b.rlib
+        //     /dioxus/target/subsecond-dev/deps/libanyhow-e69ac15c094daba6.rlib
+        //     /dioxus/target/subsecond-dev/deps/libratatui-c3364579b86a1dfc.rlib
+        //     /.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/aarch64-apple-darwin/lib/libstd-019f0f6ae6e6562b.rlib
+        //     /.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/aarch64-apple-darwin/lib/libpanic_unwind-7387d38173a2eb37.rlib
+        //     /.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/aarch64-apple-darwin/lib/libobject-2b03cf6ece171d21.rlib
+        //     -framework AppKit
+        //     -lc
+        //     -framework Foundation
+        //     -framework Carbon
+        //     -lSystem
+        //     -framework CoreFoundation
+        //     -lobjc
+        //     -liconv
+        //     -lm
+        //     -arch arm64
+        //     -mmacosx-version-min=11.0.0
+        //     -L /dioxus/target/subsecond-dev/build/objc_exception-dc226cad0480ea65/out
+        //     -o /dioxus/target/subsecond-dev/deps/subsecond_harness-acfb69cb29ffb8fa
+        //     -nodefaultlibs
+        //     -Wl,-all_load
+        // ```
+        let mut object_files = args
+            .iter()
+            .filter(|arg| arg.ends_with(".rcgu.o"))
+            .sorted()
+            .map(PathBuf::from)
+            .collect::<Vec<_>>();
+
+        // On non-wasm platforms, we generate a special shim object file which converts symbols from
+        // fat binary into direct addresses from the running process.
+        //
+        // Our wasm approach is quite specific to wasm. We don't need to resolve any missing symbols
+        // there since wasm is relocatable, but there is considerable pre and post processing work to
+        // satisfy undefined symbols that we do by munging the binary directly.
+        //
+        // todo: can we adjust our wasm approach to also use a similar system?
+        // todo: don't require the aslr reference and just patch the got when loading.
+        //
+        // Requiring the ASLR offset here is necessary but unfortunately might be flakey in practice.
+        // Android apps can take a long time to open, and a hot patch might've been issued in the interim,
+        // making this hotpatch a failure.
+        if self.platform != Platform::Web {
+            let stub_bytes = crate::build::create_undefined_symbol_stub(
+                cache,
+                &object_files,
+                &self.triple,
+                aslr_reference,
+            )
+            .expect("failed to resolve patch symbols");
 
-        if !self.build.target_args.no_default_features {
-            features.extend(
-                self.krate
-                    .package()
-                    .features
-                    .get("default")
-                    .cloned()
-                    .unwrap_or_default(),
-            );
+            // Currently we're dropping stub.o in the exe dir, but should probably just move to a tempfile?
+            let patch_file = self.main_exe().with_file_name("stub.o");
+            std::fs::write(&patch_file, stub_bytes)?;
+            object_files.push(patch_file);
         }
 
-        features.dedup();
+        // And now we can run the linker with our new args
+        let linker = self.select_linker()?;
 
-        features
-    }
+        let out_exe = self.patch_exe(artifacts.time_start);
+        let out_arg = match self.triple.operating_system {
+            OperatingSystem::Windows => vec![format!("/OUT:{}", out_exe.display())],
+            _ => vec!["-o".to_string(), out_exe.display().to_string()],
+        };
 
-    /// Try to get the unit graph for the crate. This is a nightly only feature which may not be available with the current version of rustc the user has installed.
-    pub(crate) async fn get_unit_count(&self) -> crate::Result<usize> {
-        #[derive(Debug, Deserialize)]
-        struct UnitGraph {
-            units: Vec<serde_json::Value>,
-        }
+        tracing::trace!("Linking with {:?} using args: {:#?}", linker, object_files);
 
-        let output = tokio::process::Command::new("cargo")
-            .arg("+nightly")
-            .arg("build")
-            .arg("--unit-graph")
-            .arg("-Z")
-            .arg("unstable-options")
-            .args(self.build_arguments())
-            .envs(self.env_vars()?)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
+        // Run the linker directly!
+        //
+        // We dump its output directly into the patch exe location which is different than how rustc
+        // does it since it uses llvm-objcopy into the `target/debug/` folder.
+        let res = Command::new(linker)
+            .args(object_files.iter())
+            .args(self.thin_link_args(&args)?)
+            .args(out_arg)
             .output()
             .await?;
 
-        if !output.status.success() {
-            return Err(anyhow::anyhow!("Failed to get unit count").into());
+        if !res.stderr.is_empty() {
+            let errs = String::from_utf8_lossy(&res.stderr);
+            if !self.patch_exe(artifacts.time_start).exists() || !res.status.success() {
+                tracing::error!("Failed to generate patch: {}", errs.trim());
+            } else {
+                tracing::trace!("Linker output during thin linking: {}", errs.trim());
+            }
         }
 
-        let output_text = String::from_utf8(output.stdout).context("Failed to get unit count")?;
-        let graph: UnitGraph =
-            serde_json::from_str(&output_text).context("Failed to get unit count")?;
+        // For some really weird reason that I think is because of dlopen caching, future loads of the
+        // jump library will fail if we don't remove the original fat file. I think this could be
+        // because of library versioning and namespaces, but really unsure.
+        //
+        // The errors if you forget to do this are *extremely* cryptic - missing symbols that never existed.
+        //
+        // Fortunately, this binary exists in two places - the deps dir and the target out dir. We
+        // can just remove the one in the deps dir and the problem goes away.
+        if let Some(idx) = args.iter().position(|arg| *arg == "-o") {
+            _ = std::fs::remove_file(PathBuf::from(args[idx + 1]));
+        }
 
-        Ok(graph.units.len())
-    }
+        // Now extract the assets from the fat binary
+        artifacts
+            .assets
+            .add_from_object_path(&self.patch_exe(artifacts.time_start))?;
 
-    /// Get an estimate of the number of units in the crate. If nightly rustc is not available, this will return an estimate of the number of units in the crate based on cargo metadata.
-    /// TODO: always use https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#unit-graph once it is stable
-    pub(crate) async fn get_unit_count_estimate(&self) -> usize {
-        // Try to get it from nightly
-        self.get_unit_count().await.unwrap_or_else(|_| {
-            // Otherwise, use cargo metadata
-            (self
-                .krate
-                .krates
-                .krates_filtered(krates::DepKind::Dev)
-                .iter()
-                .map(|k| k.targets.len())
-                .sum::<usize>() as f64
-                / 3.5) as usize
-        })
+        // Clean up the temps manually
+        // todo: we might want to keep them around for debugging purposes
+        for file in object_files {
+            _ = std::fs::remove_file(file);
+        }
+
+        Ok(())
     }
 
-    /// We used to require traversing incremental artifacts for assets that were included but not
-    /// directly exposed to the final binary. Now, however, we force APIs to carry items created
-    /// from asset calls into top-level items such that they *do* get included in the final binary.
+    /// Take the original args passed to the "fat" build and then create the "thin" variant.
     ///
-    /// There's a chance that's not actually true, so this function is kept around in case we do
-    /// need to revert to "deep extraction".
-    #[allow(unused)]
-    async fn deep_linker_asset_extract(&self) -> Result<AssetManifest> {
-        // Create a temp file to put the output of the args
-        // We need to do this since rustc won't actually print the link args to stdout, so we need to
-        // give `dx` a file to dump its env::args into
-        let tmp_file = tempfile::NamedTempFile::new()?;
-
-        // Run `cargo rustc` again, but this time with a custom linker (dx) and an env var to force
-        // `dx` to act as a linker
-        //
-        // This will force `dx` to look through the incremental cache and find the assets from the previous build
-        Command::new("cargo")
-            .arg("rustc")
-            .args(self.build_arguments())
-            .envs(self.env_vars()?)
-            .arg("--offline") /* don't use the network, should already be resolved */
-            .arg("--")
-            .arg(format!(
-                "-Clinker={}",
-                std::env::current_exe()
-                    .unwrap()
-                    .canonicalize()
-                    .unwrap()
-                    .display()
-            ))
-            .env(
-                LinkAction::ENV_VAR_NAME,
-                LinkAction::BuildAssetManifest {
-                    destination: tmp_file.path().to_path_buf().clone(),
-                }
-                .to_json(),
-            )
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .output()
-            .await?;
+    /// This is basically just stripping away the rlibs and other libraries that will be satisfied
+    /// by our stub step.
+    fn thin_link_args(&self, original_args: &[&str]) -> Result<Vec<String>> {
+        use target_lexicon::OperatingSystem;
 
-        // The linker wrote the manifest to the temp file, let's load it!
-        let manifest = AssetManifest::load_from_file(tmp_file.path())?;
+        let triple = self.triple.clone();
+        let mut out_args = vec![];
 
-        if let Ok(path) = std::env::var("DEEPLINK").map(|s| s.parse::<PathBuf>().unwrap()) {
-            _ = tmp_file.persist(path);
-        }
+        match triple.operating_system {
+            // wasm32-unknown-unknown -> use wasm-ld (gnu-lld)
+            //
+            // We need to import a few things - namely the memory and ifunc table.
+            //
+            // We can safely export everything, I believe, though that led to issues with the "fat"
+            // binaries that also might lead to issues here too. wasm-bindgen chokes on some symbols
+            // and the resulting JS has issues.
+            //
+            // We turn on both --pie and --experimental-pic but I think we only need --pie.
+            //
+            // We don't use *any* of the original linker args since they do lots of custom exports
+            // and other things that we don't need.
+            OperatingSystem::Unknown if self.platform == Platform::Web => {
+                out_args.extend([
+                    "--fatal-warnings".to_string(),
+                    "--verbose".to_string(),
+                    "--import-memory".to_string(),
+                    "--import-table".to_string(),
+                    "--growable-table".to_string(),
+                    "--export".to_string(),
+                    "main".to_string(),
+                    "--allow-undefined".to_string(),
+                    "--no-demangle".to_string(),
+                    "--no-entry".to_string(),
+                    "--pie".to_string(),
+                    "--experimental-pic".to_string(),
+                ]);
+            }
 
-        Ok(manifest)
-    }
+            // This uses "cc" and these args need to be ld compatible
+            //
+            // Most importantly, we want to pass `-dylib` to both CC and the linker to indicate that
+            // we want to generate the shared library instead of an executable.
+            OperatingSystem::IOS(_) | OperatingSystem::MacOSX(_) | OperatingSystem::Darwin(_) => {
+                out_args.extend(["-Wl,-dylib".to_string()]);
+
+                // Preserve the original args. We only preserve:
+                // -framework
+                // -arch
+                // -lxyz
+                // There might be more, but some flags might break our setup.
+                for (idx, arg) in original_args.iter().enumerate() {
+                    if *arg == "-framework" || *arg == "-arch" || *arg == "-L" {
+                        out_args.push(arg.to_string());
+                        out_args.push(original_args[idx + 1].to_string());
+                    }
 
-    fn env_vars(&self) -> Result<Vec<(&str, String)>> {
-        let mut env_vars = vec![];
+                    if arg.starts_with("-l") || arg.starts_with("-m") {
+                        out_args.push(arg.to_string());
+                    }
+                }
+            }
 
-        if self.build.platform() == Platform::Android {
-            let ndk = self
-                .krate
-                .android_ndk()
-                .context("Could not autodetect android linker")?;
-            let arch = self.build.target_args.arch();
-            let linker = arch.android_linker(&ndk);
-            let min_sdk_version = arch.android_min_sdk_version();
-            let ar_path = arch.android_ar_path(&ndk);
-            let target_cc = arch.target_cc(&ndk);
-            let target_cxx = arch.target_cxx(&ndk);
-            let java_home = arch.java_home();
+            // android/linux need to be compatible with lld
+            //
+            // android currently drags along its own libraries and other zany flags
+            OperatingSystem::Linux => {
+                out_args.extend([
+                    "-shared".to_string(),
+                    "-Wl,--eh-frame-hdr".to_string(),
+                    "-Wl,-z,noexecstack".to_string(),
+                    "-Wl,-z,relro,-z,now".to_string(),
+                    "-nodefaultlibs".to_string(),
+                    "-Wl,-Bdynamic".to_string(),
+                ]);
+
+                // Preserve the original args. We only preserve:
+                // -L <path>
+                // -arch
+                // -lxyz
+                // There might be more, but some flags might break our setup.
+                for (idx, arg) in original_args.iter().enumerate() {
+                    if *arg == "-L" {
+                        out_args.push(arg.to_string());
+                        out_args.push(original_args[idx + 1].to_string());
+                    }
 
-            tracing::debug!(
-                r#"Using android:
-            min_sdk_version: {min_sdk_version}
-            linker: {linker:?}
-            ar_path: {ar_path:?}
-            target_cc: {target_cc:?}
-            target_cxx: {target_cxx:?}
-            java_home: {java_home:?}
-            "#
-            );
+                    if arg.starts_with("-l")
+                        || arg.starts_with("-m")
+                        || arg.starts_with("-Wl,--target=")
+                    {
+                        out_args.push(arg.to_string());
+                    }
+                }
+            }
 
-            env_vars.push(("ANDROID_NATIVE_API_LEVEL", min_sdk_version.to_string()));
-            env_vars.push(("TARGET_AR", ar_path.display().to_string()));
-            env_vars.push(("TARGET_CC", target_cc.display().to_string()));
-            env_vars.push(("TARGET_CXX", target_cxx.display().to_string()));
-            env_vars.push(("ANDROID_NDK_ROOT", ndk.display().to_string()));
-
-            // attempt to set java_home to the android studio java home if it exists.
-            // https://stackoverflow.com/questions/71381050/java-home-is-set-to-an-invalid-directory-android-studio-flutter
-            // attempt to set java_home to the android studio java home if it exists and java_home was not already set
-            if let Some(java_home) = java_home {
-                tracing::debug!("Setting JAVA_HOME to {java_home:?}");
-                env_vars.push(("JAVA_HOME", java_home.display().to_string()));
-            }
-
-            env_vars.push(("WRY_ANDROID_PACKAGE", "dev.dioxus.main".to_string()));
-            env_vars.push(("WRY_ANDROID_LIBRARY", "dioxusmain".to_string()));
-            env_vars.push((
-                "WRY_ANDROID_KOTLIN_FILES_OUT_DIR",
-                self.wry_android_kotlin_files_out_dir()
-                    .display()
-                    .to_string(),
-            ));
+            OperatingSystem::Windows => {
+                out_args.extend([
+                    "shlwapi.lib".to_string(),
+                    "kernel32.lib".to_string(),
+                    "advapi32.lib".to_string(),
+                    "ntdll.lib".to_string(),
+                    "userenv.lib".to_string(),
+                    "ws2_32.lib".to_string(),
+                    "dbghelp.lib".to_string(),
+                    "/defaultlib:msvcrt".to_string(),
+                    "/DLL".to_string(),
+                    "/DEBUG".to_string(),
+                    "/PDBALTPATH:%_PDB%".to_string(),
+                    "/EXPORT:main".to_string(),
+                    "/HIGHENTROPYVA:NO".to_string(),
+                    // "/SUBSYSTEM:WINDOWS".to_string(),
+                ]);
+            }
 
-            env_vars.push(("RUSTFLAGS", self.android_rust_flags()))
+            _ => return Err(anyhow::anyhow!("Unsupported platform for thin linking").into()),
+        }
 
-            // todo(jon): the guide for openssl recommends extending the path to include the tools dir
-            //            in practice I couldn't get this to work, but this might eventually become useful.
-            //
-            // https://github.com/openssl/openssl/blob/master/NOTES-ANDROID.md#configuration
-            //
-            // They recommend a configuration like this:
-            //
-            // // export ANDROID_NDK_ROOT=/home/whoever/Android/android-sdk/ndk/20.0.5594570
-            // PATH=$ANDROID_NDK_ROOT/toolchains/llvm/prebuilt/linux-x86_64/bin:$ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin:$PATH
-            // ./Configure android-arm64 -D__ANDROID_API__=29
-            // make
-            //
-            // let tools_dir = arch.android_tools_dir(&ndk);
-            // let extended_path = format!(
-            //     "{}:{}",
-            //     tools_dir.display(),
-            //     std::env::var("PATH").unwrap_or_default()
-            // );
-            // env_vars.push(("PATH", extended_path));
+        let extract_value = |arg: &str| -> Option<String> {
+            original_args
+                .iter()
+                .position(|a| *a == arg)
+                .map(|i| original_args[i + 1].to_string())
         };
 
-        // If this is a release build, bake the base path and title
-        // into the binary with env vars
-        if self.build.release {
-            if let Some(base_path) = &self.krate.config.web.app.base_path {
-                env_vars.push((ASSET_ROOT_ENV, base_path.clone()));
-            }
-            env_vars.push((APP_TITLE_ENV, self.krate.config.web.app.title.clone()));
+        if let Some(vale) = extract_value("-target") {
+            out_args.push("-target".to_string());
+            out_args.push(vale);
         }
 
-        Ok(env_vars)
+        if let Some(vale) = extract_value("-isysroot") {
+            out_args.push("-isysroot".to_string());
+            out_args.push(vale);
+        }
+
+        Ok(out_args)
     }
 
-    /// We only really currently care about:
+    /// Patches are stored in the same directory as the main executable, but with a name based on the
+    /// time the patch started compiling.
     ///
-    /// - app dir (.app, .exe, .apk, etc)
-    /// - assets dir
-    /// - exe dir (.exe, .app, .apk, etc)
-    /// - extra scaffolding
+    /// - lib{name}-patch-{time}.(so/dll/dylib) (next to the main exe)
     ///
-    /// It's not guaranteed that they're different from any other folder
-    fn prepare_build_dir(&self) -> Result<()> {
-        use once_cell::sync::OnceCell;
-        use std::fs::{create_dir_all, remove_dir_all};
+    /// Note that weirdly enough, the name of dylibs can actually matter. In some environments, libs
+    /// can override each other with symbol interposition.
+    ///
+    /// Also, on Android - and some Linux, we *need* to start the lib name with `lib` for the dynamic
+    /// loader to consider it a shared library.
+    ///
+    /// todo: the time format might actually be problematic if two platforms share the same build folder.
+    pub(crate) fn patch_exe(&self, time_start: SystemTime) -> PathBuf {
+        let path = self.main_exe().with_file_name(format!(
+            "lib{}-patch-{}",
+            self.executable_name(),
+            time_start
+                .duration_since(UNIX_EPOCH)
+                .map(|f| f.as_millis())
+                .unwrap_or(0),
+        ));
+
+        let extension = match self.triple.operating_system {
+            OperatingSystem::Darwin(_) => "dylib",
+            OperatingSystem::MacOSX(_) => "dylib",
+            OperatingSystem::IOS(_) => "dylib",
+            OperatingSystem::Windows => "dll",
+            OperatingSystem::Linux => "so",
+            OperatingSystem::Wasi => "wasm",
+            OperatingSystem::Unknown if self.platform == Platform::Web => "wasm",
+            _ => "",
+        };
 
-        static INITIALIZED: OnceCell<Result<()>> = OnceCell::new();
+        path.with_extension(extension)
+    }
 
-        let success = INITIALIZED.get_or_init(|| {
-            _ = remove_dir_all(self.exe_dir());
+    /// When we link together the fat binary, we need to make sure every `.o` file in *every* rlib
+    /// is taken into account. This is the same work that the rust compiler does when assembling
+    /// staticlibs.
+    ///
+    /// <https://github.com/rust-lang/rust/blob/191df20fcad9331d3a948aa8e8556775ec3fe69d/compiler/rustc_codegen_ssa/src/back/link.rs#L448>
+    ///
+    /// Since we're going to be passing these to the linker, we need to make sure and not provide any
+    /// weird files (like the rmeta) file that rustc generates.
+    ///
+    /// We discovered the need for this after running into issues with wasm-ld not being able to
+    /// handle the rmeta file.
+    ///
+    /// <https://github.com/llvm/llvm-project/issues/55786>
+    ///
+    /// Also, crates might not drag in all their dependent code. The monorphizer won't lift trait-based generics:
+    ///
+    /// <https://github.com/rust-lang/rust/blob/191df20fcad9331d3a948aa8e8556775ec3fe69d/compiler/rustc_monomorphize/src/collector.rs>
+    ///
+    /// When Rust normally handles this, it uses the +whole-archive directive which adjusts how the rlib
+    /// is written to disk.
+    ///
+    /// Since creating this object file can be a lot of work, we cache it in the target dir by hashing
+    /// the names of the rlibs in the command and storing it in the target dir. That way, when we run
+    /// this command again, we can just used the cached object file.
+    ///
+    /// In theory, we only need to do this for every crate accessible by the current crate, but that's
+    /// hard acquire without knowing the exported symbols from each crate.
+    ///
+    /// todo: I think we can traverse our immediate dependencies and inspect their symbols, unless they `pub use` a crate
+    /// todo: we should try and make this faster with memmapping
+    pub(crate) async fn run_fat_link(&self, ctx: &BuildContext, exe: &Path) -> Result<()> {
+        ctx.status_starting_link();
+
+        let raw_args = std::fs::read_to_string(self.link_args_file.path())
+            .context("Failed to read link args from file")?;
+        let args = raw_args.lines().collect::<Vec<_>>();
+
+        // Filter out the rlib files from the arguments
+        let rlibs = args
+            .iter()
+            .filter(|arg| arg.ends_with(".rlib"))
+            .map(PathBuf::from)
+            .collect::<Vec<_>>();
+
+        // Acquire a hash from the rlib names
+        let hash_id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            rlibs
+                .iter()
+                .map(|p| p.file_name().unwrap().to_string_lossy())
+                .collect::<String>()
+                .as_bytes(),
+        );
 
-            create_dir_all(self.root_dir())?;
-            create_dir_all(self.exe_dir())?;
-            create_dir_all(self.asset_dir())?;
+        // Check if we already have a cached object file
+        let out_ar_path = exe.with_file_name(format!("libfatdependencies-{hash_id}.a"));
 
-            tracing::debug!("Initialized Root dir: {:?}", self.root_dir());
-            tracing::debug!("Initialized Exe dir: {:?}", self.exe_dir());
-            tracing::debug!("Initialized Asset dir: {:?}", self.asset_dir());
+        let mut compiler_rlibs = vec![];
 
-            // we could download the templates from somewhere (github?) but after having banged my head against
-            // cargo-mobile2 for ages, I give up with that. We're literally just going to hardcode the templates
-            // by writing them here.
-            if let Platform::Android = self.build.platform() {
-                self.build_android_app_dir()?;
+        // Create it by dumping all the rlibs into it
+        // This will include the std rlibs too, which can severely bloat the size of the archive
+        //
+        // The nature of this process involves making extremely fat archives, so we should try and
+        // speed up the future linking process by caching the archive.
+        if !crate::devcfg::should_cache_dep_lib(&out_ar_path) {
+            let mut bytes = vec![];
+            let mut out_ar = ar::Builder::new(&mut bytes);
+            for rlib in &rlibs {
+                // Skip compiler rlibs since they're missing bitcode
+                //
+                // https://github.com/rust-lang/rust/issues/94232#issuecomment-1048342201
+                //
+                // if the rlib is not in the target directory, we skip it.
+                if !rlib.starts_with(self.workspace_dir()) {
+                    compiler_rlibs.push(rlib.clone());
+                    tracing::trace!("Skipping rlib: {:?}", rlib);
+                    continue;
+                }
+
+                tracing::trace!("Adding rlib to staticlib: {:?}", rlib);
+
+                let rlib_contents = std::fs::read(rlib)?;
+                let mut reader = ar::Archive::new(std::io::Cursor::new(rlib_contents));
+                while let Some(Ok(object_file)) = reader.next_entry() {
+                    let name = std::str::from_utf8(object_file.header().identifier()).unwrap();
+                    if name.ends_with(".rmeta") {
+                        continue;
+                    }
+
+                    if object_file.header().size() == 0 {
+                        continue;
+                    }
+
+                    // rlibs might contain dlls/sos/lib files which we don't want to include
+                    if name.ends_with(".dll") || name.ends_with(".so") || name.ends_with(".lib") {
+                        compiler_rlibs.push(rlib.to_owned());
+                        continue;
+                    }
+
+                    if !(name.ends_with(".o") || name.ends_with(".obj")) {
+                        tracing::debug!("Unknown object file in rlib: {:?}", name);
+                    }
+
+                    out_ar
+                        .append(&object_file.header().clone(), object_file)
+                        .context("Failed to add object file to archive")?;
+                }
             }
 
-            Ok(())
-        });
+            let bytes = out_ar.into_inner().context("Failed to finalize archive")?;
+            std::fs::write(&out_ar_path, bytes).context("Failed to write archive")?;
+            tracing::debug!("Wrote fat archive to {:?}", out_ar_path);
+        }
 
-        if let Err(e) = success.as_ref() {
-            return Err(format!("Failed to initialize build directory: {e}").into());
+        compiler_rlibs.dedup();
+
+        // We're going to replace the first rlib in the args with our fat archive
+        // And then remove the rest of the rlibs
+        //
+        // We also need to insert the -force_load flag to force the linker to load the archive
+        let mut args = args.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        if let Some(first_rlib) = args.iter().position(|arg| arg.ends_with(".rlib")) {
+            match self.triple.operating_system {
+                OperatingSystem::Unknown if self.platform == Platform::Web => {
+                    // We need to use the --whole-archive flag for wasm
+                    args[first_rlib] = "--whole-archive".to_string();
+                    args.insert(first_rlib + 1, out_ar_path.display().to_string());
+                    args.insert(first_rlib + 2, "--no-whole-archive".to_string());
+                    args.retain(|arg| !arg.ends_with(".rlib"));
+
+                    // add back the compiler rlibs
+                    for rlib in compiler_rlibs.iter().rev() {
+                        args.insert(first_rlib + 3, rlib.display().to_string());
+                    }
+                }
+
+                // Subtle difference - on linux and android we go through clang and thus pass `-Wl,` prefix
+                OperatingSystem::Linux => {
+                    args[first_rlib] = "-Wl,--whole-archive".to_string();
+                    args.insert(first_rlib + 1, out_ar_path.display().to_string());
+                    args.insert(first_rlib + 2, "-Wl,--no-whole-archive".to_string());
+                    args.retain(|arg| !arg.ends_with(".rlib"));
+
+                    // add back the compiler rlibs
+                    for rlib in compiler_rlibs.iter().rev() {
+                        args.insert(first_rlib + 3, rlib.display().to_string());
+                    }
+                }
+
+                OperatingSystem::Darwin(_) | OperatingSystem::IOS(_) => {
+                    args[first_rlib] = "-Wl,-force_load".to_string();
+                    args.insert(first_rlib + 1, out_ar_path.display().to_string());
+                    args.retain(|arg| !arg.ends_with(".rlib"));
+
+                    // add back the compiler rlibs
+                    for rlib in compiler_rlibs.iter().rev() {
+                        args.insert(first_rlib + 2, rlib.display().to_string());
+                    }
+
+                    args.insert(first_rlib + 3, "-Wl,-all_load".to_string());
+                }
+
+                OperatingSystem::Windows => {
+                    args[first_rlib] = format!("/WHOLEARCHIVE:{}", out_ar_path.display());
+                    args.retain(|arg| !arg.ends_with(".rlib"));
+
+                    // add back the compiler rlibs
+                    for rlib in compiler_rlibs.iter().rev() {
+                        args.insert(first_rlib + 1, rlib.display().to_string());
+                    }
+
+                    args.insert(first_rlib, "/HIGHENTROPYVA:NO".to_string());
+                }
+
+                _ => {}
+            };
         }
 
-        Ok(())
-    }
+        // We also need to remove the `-o` flag since we want the linker output to end up in the
+        // rust exe location, not in the deps dir as it normally would.
+        if let Some(idx) = args
+            .iter()
+            .position(|arg| *arg == "-o" || *arg == "--output")
+        {
+            args.remove(idx + 1);
+            args.remove(idx);
+        }
 
-    /// The directory in which we'll put the main exe
-    ///
-    /// Mac, Android, Web are a little weird
-    /// - mac wants to be in Contents/MacOS
-    /// - android wants to be in jniLibs/arm64-v8a (or others, depending on the platform / architecture)
-    /// - web wants to be in wasm (which... we don't really need to, we could just drop the wasm into public and it would work)
-    ///
-    /// I think all others are just in the root folder
-    ///
-    /// todo(jon): investigate if we need to put .wasm in `wasm`. It kinda leaks implementation details, which ideally we don't want to do.
-    pub fn exe_dir(&self) -> PathBuf {
-        match self.build.platform() {
-            Platform::MacOS => self.root_dir().join("Contents").join("MacOS"),
-            Platform::Web => self.root_dir().join("wasm"),
+        // same but windows support
+        if let Some(idx) = args.iter().position(|arg| arg.starts_with("/OUT")) {
+            args.remove(idx);
+        }
 
-            // Android has a whole build structure to it
-            Platform::Android => self
-                .root_dir()
-                .join("app")
-                .join("src")
-                .join("main")
-                .join("jniLibs")
-                .join(self.build.target_args.arch().android_jnilib()),
+        // We want to go through wasm-ld directly, so we need to remove the -flavor flag
+        if self.platform == Platform::Web {
+            let flavor_idx = args.iter().position(|arg| *arg == "-flavor").unwrap();
+            args.remove(flavor_idx + 1);
+            args.remove(flavor_idx);
+        }
 
-            // these are all the same, I think?
-            Platform::Windows
-            | Platform::Linux
-            | Platform::Ios
-            | Platform::Server
-            | Platform::Liveview => self.root_dir(),
+        // And now we can run the linker with our new args
+        let linker = self.select_linker()?;
+
+        tracing::trace!("Fat linking with args: {:?} {:#?}", linker, args);
+
+        // Run the linker directly!
+        let out_arg = match self.triple.operating_system {
+            OperatingSystem::Windows => vec![format!("/OUT:{}", exe.display())],
+            _ => vec!["-o".to_string(), exe.display().to_string()],
+        };
+
+        let res = Command::new(linker)
+            .args(args.iter().skip(1))
+            .args(out_arg)
+            .output()
+            .await?;
+
+        if !res.stderr.is_empty() {
+            let errs = String::from_utf8_lossy(&res.stderr);
+            if !res.status.success() {
+                tracing::error!("Failed to generate fat binary: {}", errs.trim());
+            } else {
+                tracing::trace!("Warnings during fat linking: {}", errs.trim());
+            }
         }
-    }
 
-    /// Get the path to the wasm bindgen temporary output folder
-    pub fn wasm_bindgen_out_dir(&self) -> PathBuf {
-        self.root_dir().join("wasm")
-    }
+        if !res.stdout.is_empty() {
+            let out = String::from_utf8_lossy(&res.stdout);
+            tracing::trace!("Output from fat linking: {}", out.trim());
+        }
 
-    /// Get the path to the wasm bindgen javascript output file
-    pub fn wasm_bindgen_js_output_file(&self) -> PathBuf {
-        self.wasm_bindgen_out_dir()
-            .join(self.krate.executable_name())
-            .with_extension("js")
-    }
+        // Clean up the temps manually
+        for f in args.iter().filter(|arg| arg.ends_with(".rcgu.o")) {
+            _ = std::fs::remove_file(f);
+        }
 
-    /// Get the path to the wasm bindgen wasm output file
-    pub fn wasm_bindgen_wasm_output_file(&self) -> PathBuf {
-        self.wasm_bindgen_out_dir()
-            .join(format!("{}_bg", self.krate.executable_name()))
-            .with_extension("wasm")
+        Ok(())
     }
 
-    /// returns the path to root build folder. This will be our working directory for the build.
+    /// Select the linker to use for this platform.
     ///
-    /// we only add an extension to the folders where it sorta matters that it's named with the extension.
-    /// for example, on mac, the `.app` indicates we can `open` it and it pulls in icons, dylibs, etc.
+    /// We prefer to use the rust-lld linker when we can since it's usually there.
+    /// On macos, we use the system linker since macho files can be a bit finicky.
     ///
-    /// for our simulator-based platforms, this is less important since they need to be zipped up anyways
-    /// to run in the simulator.
+    /// This means we basically ignore the linker flavor that the user configured, which could
+    /// cause issues with a custom linker setup. In theory, rust translates most flags to the right
+    /// linker format.
+    fn select_linker(&self) -> Result<PathBuf, Error> {
+        let cc = match self.triple.operating_system {
+            OperatingSystem::Unknown if self.platform == Platform::Web => self.workspace.wasm_ld(),
+
+            // The android clang linker is *special* and has some android-specific flags that we need
+            //
+            // Note that this is *clang*, not `lld`.
+            OperatingSystem::Linux if self.platform == Platform::Android => {
+                self.workspace.android_tools()?.android_cc(&self.triple)
+            }
+
+            // On macOS, we use the system linker since it's usually there.
+            // We could also use `lld` here, but it might not be installed by default.
+            //
+            // Note that this is *clang*, not `lld`.
+            OperatingSystem::Darwin(_) | OperatingSystem::IOS(_) => self.workspace.cc(),
+
+            // On windows, instead of trying to find the system linker, we just go with the lld.link
+            // that rustup provides. It's faster and more stable then reyling on link.exe in path.
+            OperatingSystem::Windows => self.workspace.lld_link(),
+
+            // The rest of the platforms use `cc` as the linker which should be available in your path,
+            // provided you have build-tools setup. On mac/linux this is the default, but on Windows
+            // it requires msvc or gnu downloaded, which is a requirement to use rust anyways.
+            //
+            // The default linker might actually be slow though, so we could consider using lld or rust-lld
+            // since those are shipping by default on linux as of 1.86. Window's linker is the really slow one.
+            //
+            // https://blog.rust-lang.org/2024/05/17/enabling-rust-lld-on-linux.html
+            //
+            // Note that "cc" is *not* a linker. It's a compiler! The arguments we pass need to be in
+            // the form of `-Wl,<args>` for them to make it to the linker. This matches how rust does it
+            // which is confusing.
+            _ => self.workspace.cc(),
+        };
+
+        Ok(cc)
+    }
+
+    /// Assemble the `cargo rustc` / `rustc` command
     ///
-    /// For windows/linux, it's also not important since we're just running the exe directly out of the folder
+    /// When building fat/base binaries, we use `cargo rustc`.
+    /// When building thin binaries, we use `rustc` directly.
     ///
-    /// The idea of this folder is that we can run our top-level build command against it and we'll get
-    /// a final build output somewhere. Some platforms have basically no build command, and can simply
-    /// be ran by executing the exe directly.
-    pub(crate) fn root_dir(&self) -> PathBuf {
-        let platform_dir = self.platform_dir();
+    /// When processing the output of this command, you need to make sure to handle both cases which
+    /// both have different formats (but with json output for both).
+    fn build_command(&self, ctx: &BuildContext) -> Result<Command> {
+        match &ctx.mode {
+            // We're assembling rustc directly, so we need to be *very* careful. Cargo sets rustc's
+            // env up very particularly, and we want to match it 1:1 but with some changes.
+            //
+            // To do this, we reset the env completely, and then pass every env var that the original
+            // rustc process had 1:1.
+            //
+            // We need to unset a few things, like the RUSTC wrappers and then our special env var
+            // indicating that dx itself is the compiler. If we forget to do this, then the compiler
+            // ends up doing some recursive nonsense and dx is trying to link instead of compiling.
+            //
+            // todo: maybe rustc needs to be found on the FS instead of using the one in the path?
+            BuildMode::Thin { rustc_args, .. } => {
+                let mut cmd = Command::new("rustc");
+                cmd.current_dir(self.workspace_dir());
+                cmd.env_clear();
+                cmd.args(rustc_args.args[1..].iter());
+                cmd.envs(rustc_args.envs.iter().cloned());
+                cmd.env_remove("RUSTC_WORKSPACE_WRAPPER");
+                cmd.env_remove("RUSTC_WRAPPER");
+                cmd.env_remove(DX_RUSTC_WRAPPER_ENV_VAR);
+                cmd.envs(self.cargo_build_env_vars(ctx)?);
+                cmd.arg(format!("-Clinker={}", Workspace::path_to_dx()?.display()));
+
+                if self.platform == Platform::Web {
+                    cmd.arg("-Crelocation-model=pic");
+                }
 
-        match self.build.platform() {
-            Platform::Web => platform_dir.join("public"),
-            Platform::Server => platform_dir.clone(), // ends up *next* to the public folder
+                tracing::trace!("Direct rustc command: {:#?}", rustc_args.args);
 
-            // These might not actually need to be called `.app` but it does let us run these with `open`
-            Platform::MacOS => platform_dir.join(format!("{}.app", self.krate.bundled_app_name())),
-            Platform::Ios => platform_dir.join(format!("{}.app", self.krate.bundled_app_name())),
+                Ok(cmd)
+            }
 
-            // in theory, these all could end up directly in the root dir
-            Platform::Android => platform_dir.join("app"), // .apk (after bundling)
-            Platform::Linux => platform_dir.join("app"),   // .appimage (after bundling)
-            Platform::Windows => platform_dir.join("app"), // .exe (after bundling)
-            Platform::Liveview => platform_dir.join("app"), // .exe (after bundling)
+            // For Base and Fat builds, we use a regular cargo setup, but we might need to intercept
+            // rustc itself in case we're hot-patching and need a reliable rustc environment to
+            // continuously recompile the top-level crate with.
+            //
+            // In the future, when we support hot-patching *all* workspace crates, we will need to
+            // make use of the RUSTC_WORKSPACE_WRAPPER environment variable instead of RUSTC_WRAPPER
+            // and then keep track of env and args on a per-crate basis.
+            //
+            // We've also had a number of issues with incorrect canonicalization when passing paths
+            // through envs on windows, hence the frequent use of dunce::canonicalize.
+            _ => {
+                let mut cmd = Command::new("cargo");
+
+                cmd.arg("rustc")
+                    .current_dir(self.crate_dir())
+                    .arg("--message-format")
+                    .arg("json-diagnostic-rendered-ansi")
+                    .args(self.cargo_build_arguments(ctx))
+                    .envs(self.cargo_build_env_vars(ctx)?);
+
+                tracing::trace!("Cargo command: {:#?}", cmd);
+
+                if ctx.mode == BuildMode::Fat {
+                    cmd.env(
+                        DX_RUSTC_WRAPPER_ENV_VAR,
+                        dunce::canonicalize(self.rustc_wrapper_args_file.path())
+                            .unwrap()
+                            .display()
+                            .to_string(),
+                    );
+                    cmd.env(
+                        "RUSTC_WRAPPER",
+                        Workspace::path_to_dx()?.display().to_string(),
+                    );
+                }
+
+                Ok(cmd)
+            }
         }
     }
 
-    pub(crate) fn platform_dir(&self) -> PathBuf {
-        self.krate
-            .build_dir(self.build.platform(), self.build.release)
-    }
+    /// Create a list of arguments for cargo builds
+    ///
+    /// We always use `cargo rustc` *or* `rustc` directly. This means we can pass extra flags like
+    /// `-C` arguments directly to the compiler.
+    #[allow(clippy::vec_init_then_push)]
+    fn cargo_build_arguments(&self, ctx: &BuildContext) -> Vec<String> {
+        let mut cargo_args = Vec::with_capacity(4);
 
-    pub fn asset_dir(&self) -> PathBuf {
-        match self.build.platform() {
-            Platform::MacOS => self
-                .root_dir()
-                .join("Contents")
-                .join("Resources")
-                .join("assets"),
+        // Add required profile flags. --release overrides any custom profiles.
+        cargo_args.push("--profile".to_string());
+        cargo_args.push(self.profile.to_string());
 
-            Platform::Android => self
-                .root_dir()
-                .join("app")
-                .join("src")
-                .join("main")
-                .join("assets"),
+        // Pass the appropriate target to cargo. We *always* specify a target which is somewhat helpful for preventing thrashing
+        cargo_args.push("--target".to_string());
+        cargo_args.push(self.triple.to_string());
 
-            // everyone else is soooo normal, just app/assets :)
-            Platform::Web
-            | Platform::Ios
-            | Platform::Windows
-            | Platform::Linux
-            | Platform::Server
-            | Platform::Liveview => self.root_dir().join("assets"),
+        // We always run in verbose since the CLI itself is the one doing the presentation
+        cargo_args.push("--verbose".to_string());
+
+        if self.no_default_features {
+            cargo_args.push("--no-default-features".to_string());
         }
-    }
 
-    /// Get the path to the asset optimizer version file
-    pub fn asset_optimizer_version_file(&self) -> PathBuf {
-        self.platform_dir().join(".cli-version")
-    }
+        if !self.features.is_empty() {
+            cargo_args.push("--features".to_string());
+            cargo_args.push(self.features.join(" "));
+        }
 
-    pub fn platform_exe_name(&self) -> String {
-        match self.build.platform() {
-            Platform::MacOS => self.krate.executable_name().to_string(),
-            Platform::Ios => self.krate.executable_name().to_string(),
-            Platform::Server => self.krate.executable_name().to_string(),
-            Platform::Liveview => self.krate.executable_name().to_string(),
-            Platform::Windows => format!("{}.exe", self.krate.executable_name()),
+        // We *always* set the package since that's discovered from cargo metadata
+        cargo_args.push(String::from("-p"));
+        cargo_args.push(self.package.clone());
 
-            // from the apk spec, the root exe is a shared library
-            // we include the user's rust code as a shared library with a fixed namespacea
-            Platform::Android => "libdioxusmain.so".to_string(),
+        // Set the executable
+        match self.executable_type() {
+            TargetKind::Bin => cargo_args.push("--bin".to_string()),
+            TargetKind::Lib => cargo_args.push("--lib".to_string()),
+            TargetKind::Example => cargo_args.push("--example".to_string()),
+            _ => {}
+        };
+        cargo_args.push(self.executable_name().to_string());
 
-            Platform::Web => unimplemented!("there's no main exe on web"), // this will be wrong, I think, but not important?
+        // Merge in extra args. Order shouldn't really matter.
+        cargo_args.extend(self.extra_cargo_args.clone());
+        cargo_args.push("--".to_string());
+        cargo_args.extend(self.extra_rustc_args.clone());
 
-            // todo: maybe this should be called AppRun?
-            Platform::Linux => self.krate.executable_name().to_string(),
+        // The bundle splitter needs relocation data to create a call-graph.
+        // This will automatically be erased by wasm-opt during the optimization step.
+        if self.platform == Platform::Web && self.wasm_split {
+            cargo_args.push("-Clink-args=--emit-relocs".to_string());
+        }
+
+        // dx *always* links android and thin builds
+        if self.custom_linker.is_some()
+            || matches!(ctx.mode, BuildMode::Thin { .. } | BuildMode::Fat)
+        {
+            cargo_args.push(format!(
+                "-Clinker={}",
+                Workspace::path_to_dx().expect("can't find dx").display()
+            ));
+        }
+
+        // Our fancy hot-patching engine needs a lot of customization to work properly.
+        //
+        // These args are mostly intended to be passed when *fat* linking but are generally fine to
+        // pass for both fat and thin linking.
+        //
+        // We need save-temps and no-dead-strip in both cases though. When we run `cargo rustc` with
+        // these args, they will be captured and re-ran for the fast compiles in the future, so whatever
+        // we set here will be set for all future hot patches too.
+        if matches!(ctx.mode, BuildMode::Thin { .. } | BuildMode::Fat) {
+            // rustc gives us some portable flags required:
+            // - link-dead-code: prevents rust from passing -dead_strip to the linker since that's the default.
+            // - save-temps=true: keeps the incremental object files around, which we need for manually linking.
+            cargo_args.extend_from_slice(&[
+                "-Csave-temps=true".to_string(),
+                "-Clink-dead-code".to_string(),
+            ]);
+
+            // We need to set some extra args that ensure all symbols make it into the final output
+            // and that the linker doesn't strip them out.
+            //
+            // This basically amounts of -all_load or --whole-archive, depending on the linker.
+            // We just assume an ld-like interface on macos and a gnu-ld interface elsewhere.
+            //
+            // macOS/iOS use ld64 but through the `cc` interface.
+            // cargo_args.push("-Clink-args=-Wl,-all_load".to_string());
+            //
+            // Linux and Android fit under this umbrella, both with the same clang-like entrypoint
+            // and the gnu-ld interface.
+            //
+            // cargo_args.push("-Clink-args=-Wl,--whole-archive".to_string());
+            //
+            // If windows -Wl,--whole-archive is required since it follows gnu-ld convention.
+            // There might be other flags on windows - we haven't tested windows thoroughly.
+            //
+            // cargo_args.push("-Clink-args=-Wl,--whole-archive".to_string());
+            // https://learn.microsoft.com/en-us/cpp/build/reference/wholearchive-include-all-library-object-files?view=msvc-170
+            //
+            // ------------------------------------------------------------
+            //
+            // if web, -Wl,--whole-archive is required since it follows gnu-ld convention.
+            //
+            // We also use --no-gc-sections and --export-table and --export-memory  to push
+            // said symbols into the export table.
+            //
+            // We use --emit-relocs to build up a solid call graph.
+            //
+            // rust uses its own wasm-ld linker which can be found here (it's just gcc-ld with a `-target wasm` flag):
+            // - ~/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/aarch64-apple-darwin/bin/gcc-ld
+            // - ~/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/aarch64-apple-darwin/bin/gcc-ld/wasm-ld
+            //
+            // Note that we can't use --export-all, unfortunately, since some symbols are internal
+            // to wasm-bindgen and exporting them causes the JS generation to fail.
+            //
+            // We are basically replicating what emscripten does here with its dynamic linking
+            // approach where the MAIN_MODULE is very "fat" and exports the necessary arguments
+            // for the side modules to be linked in. This guide is really helpful:
+            //
+            // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
+            //
+            // The trickiest one here is -Crelocation-model=pic, which forces data symbols
+            // into a GOT, making it possible to import them from the main module.
+            //
+            // I think we can make relocation-model=pic work for non-wasm platforms, enabling
+            // fully relocatable modules with no host coordination in lieu of sending out
+            // the aslr slide at runtime.
+            //
+            // The other tricky one is -Ctarget-cpu=mvp, which prevents rustc from generating externref
+            // entries.
+            //
+            // https://blog.rust-lang.org/2024/09/24/webassembly-targets-change-in-default-target-features/#disabling-on-by-default-webassembly-proposals
+            //
+            // It's fine that these exist in the base module but not in the patch.
+            if self.platform == Platform::Web
+                || self.triple.operating_system == OperatingSystem::Wasi
+            {
+                // cargo_args.push("-Crelocation-model=pic".into());
+                cargo_args.push("-Ctarget-cpu=mvp".into());
+                cargo_args.push("-Clink-arg=--no-gc-sections".into());
+                cargo_args.push("-Clink-arg=--growable-table".into());
+                cargo_args.push("-Clink-arg=--export-table".into());
+                cargo_args.push("-Clink-arg=--export-memory".into());
+                cargo_args.push("-Clink-arg=--emit-relocs".into());
+                cargo_args.push("-Clink-arg=--export=__stack_pointer".into());
+                cargo_args.push("-Clink-arg=--export=__heap_base".into());
+                cargo_args.push("-Clink-arg=--export=__data_end".into());
+            }
         }
+
+        cargo_args
     }
 
-    fn build_android_app_dir(&self) -> Result<()> {
-        use std::fs::{create_dir_all, write};
-        let root = self.root_dir();
+    fn cargo_build_env_vars(&self, ctx: &BuildContext) -> Result<Vec<(&'static str, String)>> {
+        let mut env_vars = vec![];
 
-        // gradle
-        let wrapper = root.join("gradle").join("wrapper");
-        create_dir_all(&wrapper)?;
-        tracing::debug!("Initialized Gradle wrapper: {:?}", wrapper);
+        // Make sure to set all the crazy android flags. Cross-compiling is hard, man.
+        if self.platform == Platform::Android {
+            env_vars.extend(self.android_env_vars()?);
+        };
 
-        // app
-        let app = root.join("app");
-        let app_main = app.join("src").join("main");
-        let app_kotlin = app_main.join("kotlin");
-        let app_jnilibs = app_main.join("jniLibs");
-        let app_assets = app_main.join("assets");
-        let app_kotlin_out = self.wry_android_kotlin_files_out_dir();
-        create_dir_all(&app)?;
-        create_dir_all(&app_main)?;
-        create_dir_all(&app_kotlin)?;
-        create_dir_all(&app_jnilibs)?;
-        create_dir_all(&app_assets)?;
-        create_dir_all(&app_kotlin_out)?;
-        tracing::debug!("Initialized app: {:?}", app);
-        tracing::debug!("Initialized app/src: {:?}", app_main);
-        tracing::debug!("Initialized app/src/kotlin: {:?}", app_kotlin);
-        tracing::debug!("Initialized app/src/jniLibs: {:?}", app_jnilibs);
-        tracing::debug!("Initialized app/src/assets: {:?}", app_assets);
-        tracing::debug!("Initialized app/src/kotlin/main: {:?}", app_kotlin_out);
-
-        // handlerbars
-        let hbs = handlebars::Handlebars::new();
-        #[derive(serde::Serialize)]
-        struct HbsTypes {
-            application_id: String,
-            app_name: String,
+        // If we're either zero-linking or using a custom linker, make `dx` itself do the linking.
+        if self.custom_linker.is_some()
+            || matches!(ctx.mode, BuildMode::Thin { .. } | BuildMode::Fat)
+        {
+            LinkAction {
+                triple: self.triple.clone(),
+                linker: self.custom_linker.clone(),
+                link_err_file: dunce::canonicalize(self.link_err_file.path())?,
+                link_args_file: dunce::canonicalize(self.link_args_file.path())?,
+            }
+            .write_env_vars(&mut env_vars)?;
         }
-        let hbs_data = HbsTypes {
-            application_id: self.krate.full_mobile_app_name(),
-            app_name: self.krate.bundled_app_name(),
-        };
 
-        // Top-level gradle config
+        // Disable reference types on wasm when using hotpatching
+        // https://blog.rust-lang.org/2024/09/24/webassembly-targets-change-in-default-target-features/#disabling-on-by-default-webassembly-proposals
+        if self.platform == Platform::Web
+            && matches!(ctx.mode, BuildMode::Thin { .. } | BuildMode::Fat)
+        {
+            env_vars.push(("RUSTFLAGS", {
+                let mut rust_flags = std::env::var("RUSTFLAGS").unwrap_or_default();
+                rust_flags.push_str(" -Ctarget-cpu=mvp");
+                rust_flags
+            }));
+        }
+
+        if let Some(target_dir) = self.custom_target_dir.as_ref() {
+            env_vars.push(("CARGO_TARGET_DIR", target_dir.display().to_string()));
+        }
+
+        // If this is a release build, bake the base path and title into the binary with env vars.
+        // todo: should we even be doing this? might be better being a build.rs or something else.
+        if self.release {
+            if let Some(base_path) = &self.config.web.app.base_path {
+                env_vars.push((ASSET_ROOT_ENV, base_path.clone()));
+            }
+            env_vars.push((APP_TITLE_ENV, self.config.web.app.title.clone()));
+        }
+
+        Ok(env_vars)
+    }
+
+    fn android_env_vars(&self) -> Result<Vec<(&'static str, String)>> {
+        let mut env_vars = vec![];
+
+        let tools = self.workspace.android_tools()?;
+        let linker = tools.android_cc(&self.triple);
+        let min_sdk_version = tools.min_sdk_version();
+        let ar_path = tools.ar_path();
+        let target_cc = tools.target_cc();
+        let target_cxx = tools.target_cxx();
+        let java_home = tools.java_home();
+        let ndk = tools.ndk.clone();
+        tracing::debug!(
+            r#"Using android:
+            min_sdk_version: {min_sdk_version}
+            linker: {linker:?}
+            ar_path: {ar_path:?}
+            target_cc: {target_cc:?}
+            target_cxx: {target_cxx:?}
+            java_home: {java_home:?}
+            "#
+        );
+        env_vars.push(("ANDROID_NATIVE_API_LEVEL", min_sdk_version.to_string()));
+        env_vars.push(("TARGET_AR", ar_path.display().to_string()));
+        env_vars.push(("TARGET_CC", target_cc.display().to_string()));
+        env_vars.push(("TARGET_CXX", target_cxx.display().to_string()));
+        env_vars.push(("ANDROID_NDK_ROOT", ndk.display().to_string()));
+
+        if let Some(java_home) = java_home {
+            tracing::debug!("Setting JAVA_HOME to {java_home:?}");
+            env_vars.push(("JAVA_HOME", java_home.display().to_string()));
+        }
+
+        // Set the wry env vars - this is where wry will dump its kotlin files.
+        // Their setup is really annyoing and requires us to hardcode `dx` to specific versions of tao/wry.
+        env_vars.push(("WRY_ANDROID_PACKAGE", "dev.dioxus.main".to_string()));
+        env_vars.push(("WRY_ANDROID_LIBRARY", "dioxusmain".to_string()));
+        env_vars.push((
+            "WRY_ANDROID_KOTLIN_FILES_OUT_DIR",
+            self.wry_android_kotlin_files_out_dir()
+                .display()
+                .to_string(),
+        ));
+
+        // Set the rust flags for android which get passed to *every* crate in the graph.
+        env_vars.push(("RUSTFLAGS", {
+            let mut rust_flags = std::env::var("RUSTFLAGS").unwrap_or_default();
+            rust_flags.push_str(" -Clink-arg=-landroid");
+            rust_flags.push_str(" -Clink-arg=-llog");
+            rust_flags.push_str(" -Clink-arg=-lOpenSLES");
+            rust_flags.push_str(" -Clink-arg=-Wl,--export-dynamic");
+            rust_flags
+        }));
+
+        // todo(jon): the guide for openssl recommends extending the path to include the tools dir
+        //            in practice I couldn't get this to work, but this might eventually become useful.
+        //
+        // https://github.com/openssl/openssl/blob/master/NOTES-ANDROID.md#configuration
+        //
+        // They recommend a configuration like this:
+        //
+        // // export ANDROID_NDK_ROOT=/home/whoever/Android/android-sdk/ndk/20.0.5594570
+        // PATH=$ANDROID_NDK_ROOT/toolchains/llvm/prebuilt/linux-x86_64/bin:$ANDROID_NDK_ROOT/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin:$PATH
+        // ./Configure android-arm64 -D__ANDROID_API__=29
+        // make
+        //
+        // let tools_dir = arch.android_tools_dir(&ndk);
+        // let extended_path = format!(
+        //     "{}:{}",
+        //     tools_dir.display(),
+        //     std::env::var("PATH").unwrap_or_default()
+        // );
+        // env_vars.push(("PATH", extended_path));
+
+        Ok(env_vars)
+    }
+
+    /// Get an estimate of the number of units in the crate. If nightly rustc is not available, this
+    /// will return an estimate of the number of units in the crate based on cargo metadata.
+    ///
+    /// TODO: always use <https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#unit-graph> once it is stable
+    async fn get_unit_count_estimate(&self, ctx: &BuildContext) -> usize {
+        // Try to get it from nightly
+        if let Ok(count) = self.get_unit_count(ctx).await {
+            return count;
+        }
+
+        // Otherwise, use cargo metadata
+        let units = self
+            .workspace
+            .krates
+            .krates_filtered(krates::DepKind::Dev)
+            .iter()
+            .map(|k| k.targets.len())
+            .sum::<usize>();
+
+        (units as f64 / 3.5) as usize
+    }
+
+    /// Try to get the unit graph for the crate. This is a nightly only feature which may not be
+    /// available with the current version of rustc the user has installed.
+    ///
+    /// It also might not be super reliable - I think in practice it occasionally returns 2x the units.
+    async fn get_unit_count(&self, ctx: &BuildContext) -> crate::Result<usize> {
+        #[derive(Debug, Deserialize)]
+        struct UnitGraph {
+            units: Vec<serde_json::Value>,
+        }
+
+        let output = tokio::process::Command::new("cargo")
+            .arg("+nightly")
+            .arg("build")
+            .arg("--unit-graph")
+            .arg("-Z")
+            .arg("unstable-options")
+            .args(self.cargo_build_arguments(ctx))
+            .envs(self.cargo_build_env_vars(ctx)?)
+            .output()
+            .await?;
+
+        if !output.status.success() {
+            return Err(anyhow::anyhow!("Failed to get unit count").into());
+        }
+
+        let output_text = String::from_utf8(output.stdout).context("Failed to get unit count")?;
+        let graph: UnitGraph =
+            serde_json::from_str(&output_text).context("Failed to get unit count")?;
+
+        Ok(graph.units.len())
+    }
+
+    pub(crate) fn all_target_features(&self) -> Vec<String> {
+        let mut features = self.features.clone();
+
+        if !self.no_default_features {
+            features.extend(
+                self.package()
+                    .features
+                    .get("default")
+                    .cloned()
+                    .unwrap_or_default(),
+            );
+        }
+
+        features.dedup();
+
+        features
+    }
+
+    /// returns the path to root build folder. This will be our working directory for the build.
+    ///
+    /// we only add an extension to the folders where it sorta matters that it's named with the extension.
+    /// for example, on mac, the `.app` indicates we can `open` it and it pulls in icons, dylibs, etc.
+    ///
+    /// for our simulator-based platforms, this is less important since they need to be zipped up anyways
+    /// to run in the simulator.
+    ///
+    /// For windows/linux, it's also not important since we're just running the exe directly out of the folder
+    ///
+    /// The idea of this folder is that we can run our top-level build command against it and we'll get
+    /// a final build output somewhere. Some platforms have basically no build command, and can simply
+    /// be ran by executing the exe directly.
+    pub(crate) fn root_dir(&self) -> PathBuf {
+        let platform_dir = self.platform_dir();
+
+        match self.platform {
+            Platform::Web => platform_dir.join("public"),
+            Platform::Server => platform_dir.clone(), // ends up *next* to the public folder
+
+            // These might not actually need to be called `.app` but it does let us run these with `open`
+            Platform::MacOS => platform_dir.join(format!("{}.app", self.bundled_app_name())),
+            Platform::Ios => platform_dir.join(format!("{}.app", self.bundled_app_name())),
+
+            // in theory, these all could end up directly in the root dir
+            Platform::Android => platform_dir.join("app"), // .apk (after bundling)
+            Platform::Linux => platform_dir.join("app"),   // .appimage (after bundling)
+            Platform::Windows => platform_dir.join("app"), // .exe (after bundling)
+            Platform::Liveview => platform_dir.join("app"), // .exe (after bundling)
+        }
+    }
+
+    fn platform_dir(&self) -> PathBuf {
+        self.build_dir(self.platform, self.release)
+    }
+
+    fn platform_exe_name(&self) -> String {
+        match self.platform {
+            Platform::MacOS => self.executable_name().to_string(),
+            Platform::Ios => self.executable_name().to_string(),
+            Platform::Server => self.executable_name().to_string(),
+            Platform::Liveview => self.executable_name().to_string(),
+            Platform::Windows => format!("{}.exe", self.executable_name()),
+
+            // from the apk spec, the root exe is a shared library
+            // we include the user's rust code as a shared library with a fixed namespace
+            Platform::Android => "libdioxusmain.so".to_string(),
+
+            // this will be wrong, I think, but not important?
+            Platform::Web => format!("{}_bg.wasm", self.executable_name()),
+
+            // todo: maybe this should be called AppRun?
+            Platform::Linux => self.executable_name().to_string(),
+        }
+    }
+
+    /// Assemble the android app dir.
+    ///
+    /// This is a bit of a mess since we need to create a lot of directories and files. Other approaches
+    /// would be to unpack some zip folder or something stored via `include_dir!()`. However, we do
+    /// need to customize the whole setup a bit, so it's just simpler (though messier) to do it this way.
+    fn build_android_app_dir(&self) -> Result<()> {
+        use std::fs::{create_dir_all, write};
+        let root = self.root_dir();
+
+        // gradle
+        let wrapper = root.join("gradle").join("wrapper");
+        create_dir_all(&wrapper)?;
+
+        // app
+        let app = root.join("app");
+        let app_main = app.join("src").join("main");
+        let app_kotlin = app_main.join("kotlin");
+        let app_jnilibs = app_main.join("jniLibs");
+        let app_assets = app_main.join("assets");
+        let app_kotlin_out = self.wry_android_kotlin_files_out_dir();
+        create_dir_all(&app)?;
+        create_dir_all(&app_main)?;
+        create_dir_all(&app_kotlin)?;
+        create_dir_all(&app_jnilibs)?;
+        create_dir_all(&app_assets)?;
+        create_dir_all(&app_kotlin_out)?;
+
+        tracing::debug!(
+            r#"Initialized android dirs:
+- gradle:              {wrapper:?}
+- app/                 {app:?}
+- app/src:             {app_main:?}
+- app/src/kotlin:      {app_kotlin:?}
+- app/src/jniLibs:     {app_jnilibs:?}
+- app/src/assets:      {app_assets:?}
+- app/src/kotlin/main: {app_kotlin_out:?}
+"#
+        );
+
+        // handlebars
+        #[derive(Serialize)]
+        struct AndroidHandlebarsObjects {
+            application_id: String,
+            app_name: String,
+        }
+        let hbs_data = AndroidHandlebarsObjects {
+            application_id: self.full_mobile_app_name(),
+            app_name: self.bundled_app_name(),
+        };
+        let hbs = handlebars::Handlebars::new();
+
+        // Top-level gradle config
         write(
             root.join("build.gradle.kts"),
             include_bytes!("../../assets/android/gen/build.gradle.kts"),
@@ -878,7 +2346,7 @@ impl BuildRequest {
             )?,
         )?;
 
-        // Write the res folder
+        // Write the res folder, containing stuff like default icons, colors, and menubars.
         let res = app_main.join("res");
         create_dir_all(&res)?;
         create_dir_all(res.join("values"))?;
@@ -958,7 +2426,7 @@ impl BuildRequest {
         Ok(())
     }
 
-    pub(crate) fn wry_android_kotlin_files_out_dir(&self) -> PathBuf {
+    fn wry_android_kotlin_files_out_dir(&self) -> PathBuf {
         let mut kotlin_dir = self
             .root_dir()
             .join("app")
@@ -970,8 +2438,1301 @@ impl BuildRequest {
             kotlin_dir = kotlin_dir.join(segment);
         }
 
-        tracing::debug!("app_kotlin_out: {:?}", kotlin_dir);
-
         kotlin_dir
     }
+
+    /// Get the directory where this app can write to for this session that's guaranteed to be stable
+    /// for the same app. This is useful for emitting state like window position and size.
+    ///
+    /// The directory is specific for this app and might be
+    pub(crate) fn session_cache_dir(&self) -> PathBuf {
+        self.session_cache_dir.path().to_path_buf()
+    }
+
+    /// Get the outdir specified by the Dioxus.toml, relative to the crate directory.
+    /// We don't support workspaces yet since that would cause a collision of bundles per project.
+    pub(crate) fn crate_out_dir(&self) -> Option<PathBuf> {
+        self.config
+            .application
+            .out_dir
+            .as_ref()
+            .map(|out_dir| self.crate_dir().join(out_dir))
+    }
+
+    /// Compose an out directory. Represents the typical "dist" directory that
+    /// is "distributed" after building an application (configurable in the
+    /// `Dioxus.toml`).
+    fn internal_out_dir(&self) -> PathBuf {
+        let dir = self.workspace_dir().join("target").join("dx");
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    /// Create a workdir for the given platform
+    /// This can be used as a temporary directory for the build, but in an observable way such that
+    /// you can see the files in the directory via `target`
+    ///
+    /// target/dx/build/app/web/
+    /// target/dx/build/app/web/public/
+    /// target/dx/build/app/web/server.exe
+    pub(crate) fn build_dir(&self, platform: Platform, release: bool) -> PathBuf {
+        self.internal_out_dir()
+            .join(self.executable_name())
+            .join(if release { "release" } else { "debug" })
+            .join(platform.build_folder_name())
+    }
+
+    /// target/dx/bundle/app/
+    /// target/dx/bundle/app/blah.app
+    /// target/dx/bundle/app/blah.exe
+    /// target/dx/bundle/app/public/
+    pub(crate) fn bundle_dir(&self, platform: Platform) -> PathBuf {
+        self.internal_out_dir()
+            .join(self.executable_name())
+            .join("bundle")
+            .join(platform.build_folder_name())
+    }
+
+    /// Get the workspace directory for the crate
+    pub(crate) fn workspace_dir(&self) -> PathBuf {
+        self.workspace
+            .krates
+            .workspace_root()
+            .as_std_path()
+            .to_path_buf()
+    }
+
+    /// Get the directory of the crate
+    pub(crate) fn crate_dir(&self) -> PathBuf {
+        self.package()
+            .manifest_path
+            .parent()
+            .unwrap()
+            .as_std_path()
+            .to_path_buf()
+    }
+
+    /// Get the package we are currently in
+    pub(crate) fn package(&self) -> &krates::cm::Package {
+        &self.workspace.krates[self.crate_package]
+    }
+
+    /// Get the name of the package we are compiling
+    pub(crate) fn executable_name(&self) -> &str {
+        &self.crate_target.name
+    }
+
+    /// Get the type of executable we are compiling
+    pub(crate) fn executable_type(&self) -> TargetKind {
+        self.crate_target.kind[0]
+    }
+
+    /// Get the features required to build for the given platform
+    fn feature_for_platform(package: &krates::cm::Package, platform: Platform) -> String {
+        // Try to find the feature that activates the dioxus feature for the given platform
+        let dioxus_feature = platform.feature_name();
+
+        let res = package.features.iter().find_map(|(key, features)| {
+            // if the feature is just the name of the platform, we use that
+            if key == dioxus_feature {
+                return Some(key.clone());
+            }
+
+            // Otherwise look for the feature that starts with dioxus/ or dioxus?/ and matches the platform
+            for feature in features {
+                if let Some((_, after_dioxus)) = feature.split_once("dioxus") {
+                    if let Some(dioxus_feature_enabled) =
+                        after_dioxus.trim_start_matches('?').strip_prefix('/')
+                    {
+                        // If that enables the feature we are looking for, return that feature
+                        if dioxus_feature_enabled == dioxus_feature {
+                            return Some(key.clone());
+                        }
+                    }
+                }
+            }
+
+            None
+        });
+
+        res.unwrap_or_else(|| {
+            let fallback = format!("dioxus/{}", platform.feature_name()) ;
+            tracing::debug!(
+                "Could not find explicit feature for platform {platform}, passing `fallback` instead"
+            );
+            fallback
+        })
+    }
+
+    // The `opt-level=1` increases build times, but can noticeably decrease time
+    // between saving changes and being able to interact with an app (for wasm/web). The "overall"
+    // time difference (between having and not having the optimization) can be
+    // almost imperceptible (~1 s) but also can be very noticeable (~6 s) — depends
+    // on setup (hardware, OS, browser, idle load).
+    //
+    // Find or create the client and server profiles in the top-level Cargo.toml file
+    // todo(jon): we should/could make these optional by placing some defaults somewhere
+    pub(crate) fn initialize_profiles(&self) -> crate::Result<()> {
+        let config_path = self.workspace_dir().join("Cargo.toml");
+        let mut config = match std::fs::read_to_string(&config_path) {
+            Ok(config) => config.parse::<toml_edit::DocumentMut>().map_err(|e| {
+                crate::Error::Other(anyhow::anyhow!("Failed to parse Cargo.toml: {}", e))
+            })?,
+            Err(_) => Default::default(),
+        };
+
+        if let Item::Table(table) = config
+            .as_table_mut()
+            .entry("profile")
+            .or_insert(Item::Table(Default::default()))
+        {
+            if let toml_edit::Entry::Vacant(entry) = table.entry(PROFILE_WASM) {
+                let mut client = toml_edit::Table::new();
+                client.insert("inherits", Item::Value("dev".into()));
+                client.insert("opt-level", Item::Value(1.into()));
+                entry.insert(Item::Table(client));
+            }
+
+            if let toml_edit::Entry::Vacant(entry) = table.entry(PROFILE_SERVER) {
+                let mut server = toml_edit::Table::new();
+                server.insert("inherits", Item::Value("dev".into()));
+                entry.insert(Item::Table(server));
+            }
+
+            if let toml_edit::Entry::Vacant(entry) = table.entry(PROFILE_ANDROID) {
+                let mut android = toml_edit::Table::new();
+                android.insert("inherits", Item::Value("dev".into()));
+                entry.insert(Item::Table(android));
+            }
+        }
+
+        std::fs::write(config_path, config.to_string())
+            .context("Failed to write profiles to Cargo.toml")?;
+
+        Ok(())
+    }
+
+    /// Return the version of the wasm-bindgen crate if it exists
+    fn wasm_bindgen_version(&self) -> Option<String> {
+        self.workspace
+            .krates
+            .krates_by_name("wasm-bindgen")
+            .next()
+            .map(|krate| krate.krate.version.to_string())
+    }
+
+    /// Return the platforms that are enabled for the package
+    ///
+    /// Ideally only one platform is enabled but we need to be able to
+    pub(crate) fn enabled_cargo_toml_platforms(
+        package: &krates::cm::Package,
+        no_default_features: bool,
+    ) -> Vec<Platform> {
+        let mut platforms = vec![];
+
+        // Attempt to discover the platform directly from the dioxus dependency
+        //
+        // [dependencies]
+        // dioxus = { features = ["web"] }
+        //
+        if let Some(dxs) = package.dependencies.iter().find(|dep| dep.name == "dioxus") {
+            for f in dxs.features.iter() {
+                if let Some(platform) = Platform::autodetect_from_cargo_feature(f) {
+                    platforms.push(platform);
+                }
+            }
+        }
+
+        // Start searching through the default features
+        //
+        // [features]
+        // default = ["dioxus/web"]
+        //
+        // or
+        //
+        // [features]
+        // default = ["web"]
+        // web = ["dioxus/web"]
+        if no_default_features {
+            return platforms;
+        }
+
+        let Some(default) = package.features.get("default") else {
+            return platforms;
+        };
+
+        tracing::debug!("Default features: {default:?}");
+
+        // we only trace features 1 level deep..
+        for feature in default.iter() {
+            // If the user directly specified a platform we can just use that.
+            if feature.starts_with("dioxus/") {
+                let dx_feature = feature.trim_start_matches("dioxus/");
+                let auto = Platform::autodetect_from_cargo_feature(dx_feature);
+                if let Some(auto) = auto {
+                    platforms.push(auto);
+                }
+            }
+
+            // If the user is specifying an internal feature that points to a platform, we can use that
+            let internal_feature = package.features.get(feature);
+            if let Some(internal_feature) = internal_feature {
+                for feature in internal_feature {
+                    if feature.starts_with("dioxus/") {
+                        let dx_feature = feature.trim_start_matches("dioxus/");
+                        let auto = Platform::autodetect_from_cargo_feature(dx_feature);
+                        if let Some(auto) = auto {
+                            platforms.push(auto);
+                        }
+                    }
+                }
+            }
+        }
+
+        platforms.sort();
+        platforms.dedup();
+
+        tracing::debug!("Default platforms: {platforms:?}");
+
+        platforms
+    }
+
+    /// Gather the features that are enabled for the package
+    fn platformless_features(package: &krates::cm::Package) -> Vec<String> {
+        let Some(default) = package.features.get("default") else {
+            return Vec::new();
+        };
+
+        let mut kept_features = vec![];
+
+        // Only keep the top-level features in the default list that don't point to a platform directly
+        // IE we want to drop `web` if default = ["web"]
+        'top: for feature in default {
+            // Don't keep features that point to a platform via dioxus/blah
+            if feature.starts_with("dioxus/") {
+                let dx_feature = feature.trim_start_matches("dioxus/");
+                if Platform::autodetect_from_cargo_feature(dx_feature).is_some() {
+                    continue 'top;
+                }
+            }
+
+            // Don't keep features that point to a platform via an internal feature
+            if let Some(internal_feature) = package.features.get(feature) {
+                for feature in internal_feature {
+                    if feature.starts_with("dioxus/") {
+                        let dx_feature = feature.trim_start_matches("dioxus/");
+                        if Platform::autodetect_from_cargo_feature(dx_feature).is_some() {
+                            continue 'top;
+                        }
+                    }
+                }
+            }
+
+            // Otherwise we can keep it
+            kept_features.push(feature.to_string());
+        }
+
+        kept_features
+    }
+
+    pub(crate) fn mobile_org(&self) -> String {
+        let identifier = self.bundle_identifier();
+        let mut split = identifier.splitn(3, '.');
+        let sub = split
+            .next()
+            .expect("Identifier to have at least 3 periods like `com.example.app`");
+        let tld = split
+            .next()
+            .expect("Identifier to have at least 3 periods like `com.example.app`");
+        format!("{}.{}", sub, tld)
+    }
+
+    pub(crate) fn bundled_app_name(&self) -> String {
+        use convert_case::{Case, Casing};
+        self.executable_name().to_case(Case::Pascal)
+    }
+
+    pub(crate) fn full_mobile_app_name(&self) -> String {
+        format!("{}.{}", self.mobile_org(), self.bundled_app_name())
+    }
+
+    pub(crate) fn bundle_identifier(&self) -> String {
+        if let Some(identifier) = self.config.bundle.identifier.clone() {
+            return identifier.clone();
+        }
+
+        format!("com.example.{}", self.bundled_app_name())
+    }
+
+    /// The item that we'll try to run directly if we need to.
+    ///
+    /// todo(jon): we should name the app properly instead of making up the exe name. It's kinda okay for dev mode, but def not okay for prod
+    pub(crate) fn main_exe(&self) -> PathBuf {
+        self.exe_dir().join(self.platform_exe_name())
+    }
+
+    /// Does the app specify:
+    ///
+    /// - Dioxus with "fullstack" enabled? (access to serverfns, etc)
+    /// - An explicit "fullstack" feature that enables said feature?
+    ///
+    /// Note that we don't detect if dependencies enable it transitively since we want to be explicit about it.
+    ///
+    /// The intention here is to detect if "fullstack" is enabled in the target's features list:
+    /// ```toml
+    /// [dependencies]
+    /// dioxus = { version = "0.4", features = ["fullstack"] }
+    /// ```
+    ///
+    /// or as an explicit feature in default:
+    /// ```toml
+    /// [features]
+    /// default = ["dioxus/fullstack"]
+    /// ```
+    ///
+    /// or as a default feature that enables the dioxus feature:
+    /// ```toml
+    /// [features]
+    /// default = ["fullstack"]
+    /// fullstack = ["dioxus/fullstack"]
+    /// ```
+    ///
+    /// or as an explicit feature (that enables the dioxus feature):
+    /// ```
+    /// dx serve app --features "fullstack"
+    /// ```
+    pub(crate) fn fullstack_feature_enabled(&self) -> bool {
+        let dioxus_dep = self
+            .package()
+            .dependencies
+            .iter()
+            .find(|dep| dep.name == "dioxus");
+
+        // If we don't have a dioxus dependency, we can't be fullstack. This shouldn't impact non-dioxus projects
+        let Some(dioxus_dep) = dioxus_dep else {
+            return false;
+        };
+
+        // Check if the dioxus dependency has the "fullstack" feature enabled
+        if dioxus_dep.features.iter().any(|f| f == "fullstack") {
+            return true;
+        }
+
+        // Check if any of the features in our feature list enables a feature that enables "fullstack"
+        let transitive = self
+            .package()
+            .features
+            .iter()
+            .filter(|(_name, list)| list.iter().any(|f| f == "dioxus/fullstack"));
+
+        for (name, _list) in transitive {
+            if self.features.contains(name) {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    /// todo(jon): use handlebars templates instead of these prebaked templates
+    async fn write_metadata(&self) -> Result<()> {
+        // write the Info.plist file
+        match self.platform {
+            Platform::MacOS => {
+                let dest = self.root_dir().join("Contents").join("Info.plist");
+                let plist = self.info_plist_contents(self.platform)?;
+                std::fs::write(dest, plist)?;
+            }
+
+            Platform::Ios => {
+                let dest = self.root_dir().join("Info.plist");
+                let plist = self.info_plist_contents(self.platform)?;
+                std::fs::write(dest, plist)?;
+            }
+
+            // AndroidManifest.xml
+            // er.... maybe even all the kotlin/java/gradle stuff?
+            Platform::Android => {}
+
+            // Probably some custom format or a plist file (haha)
+            // When we do the proper bundle, we'll need to do something with wix templates, I think?
+            Platform::Windows => {}
+
+            // eventually we'll create the .appimage file, I guess?
+            Platform::Linux => {}
+
+            // These are served as folders, not appimages, so we don't need to do anything special (I think?)
+            // Eventually maybe write some secrets/.env files for the server?
+            // We could also distribute them as a deb/rpm for linux and msi for windows
+            Platform::Web => {}
+            Platform::Server => {}
+            Platform::Liveview => {}
+        }
+
+        Ok(())
+    }
+
+    /// Run the optimizers, obfuscators, minimizers, signers, etc
+    async fn optimize(&self, ctx: &BuildContext) -> Result<()> {
+        match self.platform {
+            Platform::Web => {
+                // Compress the asset dir
+                // If pre-compressing is enabled, we can pre_compress the wasm-bindgen output
+                let pre_compress = self.should_pre_compress_web_assets(self.release);
+
+                ctx.status_compressing_assets();
+                let asset_dir = self.asset_dir();
+                tokio::task::spawn_blocking(move || {
+                    crate::fastfs::pre_compress_folder(&asset_dir, pre_compress)
+                })
+                .await
+                .unwrap()?;
+            }
+            Platform::MacOS => {}
+            Platform::Windows => {}
+            Platform::Linux => {}
+            Platform::Ios => {}
+            Platform::Android => {}
+            Platform::Server => {}
+            Platform::Liveview => {}
+        }
+
+        Ok(())
+    }
+
+    /// Check if assets should be pre_compressed. This will only be true in release mode if the user
+    /// has enabled pre_compress in the web config.
+    fn should_pre_compress_web_assets(&self, release: bool) -> bool {
+        self.config.web.pre_compress && release
+    }
+
+    /// Bundle the web app
+    /// - Run wasm-bindgen
+    /// - Bundle split
+    /// - Run wasm-opt
+    /// - Register the .wasm and .js files with the asset system
+    async fn bundle_web(
+        &self,
+        ctx: &BuildContext,
+        exe: &Path,
+        assets: &mut AssetManifest,
+    ) -> Result<()> {
+        use crate::{wasm_bindgen::WasmBindgen, wasm_opt};
+        use std::fmt::Write;
+
+        // Locate the output of the build files and the bindgen output
+        // We'll fill these in a second if they don't already exist
+        let bindgen_outdir = self.wasm_bindgen_out_dir();
+        let post_bindgen_wasm = self.wasm_bindgen_wasm_output_file();
+        let should_bundle_split: bool = self.wasm_split;
+        let bindgen_version = self
+            .wasm_bindgen_version()
+            .expect("this should have been checked by tool verification");
+
+        // Prepare any work dirs
+        std::fs::create_dir_all(&bindgen_outdir)?;
+
+        // Lift the internal functions to exports
+        if ctx.mode == BuildMode::Fat {
+            let unprocessed = std::fs::read(exe)?;
+            let all_exported_bytes = crate::build::prepare_wasm_base_module(&unprocessed)?;
+            std::fs::write(exe, all_exported_bytes)?;
+        }
+
+        // Prepare our configuration
+        //
+        // we turn off debug symbols in dev mode but leave them on in release mode (weird!) since
+        // wasm-opt and wasm-split need them to do better optimizations.
+        //
+        // We leave demangling to false since it's faster and these tools seem to prefer the raw symbols.
+        // todo(jon): investigate if the chrome extension needs them demangled or demangles them automatically.
+        let will_wasm_opt = (self.release || self.wasm_split)
+            && (self.workspace.wasm_opt.is_some() || cfg!(feature = "optimizations"));
+        let keep_debug = self.config.web.wasm_opt.debug
+            || self.debug_symbols
+            || self.wasm_split
+            || !self.release
+            || will_wasm_opt
+            || ctx.mode == BuildMode::Fat;
+        let keep_names = will_wasm_opt || ctx.mode == BuildMode::Fat;
+        let demangle = false;
+        let wasm_opt_options = WasmOptConfig {
+            memory_packing: self.wasm_split,
+            debug: self.debug_symbols,
+            ..self.config.web.wasm_opt.clone()
+        };
+
+        // Run wasm-bindgen. Some of the options are not "optimal" but will be fixed up by wasm-opt
+        //
+        // There's performance implications here. Running with --debug is slower than without
+        // We're keeping around lld sections and names but wasm-opt will fix them
+        // todo(jon): investigate a good balance of wiping debug symbols during dev (or doing a double build?)
+        ctx.status_wasm_bindgen_start();
+        tracing::debug!(dx_src = ?TraceSrc::Bundle, "Running wasm-bindgen");
+        let start = std::time::Instant::now();
+        WasmBindgen::new(&bindgen_version)
+            .input_path(exe)
+            .target("web")
+            .debug(keep_debug)
+            .demangle(demangle)
+            .keep_debug(keep_debug)
+            .keep_lld_sections(true)
+            .out_name(self.executable_name())
+            .out_dir(&bindgen_outdir)
+            .remove_name_section(!keep_names)
+            .remove_producers_section(!keep_names)
+            .run()
+            .await
+            .context("Failed to generate wasm-bindgen bindings")?;
+        tracing::debug!(dx_src = ?TraceSrc::Bundle, "wasm-bindgen complete in {:?}", start.elapsed());
+
+        // Run bundle splitting if the user has requested it
+        // It's pretty expensive but because of rayon should be running separate threads, hopefully
+        // not blocking this thread. Dunno if that's true
+        if should_bundle_split {
+            ctx.status_splitting_bundle();
+
+            if !will_wasm_opt {
+                return Err(anyhow::anyhow!(
+                    "Bundle splitting requires wasm-opt to be installed or the CLI to be built with `--features optimizations`. Please install wasm-opt and try again."
+                )
+                .into());
+            }
+
+            // Load the contents of these binaries since we need both of them
+            // We're going to use the default makeLoad glue from wasm-split
+            let original = std::fs::read(exe)?;
+            let bindgened = std::fs::read(&post_bindgen_wasm)?;
+            let mut glue = wasm_split_cli::MAKE_LOAD_JS.to_string();
+
+            // Run the emitter
+            let splitter = wasm_split_cli::Splitter::new(&original, &bindgened);
+            let modules = splitter
+                .context("Failed to parse wasm for splitter")?
+                .emit()
+                .context("Failed to emit wasm split modules")?;
+
+            // Write the chunks that contain shared imports
+            // These will be in the format of chunk_0_modulename.wasm - this is hardcoded in wasm-split
+            tracing::debug!("Writing split chunks to disk");
+            for (idx, chunk) in modules.chunks.iter().enumerate() {
+                let path = bindgen_outdir.join(format!("chunk_{}_{}.wasm", idx, chunk.module_name));
+                wasm_opt::write_wasm(&chunk.bytes, &path, &wasm_opt_options).await?;
+                writeln!(
+                    glue, "export const __wasm_split_load_chunk_{idx} = makeLoad(\"/assets/{url}\", [], fusedImports);",
+                    url = assets
+                        .register_asset(&path, AssetOptions::Unknown)?.bundled_path(),
+                )?;
+            }
+
+            // Write the modules that contain the entrypoints
+            tracing::debug!("Writing split modules to disk");
+            for (idx, module) in modules.modules.iter().enumerate() {
+                let comp_name = module
+                    .component_name
+                    .as_ref()
+                    .context("generated bindgen module has no name?")?;
+
+                let path = bindgen_outdir.join(format!("module_{}_{}.wasm", idx, comp_name));
+                wasm_opt::write_wasm(&module.bytes, &path, &wasm_opt_options).await?;
+
+                let hash_id = module
+                    .hash_id
+                    .as_ref()
+                    .context("generated wasm-split bindgen module has no hash id?")?;
+
+                writeln!(
+                    glue,
+                    "export const __wasm_split_load_{module}_{hash_id}_{comp_name} = makeLoad(\"/assets/{url}\", [{deps}], fusedImports);",
+                    module = module.module_name,
+
+
+                    // Again, register this wasm with the asset system
+                    url = assets
+                        .register_asset(&path, AssetOptions::Unknown)?.bundled_path(),
+
+                    // This time, make sure to write the dependencies of this chunk
+                    // The names here are again, hardcoded in wasm-split - fix this eventually.
+                    deps = module
+                        .relies_on_chunks
+                        .iter()
+                        .map(|idx| format!("__wasm_split_load_chunk_{idx}"))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )?;
+            }
+
+            // Write the js binding
+            // It's not registered as an asset since it will get included in the main.js file
+            let js_output_path = bindgen_outdir.join("__wasm_split.js");
+            std::fs::write(&js_output_path, &glue)?;
+
+            // Make sure to write some entropy to the main.js file so it gets a new hash
+            // If we don't do this, the main.js file will be cached and never pick up the chunk names
+            let uuid = Uuid::new_v5(&Uuid::NAMESPACE_URL, glue.as_bytes());
+            std::fs::OpenOptions::new()
+                .append(true)
+                .open(self.wasm_bindgen_js_output_file())
+                .context("Failed to open main.js file")?
+                .write_all(format!("/*{uuid}*/").as_bytes())?;
+
+            // Write the main wasm_bindgen file and register it with the asset system
+            // This will overwrite the file in place
+            // We will wasm-opt it in just a second...
+            std::fs::write(&post_bindgen_wasm, modules.main.bytes)?;
+        }
+
+        if matches!(ctx.mode, BuildMode::Fat) {
+            // add `export { __wbg_get_imports };` to the end of the wasmbindgen js file
+            let mut js = std::fs::read(self.wasm_bindgen_js_output_file())?;
+            writeln!(js, "\nexport {{ __wbg_get_imports }};")?;
+            std::fs::write(self.wasm_bindgen_js_output_file(), js)?;
+        }
+
+        // Make sure to optimize the main wasm file if requested or if bundle splitting
+        if should_bundle_split || self.release {
+            ctx.status_optimizing_wasm();
+            wasm_opt::optimize(&post_bindgen_wasm, &post_bindgen_wasm, &wasm_opt_options).await?;
+        }
+
+        // In release mode, we make the wasm and bindgen files into assets so they get bundled with max
+        // optimizations.
+        let wasm_path = if self.release {
+            // Register the main.js with the asset system so it bundles in the snippets and optimizes
+            let name = assets.register_asset(
+                &self.wasm_bindgen_js_output_file(),
+                AssetOptions::Js(JsAssetOptions::new().with_minify(true).with_preload(true)),
+            )?;
+            format!("assets/{}", name.bundled_path())
+        } else {
+            let asset = self.wasm_bindgen_wasm_output_file();
+            format!("wasm/{}", asset.file_name().unwrap().to_str().unwrap())
+        };
+
+        let js_path = if self.release {
+            // Make sure to register the main wasm file with the asset system
+            let name = assets.register_asset(&post_bindgen_wasm, AssetOptions::Unknown)?;
+            format!("assets/{}", name.bundled_path())
+        } else {
+            let asset = self.wasm_bindgen_js_output_file();
+            format!("wasm/{}", asset.file_name().unwrap().to_str().unwrap())
+        };
+
+        // Write the index.html file with the pre-configured contents we got from pre-rendering
+        std::fs::write(
+            self.root_dir().join("index.html"),
+            self.prepare_html(assets, &wasm_path, &js_path)?,
+        )?;
+
+        Ok(())
+    }
+
+    fn info_plist_contents(&self, platform: Platform) -> Result<String> {
+        #[derive(Serialize)]
+        pub struct InfoPlistData {
+            pub display_name: String,
+            pub bundle_name: String,
+            pub bundle_identifier: String,
+            pub executable_name: String,
+        }
+
+        match platform {
+            Platform::MacOS => handlebars::Handlebars::new()
+                .render_template(
+                    include_str!("../../assets/macos/mac.plist.hbs"),
+                    &InfoPlistData {
+                        display_name: self.bundled_app_name(),
+                        bundle_name: self.bundled_app_name(),
+                        executable_name: self.platform_exe_name(),
+                        bundle_identifier: self.bundle_identifier(),
+                    },
+                )
+                .map_err(|e| e.into()),
+            Platform::Ios => handlebars::Handlebars::new()
+                .render_template(
+                    include_str!("../../assets/ios/ios.plist.hbs"),
+                    &InfoPlistData {
+                        display_name: self.bundled_app_name(),
+                        bundle_name: self.bundled_app_name(),
+                        executable_name: self.platform_exe_name(),
+                        bundle_identifier: self.bundle_identifier(),
+                    },
+                )
+                .map_err(|e| e.into()),
+            _ => Err(anyhow::anyhow!("Unsupported platform for Info.plist").into()),
+        }
+    }
+
+    /// Run any final tools to produce apks or other artifacts we might need.
+    ///
+    /// This might include codesigning, zipping, creating an appimage, etc
+    async fn assemble(&self, ctx: &BuildContext) -> Result<()> {
+        if let Platform::Android = self.platform {
+            ctx.status_running_gradle();
+
+            let output = Command::new(self.gradle_exe()?)
+                .arg("assembleDebug")
+                .current_dir(self.root_dir())
+                .output()
+                .await?;
+
+            if !output.status.success() {
+                return Err(anyhow::anyhow!("Failed to assemble apk: {output:?}").into());
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Run bundleRelease and return the path to the `.aab` file
+    ///
+    /// <https://stackoverflow.com/questions/57072558/whats-the-difference-between-gradlewassemblerelease-gradlewinstallrelease-and>
+    pub(crate) async fn android_gradle_bundle(&self) -> Result<PathBuf> {
+        let output = Command::new(self.gradle_exe()?)
+            .arg("bundleRelease")
+            .current_dir(self.root_dir())
+            .output()
+            .await
+            .context("Failed to run gradle bundleRelease")?;
+
+        if !output.status.success() {
+            return Err(anyhow::anyhow!("Failed to bundleRelease: {output:?}").into());
+        }
+
+        let app_release = self
+            .root_dir()
+            .join("app")
+            .join("build")
+            .join("outputs")
+            .join("bundle")
+            .join("release");
+
+        // Rename it to Name-arch.aab
+        let from = app_release.join("app-release.aab");
+        let to = app_release.join(format!("{}-{}.aab", self.bundled_app_name(), self.triple));
+
+        std::fs::rename(from, &to).context("Failed to rename aab")?;
+
+        Ok(to)
+    }
+
+    fn gradle_exe(&self) -> Result<PathBuf> {
+        // make sure we can execute the gradlew script
+        #[cfg(unix)]
+        {
+            use std::os::unix::prelude::PermissionsExt;
+            std::fs::set_permissions(
+                self.root_dir().join("gradlew"),
+                std::fs::Permissions::from_mode(0o755),
+            )?;
+        }
+
+        let gradle_exec_name = match cfg!(windows) {
+            true => "gradlew.bat",
+            false => "gradlew",
+        };
+
+        Ok(self.root_dir().join(gradle_exec_name))
+    }
+
+    pub(crate) fn debug_apk_path(&self) -> PathBuf {
+        self.root_dir()
+            .join("app")
+            .join("build")
+            .join("outputs")
+            .join("apk")
+            .join("debug")
+            .join("app-debug.apk")
+    }
+
+    /// We only really currently care about:
+    ///
+    /// - app dir (.app, .exe, .apk, etc)
+    /// - assetas dir
+    /// - exe dir (.exe, .app, .apk, etc)
+    /// - extra scaffolding
+    ///
+    /// It's not guaranteed that they're different from any other folder
+    pub(crate) fn prepare_build_dir(&self) -> Result<()> {
+        use once_cell::sync::OnceCell;
+        use std::fs::{create_dir_all, remove_dir_all};
+
+        static INITIALIZED: OnceCell<Result<()>> = OnceCell::new();
+
+        let success = INITIALIZED.get_or_init(|| {
+            if self.platform != Platform::Server {
+                _ = remove_dir_all(self.exe_dir());
+            }
+
+            self.flush_session_cache();
+
+            create_dir_all(self.root_dir())?;
+            create_dir_all(self.exe_dir())?;
+            create_dir_all(self.asset_dir())?;
+
+            tracing::debug!("Initialized Root dir: {:?}", self.root_dir());
+            tracing::debug!("Initialized Exe dir: {:?}", self.exe_dir());
+            tracing::debug!("Initialized Asset dir: {:?}", self.asset_dir());
+
+            // we could download the templates from somewhere (github?) but after having banged my head against
+            // cargo-mobile2 for ages, I give up with that. We're literally just going to hardcode the templates
+            // by writing them here.
+            if let Platform::Android = self.platform {
+                self.build_android_app_dir()?;
+            }
+
+            Ok(())
+        });
+
+        if let Err(e) = success.as_ref() {
+            return Err(format!("Failed to initialize build directory: {e}").into());
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn asset_dir(&self) -> PathBuf {
+        match self.platform {
+            Platform::MacOS => self
+                .root_dir()
+                .join("Contents")
+                .join("Resources")
+                .join("assets"),
+
+            Platform::Android => self
+                .root_dir()
+                .join("app")
+                .join("src")
+                .join("main")
+                .join("assets"),
+
+            // everyone else is soooo normal, just app/assets :)
+            Platform::Web
+            | Platform::Ios
+            | Platform::Windows
+            | Platform::Linux
+            | Platform::Server
+            | Platform::Liveview => self.root_dir().join("assets"),
+        }
+    }
+
+    /// The directory in which we'll put the main exe
+    ///
+    /// Mac, Android, Web are a little weird
+    /// - mac wants to be in Contents/MacOS
+    /// - android wants to be in jniLibs/arm64-v8a (or others, depending on the platform / architecture)
+    /// - web wants to be in wasm (which... we don't really need to, we could just drop the wasm into public and it would work)
+    ///
+    /// I think all others are just in the root folder
+    ///
+    /// todo(jon): investigate if we need to put .wasm in `wasm`. It kinda leaks implementation details, which ideally we don't want to do.
+    fn exe_dir(&self) -> PathBuf {
+        match self.platform {
+            Platform::MacOS => self.root_dir().join("Contents").join("MacOS"),
+            Platform::Web => self.root_dir().join("wasm"),
+
+            // Android has a whole build structure to it
+            Platform::Android => self
+                .root_dir()
+                .join("app")
+                .join("src")
+                .join("main")
+                .join("jniLibs")
+                .join(AndroidTools::android_jnilib(&self.triple)),
+
+            // these are all the same, I think?
+            Platform::Windows
+            | Platform::Linux
+            | Platform::Ios
+            | Platform::Server
+            | Platform::Liveview => self.root_dir(),
+        }
+    }
+
+    /// Get the path to the wasm bindgen temporary output folder
+    fn wasm_bindgen_out_dir(&self) -> PathBuf {
+        self.root_dir().join("wasm")
+    }
+
+    /// Get the path to the wasm bindgen javascript output file
+    pub(crate) fn wasm_bindgen_js_output_file(&self) -> PathBuf {
+        self.wasm_bindgen_out_dir()
+            .join(self.executable_name())
+            .with_extension("js")
+    }
+
+    /// Get the path to the wasm bindgen wasm output file
+    pub(crate) fn wasm_bindgen_wasm_output_file(&self) -> PathBuf {
+        self.wasm_bindgen_out_dir()
+            .join(format!("{}_bg", self.executable_name()))
+            .with_extension("wasm")
+    }
+
+    /// Get the path to the asset optimizer version file
+    pub(crate) fn asset_optimizer_version_file(&self) -> PathBuf {
+        self.platform_dir().join(".cli-version")
+    }
+
+    fn flush_session_cache(&self) {
+        let cache_dir = self.session_cache_dir();
+        _ = std::fs::remove_dir_all(&cache_dir);
+        _ = std::fs::create_dir_all(&cache_dir);
+    }
+
+    /// Check for tooling that might be required for this build.
+    ///
+    /// This should generally be only called on the first build since it takes time to verify the tooling
+    /// is in place, and we don't want to slow down subsequent builds.
+    pub(crate) async fn verify_tooling(&self, ctx: &BuildContext) -> Result<()> {
+        tracing::debug!("Verifying tooling...");
+        ctx.status_installing_tooling();
+
+        self
+            .initialize_profiles()
+            .context("Failed to initialize profiles - dioxus can't build without them. You might need to initialize them yourself.")?;
+
+        match self.platform {
+            Platform::Web => self.verify_web_tooling().await?,
+            Platform::Ios => self.verify_ios_tooling().await?,
+            Platform::Android => self.verify_android_tooling().await?,
+            Platform::Linux => self.verify_linux_tooling().await?,
+            Platform::MacOS | Platform::Windows | Platform::Server | Platform::Liveview => {}
+        }
+
+        Ok(())
+    }
+
+    async fn verify_web_tooling(&self) -> Result<()> {
+        // Install target using rustup.
+        #[cfg(not(feature = "no-downloads"))]
+        if !self.workspace.has_wasm32_unknown_unknown() {
+            tracing::info!(
+                "Web platform requires wasm32-unknown-unknown to be installed. Installing..."
+            );
+
+            let _ = tokio::process::Command::new("rustup")
+                .args(["target", "add", "wasm32-unknown-unknown"])
+                .output()
+                .await?;
+        }
+
+        // Ensure target is installed.
+        if !self.workspace.has_wasm32_unknown_unknown() {
+            return Err(Error::Other(anyhow::anyhow!(
+                "Missing target wasm32-unknown-unknown."
+            )));
+        }
+
+        // Wasm bindgen
+        let krate_bindgen_version = self.wasm_bindgen_version().ok_or(anyhow::anyhow!(
+            "failed to detect wasm-bindgen version, unable to proceed"
+        ))?;
+
+        WasmBindgen::verify_install(&krate_bindgen_version).await?;
+
+        Ok(())
+    }
+
+    /// Currently does nothing, but eventually we need to check that the mobile tooling is installed.
+    ///
+    /// For ios, this would be just aarch64-apple-ios + aarch64-apple-ios-sim, as well as xcrun and xcode-select
+    ///
+    /// We don't auto-install these yet since we're not doing an architecture check. We assume most users
+    /// are running on an Apple Silicon Mac, but it would be confusing if we installed these when we actually
+    /// should be installing the x86 versions.
+    async fn verify_ios_tooling(&self) -> Result<()> {
+        // open the simulator
+        // _ = tokio::process::Command::new("open")
+        //     .arg("/Applications/Xcode.app/Contents/Developer/Applications/Simulator.app")
+        //     .output()
+        //     .await;
+
+        // Now xcrun to open the device
+        // todo: we should try and query the device list and/or parse it rather than hardcode this simulator
+        // _ = tokio::process::Command::new("xcrun")
+        //     .args(["simctl", "boot", "83AE3067-987F-4F85-AE3D-7079EF48C967"])
+        //     .output()
+        //     .await;
+
+        // if !rustup
+        //     .installed_toolchains
+        //     .contains(&"aarch64-apple-ios".to_string())
+        // {
+        //     tracing::error!("You need to install aarch64-apple-ios to build for ios. Run `rustup target add aarch64-apple-ios` to install it.");
+        // }
+
+        // if !rustup
+        //     .installed_toolchains
+        //     .contains(&"aarch64-apple-ios-sim".to_string())
+        // {
+        //     tracing::error!("You need to install aarch64-apple-ios to build for ios. Run `rustup target add aarch64-apple-ios` to install it.");
+        // }
+
+        Ok(())
+    }
+
+    /// Check if the android tooling is installed
+    ///
+    /// looks for the android sdk + ndk
+    ///
+    /// will do its best to fill in the missing bits by exploring the sdk structure
+    /// IE will attempt to use the Java installed from android studio if possible.
+    async fn verify_android_tooling(&self) -> Result<()> {
+        let linker = self.workspace.android_tools()?.android_cc(&self.triple);
+
+        tracing::debug!("Verifying android linker: {linker:?}");
+
+        if linker.exists() {
+            return Ok(());
+        }
+
+        Err(anyhow::anyhow!(
+            "Android linker not found. Please set the `ANDROID_NDK_HOME` environment variable to the root of your NDK installation."
+        ).into())
+    }
+
+    /// Ensure the right dependencies are installed for linux apps.
+    /// This varies by distro, so we just do nothing for now.
+    ///
+    /// Eventually, we want to check for the prereqs for wry/tao as outlined by tauri:
+    ///     <https://tauri.app/start/prerequisites/>
+    async fn verify_linux_tooling(&self) -> Result<()> {
+        Ok(())
+    }
+
+    /// update the mtime of the "main" file to bust the fingerprint, forcing rustc to recompile it.
+    ///
+    /// This prevents rustc from using the cached version of the binary, which can cause issues
+    /// with our hotpatching setup since it uses linker interception.
+    ///
+    /// This is sadly a hack. I think there might be other ways of busting the fingerprint (rustc wrapper?)
+    /// but that would require relying on cargo internals.
+    ///
+    /// This might stop working if/when cargo stabilizes contents-based fingerprinting.
+    fn bust_fingerprint(&self, ctx: &BuildContext) -> Result<()> {
+        // if matches!(ctx.mode, BuildMode::Fat | BuildMode::Base) {
+        if !matches!(ctx.mode, BuildMode::Thin { .. }) {
+            std::fs::File::open(&self.crate_target.src_path)?.set_modified(SystemTime::now())?;
+        }
+        Ok(())
+    }
+
+    async fn create_patch_cache(&self, exe: &Path) -> Result<HotpatchModuleCache> {
+        let exe = match self.platform {
+            Platform::Web => self.wasm_bindgen_wasm_output_file(),
+            _ => exe.to_path_buf(),
+        };
+
+        Ok(HotpatchModuleCache::new(&exe, &self.triple)?)
+    }
+
+    /// Users create an index.html for their SPA if they want it
+    ///
+    /// We always write our wasm as main.js and main_bg.wasm
+    ///
+    /// In prod we run the optimizer which bundles everything together properly
+    ///
+    /// So their index.html needs to include main.js in the scripts otherwise nothing happens?
+    ///
+    /// Seems like every platform has a weird file that declares a bunch of stuff
+    /// - web: index.html
+    /// - ios: info.plist
+    /// - macos: info.plist
+    /// - linux: appimage root thing?
+    /// - android: androidmanifest.xml
+    ///
+    /// You also might different variants of these files (staging / prod) and different flavors (eu/us)
+    ///
+    /// web's index.html is weird since it's not just a bundle format but also a *content* format
+    pub(crate) fn prepare_html(
+        &self,
+        assets: &AssetManifest,
+        wasm_path: &str,
+        js_path: &str,
+    ) -> Result<String> {
+        let mut html = {
+            const DEV_DEFAULT_HTML: &str = include_str!("../../assets/web/dev.index.html");
+            const PROD_DEFAULT_HTML: &str = include_str!("../../assets/web/prod.index.html");
+
+            let crate_root: &Path = &self.crate_dir();
+            let custom_html_file = crate_root.join("index.html");
+            let default_html = match self.release {
+                true => PROD_DEFAULT_HTML,
+                false => DEV_DEFAULT_HTML,
+            };
+            std::fs::read_to_string(custom_html_file).unwrap_or_else(|_| String::from(default_html))
+        };
+
+        // Inject any resources from the config into the html
+        self.inject_resources(assets, &mut html)?;
+
+        // Inject loading scripts if they are not already present
+        self.inject_loading_scripts(&mut html);
+
+        // Replace any special placeholders in the HTML with resolved values
+        self.replace_template_placeholders(&mut html, wasm_path, js_path);
+
+        let title = self.config.web.app.title.clone();
+        Self::replace_or_insert_before("{app_title}", "</title", &title, &mut html);
+
+        Ok(html)
+    }
+
+    fn is_dev_build(&self) -> bool {
+        !self.release
+    }
+
+    // Inject any resources from the config into the html
+    fn inject_resources(&self, assets: &AssetManifest, html: &mut String) -> Result<()> {
+        use std::fmt::Write;
+
+        // Collect all resources into a list of styles and scripts
+        let resources = &self.config.web.resource;
+        let mut style_list = resources.style.clone().unwrap_or_default();
+        let mut script_list = resources.script.clone().unwrap_or_default();
+
+        if self.is_dev_build() {
+            style_list.extend(resources.dev.style.iter().cloned());
+            script_list.extend(resources.dev.script.iter().cloned());
+        }
+
+        let mut head_resources = String::new();
+
+        // Add all styles to the head
+        for style in &style_list {
+            writeln!(
+                &mut head_resources,
+                "<link rel=\"stylesheet\" href=\"{}\">",
+                &style.to_str().unwrap(),
+            )?;
+        }
+
+        // Add all scripts to the head
+        for script in &script_list {
+            writeln!(
+                &mut head_resources,
+                "<script src=\"{}\"></script>",
+                &script.to_str().unwrap(),
+            )?;
+        }
+
+        // Add the base path to the head if this is a debug build
+        if self.is_dev_build() {
+            if let Some(base_path) = &self.config.web.app.base_path {
+                head_resources.push_str(&format_base_path_meta_element(base_path));
+            }
+        }
+
+        // Inject any resources from manganis into the head
+        for asset in assets.assets.values() {
+            let asset_path = asset.bundled_path();
+            match asset.options() {
+                AssetOptions::Css(css_options) => {
+                    if css_options.preloaded() {
+                        head_resources.push_str(&format!(
+                            "<link rel=\"preload\" as=\"style\" href=\"/{{base_path}}/assets/{asset_path}\" crossorigin>"
+                        ))
+                    }
+                }
+                AssetOptions::Image(image_options) => {
+                    if image_options.preloaded() {
+                        head_resources.push_str(&format!(
+                            "<link rel=\"preload\" as=\"image\" href=\"/{{base_path}}/assets/{asset_path}\" crossorigin>"
+                        ))
+                    }
+                }
+                AssetOptions::Js(js_options) => {
+                    if js_options.preloaded() {
+                        head_resources.push_str(&format!(
+                            "<link rel=\"preload\" as=\"script\" href=\"/{{base_path}}/assets/{asset_path}\" crossorigin>"
+                        ))
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Manually inject the wasm file for preloading. WASM currently doesn't support preloading in the manganis asset system
+        let wasm_source_path = self.wasm_bindgen_wasm_output_file();
+        if let Some(wasm_path) = assets.assets.get(&wasm_source_path) {
+            let wasm_path = wasm_path.bundled_path();
+            head_resources.push_str(&format!(
+                    "<link rel=\"preload\" as=\"fetch\" type=\"application/wasm\" href=\"/{{base_path}}/assets/{wasm_path}\" crossorigin>"
+                ));
+
+            Self::replace_or_insert_before("{style_include}", "</head", &head_resources, html);
+        }
+
+        Ok(())
+    }
+
+    /// Inject loading scripts if they are not already present
+    fn inject_loading_scripts(&self, html: &mut String) {
+        // If it looks like we are already loading wasm or the current build opted out of injecting loading scripts, don't inject anything
+        if !self.inject_loading_scripts || html.contains("__wbindgen_start") {
+            return;
+        }
+
+        // If not, insert the script
+        *html = html.replace(
+            "</body",
+r#" <script>
+  // We can't use a module script here because we need to start the script immediately when streaming
+  import("/{base_path}/{js_path}").then(
+    ({ default: init, initSync, __wbg_get_imports }) => {
+      // export initSync in case a split module needs to initialize
+      window.__wasm_split_main_initSync = initSync;
+
+      // Actually perform the load
+      init({module_or_path: "/{base_path}/{wasm_path}"}).then((wasm) => {
+        // assign this module to be accessible globally
+        window.__dx_mainWasm = wasm;
+        window.__dx_mainInit = init;
+        window.__dx_mainInitSync = initSync;
+        window.__dx___wbg_get_imports = __wbg_get_imports;
+
+        if (wasm.__wbindgen_start == undefined) {
+            wasm.main();
+        }
+      });
+    }
+  );
+  </script>
+            </body"#,
+        );
+    }
+
+    /// Replace any special placeholders in the HTML with resolved values
+    fn replace_template_placeholders(&self, html: &mut String, wasm_path: &str, js_path: &str) {
+        let base_path = self.config.web.app.base_path();
+        *html = html.replace("{base_path}", base_path);
+
+        let app_name = &self.executable_name();
+
+        // If the html contains the old `{app_name}` placeholder, replace {app_name}_bg.wasm and {app_name}.js
+        // with the new paths
+        *html = html.replace("wasm/{app_name}_bg.wasm", wasm_path);
+        *html = html.replace("wasm/{app_name}.js", js_path);
+
+        // Otherwise replace the new placeholders
+        *html = html.replace("{wasm_path}", wasm_path);
+        *html = html.replace("{js_path}", js_path);
+
+        // Replace the app_name if we find it anywhere standalone
+        *html = html.replace("{app_name}", app_name);
+    }
+
+    /// Replace a string or insert the new contents before a marker
+    fn replace_or_insert_before(
+        replace: &str,
+        or_insert_before: &str,
+        with: &str,
+        content: &mut String,
+    ) {
+        if content.contains(replace) {
+            *content = content.replace(replace, with);
+        } else if let Some(pos) = content.find(or_insert_before) {
+            content.insert_str(pos, with);
+        }
+    }
 }

packages/cli/src/build/templates.rs

@@ -1,7 +0,0 @@
-#[derive(serde::Serialize)]
-pub struct InfoPlistData {
-    pub display_name: String,
-    pub bundle_name: String,
-    pub bundle_identifier: String,
-    pub executable_name: String,
-}

packages/cli/src/build/tools.rs

@@ -0,0 +1,257 @@
+use itertools::Itertools;
+use std::{path::PathBuf, sync::Arc};
+use target_lexicon::{
+    Aarch64Architecture, Architecture, ArmArchitecture, Environment, OperatingSystem, Triple,
+    X86_32Architecture,
+};
+use tokio::process::Command;
+
+/// The tools for Android (ndk, sdk, etc)
+///
+/// https://gist.github.com/Pulimet/5013acf2cd5b28e55036c82c91bd56d8?permalink_comment_id=3678614
+#[derive(Debug, Clone)]
+pub(crate) struct AndroidTools {
+    pub(crate) ndk: PathBuf,
+    pub(crate) adb: PathBuf,
+    pub(crate) java_home: Option<PathBuf>,
+}
+
+pub fn get_android_tools() -> Option<Arc<AndroidTools>> {
+    // We check for SDK first since users might install Android Studio and then install the SDK
+    // After that they might install the NDK, so the SDK drives the source of truth.
+    let sdk = var_or_debug("ANDROID_SDK_ROOT")
+        .or_else(|| var_or_debug("ANDROID_SDK"))
+        .or_else(|| var_or_debug("ANDROID_HOME"));
+
+    // Check the ndk. We look for users's overrides first and then look into the SDK.
+    // Sometimes users set only the NDK (especially if they're somewhat advanced) so we need to look for it manually
+    //
+    // Might look like this, typically under "sdk":
+    // "/Users/jonkelley/Library/Android/sdk/ndk/25.2.9519653/toolchains/llvm/prebuilt/darwin-x86_64/bin/aarch64-linux-android24-clang"
+    let ndk = var_or_debug("NDK_HOME")
+        .or_else(|| var_or_debug("ANDROID_NDK_HOME"))
+        .or_else(|| {
+            // Look for the most recent NDK in the event the user has installed multiple NDK
+            // Eventually we might need to drive this from Dioxus.toml
+            let sdk = sdk.as_ref()?;
+            let ndk_dir = sdk.join("ndk").read_dir().ok()?;
+            ndk_dir
+                .flatten()
+                .map(|dir| (dir.file_name(), dir.path()))
+                .sorted()
+                .next_back()
+                .map(|(_, path)| path.to_path_buf())
+        })?;
+
+    // Look for ADB in the SDK. If it's not there we'll use `adb` from the PATH
+    let adb = sdk
+        .as_ref()
+        .and_then(|sdk| {
+            let tools = sdk.join("platform-tools");
+            if tools.join("adb").exists() {
+                return Some(tools.join("adb"));
+            }
+            if tools.join("adb.exe").exists() {
+                return Some(tools.join("adb.exe"));
+            }
+            None
+        })
+        .unwrap_or_else(|| PathBuf::from("adb"));
+
+    // https://stackoverflow.com/questions/71381050/java-home-is-set-to-an-invalid-directory-android-studio-flutter
+    // always respect the user's JAVA_HOME env var above all other options
+    //
+    // we only attempt autodetection if java_home is not set
+    //
+    // this is a better fallback than falling onto the users' system java home since many users might
+    // not even know which java that is - they just know they have android studio installed
+    let java_home = std::env::var_os("JAVA_HOME")
+        .map(PathBuf::from)
+        .or_else(|| {
+            // Attempt to autodetect java home from the android studio path or jdk path on macos
+            #[cfg(target_os = "macos")]
+            {
+                let jbr_home =
+                    PathBuf::from("/Applications/Android Studio.app/Contents/jbr/Contents/Home/");
+                if jbr_home.exists() {
+                    return Some(jbr_home);
+                }
+
+                let jre_home =
+                    PathBuf::from("/Applications/Android Studio.app/Contents/jre/Contents/Home");
+                if jre_home.exists() {
+                    return Some(jre_home);
+                }
+
+                let jdk_home =
+                    PathBuf::from("/Library/Java/JavaVirtualMachines/openjdk.jdk/Contents/Home/");
+                if jdk_home.exists() {
+                    return Some(jdk_home);
+                }
+            }
+
+            #[cfg(target_os = "windows")]
+            {
+                let jbr_home = PathBuf::from("C:\\Program Files\\Android\\Android Studio\\jbr");
+                if jbr_home.exists() {
+                    return Some(jbr_home);
+                }
+            }
+
+            // todo(jon): how do we detect java home on linux?
+            #[cfg(target_os = "linux")]
+            {
+                let jbr_home = PathBuf::from("/usr/lib/jvm/java-11-openjdk-amd64");
+                if jbr_home.exists() {
+                    return Some(jbr_home);
+                }
+            }
+
+            None
+        });
+
+    Some(Arc::new(AndroidTools {
+        ndk,
+        adb,
+        java_home,
+    }))
+}
+
+impl AndroidTools {
+    pub(crate) fn android_tools_dir(&self) -> PathBuf {
+        let prebuilt = self.ndk.join("toolchains").join("llvm").join("prebuilt");
+
+        if cfg!(target_os = "macos") {
+            // for whatever reason, even on aarch64 macos, the linker is under darwin-x86_64
+            return prebuilt.join("darwin-x86_64").join("bin");
+        }
+
+        if cfg!(target_os = "linux") {
+            return prebuilt.join("linux-x86_64").join("bin");
+        }
+
+        if cfg!(target_os = "windows") {
+            return prebuilt.join("windows-x86_64").join("bin");
+        }
+
+        // Otherwise return the first entry in the prebuilt directory
+        prebuilt
+            .read_dir()
+            .expect("Failed to read android toolchains directory")
+            .next()
+            .expect("Failed to find android toolchains directory")
+            .expect("Failed to read android toolchain file")
+            .path()
+    }
+
+    /// Return the location of the clang toolchain for the given target triple.
+    ///
+    /// Note that we use clang:
+    /// "~/Library/Android/sdk/ndk/25.2.9519653/toolchains/llvm/prebuilt/darwin-x86_64/bin/aarch64-linux-android24-clang"
+    ///
+    /// But if we needed the linker, we would use:
+    /// "~/Library/Android/sdk/ndk/25.2.9519653/toolchains/llvm/prebuilt/darwin-x86_64/bin/ld"
+    ///
+    /// However, for our purposes, we only go through the cc driver and not the linker directly.
+    pub(crate) fn android_cc(&self, triple: &Triple) -> PathBuf {
+        let suffix = if cfg!(target_os = "windows") {
+            ".cmd"
+        } else {
+            ""
+        };
+
+        self.android_tools_dir().join(format!(
+            "{}{}-clang{}",
+            triple,
+            self.min_sdk_version(),
+            suffix
+        ))
+    }
+
+    // todo(jon): this should be configurable
+    pub(crate) fn min_sdk_version(&self) -> u32 {
+        24
+    }
+
+    pub(crate) fn ar_path(&self) -> PathBuf {
+        self.android_tools_dir().join("llvm-ar")
+    }
+
+    pub(crate) fn target_cc(&self) -> PathBuf {
+        self.android_tools_dir().join("clang")
+    }
+
+    pub(crate) fn target_cxx(&self) -> PathBuf {
+        self.android_tools_dir().join("clang++")
+    }
+
+    pub(crate) fn java_home(&self) -> Option<PathBuf> {
+        self.java_home.clone()
+    }
+
+    pub(crate) fn android_jnilib(triple: &Triple) -> &'static str {
+        use target_lexicon::Architecture;
+        match triple.architecture {
+            Architecture::Arm(_) => "armeabi-v7a",
+            Architecture::Aarch64(_) => "arm64-v8a",
+            Architecture::X86_32(_) => "x86",
+            Architecture::X86_64 => "x86_64",
+            _ => unimplemented!("Unsupported architecture"),
+        }
+    }
+
+    pub(crate) async fn autodetect_android_device_triple(&self) -> Triple {
+        // Use the host's triple and then convert field by field
+        // ie, the "best" emulator for an m1 mac would be: "aarch64-linux-android"
+        //  - We assume android is always "linux"
+        //  - We try to match the architecture unless otherwise specified. This is because
+        //    emulators that match the host arch are usually faster.
+        let mut triple = "aarch64-linux-android".parse::<Triple>().unwrap();
+        triple.operating_system = OperatingSystem::Linux;
+        triple.environment = Environment::Android;
+        triple.architecture = target_lexicon::HOST.architecture;
+
+        // TODO: Wire this up with --device flag. (add `-s serial`` flag before `shell` arg)
+        let output = Command::new(&self.adb)
+            .arg("shell")
+            .arg("uname")
+            .arg("-m")
+            .output()
+            .await
+            .map(|out| String::from_utf8(out.stdout));
+
+        match output {
+            Ok(Ok(out)) => match out.trim() {
+                "armv7l" => triple.architecture = Architecture::Arm(ArmArchitecture::Arm),
+                "aarch64" => {
+                    triple.architecture = Architecture::Aarch64(Aarch64Architecture::Aarch64)
+                }
+                "i386" => triple.architecture = Architecture::X86_32(X86_32Architecture::I386),
+                "x86_64" => {
+                    triple.architecture = Architecture::X86_64;
+                }
+                other => {
+                    tracing::warn!("Unknown architecture from adb: {other}");
+                }
+            },
+            Ok(Err(err)) => {
+                tracing::debug!("Failed to parse adb output: {err}");
+            }
+            Err(err) => {
+                tracing::debug!("ADB command failed: {:?}", err);
+            }
+        };
+
+        triple
+    }
+}
+
+fn var_or_debug(name: &str) -> Option<PathBuf> {
+    use std::env::var;
+    use tracing::debug;
+
+    var(name)
+        .inspect_err(|_| debug!("{name} not set"))
+        .ok()
+        .map(PathBuf::from)
+}

packages/cli/src/build/verify.rs

@@ -1,143 +0,0 @@
-use crate::{wasm_bindgen::WasmBindgen, BuildRequest, Error, Platform, Result, RustcDetails};
-use anyhow::{anyhow, Context};
-
-impl BuildRequest {
-    /// Check for tooling that might be required for this build.
-    ///
-    /// This should generally be only called on the first build since it takes time to verify the tooling
-    /// is in place, and we don't want to slow down subsequent builds.
-    pub(crate) async fn verify_tooling(&self) -> Result<()> {
-        tracing::debug!("Verifying tooling...");
-        self.status_installing_tooling();
-
-        self.krate
-            .initialize_profiles()
-            .context("Failed to initialize profiles - dioxus can't build without them. You might need to initialize them yourself.")?;
-
-        let rustc = match RustcDetails::from_cli().await {
-            Ok(out) => out,
-            Err(err) => {
-                tracing::error!("Failed to verify tooling: {err}\ndx will proceed, but you might run into errors later.");
-                return Ok(());
-            }
-        };
-
-        match self.build.platform() {
-            Platform::Web => self.verify_web_tooling(rustc).await?,
-            Platform::Ios => self.verify_ios_tooling(rustc).await?,
-            Platform::Android => self.verify_android_tooling(rustc).await?,
-            Platform::Linux => self.verify_linux_tooling(rustc).await?,
-            Platform::MacOS => {}
-            Platform::Windows => {}
-            Platform::Server => {}
-            Platform::Liveview => {}
-        }
-
-        Ok(())
-    }
-
-    pub(crate) async fn verify_web_tooling(&self, rustc: RustcDetails) -> Result<()> {
-        // Install target using rustup.
-        #[cfg(not(feature = "no-downloads"))]
-        if !rustc.has_wasm32_unknown_unknown() {
-            tracing::info!(
-                "Web platform requires wasm32-unknown-unknown to be installed. Installing..."
-            );
-
-            let _ = tokio::process::Command::new("rustup")
-                .args(["target", "add", "wasm32-unknown-unknown"])
-                .output()
-                .await?;
-        }
-
-        // Ensure target is installed.
-        if !rustc.has_wasm32_unknown_unknown() {
-            return Err(Error::Other(anyhow!(
-                "Missing target wasm32-unknown-unknown."
-            )));
-        }
-
-        // Wasm bindgen
-        let krate_bindgen_version = self.krate.wasm_bindgen_version().ok_or(anyhow!(
-            "failed to detect wasm-bindgen version, unable to proceed"
-        ))?;
-
-        WasmBindgen::verify_install(&krate_bindgen_version).await?;
-
-        Ok(())
-    }
-
-    /// Currently does nothing, but eventually we need to check that the mobile tooling is installed.
-    ///
-    /// For ios, this would be just aarch64-apple-ios + aarch64-apple-ios-sim, as well as xcrun and xcode-select
-    ///
-    /// We don't auto-install these yet since we're not doing an architecture check. We assume most users
-    /// are running on an Apple Silicon Mac, but it would be confusing if we installed these when we actually
-    /// should be installing the x86 versions.
-    pub(crate) async fn verify_ios_tooling(&self, _rustc: RustcDetails) -> Result<()> {
-        // open the simulator
-        // _ = tokio::process::Command::new("open")
-        //     .arg("/Applications/Xcode.app/Contents/Developer/Applications/Simulator.app")
-        //     .stderr(Stdio::piped())
-        //     .stdout(Stdio::piped())
-        //     .status()
-        //     .await;
-
-        // Now xcrun to open the device
-        // todo: we should try and query the device list and/or parse it rather than hardcode this simulator
-        // _ = tokio::process::Command::new("xcrun")
-        //     .args(["simctl", "boot", "83AE3067-987F-4F85-AE3D-7079EF48C967"])
-        //     .stderr(Stdio::piped())
-        //     .stdout(Stdio::piped())
-        //     .status()
-        //     .await;
-
-        // if !rustup
-        //     .installed_toolchains
-        //     .contains(&"aarch64-apple-ios".to_string())
-        // {
-        //     tracing::error!("You need to install aarch64-apple-ios to build for ios. Run `rustup target add aarch64-apple-ios` to install it.");
-        // }
-
-        // if !rustup
-        //     .installed_toolchains
-        //     .contains(&"aarch64-apple-ios-sim".to_string())
-        // {
-        //     tracing::error!("You need to install aarch64-apple-ios to build for ios. Run `rustup target add aarch64-apple-ios` to install it.");
-        // }
-
-        Ok(())
-    }
-
-    /// Check if the android tooling is installed
-    ///
-    /// looks for the android sdk + ndk
-    ///
-    /// will do its best to fill in the missing bits by exploring the sdk structure
-    /// IE will attempt to use the Java installed from android studio if possible.
-    pub(crate) async fn verify_android_tooling(&self, _rustc: RustcDetails) -> Result<()> {
-        let result = self
-            .krate
-            .android_ndk()
-            .map(|ndk| self.build.target_args.arch().android_linker(&ndk));
-
-        if let Some(path) = result {
-            if path.exists() {
-                return Ok(());
-            }
-        }
-
-        Err(anyhow::anyhow!(
-            "Android linker not found. Please set the `ANDROID_NDK_HOME` environment variable to the root of your NDK installation."
-        ).into())
-    }
-
-    /// Ensure the right dependencies are installed for linux apps.
-    /// This varies by distro, so we just do nothing for now.
-    ///
-    /// Eventually, we want to check for the prereqs for wry/tao as outlined by tauri:
-    ///     https://tauri.app/start/prerequisites/
-    pub(crate) async fn verify_linux_tooling(&self, _rustc: RustcDetails) -> Result<()> {
-        Ok(())
-    }
-}

packages/cli/src/build/web.rs

@@ -1,272 +0,0 @@
-use dioxus_cli_config::format_base_path_meta_element;
-use manganis::AssetOptions;
-
-use crate::error::Result;
-use std::fmt::Write;
-use std::path::{Path, PathBuf};
-
-use super::AppBundle;
-
-const DEFAULT_HTML: &str = include_str!("../../assets/web/index.html");
-const TOAST_HTML: &str = include_str!("../../assets/web/toast.html");
-
-impl AppBundle {
-    pub(crate) fn prepare_html(&self) -> Result<String> {
-        let mut html = {
-            let crate_root: &Path = &self.build.krate.crate_dir();
-            let custom_html_file = crate_root.join("index.html");
-            std::fs::read_to_string(custom_html_file).unwrap_or_else(|_| String::from(DEFAULT_HTML))
-        };
-
-        // Inject any resources from the config into the html
-        self.inject_resources(&mut html)?;
-
-        // Inject loading scripts if they are not already present
-        self.inject_loading_scripts(&mut html);
-
-        // Replace any special placeholders in the HTML with resolved values
-        self.replace_template_placeholders(&mut html);
-
-        let title = self.build.krate.config.web.app.title.clone();
-
-        replace_or_insert_before("{app_title}", "</title", &title, &mut html);
-
-        Ok(html)
-    }
-
-    fn is_dev_build(&self) -> bool {
-        !self.build.build.release
-    }
-
-    // Inject any resources from the config into the html
-    fn inject_resources(&self, html: &mut String) -> Result<()> {
-        // Collect all resources into a list of styles and scripts
-        let resources = &self.build.krate.config.web.resource;
-        let mut style_list = resources.style.clone().unwrap_or_default();
-        let mut script_list = resources.script.clone().unwrap_or_default();
-
-        if self.is_dev_build() {
-            style_list.extend(resources.dev.style.iter().cloned());
-            script_list.extend(resources.dev.script.iter().cloned());
-        }
-
-        let mut head_resources = String::new();
-
-        // Add all styles to the head
-        for style in &style_list {
-            writeln!(
-                &mut head_resources,
-                "<link rel=\"stylesheet\" href=\"{}\">",
-                &style.to_str().unwrap(),
-            )?;
-        }
-
-        // Add all scripts to the head
-        for script in &script_list {
-            writeln!(
-                &mut head_resources,
-                "<script src=\"{}\"></script>",
-                &script.to_str().unwrap(),
-            )?;
-        }
-
-        // Add the base path to the head if this is a debug build
-        if self.is_dev_build() {
-            if let Some(base_path) = &self.build.krate.config.web.app.base_path {
-                head_resources.push_str(&format_base_path_meta_element(base_path));
-            }
-        }
-
-        if !style_list.is_empty() {
-            self.send_resource_deprecation_warning(style_list, ResourceType::Style);
-        }
-        if !script_list.is_empty() {
-            self.send_resource_deprecation_warning(script_list, ResourceType::Script);
-        }
-
-        // Inject any resources from manganis into the head
-        for asset in self.app.assets.assets.values() {
-            let asset_path = asset.bundled_path();
-            match asset.options() {
-                AssetOptions::Css(css_options) => {
-                    if css_options.preloaded() {
-                        head_resources.push_str(&format!(
-                            "<link rel=\"preload\" as=\"style\" href=\"/{{base_path}}/assets/{asset_path}\" crossorigin>"
-                        ))
-                    }
-                }
-                AssetOptions::Image(image_options) => {
-                    if image_options.preloaded() {
-                        head_resources.push_str(&format!(
-                            "<link rel=\"preload\" as=\"image\" href=\"/{{base_path}}/assets/{asset_path}\" crossorigin>"
-                        ))
-                    }
-                }
-                AssetOptions::Js(js_options) => {
-                    if js_options.preloaded() {
-                        head_resources.push_str(&format!(
-                            "<link rel=\"preload\" as=\"script\" href=\"/{{base_path}}/assets/{asset_path}\" crossorigin>"
-                        ))
-                    }
-                }
-                _ => {}
-            }
-        }
-        // Manually inject the wasm file for preloading. WASM currently doesn't support preloading in the manganis asset system
-        let wasm_source_path = self.build.wasm_bindgen_wasm_output_file();
-        let wasm_path = self
-            .app
-            .assets
-            .assets
-            .get(&wasm_source_path)
-            .expect("WASM asset should exist in web bundles")
-            .bundled_path();
-        head_resources.push_str(&format!(
-            "<link rel=\"preload\" as=\"fetch\" type=\"application/wasm\" href=\"/{{base_path}}/assets/{wasm_path}\" crossorigin>"
-        ));
-
-        replace_or_insert_before("{style_include}", "</head", &head_resources, html);
-
-        Ok(())
-    }
-
-    /// Inject loading scripts if they are not already present
-    fn inject_loading_scripts(&self, html: &mut String) {
-        // If it looks like we are already loading wasm or the current build opted out of injecting loading scripts, don't inject anything
-        if !self.build.build.inject_loading_scripts || html.contains("__wbindgen_start") {
-            return;
-        }
-
-        // If not, insert the script
-        *html = html.replace(
-            "</body",
-r#" <script>
-  // We can't use a module script here because we need to start the script immediately when streaming
-  import("/{base_path}/{js_path}").then(
-    ({ default: init, initSync }) => {
-      // export initSync in case a split module needs to initialize
-      window.__wasm_split_main_initSync = initSync;
-
-      // Actually perform the load
-      init({module_or_path: "/{base_path}/{wasm_path}"}).then((wasm) => {
-        if (wasm.__wbindgen_start == undefined) {
-            wasm.main();
-        }
-      });
-    }
-  );
-  </script>
-  {DX_TOAST_UTILITIES}
-            </body"#,
-        );
-
-        // Trim out the toasts if we're in release, or add them if we're serving
-        *html = match self.is_dev_build() {
-            true => html.replace("{DX_TOAST_UTILITIES}", TOAST_HTML),
-            false => html.replace("{DX_TOAST_UTILITIES}", ""),
-        };
-    }
-
-    /// Replace any special placeholders in the HTML with resolved values
-    fn replace_template_placeholders(&self, html: &mut String) {
-        let base_path = self.build.krate.config.web.app.base_path();
-        *html = html.replace("{base_path}", base_path);
-
-        let app_name = &self.build.krate.executable_name();
-        let wasm_source_path = self.build.wasm_bindgen_wasm_output_file();
-        let wasm_path = self
-            .app
-            .assets
-            .assets
-            .get(&wasm_source_path)
-            .expect("WASM asset should exist in web bundles")
-            .bundled_path();
-        let wasm_path = format!("assets/{wasm_path}");
-        let js_source_path = self.build.wasm_bindgen_js_output_file();
-        let js_path = self
-            .app
-            .assets
-            .assets
-            .get(&js_source_path)
-            .expect("JS asset should exist in web bundles")
-            .bundled_path();
-        let js_path = format!("assets/{js_path}");
-
-        // If the html contains the old `{app_name}` placeholder, replace {app_name}_bg.wasm and {app_name}.js
-        // with the new paths
-        *html = html.replace("wasm/{app_name}_bg.wasm", &wasm_path);
-        *html = html.replace("wasm/{app_name}.js", &js_path);
-        // Otherwise replace the new placeholders
-        *html = html.replace("{wasm_path}", &wasm_path);
-        *html = html.replace("{js_path}", &js_path);
-        // Replace the app_name if we find it anywhere standalone
-        *html = html.replace("{app_name}", app_name);
-    }
-
-    fn send_resource_deprecation_warning(&self, paths: Vec<PathBuf>, variant: ResourceType) {
-        const RESOURCE_DEPRECATION_MESSAGE: &str = r#"The `web.resource` config has been deprecated in favor of head components and will be removed in a future release. Instead of including assets in the config, you can include assets with the `asset!` macro and add them to the head with `document::Link` and `Script` components."#;
-
-        let replacement_components = paths
-            .iter()
-            .map(|path| {
-                let path = if path.exists() {
-                    path.to_path_buf()
-                } else {
-                    // If the path is absolute, make it relative to the current directory before we join it
-                    // The path is actually a web path which is relative to the root of the website
-                    let path = path.strip_prefix("/").unwrap_or(path);
-                    let asset_dir_path = self
-                        .build
-                        .krate
-                        .legacy_asset_dir()
-                        .map(|dir| dir.join(path).canonicalize());
-
-                    if let Some(Ok(absolute_path)) = asset_dir_path {
-                        let absolute_crate_root =
-                            self.build.krate.crate_dir().canonicalize().unwrap();
-                        PathBuf::from("./")
-                            .join(absolute_path.strip_prefix(absolute_crate_root).unwrap())
-                    } else {
-                        path.to_path_buf()
-                    }
-                };
-                match variant {
-                    ResourceType::Style => {
-                        format!("    Stylesheet {{ href: asset!(\"{}\") }}", path.display())
-                    }
-                    ResourceType::Script => {
-                        format!("    Script {{ src: asset!(\"{}\") }}", path.display())
-                    }
-                }
-            })
-            .collect::<Vec<_>>();
-        let replacement_components = format!("rsx! {{\n{}\n}}", replacement_components.join("\n"));
-        let section_name = match variant {
-            ResourceType::Style => "web.resource.style",
-            ResourceType::Script => "web.resource.script",
-        };
-
-        tracing::warn!(
-            "{RESOURCE_DEPRECATION_MESSAGE}\nTo migrate to head components, remove `{section_name}` and include the following rsx in your root component:\n```rust\n{replacement_components}\n```"
-        );
-    }
-}
-
-enum ResourceType {
-    Style,
-    Script,
-}
-
-/// Replace a string or insert the new contents before a marker
-fn replace_or_insert_before(
-    replace: &str,
-    or_insert_before: &str,
-    with: &str,
-    content: &mut String,
-) {
-    if content.contains(replace) {
-        *content = content.replace(replace, with);
-    } else if let Some(pos) = content.find(or_insert_before) {
-        content.insert_str(pos, with);
-    }
-}

packages/cli/src/cli/autoformat.rs

@@ -1,5 +1,5 @@
-use super::*;
-use crate::{metadata::collect_rs_files, DioxusCrate};
+use super::{check::collect_rs_files, *};
+use crate::Workspace;
 use anyhow::Context;
 use dioxus_autofmt::{IndentOptions, IndentType};
 use rayon::prelude::*;
@@ -38,7 +38,7 @@ pub(crate) struct Autoformat {
 }
 
 impl Autoformat {
-    pub(crate) fn autoformat(self) -> Result<StructuredOutput> {
+    pub(crate) async fn autoformat(self) -> Result<StructuredOutput> {
         let Autoformat {
             check,
             raw,
@@ -62,15 +62,16 @@ impl Autoformat {
         } else {
             // Default to formatting the project.
             let crate_dir = if let Some(package) = self.package {
-                // TODO (matt): Do we need to use the entire `DioxusCrate` here?
-                let target_args = TargetArgs {
-                    package: Some(package),
-                    ..Default::default()
-                };
-                let dx_crate =
-                    DioxusCrate::new(&target_args).context("failed to parse crate graph")?;
-
-                Cow::Owned(dx_crate.crate_dir())
+                let workspace = Workspace::current().await?;
+                let dx_crate = workspace
+                    .find_main_package(Some(package))
+                    .context("Failed to find package")?;
+                workspace.krates[dx_crate]
+                    .manifest_path
+                    .parent()
+                    .unwrap()
+                    .to_path_buf()
+                    .into()
             } else {
                 Cow::Borrowed(Path::new("."))
             };
@@ -171,7 +172,8 @@ fn autoformat_project(
     format_rust_code: bool,
     dir: impl AsRef<Path>,
 ) -> Result<()> {
-    let files_to_format = collect_rs_files(dir);
+    let mut files_to_format = vec![];
+    collect_rs_files(dir.as_ref(), &mut files_to_format);
 
     if files_to_format.is_empty() {
         return Ok(());
@@ -297,5 +299,5 @@ async fn test_auto_fmt() {
         package: None,
     };
 
-    fmt.autoformat().unwrap();
+    fmt.autoformat().await.unwrap();
 }

packages/cli/src/cli/build.rs

@@ -1,207 +1,177 @@
-use super::*;
-use crate::{Builder, DioxusCrate, Platform, PROFILE_SERVER};
+use crate::{cli::*, AppBuilder, BuildRequest, Workspace, PROFILE_SERVER};
+use crate::{BuildMode, Platform};
+use target_lexicon::Triple;
+
+use super::target::{TargetArgs, TargetCmd};
 
 /// Build the Rust Dioxus app and all of its assets.
 ///
-/// Produces a final output bundle designed to be run on the target platform.
-#[derive(Clone, Debug, Default, Deserialize, Parser)]
-pub(crate) struct BuildArgs {
-    /// Build in release mode [default: false]
-    #[clap(long, short)]
-    #[serde(default)]
-    pub(crate) release: bool,
-
-    /// This flag only applies to fullstack builds. By default fullstack builds will run the server and client builds in parallel. This flag will force the build to run the server build first, then the client build. [default: false]
+/// Produces a final output build. If a "server" feature is present in the package's Cargo.toml, it will
+/// be considered a fullstack app and the server will be built as well.
+#[derive(Clone, Debug, Default, Parser)]
+pub struct BuildArgs {
+    /// Enable fullstack mode [default: false]
+    ///
+    /// This is automatically detected from `dx serve` if the "fullstack" feature is enabled by default.
+    #[clap(long)]
+    pub(crate) fullstack: Option<bool>,
+
+    /// The feature to use for the client in a fullstack app [default: "web"]
     #[clap(long)]
-    #[serde(default)]
-    pub(crate) force_sequential: bool,
+    pub(crate) client_features: Vec<String>,
 
-    /// Build the app with custom a profile
+    /// The feature to use for the server in a fullstack app [default: "server"]
     #[clap(long)]
-    pub(crate) profile: Option<String>,
+    pub(crate) server_features: Vec<String>,
 
     /// Build with custom profile for the fullstack server
     #[clap(long, default_value_t = PROFILE_SERVER.to_string())]
     pub(crate) server_profile: String,
 
-    /// Build platform: support Web & Desktop [default: "default_platform"]
-    #[clap(long, value_enum)]
-    pub(crate) platform: Option<Platform>,
-
-    /// Build the fullstack variant of this app, using that as the fileserver and backend
+    /// The target to build for the server.
     ///
-    /// This defaults to `false` but will be overridden to true if the `fullstack` feature is enabled.
-    #[arg(long, default_missing_value="true", num_args=0..=1)]
-    pub(crate) fullstack: Option<bool>,
-
-    /// Run the ssg config of the app and generate the files
-    #[clap(long)]
-    pub(crate) ssg: bool,
-
-    /// Skip collecting assets from dependencies [default: false]
+    /// This can be different than the host allowing cross-compilation of the server. This is useful for
+    /// platforms like Cloudflare Workers where the server is compiled to wasm and then uploaded to the edge.
     #[clap(long)]
-    #[serde(default)]
-    pub(crate) skip_assets: bool,
+    pub(crate) server_target: Option<Triple>,
 
-    /// Extra arguments passed to cargo build
-    #[clap(last = true)]
-    pub(crate) cargo_args: Vec<String>,
-
-    /// Inject scripts to load the wasm and js files for your dioxus app if they are not already present [default: true]
-    #[clap(long, default_value_t = true)]
-    pub(crate) inject_loading_scripts: bool,
-
-    /// Experimental: Bundle split the wasm binary into multiple chunks based on `#[wasm_split]` annotations [default: false]
-    #[clap(long, default_value_t = false)]
-    pub(crate) experimental_wasm_split: bool,
+    /// Arguments for the build itself
+    #[clap(flatten)]
+    pub(crate) build_arguments: TargetArgs,
 
-    /// Generate debug symbols for the wasm binary [default: true]
+    /// A list of additional targets to build.
     ///
-    /// This will make the binary larger and take longer to compile, but will allow you to debug the
-    /// wasm binary
-    #[clap(long, default_value_t = true)]
-    pub(crate) debug_symbols: bool,
+    /// Server and Client are special targets that integrate with `dx serve`, while `crate` is a generic.
+    ///
+    /// ```
+    /// dx serve \
+    ///     client --target aarch64-apple-darwin \
+    ///     server --target wasm32-unknown-unknown \
+    ///     crate --target aarch64-unknown-linux-gnu --package foo \
+    ///     crate --target x86_64-unknown-linux-gnu --package bar
+    /// ```
+    #[command(subcommand)]
+    pub(crate) targets: Option<TargetCmd>,
+}
 
-    /// Information about the target to build
-    #[clap(flatten)]
-    pub(crate) target_args: TargetArgs,
+pub struct BuildTargets {
+    pub client: BuildRequest,
+    pub server: Option<BuildRequest>,
 }
 
 impl BuildArgs {
-    pub async fn run_cmd(mut self) -> Result<StructuredOutput> {
+    pub async fn build(self) -> Result<StructuredOutput> {
         tracing::info!("Building project...");
 
-        let krate =
-            DioxusCrate::new(&self.target_args).context("Failed to load Dioxus workspace")?;
-
-        self.resolve(&krate).await?;
+        let targets = self.into_targets().await?;
 
-        let bundle = Builder::start(&krate, self.clone())?.finish().await?;
+        AppBuilder::start(&targets.client, BuildMode::Base)?
+            .finish_build()
+            .await?;
 
-        tracing::info!(path = ?bundle.build.root_dir(), "Build completed successfully! 🚀");
-
-        Ok(StructuredOutput::BuildFinished {
-            path: bundle.build.root_dir(),
-        })
-    }
+        tracing::info!(path = ?targets.client.root_dir(), "Client build completed successfully! 🚀");
 
-    /// Update the arguments of the CLI by inspecting the DioxusCrate itself and learning about how
-    /// the user has configured their app.
-    ///
-    /// IE if they've specified "fullstack" as a feature on `dioxus`, then we want to build the
-    /// fullstack variant even if they omitted the `--fullstack` flag.
-    pub(crate) async fn resolve(&mut self, krate: &DioxusCrate) -> Result<()> {
-        let default_platforms = krate.default_platforms();
-        let default_platform = default_platforms.iter().find(|p| **p != Platform::Server);
-        let default_server = default_platforms.iter().any(|p| *p == Platform::Server);
-        let auto_platform = krate.autodetect_platform();
-
-        // Make sure we set the fullstack platform so we actually build the fullstack variant
-        // Users need to enable "fullstack" in their default feature set or explicitly pass the flag
-        self.fullstack = Some(
-            self.fullstack()
-                || self.fullstack.is_none()
-                    && (default_server || krate.has_dioxus_feature("fullstack")),
-        );
-
-        // If the current build is a fullstack build which includes either the client or the server in the default features,
-        // remove that default feature and just add it back into the client or server args. If they passed in an explicit platform
-        // but they also have a default feature platform, strip out the default features and add back in the platform they passed in.
-        if self.fullstack() && (default_server || default_platform.is_some())
-            || self.platform.is_some() && default_platform.is_some()
-        {
-            self.target_args.no_default_features = true;
-            self.target_args
-                .features
-                .extend(krate.platformless_features());
-        }
+        if let Some(server) = targets.server.as_ref() {
+            // If the server is present, we need to build it as well
+            AppBuilder::start(server, BuildMode::Base)?
+                .finish_build()
+                .await?;
 
-        // Inherit the platform from the args, or auto-detect it
-        if self.platform.is_none() {
-            let (platform, _feature) = auto_platform.ok_or_else(|| {
-                anyhow::anyhow!("No platform was specified and could not be auto-detected. Please specify a platform with `--platform <platform>` or set a default platform using a cargo feature.")
-            })?;
-            self.platform = Some(platform);
+            tracing::info!(path = ?targets.client.root_dir(), "Server build completed successfully! 🚀");
         }
 
-        let platform = self
-            .platform
-            .expect("Platform to be set after autodetection");
-
-        // Add any features required to turn on the client
-        self.target_args
-            .client_features
-            .push(krate.feature_for_platform(platform));
-
-        // Add any features required to turn on the server
-        // This won't take effect in the server is not built, so it's fine to just set it here even if it's not used
-        self.target_args
-            .server_features
-            .push(krate.feature_for_platform(Platform::Server));
-
-        // Make sure we have a server feature if we're building a fullstack app
-        //
-        // todo(jon): eventually we want to let users pass a `--server <crate>` flag to specify a package to use as the server
-        // however, it'll take some time to support that and we don't have a great RPC binding layer between the two yet
-        if self.fullstack() && self.target_args.server_features.is_empty() {
-            return Err(anyhow::anyhow!("Fullstack builds require a server feature on the target crate. Add a `server` feature to the crate and try again.").into());
-        }
+        Ok(StructuredOutput::BuildsFinished {
+            client: targets.client.root_dir(),
+            server: targets.server.map(|s| s.root_dir()),
+        })
+    }
 
-        // Set the profile of the build if it's not already set
-        // We do this for android/wasm since they require
-        if self.profile.is_none() && !self.release {
-            match self.platform {
-                Some(Platform::Android) => {
-                    self.profile = Some(crate::dioxus_crate::PROFILE_ANDROID.to_string());
-                }
-                Some(Platform::Web) => {
-                    self.profile = Some(crate::dioxus_crate::PROFILE_WASM.to_string());
-                }
-                Some(Platform::Server) => {
-                    self.profile = Some(crate::dioxus_crate::PROFILE_SERVER.to_string());
+    pub async fn into_targets(self) -> Result<BuildTargets> {
+        let workspace = Workspace::current().await?;
+
+        let mut server = None;
+
+        let client = match self.targets {
+            // A simple `dx serve` command with no explicit targets
+            None => {
+                // Now resolve the builds that we need to.
+                // These come from the args, but we'd like them to come from the `TargetCmd` chained object
+                //
+                // The process here is as follows:
+                //
+                // - Create the BuildRequest for the primary target
+                // - If that BuildRequest is "fullstack", then add the client features
+                // - If that BuildRequest is "fullstack", then also create a BuildRequest for the server
+                //   with the server features
+                //
+                // This involves modifying the BuildRequest to add the client features and server features
+                // only if we can properly detect that it's a fullstack build. Careful with this, since
+                // we didn't build BuildRequest to be generally mutable.
+                let client = BuildRequest::new(&self.build_arguments, workspace.clone()).await?;
+                let default_server = client
+                    .enabled_platforms
+                    .iter()
+                    .any(|p| *p == Platform::Server);
+
+                // Make sure we set the fullstack platform so we actually build the fullstack variant
+                // Users need to enable "fullstack" in their default feature set.
+                // todo(jon): fullstack *could* be a feature of the app, but right now we're assuming it's always enabled
+                //
+                // Now we need to resolve the client features
+                let fullstack = ((default_server || client.fullstack_feature_enabled())
+                    || self.fullstack.unwrap_or(false))
+                    && self.fullstack != Some(false);
+
+                if fullstack {
+                    let mut build_args = self.build_arguments.clone();
+                    build_args.platform = Some(Platform::Server);
+
+                    let _server = BuildRequest::new(&build_args, workspace.clone()).await?;
+
+                    // ... todo: add the server features to the server build
+                    // ... todo: add the client features to the client build
+                    // // Make sure we have a server feature if we're building a fullstack app
+                    if self.fullstack.unwrap_or_default() && self.server_features.is_empty() {
+                        return Err(anyhow::anyhow!("Fullstack builds require a server feature on the target crate. Add a `server` feature to the crate and try again.").into());
+                    }
+
+                    server = Some(_server);
                 }
-                _ => {}
-            }
-        }
 
-        // Determine arch if android
-        if self.platform == Some(Platform::Android) && self.target_args.arch.is_none() {
-            tracing::debug!("No android arch provided, attempting to auto detect.");
-
-            let arch = DioxusCrate::autodetect_android_arch().await;
+                client
+            }
 
-            // Some extra logs
-            let arch = match arch {
-                Some(a) => {
-                    tracing::debug!(
-                        "Autodetected `{}` Android arch.",
-                        a.android_target_triplet()
-                    );
-                    a.to_owned()
-                }
-                None => {
-                    let a = Arch::default();
-                    tracing::debug!(
-                        "Could not detect Android arch, defaulting to `{}`",
-                        a.android_target_triplet()
-                    );
-                    a
+            // A command in the form of:
+            // ```
+            // dx serve \
+            //     client --package frontend \
+            //     server --package backend
+            // ```
+            Some(cmd) => {
+                let mut client_args_ = None;
+                let mut server_args_ = None;
+                let mut cmd_outer = Some(Box::new(cmd));
+                while let Some(cmd) = cmd_outer.take() {
+                    match *cmd {
+                        TargetCmd::Client(cmd_) => {
+                            client_args_ = Some(cmd_.inner);
+                            cmd_outer = cmd_.next;
+                        }
+                        TargetCmd::Server(cmd) => {
+                            server_args_ = Some(cmd.inner);
+                            cmd_outer = cmd.next;
+                        }
+                    }
                 }
-            };
-
-            self.target_args.arch = Some(arch);
-        }
 
-        Ok(())
-    }
+                if let Some(server_args) = server_args_ {
+                    server = Some(BuildRequest::new(&server_args, workspace.clone()).await?);
+                }
 
-    /// Get the platform from the build arguments
-    pub(crate) fn platform(&self) -> Platform {
-        self.platform.expect("Platform was not set")
-    }
+                BuildRequest::new(&client_args_.unwrap(), workspace.clone()).await?
+            }
+        };
 
-    /// Check if this is a fullstack build
-    pub(crate) fn fullstack(&self) -> bool {
-        self.fullstack.unwrap_or(false)
+        Ok(BuildTargets { client, server })
     }
 }

packages/cli/src/cli/bundle.rs

@@ -1,13 +1,24 @@
-use crate::{AppBundle, BuildArgs, Builder, DioxusCrate, Platform};
+use crate::{AppBuilder, BuildArgs, BuildMode, BuildRequest, Platform};
 use anyhow::{anyhow, Context};
+use dioxus_cli_config::{server_ip, server_port};
+use futures_util::stream::FuturesUnordered;
+use futures_util::StreamExt;
 use path_absolutize::Absolutize;
 use std::collections::HashMap;
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    path::Path,
+    time::Duration,
+};
 use tauri_bundler::{BundleBinary, BundleSettings, PackageSettings, SettingsBuilder};
+use tokio::process::Command;
 use walkdir::WalkDir;
 
 use super::*;
 
-/// Bundle the Rust desktop app and all of its assets
+/// Bundle an app and its assets.
+///
+/// This will produce a client `public` folder and the associated server executable in the output folder.
 #[derive(Clone, Debug, Parser)]
 pub struct Bundle {
     /// The package types to bundle
@@ -24,61 +35,76 @@ pub struct Bundle {
     #[clap(long)]
     pub out_dir: Option<PathBuf>,
 
+    /// Build the fullstack variant of this app, using that as the fileserver and backend
+    ///
+    /// This defaults to `false` but will be overridden to true if the `fullstack` feature is enabled.
+    #[clap(long)]
+    pub(crate) fullstack: bool,
+
+    /// Run the ssg config of the app and generate the files
+    #[clap(long)]
+    pub(crate) ssg: bool,
+
     /// The arguments for the dioxus build
     #[clap(flatten)]
-    pub(crate) build_arguments: BuildArgs,
+    pub(crate) args: BuildArgs,
 }
 
 impl Bundle {
+    // todo: make sure to run pre-render static routes! we removed this from the other bundling step
     pub(crate) async fn bundle(mut self) -> Result<StructuredOutput> {
         tracing::info!("Bundling project...");
 
-        let krate = DioxusCrate::new(&self.build_arguments.target_args)
-            .context("Failed to load Dioxus workspace")?;
+        let BuildTargets { client, server } = self.args.into_targets().await?;
 
-        // We always use `release` mode for bundling
-        self.build_arguments.release = true;
-        self.build_arguments.resolve(&krate).await?;
+        AppBuilder::start(&client, BuildMode::Base)?
+            .finish_build()
+            .await?;
 
-        tracing::info!("Building app...");
+        tracing::info!(path = ?client.root_dir(), "Client build completed successfully! 🚀");
 
-        let bundle = Builder::start(&krate, self.build_arguments.clone())?
-            .finish()
-            .await?;
+        if let Some(server) = server.as_ref() {
+            // If the server is present, we need to build it as well
+            AppBuilder::start(server, BuildMode::Base)?
+                .finish_build()
+                .await?;
+
+            tracing::info!(path = ?client.root_dir(), "Server build completed successfully! 🚀");
+        }
 
         // If we're building for iOS, we need to bundle the iOS bundle
-        if self.build_arguments.platform() == Platform::Ios && self.package_types.is_none() {
+        if client.platform == Platform::Ios && self.package_types.is_none() {
             self.package_types = Some(vec![crate::PackageType::IosBundle]);
         }
 
         let mut bundles = vec![];
 
         // Copy the server over if it exists
-        if bundle.build.build.fullstack() {
-            bundles.push(bundle.server_exe().unwrap());
+        if let Some(server) = server.as_ref() {
+            bundles.push(server.main_exe());
         }
 
         // Create a list of bundles that we might need to copy
-        match self.build_arguments.platform() {
+        match client.platform {
             // By default, mac/win/linux work with tauri bundle
             Platform::MacOS | Platform::Linux | Platform::Windows => {
                 tracing::info!("Running desktop bundler...");
-                for bundle in self.bundle_desktop(&krate, &bundle)? {
+                for bundle in Self::bundle_desktop(&client, &self.package_types)? {
                     bundles.extend(bundle.bundle_paths);
                 }
             }
 
             // Web/ios can just use their root_dir
-            Platform::Web => bundles.push(bundle.build.root_dir()),
+            Platform::Web => bundles.push(client.root_dir()),
             Platform::Ios => {
                 tracing::warn!("iOS bundles are not currently codesigned! You will need to codesign the app before distributing.");
-                bundles.push(bundle.build.root_dir())
+                bundles.push(client.root_dir())
             }
-            Platform::Server => bundles.push(bundle.build.root_dir()),
-            Platform::Liveview => bundles.push(bundle.build.root_dir()),
+            Platform::Server => bundles.push(client.root_dir()),
+            Platform::Liveview => bundles.push(client.root_dir()),
 
             Platform::Android => {
-                let aab = bundle
+                let aab = client
                     .android_gradle_bundle()
                     .await
                     .context("Failed to run gradle bundleRelease")?;
@@ -87,7 +113,7 @@ impl Bundle {
         };
 
         // Copy the bundles to the output directory if one was specified
-        let crate_outdir = bundle.build.krate.crate_out_dir();
+        let crate_outdir = client.crate_out_dir();
         if let Some(outdir) = self.out_dir.clone().or(crate_outdir) {
             let outdir = outdir
                 .absolutize()
@@ -127,35 +153,43 @@ impl Bundle {
             );
         }
 
+        // Run SSG and cache static routes
+        if self.ssg {
+            if let Some(server) = server.as_ref() {
+                tracing::info!("Running SSG for static routes...");
+                Self::pre_render_static_routes(&server.main_exe()).await?;
+                tracing::info!("SSG complete");
+            } else {
+                tracing::error!("SSG is only supported for fullstack apps. Ensure you have the server feature enabled and try again.");
+            }
+        }
+
         Ok(StructuredOutput::BundleOutput { bundles })
     }
 
     fn bundle_desktop(
-        &self,
-        krate: &DioxusCrate,
-        bundle: &AppBundle,
+        build: &BuildRequest,
+        package_types: &Option<Vec<crate::PackageType>>,
     ) -> Result<Vec<tauri_bundler::Bundle>, Error> {
-        _ = std::fs::remove_dir_all(krate.bundle_dir(self.build_arguments.platform()));
+        let krate = &build;
+        let exe = build.main_exe();
+
+        _ = std::fs::remove_dir_all(krate.bundle_dir(build.platform));
 
         let package = krate.package();
         let mut name: PathBuf = krate.executable_name().into();
         if cfg!(windows) {
             name.set_extension("exe");
         }
-        std::fs::create_dir_all(krate.bundle_dir(self.build_arguments.platform()))
+        std::fs::create_dir_all(krate.bundle_dir(build.platform))
             .context("Failed to create bundle directory")?;
-        std::fs::copy(
-            &bundle.app.exe,
-            krate
-                .bundle_dir(self.build_arguments.platform())
-                .join(&name),
-        )
-        .with_context(|| "Failed to copy the output executable into the bundle directory")?;
+        std::fs::copy(&exe, krate.bundle_dir(build.platform).join(&name))
+            .with_context(|| "Failed to copy the output executable into the bundle directory")?;
 
         let binaries = vec![
             // We use the name of the exe but it has to be in the same directory
             BundleBinary::new(krate.executable_name().to_string(), true)
-                .set_src_path(Some(bundle.app.exe.display().to_string())),
+                .set_src_path(Some(exe.display().to_string())),
         ];
 
         let mut bundle_settings: BundleSettings = krate.config.bundle.clone().into();
@@ -186,7 +220,7 @@ impl Bundle {
             bundle_settings.resources_map = Some(HashMap::new());
         }
 
-        let asset_dir = bundle.build.asset_dir();
+        let asset_dir = build.asset_dir();
         if asset_dir.exists() {
             for entry in WalkDir::new(&asset_dir) {
                 let entry = entry.unwrap();
@@ -218,7 +252,7 @@ impl Bundle {
         }
 
         let mut settings = SettingsBuilder::new()
-            .project_out_directory(krate.bundle_dir(self.build_arguments.platform()))
+            .project_out_directory(krate.bundle_dir(build.platform))
             .package_settings(PackageSettings {
                 product_name: krate.bundled_app_name(),
                 version: package.version.to_string(),
@@ -231,17 +265,11 @@ impl Bundle {
             .binaries(binaries)
             .bundle_settings(bundle_settings);
 
-        if let Some(packages) = &self.package_types {
+        if let Some(packages) = &package_types {
             settings = settings.package_types(packages.iter().map(|p| (*p).into()).collect());
         }
 
-        if let Some(target) = self.build_arguments.target_args.target.as_ref() {
-            settings = settings.target(target.to_string());
-        }
-
-        if self.build_arguments.platform() == Platform::Ios {
-            settings = settings.target("aarch64-apple-ios".to_string());
-        }
+        settings = settings.target(build.triple.to_string());
 
         let settings = settings
             .build()
@@ -260,4 +288,121 @@ impl Bundle {
 
         Ok(bundles)
     }
+
+    /// Pre-render the static routes, performing static-site generation
+    async fn pre_render_static_routes(server_exe: &Path) -> anyhow::Result<()> {
+        // Use the address passed in through environment variables or default to localhost:9999. We need
+        // to default to a value that is different than the CLI default address to avoid conflicts
+        let ip = server_ip().unwrap_or_else(|| IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
+        let port = server_port().unwrap_or(9999);
+        let fullstack_address = SocketAddr::new(ip, port);
+        let address = fullstack_address.ip().to_string();
+        let port = fullstack_address.port().to_string();
+
+        // Borrow port and address so we can easily moe them into multiple tasks below
+        let address = &address;
+        let port = &port;
+
+        tracing::info!("Running SSG at http://{address}:{port} for {server_exe:?}");
+
+        // Run the server executable
+        let _child = Command::new(server_exe)
+            .env(dioxus_cli_config::SERVER_PORT_ENV, port)
+            .env(dioxus_cli_config::SERVER_IP_ENV, address)
+            .current_dir(server_exe.parent().unwrap())
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .kill_on_drop(true)
+            .spawn()?;
+
+        // Borrow reqwest_client so we only move the reference into the futures
+        let reqwest_client = reqwest::Client::new();
+        let reqwest_client = &reqwest_client;
+
+        // Get the routes from the `/static_routes` endpoint
+        let mut routes = None;
+
+        // The server may take a few seconds to start up. Try fetching the route up to 5 times with a one second delay
+        const RETRY_ATTEMPTS: usize = 5;
+        for i in 0..=RETRY_ATTEMPTS {
+            tracing::debug!(
+                "Attempting to get static routes from server. Attempt {i} of {RETRY_ATTEMPTS}"
+            );
+
+            let request = reqwest_client
+                .post(format!("http://{address}:{port}/api/static_routes"))
+                .body("{}".to_string())
+                .send()
+                .await;
+            match request {
+                Ok(request) => {
+                    routes = Some(request
+                    .json::<Vec<String>>()
+                    .await
+                    .inspect(|text| tracing::debug!("Got static routes: {text:?}"))
+                    .context("Failed to parse static routes from the server. Make sure your server function returns Vec<String> with the (default) json encoding")?);
+                    break;
+                }
+                Err(err) => {
+                    // If the request fails, try  up to 5 times with a one second delay
+                    // If it fails 5 times, return the error
+                    if i == RETRY_ATTEMPTS {
+                        return Err(err).context("Failed to get static routes from server. Make sure you have a server function at the `/api/static_routes` endpoint that returns Vec<String> of static routes.");
+                    }
+                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                }
+            }
+        }
+
+        let routes = routes.expect(
+            "static routes should exist or an error should have been returned on the last attempt",
+        );
+
+        // Create a pool of futures that cache each route
+        let mut resolved_routes = routes
+            .into_iter()
+            .map(|route| async move {
+                tracing::info!("Rendering {route} for SSG");
+
+                // For each route, ping the server to force it to cache the response for ssg
+                let request = reqwest_client
+                    .get(format!("http://{address}:{port}{route}"))
+                    .header("Accept", "text/html")
+                    .send()
+                    .await?;
+
+                // If it takes longer than 30 seconds to resolve the route, log a warning
+                let warning_task = tokio::spawn({
+                    let route = route.clone();
+                    async move {
+                        tokio::time::sleep(Duration::from_secs(30)).await;
+                        tracing::warn!("Route {route} has been rendering for 30 seconds");
+                    }
+                });
+
+                // Wait for the streaming response to completely finish before continuing. We don't use the html it returns directly
+                // because it may contain artifacts of intermediate streaming steps while the page is loading. The SSG app should write
+                // the final clean HTML to the disk automatically after the request completes.
+                let _html = request.text().await?;
+
+                // Cancel the warning task if it hasn't already run
+                warning_task.abort();
+
+                Ok::<_, reqwest::Error>(route)
+            })
+            .collect::<FuturesUnordered<_>>();
+
+        while let Some(route) = resolved_routes.next().await {
+            match route {
+                Ok(route) => tracing::debug!("ssg success: {route:?}"),
+                Err(err) => tracing::error!("ssg error: {err:?}"),
+            }
+        }
+
+        tracing::info!("SSG complete");
+
+        drop(_child);
+
+        Ok(())
+    }
 }

packages/cli/src/cli/check.rs

@@ -4,9 +4,11 @@
 //! https://github.com/rust-lang/rustfmt/blob/master/src/bin/main.rs
 
 use super::*;
-use crate::{metadata::collect_rs_files, DioxusCrate};
+use crate::BuildRequest;
 use anyhow::Context;
 use futures_util::{stream::FuturesUnordered, StreamExt};
+use std::path::Path;
+use walkdir::WalkDir;
 
 /// Check the Rust files in the project for issues.
 #[derive(Clone, Debug, Parser)]
@@ -17,19 +19,28 @@ pub(crate) struct Check {
 
     /// Information about the target to check
     #[clap(flatten)]
-    pub(crate) target_args: TargetArgs,
+    pub(crate) build_args: BuildArgs,
 }
 
 impl Check {
     // Todo: check the entire crate
     pub(crate) async fn check(self) -> Result<StructuredOutput> {
+        let BuildTargets { client, server } = self.build_args.into_targets().await?;
+
         match self.file {
             // Default to checking the project
             None => {
-                let dioxus_crate = DioxusCrate::new(&self.target_args)?;
-                check_project_and_report(dioxus_crate)
+                check_project_and_report(&client)
                     .await
                     .context("error checking project")?;
+
+                if let Some(server) = server {
+                    if server.package != client.package {
+                        check_project_and_report(&server)
+                            .await
+                            .context("error checking project")?;
+                    }
+                }
             }
             Some(file) => {
                 check_file_and_report(file)
@@ -51,9 +62,16 @@ async fn check_file_and_report(path: PathBuf) -> Result<()> {
 /// Runs using Tokio for multithreading, so it should be really really fast
 ///
 /// Doesn't do mod-descending, so it will still try to check unreachable files. TODO.
-async fn check_project_and_report(dioxus_crate: DioxusCrate) -> Result<()> {
-    let mut files_to_check = vec![dioxus_crate.main_source_file()];
-    files_to_check.extend(collect_rs_files(dioxus_crate.crate_dir()));
+async fn check_project_and_report(build: &BuildRequest) -> Result<()> {
+    let dioxus_crate = build
+        .workspace
+        .find_main_package(Some(build.package.clone()))?;
+    let dioxus_crate = &build.workspace.krates[dioxus_crate];
+    let mut files_to_check = vec![];
+    collect_rs_files(
+        dioxus_crate.manifest_path.parent().unwrap().as_std_path(),
+        &mut files_to_check,
+    );
     check_files_and_report(files_to_check).await
 }
 
@@ -105,3 +123,12 @@ async fn check_files_and_report(files_to_check: Vec<PathBuf>) -> Result<()> {
         _ => Err(format!("{} issues found.", total_issues).into()),
     }
 }
+
+pub(crate) fn collect_rs_files(folder: &Path, files: &mut Vec<PathBuf>) {
+    let dir = WalkDir::new(folder).follow_links(true).into_iter();
+    for entry in dir.flatten() {
+        if entry.path().extension() == Some("rs".as_ref()) {
+            files.push(entry.path().to_path_buf());
+        }
+    }
+}

packages/cli/src/cli/clean.rs

@@ -12,8 +12,6 @@ impl Clean {
     pub(crate) async fn clean(self) -> Result<StructuredOutput> {
         let output = tokio::process::Command::new("cargo")
             .arg("clean")
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
             .output()
             .await?;
 

packages/cli/src/cli/config.rs

@@ -1,6 +1,5 @@
 use super::*;
-use crate::TraceSrc;
-use crate::{metadata::crate_root, CliSettings};
+use crate::{CliSettings, TraceSrc, Workspace};
 
 /// Dioxus config file controls
 #[derive(Clone, Debug, Deserialize, Subcommand)]
@@ -71,8 +70,8 @@ impl From<BoolValue> for bool {
 }
 
 impl Config {
-    pub(crate) fn config(self) -> Result<StructuredOutput> {
-        let crate_root = crate_root()?;
+    pub(crate) async fn config(self) -> Result<StructuredOutput> {
+        let crate_root = Workspace::crate_root_from_path()?;
         match self {
             Config::Init { name, force } => {
                 let conf_path = crate_root.join("Dioxus.toml");
@@ -89,15 +88,13 @@ impl Config {
                 tracing::info!(dx_src = ?TraceSrc::Dev, "🚩 Init config file completed.");
             }
             Config::FormatPrint {} => {
-                tracing::info!(
-                    "{:#?}",
-                    crate::dioxus_crate::DioxusCrate::new(&TargetArgs::default())?.config
-                );
+                let workspace = Workspace::current().await?;
+                tracing::info!("{:#?}", workspace.settings);
             }
             Config::CustomHtml {} => {
                 let html_path = crate_root.join("index.html");
                 let mut file = File::create(html_path)?;
-                let content = include_str!("../../assets/web/index.html");
+                let content = include_str!("../../assets/web/dev.index.html");
                 file.write_all(content.as_bytes())?;
                 tracing::info!(dx_src = ?TraceSrc::Dev, "🚩 Create custom html file done.");
             }

packages/cli/src/cli/create.rs

@@ -58,6 +58,9 @@ impl Create {
         // If no template is specified, use the default one and set the branch to the latest release.
         resolve_template_and_branch(&mut self.template, &mut self.branch);
 
+        // cargo-generate requires the path to be created first.
+        std::fs::create_dir_all(&self.path)?;
+
         let args = GenerateArgs {
             define: self.option,
             destination: Some(self.path),
@@ -77,11 +80,19 @@ impl Create {
                 tag: self.tag,
                 ..Default::default()
             },
+            verbose: crate::logging::VERBOSITY
+                .get()
+                .map(|f| f.verbose)
+                .unwrap_or(false),
             ..Default::default()
         };
+
         restore_cursor_on_sigint();
+        tracing::debug!(dx_src = ?TraceSrc::Dev, "Creating new project with args: {args:#?}");
         let path = cargo_generate::generate(args)?;
+
         _ = post_create(&path);
+
         Ok(StructuredOutput::Success)
     }
 }

packages/cli/src/cli/init.rs

@@ -55,6 +55,9 @@ impl Init {
         // If no template is specified, use the default one and set the branch to the latest release.
         create::resolve_template_and_branch(&mut self.template, &mut self.branch);
 
+        // cargo-generate requires the path to be created first.
+        std::fs::create_dir_all(&self.path)?;
+
         let args = GenerateArgs {
             define: self.option,
             destination: Some(self.path),

packages/cli/src/cli/link.rs

@@ -1,105 +1,252 @@
-use dioxus_cli_opt::AssetManifest;
+use crate::Result;
+use anyhow::Context;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use target_lexicon::Triple;
 
-#[derive(Debug, Serialize, Deserialize)]
-pub enum LinkAction {
-    BuildAssetManifest {
-        destination: PathBuf,
-    },
-    LinkAndroid {
-        linker: PathBuf,
-        extra_flags: Vec<String>,
-    },
+/// `dx` can act as a linker in a few scenarios. Note that we don't *actually* implement the linker logic,
+/// instead just proxying to a specified linker (or not linking at all!).
+///
+/// This comes in two flavors:
+/// --------------------------
+/// - `BaseLink`: We are linking dependencies and want to dynamically select the linker from the environment.
+///               This is mostly implemented for Android where the linker is selected in part by the
+///               device connected over ADB which can not be determined by .cargo/Config.toml.
+///               We implemented this because previous setups like cargo mobile required a hard-coded
+///               linker path in your project which does not work in team-based setups.
+///
+/// - `NoLink`: We are not linking at all, and instead deferring our linking to the driving process,
+///             usually being `dx` itself. In this case, we are just writing the linker args to a file
+///             and then outputting a dummy object file to satisfy the linker. This is generally used
+///             by the binary patching engine since we need to actually do "real linker logic" like
+///             traversing object files and satisfying missing symbols. That process is *much* easier
+///             to do in the driving host process when we have all the information available. Unfortunately,
+///             rustc doesn't provide a "real" way of granularly stepping through the compile process
+///             so this is basically a hack.
+///
+/// We use "BaseLink" when a linker is specified, and "NoLink" when it is not. Both generate a resulting
+/// object file.
+
+#[derive(Debug)]
+pub struct LinkAction {
+    pub linker: Option<PathBuf>,
+    pub triple: Triple,
+    pub link_args_file: PathBuf,
+    pub link_err_file: PathBuf,
+}
+
+/// The linker flavor to use. This influences the argument style that gets passed to the linker.
+/// We're imitating the rustc linker flavors here.
+///
+/// https://doc.rust-lang.org/beta/nightly-rustc/rustc_target/spec/enum.LinkerFlavor.html
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+pub enum LinkerFlavor {
+    Gnu,
+    Darwin,
+    WasmLld,
+    Unix,
+    Msvc,
 }
 
 impl LinkAction {
-    pub(crate) const ENV_VAR_NAME: &'static str = "dx_magic_link_file";
+    const DX_LINK_ARG: &str = "DX_LINK";
+    const DX_ARGS_FILE: &str = "DX_LINK_ARGS_FILE";
+    const DX_ERR_FILE: &str = "DX_LINK_ERR_FILE";
+    const DX_LINK_TRIPLE: &str = "DX_LINK_TRIPLE";
+    const DX_LINK_CUSTOM_LINKER: &str = "DX_LINK_CUSTOM_LINKER";
 
     /// Should we write the input arguments to a file (aka act as a linker subprocess)?
     ///
     /// Just check if the magic env var is set
     pub(crate) fn from_env() -> Option<Self> {
-        std::env::var(Self::ENV_VAR_NAME)
-            .ok()
-            .map(|var| serde_json::from_str(&var).expect("Failed to parse magic env var"))
+        if std::env::var(Self::DX_LINK_ARG).is_err() {
+            return None;
+        }
+
+        Some(Self {
+            linker: std::env::var(Self::DX_LINK_CUSTOM_LINKER)
+                .ok()
+                .map(PathBuf::from),
+            link_args_file: std::env::var(Self::DX_ARGS_FILE)
+                .expect("Linker args file not set")
+                .into(),
+            link_err_file: std::env::var(Self::DX_ERR_FILE)
+                .expect("Linker error file not set")
+                .into(),
+            triple: std::env::var(Self::DX_LINK_TRIPLE)
+                .expect("Linker triple not set")
+                .parse()
+                .expect("Failed to parse linker triple"),
+        })
     }
 
-    pub(crate) fn to_json(&self) -> String {
-        serde_json::to_string(self).unwrap()
+    pub(crate) fn write_env_vars(&self, env_vars: &mut Vec<(&str, String)>) -> Result<()> {
+        env_vars.push((Self::DX_LINK_ARG, "1".to_string()));
+        env_vars.push((
+            Self::DX_ARGS_FILE,
+            dunce::canonicalize(&self.link_args_file)?
+                .to_string_lossy()
+                .to_string(),
+        ));
+        env_vars.push((
+            Self::DX_ERR_FILE,
+            dunce::canonicalize(&self.link_err_file)?
+                .to_string_lossy()
+                .to_string(),
+        ));
+        env_vars.push((Self::DX_LINK_TRIPLE, self.triple.to_string()));
+        if let Some(linker) = &self.linker {
+            env_vars.push((
+                Self::DX_LINK_CUSTOM_LINKER,
+                dunce::canonicalize(linker)?.to_string_lossy().to_string(),
+            ));
+        }
+
+        Ok(())
+    }
+
+    pub(crate) async fn run_link(self) {
+        let link_err_file = self.link_err_file.clone();
+        let res = self.run_link_inner().await;
+
+        if let Err(err) = res {
+            // If we failed to run the linker, we need to write the error to the file
+            // so that the main process can read it.
+            _ = std::fs::create_dir_all(link_err_file.parent().unwrap());
+            _ = std::fs::write(link_err_file, format!("Linker error: {err}"));
+        }
     }
 
     /// Write the incoming linker args to a file
     ///
     /// The file will be given by the dx-magic-link-arg env var itself, so we use
     /// it both for determining if we should act as a linker and the for the file name itself.
-    ///
-    /// This will panic if it fails
-    ///
-    /// hmmmmmmmm tbh I'd rather just pass the object files back and do the parsing here, but the interface
-    /// is nicer to just bounce back the args and let the host do the parsing/canonicalization
-    pub(crate) fn run(self) {
-        match self {
-            // Literally just run the android linker :)
-            LinkAction::LinkAndroid {
-                linker,
-                extra_flags,
-            } => {
-                let mut cmd = std::process::Command::new(linker);
-                cmd.args(std::env::args().skip(1));
-                cmd.args(extra_flags);
-                cmd.stderr(std::process::Stdio::piped())
-                    .stdout(std::process::Stdio::piped())
-                    .status()
-                    .expect("Failed to run android linker");
-            }
+    async fn run_link_inner(self) -> Result<()> {
+        let mut args: Vec<_> = std::env::args().collect();
+        if args.is_empty() {
+            return Ok(());
+        }
 
-            // Assemble an asset manifest by walking the object files being passed to us
-            LinkAction::BuildAssetManifest { destination: dest } => {
-                let mut args: Vec<_> = std::env::args().collect();
-                let mut manifest = AssetManifest::default();
-
-                // Handle command files, usually a windows thing.
-                if let Some(command) = args.iter().find(|arg| arg.starts_with('@')).cloned() {
-                    let path = command.trim().trim_start_matches('@');
-                    let file_binary = std::fs::read(path).unwrap();
-
-                    // This may be a utf-16le file. Let's try utf-8 first.
-                    let content = String::from_utf8(file_binary.clone()).unwrap_or_else(|_| {
-                        // Convert Vec<u8> to Vec<u16> to convert into a String
-                        let binary_u16le: Vec<u16> = file_binary
-                            .chunks_exact(2)
-                            .map(|a| u16::from_le_bytes([a[0], a[1]]))
-                            .collect();
-
-                        String::from_utf16_lossy(&binary_u16le)
-                    });
-
-                    // Gather linker args, and reset the args to be just the linker args
-                    args = content
-                        .lines()
-                        .map(|line| {
-                            let line_parsed = line.to_string();
-                            let line_parsed = line_parsed.trim_end_matches('"').to_string();
-                            let line_parsed = line_parsed.trim_start_matches('"').to_string();
-                            line_parsed
-                        })
-                        .collect();
-                }
+        handle_linker_command_file(&mut args);
 
-                // Parse through linker args for `.o` or `.rlib` files.
-                for item in args {
-                    if item.ends_with(".o") || item.ends_with(".rlib") {
-                        let path_to_item = PathBuf::from(item);
-                        if let Ok(path) = path_to_item.canonicalize() {
-                            _ = manifest.add_from_object_path(&path);
-                        }
-                    }
+        // Write the linker args to a file for the main process to read
+        // todo: we might need to encode these as escaped shell words in case newlines are passed
+        std::fs::write(self.link_args_file, args.join("\n"))?;
+
+        // If there's a linker specified, we use that. Otherwise, we write a dummy object file to satisfy
+        // any post-processing steps that rustc does.
+        match self.linker {
+            Some(linker) => {
+                let res = std::process::Command::new(linker)
+                    .args(args.iter().skip(1))
+                    .output()
+                    .expect("Failed to run linker");
+
+                if !res.stderr.is_empty() || !res.stdout.is_empty() {
+                    _ = std::fs::create_dir_all(self.link_err_file.parent().unwrap());
+                    _ = std::fs::write(
+                        self.link_err_file,
+                        format!(
+                            "Linker error: {}\n{}",
+                            String::from_utf8_lossy(&res.stdout),
+                            String::from_utf8_lossy(&res.stderr)
+                        ),
+                    );
                 }
+            }
+            None => {
+                // Extract the out path - we're going to write a dummy object file to satisfy the linker
+                let out_file: PathBuf = match self.triple.operating_system {
+                    target_lexicon::OperatingSystem::Windows => {
+                        let out_arg = args.iter().find(|arg| arg.starts_with("/OUT")).unwrap();
+                        out_arg.trim_start_matches("/OUT:").to_string().into()
+                    }
+                    _ => {
+                        let out = args.iter().position(|arg| arg == "-o").unwrap();
+                        args[out + 1].clone().into()
+                    }
+                };
+
+                // This creates an object file that satisfies rust's use of llvm-objcopy
+                //
+                // I'd rather we *not* do this and instead generate a truly linked file (and then delete it) but
+                // this at least lets us delay linking until the host compiler is ready.
+                //
+                // This is because our host compiler is a stateful server and not a stateless linker.
+                //
+                // todo(jon): do we use Triple::host or the target triple? I think I ran into issues
+                // using the target triple, hence the use of "host" but it might not even matter?
+                let triple = Triple::host();
+                let format = match triple.binary_format {
+                    target_lexicon::BinaryFormat::Elf => object::BinaryFormat::Elf,
+                    target_lexicon::BinaryFormat::Coff => object::BinaryFormat::Coff,
+                    target_lexicon::BinaryFormat::Macho => object::BinaryFormat::MachO,
+                    target_lexicon::BinaryFormat::Wasm => object::BinaryFormat::Wasm,
+                    target_lexicon::BinaryFormat::Xcoff => object::BinaryFormat::Xcoff,
+                    target_lexicon::BinaryFormat::Unknown => todo!(),
+                    _ => todo!("Binary format not supported"),
+                };
+
+                let arch = match triple.architecture {
+                    target_lexicon::Architecture::Wasm32 => object::Architecture::Wasm32,
+                    target_lexicon::Architecture::Wasm64 => object::Architecture::Wasm64,
+                    target_lexicon::Architecture::X86_64 => object::Architecture::X86_64,
+                    target_lexicon::Architecture::Arm(_) => object::Architecture::Arm,
+                    target_lexicon::Architecture::Aarch64(_) => object::Architecture::Aarch64,
+                    target_lexicon::Architecture::LoongArch64 => object::Architecture::LoongArch64,
+                    target_lexicon::Architecture::Unknown => object::Architecture::Unknown,
+                    _ => todo!("Architecture not supported"),
+                };
+
+                let endian = match triple.endianness() {
+                    Ok(target_lexicon::Endianness::Little) => object::Endianness::Little,
+                    Ok(target_lexicon::Endianness::Big) => object::Endianness::Big,
+                    Err(_) => todo!("Endianness not supported"),
+                };
 
-                let contents = serde_json::to_string(&manifest).expect("Failed to write manifest");
-                std::fs::write(dest, contents).expect("Failed to write output file");
+                let bytes = object::write::Object::new(format, arch, endian)
+                    .write()
+                    .context("Failed to emit stub link file")?;
+
+                // Write a dummy object file to satisfy rust/linker since it'll run llvm-objcopy
+                // ... I wish it *didn't* do that but I can't tell how to disable the linker without
+                // using --emit=obj which is not exactly what we want since that will still pull in
+                // the dependencies.
+                std::fs::create_dir_all(out_file.parent().unwrap())?;
+                std::fs::write(out_file, bytes)?;
             }
         }
+
+        Ok(())
+    }
+}
+
+pub fn handle_linker_command_file(args: &mut Vec<String>) {
+    // Handle command files, usually a windows thing.
+    if let Some(command) = args.iter().find(|arg| arg.starts_with('@')).cloned() {
+        let path = command.trim().trim_start_matches('@');
+        let file_binary = std::fs::read(path).unwrap();
+
+        // This may be a utf-16le file. Let's try utf-8 first.
+        let content = String::from_utf8(file_binary.clone()).unwrap_or_else(|_| {
+            // Convert Vec<u8> to Vec<u16> to convert into a String
+            let binary_u16le: Vec<u16> = file_binary
+                .chunks_exact(2)
+                .map(|a| u16::from_le_bytes([a[0], a[1]]))
+                .collect();
+
+            String::from_utf16_lossy(&binary_u16le)
+        });
+
+        // Gather linker args, and reset the args to be just the linker args
+        *args = content
+            .lines()
+            .map(|line| {
+                let line_parsed = line.trim().to_string();
+                let line_parsed = line_parsed.trim_end_matches('"').to_string();
+                let line_parsed = line_parsed.trim_start_matches('"').to_string();
+                line_parsed
+            })
+            .collect();
     }
 }

packages/cli/src/cli/mod.rs

@@ -20,7 +20,6 @@ pub(crate) use target::*;
 pub(crate) use verbosity::*;
 
 use crate::{error::Result, Error, StructuredOutput};
-use anyhow::Context;
 use clap::{Parser, Subcommand};
 use html_parser::Dom;
 use once_cell::sync::Lazy;
@@ -30,7 +29,7 @@ use std::{
     fs::File,
     io::{Read, Write},
     path::PathBuf,
-    process::{Command, Stdio},
+    process::Command,
 };
 
 /// Build, Bundle & Ship Dioxus Apps.
@@ -93,7 +92,7 @@ pub(crate) enum Commands {
     Config(config::Config),
 
     /// Build the assets for a specific target.
-    #[clap(name = "build_assets")]
+    #[clap(name = "assets")]
     BuildAssets(build_assets::BuildAssets),
 }
 

packages/cli/src/cli/run.rs

@@ -1,67 +1,131 @@
 use super::*;
-use crate::{serve::ServeUpdate, BuildArgs, Builder, DioxusCrate, Platform, Result};
+use crate::{
+    serve::{AppServer, ServeUpdate, WebServer},
+    BuilderUpdate, Platform, Result,
+};
+use dioxus_dx_wire_format::BuildStage;
 
 /// Run the project with the given arguments
+///
+/// This is a shorthand for `dx serve` with interactive mode and hot-reload disabled.
 #[derive(Clone, Debug, Parser)]
 pub(crate) struct RunArgs {
     /// Information about the target to build
     #[clap(flatten)]
-    pub(crate) build_args: BuildArgs,
+    pub(crate) args: ServeArgs,
 }
 
 impl RunArgs {
     pub(crate) async fn run(mut self) -> Result<StructuredOutput> {
-        let krate = DioxusCrate::new(&self.build_args.target_args)
-            .context("Failed to load Dioxus workspace")?;
+        // Override the build arguments, leveraging our serve infrastructure.
+        //
+        // We want to turn off the fancy stuff like the TUI, watcher, and hot-reload, but leave logging
+        // and other things like the devserver on.
+        self.args.hot_patch = false;
+        self.args.interactive = Some(false);
+        self.args.hot_reload = Some(false);
+        self.args.watch = Some(false);
 
-        self.build_args.resolve(&krate).await?;
+        let mut builder = AppServer::start(self.args).await?;
+        let mut devserver = WebServer::start(&builder)?;
 
-        tracing::trace!("Building crate krate data: {:#?}", krate);
-        tracing::trace!("Build args: {:#?}", self.build_args);
+        loop {
+            let msg = tokio::select! {
+                msg = builder.wait() => msg,
+                msg = devserver.wait() => msg,
+            };
 
-        let bundle = Builder::start(&krate, self.build_args.clone())?
-            .finish()
-            .await?;
+            match msg {
+                // Wait for logs from the build engine
+                // These will cause us to update the screen
+                // We also can check the status of the builds here in case we have multiple ongoing builds
+                ServeUpdate::BuilderUpdate { id, update } => {
+                    let platform = builder.get_build(id).unwrap().build.platform;
 
-        let devserver_ip = "127.0.0.1:8081".parse().unwrap();
-        let fullstack_ip = "127.0.0.1:8080".parse().unwrap();
-        let mut open_address = None;
+                    // And then update the websocketed clients with the new build status in case they want it
+                    devserver.new_build_update(&update).await;
 
-        if self.build_args.platform() == Platform::Web || self.build_args.fullstack() {
-            open_address = Some(fullstack_ip);
-            tracing::info!("Serving at: {}", fullstack_ip);
-        }
+                    // And then open the app if it's ready
+                    match update {
+                        BuilderUpdate::BuildReady { bundle } => {
+                            _ = builder
+                                .open(bundle, &mut devserver)
+                                .await
+                                .inspect_err(|e| tracing::error!("Failed to open app: {}", e));
 
-        let mut runner = crate::serve::AppRunner::start(&krate);
-        runner
-            .open(bundle, devserver_ip, open_address, Some(fullstack_ip), true)
-            .await?;
+                            if platform == Platform::Web {
+                                tracing::info!(
+                                    "Serving app at http://{}:{}",
+                                    builder.devserver_bind_ip,
+                                    builder.devserver_port
+                                );
+                            }
+                        }
+                        BuilderUpdate::Progress { stage } => match stage {
+                            BuildStage::Initializing => {
+                                tracing::info!("[{platform}] Initializing build")
+                            }
+                            BuildStage::Starting { .. } => {}
+                            BuildStage::InstallingTooling => {}
+                            BuildStage::Compiling {
+                                current,
+                                total,
+                                krate,
+                            } => {
+                                tracing::info!("[{platform}] Compiling {krate} ({current}/{total})",)
+                            }
+                            BuildStage::RunningBindgen => {
+                                tracing::info!("[{platform}] Running WASM bindgen")
+                            }
+                            BuildStage::SplittingBundle => {}
+                            BuildStage::OptimizingWasm => {
+                                tracing::info!("[{platform}] Optimizing WASM with `wasm-opt`")
+                            }
+                            BuildStage::Linking => tracing::info!("Linking app"),
+                            BuildStage::Hotpatching => todo!(),
+                            BuildStage::CopyingAssets {
+                                current,
+                                total,
+                                path,
+                            } => tracing::info!(
+                                "[{platform}] Copying asset {} ({current}/{total})",
+                                path.display(),
+                            ),
+                            BuildStage::Bundling => tracing::info!("[{platform}] Bundling app"),
+                            BuildStage::RunningGradle => {
+                                tracing::info!("[{platform}] Running Gradle")
+                            }
+                            BuildStage::Success => {}
+                            BuildStage::Failed => {}
+                            BuildStage::Aborted => {}
+                            BuildStage::Restarting => {}
+                            BuildStage::CompressingAssets => {}
+                            _ => {}
+                        },
+                        BuilderUpdate::CompilerMessage { message } => {
+                            print!("{}", message);
+                        }
+                        BuilderUpdate::BuildFailed { err } => {
+                            tracing::error!("Build failed: {:#?}", err);
+                        }
+                        BuilderUpdate::StdoutReceived { msg } => {
+                            tracing::info!("[{platform}] {msg}");
+                        }
+                        BuilderUpdate::StderrReceived { msg } => {
+                            tracing::error!("[{platform}] {msg}");
+                        }
+                        BuilderUpdate::ProcessExited { status } => {
+                            if !status.success() {
+                                tracing::error!(
+                                    "Application [{platform}] exited with error: {status}"
+                                );
+                            }
 
-        // Run the app, but mostly ignore all the other messages
-        // They won't generally be emitted
-        loop {
-            match runner.wait().await {
-                ServeUpdate::StderrReceived { platform, msg } => {
-                    tracing::info!("[{platform}]: {msg}")
-                }
-                ServeUpdate::StdoutReceived { platform, msg } => {
-                    tracing::info!("[{platform}]: {msg}")
-                }
-                ServeUpdate::ProcessExited { platform, status } => {
-                    runner.cleanup().await;
-                    tracing::info!("[{platform}]: process exited with status: {status:?}");
-                    break;
+                            break;
+                        }
+                    }
                 }
-                ServeUpdate::BuildUpdate { .. } => {}
-                ServeUpdate::TracingLog { .. } => {}
-                ServeUpdate::Exit { .. } => break,
-                ServeUpdate::NewConnection => {}
-                ServeUpdate::WsMessage(_) => {}
-                ServeUpdate::FilesChanged { .. } => {}
-                ServeUpdate::RequestRebuild => {}
-                ServeUpdate::Redraw => {}
-                ServeUpdate::OpenApp => {}
-                ServeUpdate::ToggleShouldRebuild => {}
+                _ => {}
             }
         }
 

packages/cli/src/cli/serve.rs

@@ -1,7 +1,36 @@
 use super::*;
-use crate::{AddressArguments, BuildArgs, DioxusCrate, Platform};
+use crate::{AddressArguments, BuildArgs, TraceController};
+use futures_util::FutureExt;
+use once_cell::sync::OnceCell;
+use std::{backtrace::Backtrace, panic::AssertUnwindSafe};
 
 /// Serve the project
+///
+/// `dx serve` takes cargo args by default, except with a required `--platform` arg:
+///
+/// ```
+/// dx serve --example blah --target blah --platform android
+/// ```
+///
+/// A simple serve:
+/// ```
+/// dx serve --platform web
+/// ```
+///
+/// A serve with customized arguments:
+///
+/// ```
+/// ```
+///
+/// As of dioxus 0.7, `dx serve` allows independent customization of the client and server builds,
+/// allowing workspaces and removing any "magic" done to support ergonomic fullstack serving with
+/// an plain `dx serve`. These require specifying more arguments like features since they won't be autodetected.
+///
+/// ```
+/// dx serve \
+///     client --package frontend \
+///     server --package backend
+/// ```
 #[derive(Clone, Debug, Default, Parser)]
 #[command(group = clap::ArgGroup::new("release-incompatible").multiple(true).conflicts_with("release"))]
 pub(crate) struct ServeArgs {
@@ -38,9 +67,22 @@ pub(crate) struct ServeArgs {
     #[arg(long, default_missing_value="true", num_args=0..=1, short = 'i')]
     pub(crate) interactive: Option<bool>,
 
-    /// Arguments for the build itself
+    /// Enable Rust hot-patching instead of full rebuilds [default: false]
+    ///
+    /// This is quite experimental and may lead to unexpected segfaults or crashes in development.
+    #[arg(long, default_value_t = false, alias = "hotpatch")]
+    pub(crate) hot_patch: bool,
+
+    /// Watch the filesystem for changes and trigger a rebuild [default: true]
+    #[clap(long, default_missing_value = "true")]
+    pub(crate) watch: Option<bool>,
+
+    /// This flag only applies to fullstack builds. By default fullstack builds will run the server and client builds in parallel. This flag will force the build to run the server build first, then the client build. [default: false]
+    #[clap(long)]
+    pub(crate) force_sequential: bool,
+
     #[clap(flatten)]
-    pub(crate) build_arguments: BuildArgs,
+    pub(crate) targets: BuildArgs,
 }
 
 impl ServeArgs {
@@ -48,71 +90,98 @@ impl ServeArgs {
     ///
     /// Make sure not to do any intermediate logging since our tracing infra has now enabled much
     /// higher log levels
+    ///
+    /// We also set up proper panic handling since the TUI has a tendency to corrupt the terminal.
     pub(crate) async fn serve(self) -> Result<StructuredOutput> {
-        crate::serve::serve_all(self).await?;
-
-        Ok(StructuredOutput::Success)
-    }
-
-    pub(crate) async fn load_krate(&mut self) -> Result<DioxusCrate> {
-        let krate = DioxusCrate::new(&self.build_arguments.target_args)?;
-        self.resolve(&krate).await?;
-        Ok(krate)
-    }
-
-    pub(crate) async fn resolve(&mut self, krate: &DioxusCrate) -> Result<()> {
-        // Enable hot reload.
-        if self.hot_reload.is_none() {
-            self.hot_reload = Some(krate.settings.always_hot_reload.unwrap_or(true));
+        if std::env::var("RUST_BACKTRACE").is_err() {
+            std::env::set_var("RUST_BACKTRACE", "1");
         }
 
-        // Open browser.
-        if self.open.is_none() {
-            self.open = Some(krate.settings.always_open_browser.unwrap_or_default());
+        struct SavedLocation {
+            file: String,
+            line: u32,
+            column: u32,
         }
-
-        // Set WSL file poll interval.
-        if self.wsl_file_poll_interval.is_none() {
-            self.wsl_file_poll_interval = Some(krate.settings.wsl_file_poll_interval.unwrap_or(2));
+        static BACKTRACE: OnceCell<(Backtrace, Option<SavedLocation>)> = OnceCell::new();
+
+        // We *don't* want printing here, since it'll break the tui and log ordering.
+        //
+        // We *will* re-emit the panic after we've drained the tracer, so our panic hook will simply capture the panic
+        // and save it.
+        std::panic::set_hook(Box::new(move |panic_info| {
+            _ = BACKTRACE.set((
+                Backtrace::capture(),
+                panic_info.location().map(|l| SavedLocation {
+                    file: l.file().to_string(),
+                    line: l.line(),
+                    column: l.column(),
+                }),
+            ));
+        }));
+
+        let interactive = self.is_interactive_tty();
+
+        // Redirect all logging the cli logger - if there's any pending after a panic, we flush it
+        let mut tracer = TraceController::redirect(interactive);
+
+        let res = AssertUnwindSafe(crate::serve::serve_all(self, &mut tracer))
+            .catch_unwind()
+            .await;
+
+        // Kill the screen so we don't ruin the terminal
+        _ = crate::serve::Output::remote_shutdown(interactive);
+
+        // And drain the tracer as regular messages. All messages will be logged (including traces)
+        // and then we can print the panic message
+        if !matches!(res, Ok(Ok(_))) {
+            tracer.shutdown_panic();
         }
 
-        // Set always-on-top for desktop.
-        if self.always_on_top.is_none() {
-            self.always_on_top = Some(krate.settings.always_on_top.unwrap_or(true))
+        match res {
+            Ok(Ok(_res)) => Ok(StructuredOutput::Success),
+            Ok(Err(e)) => Err(e),
+            Err(panic_err) => {
+                // And then print the panic itself.
+                let as_str = if let Some(p) = panic_err.downcast_ref::<String>() {
+                    p.as_ref()
+                } else if let Some(p) = panic_err.downcast_ref::<&str>() {
+                    p
+                } else {
+                    "<unknown panic>"
+                };
+
+                // Attempt to emulate the default panic hook
+                let message = BACKTRACE
+                    .get()
+                    .map(|(back, location)| {
+                        let location_display = location
+                            .as_ref()
+                            .map(|l| format!("{}:{}:{}", l.file, l.line, l.column))
+                            .unwrap_or_else(|| "<unknown>".to_string());
+
+                        let mut backtrace_display = back.to_string();
+
+                        // split at the line that ends with ___rust_try for short backtraces
+                        if std::env::var("RUST_BACKTRACE") == Ok("1".to_string()) {
+                            backtrace_display = backtrace_display
+                                .split(" ___rust_try\n")
+                                .next()
+                                .map(|f| format!("{f} ___rust_try"))
+                                .unwrap_or_default();
+                        }
+
+                        format!("dx serve panicked at {location_display}\n{as_str}\n{backtrace_display} ___rust_try")
+                    })
+                    .unwrap_or_else(|| format!("dx serve panicked: {as_str}"));
+
+                Err(crate::error::Error::CapturedPanic(message))
+            }
         }
-
-        // Resolve the build arguments
-        self.build_arguments.resolve(krate).await?;
-
-        Ok(())
-    }
-
-    pub(crate) fn should_hotreload(&self) -> bool {
-        self.hot_reload.unwrap_or(true)
-    }
-
-    pub(crate) fn build_args(&self) -> BuildArgs {
-        self.build_arguments.clone()
     }
 
+    /// Check if the server is running in interactive mode. This involves checking the terminal as well
     pub(crate) fn is_interactive_tty(&self) -> bool {
         use std::io::IsTerminal;
         std::io::stdout().is_terminal() && self.interactive.unwrap_or(true)
     }
-
-    pub(crate) fn should_proxy_build(&self) -> bool {
-        match self.build_arguments.platform() {
-            Platform::Server => true,
-            // During SSG, just serve the static files instead of running the server
-            _ => self.build_arguments.fullstack() && !self.build_arguments.ssg,
-        }
-    }
-}
-
-impl std::ops::Deref for ServeArgs {
-    type Target = BuildArgs;
-
-    fn deref(&self) -> &Self::Target {
-        &self.build_arguments
-    }
 }

packages/cli/src/cli/target.rs

@@ -1,235 +1,167 @@
-use super::*;
-use std::path::Path;
+use crate::cli::*;
+use crate::Platform;
+use clap::{ArgMatches, Args, FromArgMatches, Subcommand};
+use target_lexicon::Triple;
 
-/// Information about the target to build
+/// A single target to build for
 #[derive(Clone, Debug, Default, Deserialize, Parser)]
 pub(crate) struct TargetArgs {
-    /// Build for nightly [default: false]
-    #[clap(long)]
-    pub(crate) nightly: bool,
-
-    /// Build a example [default: ""]
-    #[clap(long)]
-    pub(crate) example: Option<String>,
+    /// Build platform: support Web & Desktop [default: "default_platform"]
+    #[clap(long, value_enum)]
+    pub(crate) platform: Option<Platform>,
 
-    /// Build a binary [default: ""]
-    #[clap(long)]
-    pub(crate) bin: Option<String>,
+    /// Build in release mode [default: false]
+    #[clap(long, short)]
+    #[serde(default)]
+    pub(crate) release: bool,
 
     /// The package to build
     #[clap(short, long)]
     pub(crate) package: Option<String>,
 
-    /// Space separated list of features to activate
+    /// Build a specific binary [default: ""]
     #[clap(long)]
-    pub(crate) features: Vec<String>,
+    pub(crate) bin: Option<String>,
 
-    /// The feature to use for the client in a fullstack app [default: "web"]
+    /// Build a specific example [default: ""]
     #[clap(long)]
-    pub(crate) client_features: Vec<String>,
+    pub(crate) example: Option<String>,
 
-    /// The feature to use for the server in a fullstack app [default: "server"]
+    /// Build the app with custom a profile
+    #[clap(long)]
+    pub(crate) profile: Option<String>,
+
+    /// Space separated list of features to activate
     #[clap(long)]
-    pub(crate) server_features: Vec<String>,
+    pub(crate) features: Vec<String>,
 
     /// Don't include the default features in the build
     #[clap(long)]
     pub(crate) no_default_features: bool,
 
-    /// The architecture to build for.
-    #[clap(long, value_enum)]
-    pub(crate) arch: Option<Arch>,
-
-    /// Are we building for a device or just the simulator.
-    /// If device is false, then we'll build for the simulator
+    /// Include all features in the build
     #[clap(long)]
-    pub(crate) device: Option<bool>,
+    pub(crate) all_features: bool,
 
     /// Rustc platform triple
     #[clap(long)]
-    pub(crate) target: Option<String>,
-
-    /// Specify the server rustc target triple.
+    pub(crate) target: Option<Triple>,
+
+    /// Extra arguments passed to `cargo`
+    ///
+    /// To see a list of args, run `cargo rustc --help`
+    ///
+    /// This can include stuff like, "--locked", "--frozen", etc. Note that `dx` sets many of these
+    /// args directly from other args in this command.
     #[clap(long)]
-    pub(crate) server_target: Option<String>,
-}
-
-impl TargetArgs {
-    pub(crate) fn arch(&self) -> Arch {
-        self.arch.unwrap_or_default()
-    }
-}
-
-#[derive(Debug, Default, Copy, Clone, PartialEq, Deserialize, clap::ValueEnum)]
-#[non_exhaustive]
-pub(crate) enum Arch {
-    // Android: armv7l, armv7-linux-androideabi
-    Arm,
-    // Android: aarch64, aarch64-linux-android
-    #[default]
-    Arm64,
-    // Android: i386, i686-linux-android
-    X86,
-    // Android: x86_64, x86_64-linux-android
-    X64,
-}
-
-impl Arch {
-    pub(crate) fn android_target_triplet(&self) -> &'static str {
-        match self {
-            Arch::Arm => "armv7-linux-androideabi",
-            Arch::Arm64 => "aarch64-linux-android",
-            Arch::X86 => "i686-linux-android",
-            Arch::X64 => "x86_64-linux-android",
-        }
-    }
-
-    pub(crate) fn android_jnilib(&self) -> &'static str {
-        match self {
-            Arch::Arm => "armeabi-v7a",
-            Arch::Arm64 => "arm64-v8a",
-            Arch::X86 => "x86",
-            Arch::X64 => "x86_64",
-        }
-    }
-
-    pub(crate) fn android_clang_triplet(&self) -> &'static str {
-        match self {
-            Self::Arm => "armv7a-linux-androideabi",
-            _ => self.android_target_triplet(),
-        }
-    }
-
-    pub(crate) fn android_tools_dir(&self, ndk: &Path) -> PathBuf {
-        let prebuilt = ndk.join("toolchains").join("llvm").join("prebuilt");
-
-        if cfg!(target_os = "macos") {
-            // for whatever reason, even on aarch64 macos, the linker is under darwin-x86_64
-            return prebuilt.join("darwin-x86_64").join("bin");
-        }
+    pub(crate) cargo_args: Option<String>,
+
+    /// Extra arguments passed to `rustc`. This can be used to customize the linker, or other flags.
+    ///
+    /// For example, specifign `dx build --rustc-args "-Clink-arg=-Wl,-blah"` will pass "-Clink-arg=-Wl,-blah"
+    /// to the underlying the `cargo rustc` command:
+    ///
+    /// cargo rustc -- -Clink-arg=-Wl,-blah
+    ///
+    #[clap(long)]
+    pub(crate) rustc_args: Option<String>,
 
-        if cfg!(target_os = "linux") {
-            return prebuilt.join("linux-x86_64").join("bin");
-        }
+    /// Skip collecting assets from dependencies [default: false]
+    #[clap(long)]
+    #[serde(default)]
+    pub(crate) skip_assets: bool,
 
-        if cfg!(target_os = "windows") {
-            return prebuilt.join("windows-x86_64").join("bin");
-        }
+    /// Inject scripts to load the wasm and js files for your dioxus app if they are not already present [default: true]
+    #[clap(long, default_value_t = true)]
+    pub(crate) inject_loading_scripts: bool,
 
-        unimplemented!("Unsupported target os for android toolchain autodetection")
-    }
+    /// Experimental: Bundle split the wasm binary into multiple chunks based on `#[wasm_split]` annotations [default: false]
+    #[clap(long, default_value_t = false)]
+    pub(crate) wasm_split: bool,
 
-    pub(crate) fn android_linker(&self, ndk: &Path) -> PathBuf {
-        // "/Users/jonkelley/Library/Android/sdk/ndk/25.2.9519653/toolchains/llvm/prebuilt/darwin-x86_64/bin/aarch64-linux-android24-clang"
-        let triplet = self.android_clang_triplet();
-        let suffix = if cfg!(target_os = "windows") {
-            ".cmd"
-        } else {
-            ""
-        };
+    /// Generate debug symbols for the wasm binary [default: true]
+    ///
+    /// This will make the binary larger and take longer to compile, but will allow you to debug the
+    /// wasm binary
+    #[clap(long, default_value_t = true)]
+    pub(crate) debug_symbols: bool,
 
-        self.android_tools_dir(ndk)
-            .join(format!("{}24-clang{}", triplet, suffix))
-    }
+    /// Are we building for a device or just the simulator.
+    /// If device is false, then we'll build for the simulator
+    #[clap(long)]
+    pub(crate) device: Option<bool>,
+}
 
-    pub(crate) fn android_min_sdk_version(&self) -> u32 {
-        // todo(jon): this should be configurable
-        24
-    }
+/// Chain together multiple target commands
+#[derive(Debug, Subcommand, Clone)]
+#[command(subcommand_precedence_over_arg = true)]
+pub(crate) enum TargetCmd {
+    /// Specify the arguments for the client build
+    #[clap(name = "client")]
+    Client(ChainedCommand<TargetArgs, TargetCmd>),
+
+    /// Specify the arguments for the server build
+    #[clap(name = "server")]
+    Server(ChainedCommand<TargetArgs, TargetCmd>),
+}
 
-    pub(crate) fn android_ar_path(&self, ndk: &Path) -> PathBuf {
-        self.android_tools_dir(ndk).join("llvm-ar")
-    }
+// https://github.com/clap-rs/clap/issues/2222#issuecomment-2524152894
+//
+//
+/// `[Args]` wrapper to match `T` variants recursively in `U`.
+#[derive(Debug, Clone)]
+pub struct ChainedCommand<T, U> {
+    /// Specific Variant.
+    pub inner: T,
+
+    /// Enum containing `Self<T>` variants, in other words possible follow-up commands.
+    pub next: Option<Box<U>>,
+}
 
-    pub(crate) fn target_cc(&self, ndk: &Path) -> PathBuf {
-        self.android_tools_dir(ndk).join("clang")
+impl<T, U> Args for ChainedCommand<T, U>
+where
+    T: Args,
+    U: Subcommand,
+{
+    fn augment_args(cmd: clap::Command) -> clap::Command {
+        // We use the special `defer` method which lets us recursively call `augment_args` on the inner command
+        // and thus `from_arg_matches`
+        T::augment_args(cmd).defer(|cmd| U::augment_subcommands(cmd.disable_help_subcommand(true)))
     }
 
-    pub(crate) fn target_cxx(&self, ndk: &Path) -> PathBuf {
-        self.android_tools_dir(ndk).join("clang++")
+    fn augment_args_for_update(_cmd: clap::Command) -> clap::Command {
+        unimplemented!()
     }
+}
 
-    pub(crate) fn java_home(&self) -> Option<PathBuf> {
-        // wrap in a lazy so we don't accidentally keep probing for java home and potentially thrash env vars
-        once_cell::sync::Lazy::new(|| {
-            // https://stackoverflow.com/questions/71381050/java-home-is-set-to-an-invalid-directory-android-studio-flutter
-            // always respect the user's JAVA_HOME env var above all other options
+impl<T, U> FromArgMatches for ChainedCommand<T, U>
+where
+    T: Args,
+    U: Subcommand,
+{
+    fn from_arg_matches(matches: &ArgMatches) -> Result<Self, clap::Error> {
+        // Parse the first command before we try to parse the next one.
+        let inner = T::from_arg_matches(matches)?;
+
+        // Try to parse the remainder of the command as a subcommand.
+        let next = match matches.subcommand() {
+            // Subcommand skips into the matched .subcommand, hence we need to pass *outer* matches, ignoring the inner matches
+            // (which in the average case should only match enumerated T)
             //
-            // we only attempt autodetection if java_home is not set
+            // Here, we might want to eventually enable arbitrary names of subcommands if they're prefixed
+            // with a prefix like "@" ie `dx serve @dog-app/backend --args @dog-app/frontend --args`
             //
-            // this is a better fallback than falling onto the users' system java home since many users might
-            // not even know which java that is - they just know they have android studio installed
-            if let Some(java_home) = std::env::var_os("JAVA_HOME") {
-                return Some(PathBuf::from(java_home));
-            }
-
-            // Attempt to autodetect java home from the android studio path or jdk path on macos
-            #[cfg(target_os = "macos")]
-            {
-                let jbr_home =
-                    PathBuf::from("/Applications/Android Studio.app/Contents/jbr/Contents/Home/");
-                if jbr_home.exists() {
-                    return Some(jbr_home);
-                }
-
-                let jre_home =
-                    PathBuf::from("/Applications/Android Studio.app/Contents/jre/Contents/Home");
-                if jre_home.exists() {
-                    return Some(jre_home);
-                }
-
-                let jdk_home =
-                    PathBuf::from("/Library/Java/JavaVirtualMachines/openjdk.jdk/Contents/Home/");
-                if jdk_home.exists() {
-                    return Some(jdk_home);
-                }
-            }
-
-            #[cfg(target_os = "windows")]
-            {
-                let jbr_home = PathBuf::from("C:\\Program Files\\Android\\Android Studio\\jbr");
-                if jbr_home.exists() {
-                    return Some(jbr_home);
-                }
-            }
-
-            // todo(jon): how do we detect java home on linux?
-            #[cfg(target_os = "linux")]
-            {
-                let jbr_home = PathBuf::from("/usr/lib/jvm/java-11-openjdk-amd64");
-                if jbr_home.exists() {
-                    return Some(jbr_home);
-                }
-            }
-
-            None
-        })
-        .clone()
-    }
-}
+            // we are done, since sub-sub commands are matched in U::
+            Some(_) => Some(Box::new(U::from_arg_matches(matches)?)),
 
-impl TryFrom<String> for Arch {
-    type Error = ();
-
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        match value.as_str() {
-            "armv7l" => Ok(Self::Arm),
-            "aarch64" => Ok(Self::Arm64),
-            "i386" => Ok(Self::X86),
-            "x86_64" => Ok(Self::X64),
-            _ => Err(()),
-        }
+            // no subcommand matched, we are done
+            None => None,
+        };
+
+        Ok(Self { inner, next })
     }
-}
 
-impl std::fmt::Display for Arch {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Arch::Arm => "armv7l",
-            Arch::Arm64 => "aarch64",
-            Arch::X86 => "i386",
-            Arch::X64 => "x86_64",
-        }
-        .fmt(f)
+    fn update_from_arg_matches(&mut self, _matches: &ArgMatches) -> Result<(), clap::Error> {
+        unimplemented!()
     }
 }

packages/cli/src/config/app.rs

@@ -3,7 +3,6 @@ use std::path::PathBuf;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub(crate) struct ApplicationConfig {
-    #[serde(default)]
     pub(crate) asset_dir: Option<PathBuf>,
 
     #[serde(default)]

packages/cli/src/config/dioxus_config.rs

@@ -1,7 +1,4 @@
 use super::*;
-use crate::Result;
-use anyhow::Context;
-use krates::{Krates, NodeId};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -55,51 +52,3 @@ impl Default for DioxusConfig {
         }
     }
 }
-
-impl DioxusConfig {
-    pub fn load(krates: &Krates, package: NodeId) -> Result<Option<Self>> {
-        // Walk up from the cargo.toml to the root of the workspace looking for Dioxus.toml
-        let mut current_dir = krates[package]
-            .manifest_path
-            .parent()
-            .unwrap()
-            .as_std_path()
-            .to_path_buf()
-            .canonicalize()?;
-
-        let workspace_path = krates
-            .workspace_root()
-            .as_std_path()
-            .to_path_buf()
-            .canonicalize()?;
-
-        let mut dioxus_conf_file = None;
-        while current_dir.starts_with(&workspace_path) {
-            let config = ["Dioxus.toml", "dioxus.toml"]
-                .into_iter()
-                .map(|file| current_dir.join(file))
-                .find(|path| path.is_file());
-
-            // Try to find Dioxus.toml in the current directory
-            if let Some(new_config) = config {
-                dioxus_conf_file = Some(new_config.as_path().to_path_buf());
-                break;
-            }
-            // If we can't find it, go up a directory
-            current_dir = current_dir
-                .parent()
-                .context("Failed to find Dioxus.toml")?
-                .to_path_buf();
-        }
-
-        let Some(dioxus_conf_file) = dioxus_conf_file else {
-            return Ok(None);
-        };
-
-        toml::from_str::<DioxusConfig>(&std::fs::read_to_string(&dioxus_conf_file)?)
-            .map_err(|err| {
-                anyhow::anyhow!("Failed to parse Dioxus.toml at {dioxus_conf_file:?}: {err}").into()
-            })
-            .map(Some)
-    }
-}

packages/cli/src/config/serve.rs

@@ -1,7 +1,4 @@
-#![allow(unused)] // lots of configs...
-
 use clap::Parser;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
 
 /// The arguments for the address the server will run on
 #[derive(Clone, Debug, Default, Parser)]

packages/cli/src/devcfg.rs

@@ -0,0 +1,30 @@
+//! Configuration of the CLI at runtime to enable certain experimental features.
+
+use std::path::Path;
+
+/// Should we cache the dependency library?
+///
+/// When the `DIOXUS_CACHE_DEP_LIB` environment variable is set, we will cache the dependency library
+/// built from the target's dependencies.
+pub(crate) fn should_cache_dep_lib(lib: &Path) -> bool {
+    std::env::var("DIOXUS_CACHE_DEP_LIB").is_ok() && lib.exists()
+}
+
+/// Should we force the entropy to be used on the main exe?
+///
+/// This is used to verify that binaries are copied with different names such that they don't collide
+/// and should generally be only enabled on certain platforms that require it.
+pub(crate) fn should_force_entropy() -> bool {
+    std::env::var("DIOXUS_FORCE_ENTRY").is_ok()
+}
+
+/// Should the CLI not download any additional tools?
+pub(crate) fn no_downloads() -> bool {
+    std::env::var("NO_DOWNLOADS").is_ok()
+}
+
+/// Should we test the installs?
+#[allow(dead_code)] // -> used in tests only
+pub(crate) fn test_installs() -> bool {
+    std::env::var("TEST_INSTALLS").is_ok()
+}

packages/cli/src/dioxus_crate.rs

@@ -1,855 +0,0 @@
-use crate::{config::DioxusConfig, TargetArgs};
-use crate::{Arch, CliSettings};
-use crate::{Platform, Result};
-use anyhow::Context;
-use itertools::Itertools;
-use krates::{cm::Target, KrateDetails};
-use krates::{cm::TargetKind, Cmd, Krates, NodeId};
-use once_cell::sync::OnceCell;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
-use tokio::process::Command;
-use toml_edit::Item;
-
-// Contains information about the crate we are currently in and the dioxus config for that crate
-#[derive(Clone)]
-pub(crate) struct DioxusCrate {
-    pub(crate) krates: Arc<Krates>,
-    pub(crate) package: NodeId,
-    pub(crate) config: DioxusConfig,
-    pub(crate) target: Target,
-    pub(crate) settings: Arc<CliSettings>,
-}
-
-pub(crate) static PROFILE_WASM: &str = "wasm-dev";
-pub(crate) static PROFILE_ANDROID: &str = "android-dev";
-pub(crate) static PROFILE_SERVER: &str = "server-dev";
-
-impl DioxusCrate {
-    pub(crate) fn new(target: &TargetArgs) -> Result<Self> {
-        tracing::debug!("Loading crate");
-        let cmd = Cmd::new();
-        let builder = krates::Builder::new();
-        let krates = builder
-            .build(cmd, |_| {})
-            .context("Failed to run cargo metadata")?;
-
-        let package = find_main_package(&krates, target.package.clone())?;
-        tracing::debug!("Found package {package:?}");
-
-        let dioxus_config = DioxusConfig::load(&krates, package)?.unwrap_or_default();
-
-        let package_name = krates[package].name.clone();
-        let target_kind = if target.example.is_some() {
-            TargetKind::Example
-        } else {
-            TargetKind::Bin
-        };
-
-        let main_package = &krates[package];
-
-        let target_name = target
-            .example
-            .clone()
-            .or(target.bin.clone())
-            .or_else(|| {
-                if let Some(default_run) = &main_package.default_run {
-                    return Some(default_run.to_string());
-                }
-
-                let bin_count = main_package
-                    .targets
-                    .iter()
-                    .filter(|x| x.kind.contains(&target_kind))
-                    .count();
-                if bin_count != 1 {
-                    return None;
-                }
-
-                main_package.targets.iter().find_map(|x| {
-                    if x.kind.contains(&target_kind) {
-                        Some(x.name.clone())
-                    } else {
-                        None
-                    }
-                })
-            })
-            .unwrap_or(package_name);
-
-        let target = main_package
-            .targets
-            .iter()
-            .find(|target| {
-                target_name == target.name.as_str() && target.kind.contains(&target_kind)
-            })
-            .with_context(|| {
-                let target_of_kind = |kind|-> String {
-                    let filtered_packages = main_package
-                .targets
-                .iter()
-                .filter_map(|target| {
-                    target.kind.contains(kind).then_some(target.name.as_str())
-                }).collect::<Vec<_>>();
-                filtered_packages.join(", ")};
-                if let Some(example) = &target.example {
-                    let examples = target_of_kind(&TargetKind::Example);
-                    format!("Failed to find example {example}. \nAvailable examples are:\n{}", examples)
-                } else if let Some(bin) = &target.bin {
-                    let binaries = target_of_kind(&TargetKind::Bin);
-                    format!("Failed to find binary {bin}. \nAvailable binaries are:\n{}", binaries)
-                } else {
-                    format!("Failed to find target {target_name}. \nIt looks like you are trying to build dioxus in a library crate. \
-                    You either need to run dx from inside a binary crate or build a specific example with the `--example` flag. \
-                    Available examples are:\n{}", target_of_kind(&TargetKind::Example))
-                }
-            })?
-            .clone();
-
-        let settings = CliSettings::load();
-
-        Ok(Self {
-            krates: Arc::new(krates),
-            package,
-            config: dioxus_config,
-            target,
-            settings,
-        })
-    }
-
-    /// The asset dir we used to support before manganis became the default.
-    /// This generally was just a folder in your Dioxus.toml called "assets" or "public" where users
-    /// would store their assets.
-    ///
-    /// With manganis you now use `asset!()` and we pick it up automatically.
-    pub(crate) fn legacy_asset_dir(&self) -> Option<PathBuf> {
-        self.config
-            .application
-            .asset_dir
-            .clone()
-            .map(|dir| self.crate_dir().join(dir))
-    }
-
-    /// Get the list of files in the "legacy" asset directory
-    pub(crate) fn legacy_asset_dir_files(&self) -> Vec<PathBuf> {
-        let mut files = vec![];
-
-        let Some(legacy_asset_dir) = self.legacy_asset_dir() else {
-            return files;
-        };
-
-        let Ok(read_dir) = legacy_asset_dir.read_dir() else {
-            return files;
-        };
-
-        for entry in read_dir.flatten() {
-            files.push(entry.path());
-        }
-
-        files
-    }
-
-    /// Get the directory where this app can write to for this session that's guaranteed to be stable
-    /// for the same app. This is useful for emitting state like window position and size.
-    ///
-    /// The directory is specific for this app and might be
-    pub(crate) fn session_cache_dir(&self) -> PathBuf {
-        self.internal_out_dir()
-            .join(self.executable_name())
-            .join("session-cache")
-    }
-
-    /// Get the outdir specified by the Dioxus.toml, relative to the crate directory.
-    /// We don't support workspaces yet since that would cause a collision of bundles per project.
-    pub(crate) fn crate_out_dir(&self) -> Option<PathBuf> {
-        self.config
-            .application
-            .out_dir
-            .as_ref()
-            .map(|out_dir| self.crate_dir().join(out_dir))
-    }
-
-    /// Compose an out directory. Represents the typical "dist" directory that
-    /// is "distributed" after building an application (configurable in the
-    /// `Dioxus.toml`).
-    fn internal_out_dir(&self) -> PathBuf {
-        let dir = self.workspace_dir().join("target").join("dx");
-        std::fs::create_dir_all(&dir).unwrap();
-        dir
-    }
-
-    /// Create a workdir for the given platform
-    /// This can be used as a temporary directory for the build, but in an observable way such that
-    /// you can see the files in the directory via `target`
-    ///
-    /// target/dx/build/app/web/
-    /// target/dx/build/app/web/public/
-    /// target/dx/build/app/web/server.exe
-    pub(crate) fn build_dir(&self, platform: Platform, release: bool) -> PathBuf {
-        self.internal_out_dir()
-            .join(self.executable_name())
-            .join(if release { "release" } else { "debug" })
-            .join(platform.build_folder_name())
-    }
-
-    /// target/dx/bundle/app/
-    /// target/dx/bundle/app/blah.app
-    /// target/dx/bundle/app/blah.exe
-    /// target/dx/bundle/app/public/
-    pub(crate) fn bundle_dir(&self, platform: Platform) -> PathBuf {
-        self.internal_out_dir()
-            .join(self.executable_name())
-            .join("bundle")
-            .join(platform.build_folder_name())
-    }
-
-    /// Get the workspace directory for the crate
-    pub(crate) fn workspace_dir(&self) -> PathBuf {
-        self.krates.workspace_root().as_std_path().to_path_buf()
-    }
-
-    /// Get the directory of the crate
-    pub(crate) fn crate_dir(&self) -> PathBuf {
-        self.package()
-            .manifest_path
-            .parent()
-            .unwrap()
-            .as_std_path()
-            .to_path_buf()
-    }
-
-    /// Get the main source file of the target
-    pub(crate) fn main_source_file(&self) -> PathBuf {
-        self.target.src_path.as_std_path().to_path_buf()
-    }
-
-    /// Get the package we are currently in
-    pub(crate) fn package(&self) -> &krates::cm::Package {
-        &self.krates[self.package]
-    }
-
-    /// Get the name of the package we are compiling
-    pub(crate) fn executable_name(&self) -> &str {
-        &self.target.name
-    }
-
-    /// Get the type of executable we are compiling
-    pub(crate) fn executable_type(&self) -> krates::cm::TargetKind {
-        self.target.kind[0].clone()
-    }
-
-    /// Try to autodetect the platform from the package by reading its features
-    ///
-    /// Read the default-features list and/or the features list on dioxus to see if we can autodetect the platform
-    pub(crate) fn autodetect_platform(&self) -> Option<(Platform, String)> {
-        let krate = self.krates.krates_by_name("dioxus").next()?;
-
-        // We're going to accumulate the platforms that are enabled
-        // This will let us create a better warning if multiple platforms are enabled
-        let manually_enabled_platforms = self
-            .krates
-            .get_enabled_features(krate.kid)?
-            .iter()
-            .flat_map(|feature| {
-                tracing::trace!("Autodetecting platform from feature {feature}");
-                Platform::autodetect_from_cargo_feature(feature)
-                    .filter(|platform| *platform != Platform::Server)
-                    .map(|f| (f, feature.to_string()))
-            })
-            .collect::<Vec<_>>();
-
-        if manually_enabled_platforms.len() > 1 {
-            tracing::error!("Multiple platforms are enabled. Please specify a platform with `--platform <platform>` or set a single default platform using a cargo feature.");
-            for platform in manually_enabled_platforms {
-                tracing::error!("  - {platform:?}");
-            }
-            return None;
-        }
-
-        if manually_enabled_platforms.len() == 1 {
-            return manually_enabled_platforms.first().cloned();
-        }
-
-        // Let's try and find the list of platforms from the feature list
-        // This lets apps that specify web + server to work without specifying the platform.
-        // This is because we treat `server` as a binary thing rather than a dedicated platform, so at least we can disambiguate it
-        let possible_platforms = self
-            .package()
-            .features
-            .iter()
-            .filter_map(|(feature, _features)| {
-                match Platform::autodetect_from_cargo_feature(feature) {
-                    Some(platform) => Some((platform, feature.to_string())),
-                    None => {
-                        let auto_implicit = _features
-                            .iter()
-                            .filter_map(|f| {
-                                if !f.starts_with("dioxus?/") && !f.starts_with("dioxus/") {
-                                    return None;
-                                }
-
-                                let rest = f
-                                    .trim_start_matches("dioxus/")
-                                    .trim_start_matches("dioxus?/");
-
-                                Platform::autodetect_from_cargo_feature(rest)
-                            })
-                            .collect::<Vec<_>>();
-
-                        if auto_implicit.len() == 1 {
-                            Some((auto_implicit.first().copied().unwrap(), feature.to_string()))
-                        } else {
-                            None
-                        }
-                    }
-                }
-            })
-            .filter(|platform| platform.0 != Platform::Server)
-            .collect::<Vec<_>>();
-
-        if possible_platforms.len() == 1 {
-            return possible_platforms.first().cloned();
-        }
-
-        None
-    }
-
-    /// Check if dioxus is being built with a particular feature
-    pub(crate) fn has_dioxus_feature(&self, filter: &str) -> bool {
-        self.krates.krates_by_name("dioxus").any(|dioxus| {
-            self.krates
-                .get_enabled_features(dioxus.kid)
-                .map(|features| features.contains(filter))
-                .unwrap_or_default()
-        })
-    }
-
-    /// Get the features required to build for the given platform
-    pub(crate) fn feature_for_platform(&self, platform: Platform) -> String {
-        let package = self.package();
-
-        // Try to find the feature that activates the dioxus feature for the given platform
-        let dioxus_feature = platform.feature_name();
-
-        let res = package.features.iter().find_map(|(key, features)| {
-            // if the feature is just the name of the platform, we use that
-            if key == dioxus_feature {
-                return Some(key.clone());
-            }
-
-            // Otherwise look for the feature that starts with dioxus/ or dioxus?/ and matches the platform
-            for feature in features {
-                if let Some((_, after_dioxus)) = feature.split_once("dioxus") {
-                    if let Some(dioxus_feature_enabled) =
-                        after_dioxus.trim_start_matches('?').strip_prefix('/')
-                    {
-                        // If that enables the feature we are looking for, return that feature
-                        if dioxus_feature_enabled == dioxus_feature {
-                            return Some(key.clone());
-                        }
-                    }
-                }
-            }
-
-            None
-        });
-
-        res.unwrap_or_else(|| {
-            let fallback = format!("dioxus/{}", platform.feature_name()) ;
-            tracing::debug!(
-                "Could not find explicit feature for platform {platform}, passing `fallback` instead"
-            );
-            fallback
-        })
-    }
-
-    /// Check if assets should be pre_compressed. This will only be true in release mode if the user
-    /// has enabled pre_compress in the web config.
-    pub(crate) fn should_pre_compress_web_assets(&self, release: bool) -> bool {
-        self.config.web.pre_compress && release
-    }
-
-    // The `opt-level=1` increases build times, but can noticeably decrease time
-    // between saving changes and being able to interact with an app (for wasm/web). The "overall"
-    // time difference (between having and not having the optimization) can be
-    // almost imperceptible (~1 s) but also can be very noticeable (~6 s) — depends
-    // on setup (hardware, OS, browser, idle load).
-    //
-    // Find or create the client and server profiles in the top-level Cargo.toml file
-    // todo(jon): we should/could make these optional by placing some defaults somewhere
-    pub(crate) fn initialize_profiles(&self) -> crate::Result<()> {
-        let config_path = self.workspace_dir().join("Cargo.toml");
-        let mut config = match std::fs::read_to_string(&config_path) {
-            Ok(config) => config.parse::<toml_edit::DocumentMut>().map_err(|e| {
-                crate::Error::Other(anyhow::anyhow!("Failed to parse Cargo.toml: {}", e))
-            })?,
-            Err(_) => Default::default(),
-        };
-
-        if let Item::Table(table) = config
-            .as_table_mut()
-            .entry("profile")
-            .or_insert(Item::Table(Default::default()))
-        {
-            if let toml_edit::Entry::Vacant(entry) = table.entry(PROFILE_WASM) {
-                let mut client = toml_edit::Table::new();
-                client.insert("inherits", Item::Value("dev".into()));
-                client.insert("opt-level", Item::Value(1.into()));
-                entry.insert(Item::Table(client));
-            }
-
-            if let toml_edit::Entry::Vacant(entry) = table.entry(PROFILE_SERVER) {
-                let mut server = toml_edit::Table::new();
-                server.insert("inherits", Item::Value("dev".into()));
-                entry.insert(Item::Table(server));
-            }
-
-            if let toml_edit::Entry::Vacant(entry) = table.entry(PROFILE_ANDROID) {
-                let mut android = toml_edit::Table::new();
-                android.insert("inherits", Item::Value("dev".into()));
-                entry.insert(Item::Table(android));
-            }
-        }
-
-        std::fs::write(config_path, config.to_string())
-            .context("Failed to write profiles to Cargo.toml")?;
-
-        Ok(())
-    }
-
-    fn default_ignore_list(&self) -> Vec<&'static str> {
-        vec![
-            ".git",
-            ".github",
-            ".vscode",
-            "target",
-            "node_modules",
-            "dist",
-            "*~",
-            ".*",
-            "*.lock",
-            "*.log",
-        ]
-    }
-
-    /// Create a new gitignore map for this target crate
-    ///
-    /// todo(jon): this is a bit expensive to build, so maybe we should cache it?
-    pub fn workspace_gitignore(&self) -> ignore::gitignore::Gitignore {
-        let crate_dir = self.crate_dir();
-
-        let mut ignore_builder = ignore::gitignore::GitignoreBuilder::new(&crate_dir);
-        ignore_builder.add(crate_dir.join(".gitignore"));
-
-        let workspace_dir = self.workspace_dir();
-        ignore_builder.add(workspace_dir.join(".gitignore"));
-
-        for path in self.default_ignore_list() {
-            ignore_builder
-                .add_line(None, path)
-                .expect("failed to add path to file excluded");
-        }
-
-        ignore_builder.build().unwrap()
-    }
-
-    /// Return the version of the wasm-bindgen crate if it exists
-    pub fn wasm_bindgen_version(&self) -> Option<String> {
-        self.krates
-            .krates_by_name("wasm-bindgen")
-            .next()
-            .map(|krate| krate.krate.version.to_string())
-    }
-
-    pub(crate) fn default_platforms(&self) -> Vec<Platform> {
-        let Some(default) = self.package().features.get("default") else {
-            return Vec::new();
-        };
-        let mut platforms = vec![];
-
-        // we only trace features 1 level deep..
-        for feature in default.iter() {
-            // If the user directly specified a platform we can just use that.
-            if feature.starts_with("dioxus/") {
-                let dx_feature = feature.trim_start_matches("dioxus/");
-                let auto = Platform::autodetect_from_cargo_feature(dx_feature);
-                if let Some(auto) = auto {
-                    platforms.push(auto);
-                }
-            }
-
-            // If the user is specifying an internal feature that points to a platform, we can use that
-            let internal_feature = self.package().features.get(feature);
-            if let Some(internal_feature) = internal_feature {
-                for feature in internal_feature {
-                    if feature.starts_with("dioxus/") {
-                        let dx_feature = feature.trim_start_matches("dioxus/");
-                        let auto = Platform::autodetect_from_cargo_feature(dx_feature);
-                        if let Some(auto) = auto {
-                            platforms.push(auto);
-                        }
-                    }
-                }
-            }
-        }
-
-        platforms.sort();
-        platforms.dedup();
-        platforms
-    }
-
-    /// Gather the features that are enabled for the package
-    pub(crate) fn platformless_features(&self) -> Vec<String> {
-        let default = self.package().features.get("default").unwrap();
-        let mut kept_features = vec![];
-
-        // Only keep the top-level features in the default list that don't point to a platform directly
-        // IE we want to drop `web` if default = ["web"]
-        'top: for feature in default {
-            // Don't keep features that point to a platform via dioxus/blah
-            if feature.starts_with("dioxus/") {
-                let dx_feature = feature.trim_start_matches("dioxus/");
-                if Platform::autodetect_from_cargo_feature(dx_feature).is_some() {
-                    continue 'top;
-                }
-            }
-
-            // Don't keep features that point to a platform via an internal feature
-            if let Some(internal_feature) = self.package().features.get(feature) {
-                for feature in internal_feature {
-                    if feature.starts_with("dioxus/") {
-                        let dx_feature = feature.trim_start_matches("dioxus/");
-                        if Platform::autodetect_from_cargo_feature(dx_feature).is_some() {
-                            continue 'top;
-                        }
-                    }
-                }
-            }
-
-            // Otherwise we can keep it
-            kept_features.push(feature.to_string());
-        }
-
-        kept_features
-    }
-
-    /// Return the list of paths that we should watch for changes.
-    pub(crate) fn watch_paths(&self) -> Vec<PathBuf> {
-        let mut watched_paths = vec![];
-
-        // Get a list of *all* the crates with Rust code that we need to watch.
-        // This will end up being dependencies in the workspace and non-workspace dependencies on the user's computer.
-        let mut watched_crates = self.local_dependencies();
-        watched_crates.push(self.crate_dir());
-
-        // Now, watch all the folders in the crates, but respecting their respective ignore files
-        for krate_root in watched_crates {
-            // Build the ignore builder for this crate, but with our default ignore list as well
-            let ignore = self.ignore_for_krate(&krate_root);
-
-            for entry in krate_root.read_dir().unwrap() {
-                let Ok(entry) = entry else {
-                    continue;
-                };
-
-                if ignore
-                    .matched(entry.path(), entry.path().is_dir())
-                    .is_ignore()
-                {
-                    continue;
-                }
-
-                watched_paths.push(entry.path().to_path_buf());
-            }
-        }
-
-        watched_paths.dedup();
-
-        watched_paths
-    }
-
-    fn ignore_for_krate(&self, path: &Path) -> ignore::gitignore::Gitignore {
-        let mut ignore_builder = ignore::gitignore::GitignoreBuilder::new(path);
-        for path in self.default_ignore_list() {
-            ignore_builder
-                .add_line(None, path)
-                .expect("failed to add path to file excluded");
-        }
-        ignore_builder.build().unwrap()
-    }
-
-    /// Get all the Manifest paths for dependencies that we should watch. Will not return anything
-    /// in the `.cargo` folder - only local dependencies will be watched.
-    ///
-    /// This returns a list of manifest paths
-    ///
-    /// Extend the watch path to include:
-    ///
-    /// - the assets directory - this is so we can hotreload CSS and other assets by default
-    /// - the Cargo.toml file - this is so we can hotreload the project if the user changes dependencies
-    /// - the Dioxus.toml file - this is so we can hotreload the project if the user changes the Dioxus config
-    pub(crate) fn local_dependencies(&self) -> Vec<PathBuf> {
-        let mut paths = vec![];
-
-        for (dependency, _edge) in self.krates.get_deps(self.package) {
-            let krate = match dependency {
-                krates::Node::Krate { krate, .. } => krate,
-                krates::Node::Feature { krate_index, .. } => &self.krates[krate_index.index()],
-            };
-
-            if krate
-                .manifest_path
-                .components()
-                .any(|c| c.as_str() == ".cargo")
-            {
-                continue;
-            }
-
-            paths.push(
-                krate
-                    .manifest_path
-                    .parent()
-                    .unwrap()
-                    .to_path_buf()
-                    .into_std_path_buf(),
-            );
-        }
-
-        paths
-    }
-
-    pub(crate) fn all_watched_crates(&self) -> Vec<PathBuf> {
-        let mut krates: Vec<PathBuf> = self
-            .local_dependencies()
-            .into_iter()
-            .map(|p| {
-                p.parent()
-                    .expect("Local manifest to exist and have a parent")
-                    .to_path_buf()
-            })
-            .chain(Some(self.crate_dir()))
-            .collect();
-
-        krates.dedup();
-
-        krates
-    }
-
-    /// Attempt to retrieve the path to ADB
-    pub(crate) fn android_adb() -> PathBuf {
-        static PATH: once_cell::sync::Lazy<PathBuf> = once_cell::sync::Lazy::new(|| {
-            let Some(sdk) = DioxusCrate::android_sdk() else {
-                return PathBuf::from("adb");
-            };
-
-            let tools = sdk.join("platform-tools");
-
-            if tools.join("adb").exists() {
-                return tools.join("adb");
-            }
-
-            if tools.join("adb.exe").exists() {
-                return tools.join("adb.exe");
-            }
-
-            PathBuf::from("adb")
-        });
-
-        PATH.clone()
-    }
-
-    pub(crate) fn android_sdk() -> Option<PathBuf> {
-        var_or_debug("ANDROID_SDK_ROOT")
-            .or_else(|| var_or_debug("ANDROID_SDK"))
-            .or_else(|| var_or_debug("ANDROID_HOME"))
-    }
-
-    pub(crate) fn android_ndk(&self) -> Option<PathBuf> {
-        // "/Users/jonkelley/Library/Android/sdk/ndk/25.2.9519653/toolchains/llvm/prebuilt/darwin-x86_64/bin/aarch64-linux-android24-clang"
-        static PATH: once_cell::sync::Lazy<Option<PathBuf>> = once_cell::sync::Lazy::new(|| {
-            // attempt to autodetect the ndk path from env vars (usually set by the shell)
-            let auto_detected_ndk =
-                var_or_debug("NDK_HOME").or_else(|| var_or_debug("ANDROID_NDK_HOME"));
-
-            if let Some(home) = auto_detected_ndk {
-                return Some(home);
-            }
-
-            let sdk = var_or_debug("ANDROID_SDK_ROOT")
-                .or_else(|| var_or_debug("ANDROID_SDK"))
-                .or_else(|| var_or_debug("ANDROID_HOME"))?;
-
-            let ndk = sdk.join("ndk");
-
-            ndk.read_dir()
-                .ok()?
-                .flatten()
-                .map(|dir| (dir.file_name(), dir.path()))
-                .sorted()
-                .next_back()
-                .map(|(_, path)| path.to_path_buf())
-        });
-
-        PATH.clone()
-    }
-
-    pub(crate) async fn autodetect_android_arch() -> Option<Arch> {
-        // Try auto detecting arch through adb.
-        static AUTO_ARCH: OnceCell<Option<Arch>> = OnceCell::new();
-
-        match AUTO_ARCH.get() {
-            Some(a) => *a,
-            None => {
-                // TODO: Wire this up with --device flag. (add `-s serial`` flag before `shell` arg)
-                let output = Command::new("adb")
-                    .arg("shell")
-                    .arg("uname")
-                    .arg("-m")
-                    .output()
-                    .await;
-
-                let out = match output {
-                    Ok(o) => o,
-                    Err(e) => {
-                        tracing::debug!("ADB command failed: {:?}", e);
-                        return None;
-                    }
-                };
-
-                // Parse ADB output
-                let Ok(out) = String::from_utf8(out.stdout) else {
-                    tracing::debug!("ADB returned unexpected data.");
-                    return None;
-                };
-                let trimmed = out.trim().to_string();
-                tracing::trace!("ADB Returned: `{trimmed:?}`");
-
-                // Set the cell
-                let arch = Arch::try_from(trimmed).ok();
-                AUTO_ARCH
-                    .set(arch)
-                    .expect("the cell should have been checked empty by the match condition");
-
-                arch
-            }
-        }
-    }
-
-    pub(crate) fn mobile_org(&self) -> String {
-        let identifier = self.bundle_identifier();
-        let mut split = identifier.splitn(3, '.');
-        let sub = split
-            .next()
-            .expect("Identifier to have at least 3 periods like `com.example.app`");
-        let tld = split
-            .next()
-            .expect("Identifier to have at least 3 periods like `com.example.app`");
-        format!("{}.{}", sub, tld)
-    }
-
-    pub(crate) fn bundled_app_name(&self) -> String {
-        use convert_case::{Case, Casing};
-        self.executable_name().to_case(Case::Pascal)
-    }
-
-    pub(crate) fn full_mobile_app_name(&self) -> String {
-        format!("{}.{}", self.mobile_org(), self.bundled_app_name())
-    }
-
-    pub(crate) fn bundle_identifier(&self) -> String {
-        if let Some(identifier) = self.config.bundle.identifier.clone() {
-            return identifier.clone();
-        }
-
-        format!("com.example.{}", self.bundled_app_name())
-    }
-}
-
-impl std::fmt::Debug for DioxusCrate {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("DioxusCrate")
-            .field("package", &self.krates[self.package])
-            .field("dioxus_config", &self.config)
-            .field("target", &self.target)
-            .finish()
-    }
-}
-
-// Find the main package in the workspace
-fn find_main_package(krates: &Krates, package: Option<String>) -> Result<NodeId> {
-    if let Some(package) = package {
-        let mut workspace_members = krates.workspace_members();
-        let found = workspace_members.find_map(|node| {
-            if let krates::Node::Krate { id, krate, .. } = node {
-                if krate.name == package {
-                    return Some(id);
-                }
-            }
-            None
-        });
-
-        if found.is_none() {
-            tracing::error!("Could not find package {package} in the workspace. Did you forget to add it to the workspace?");
-            tracing::error!("Packages in the workspace:");
-            for package in krates.workspace_members() {
-                if let krates::Node::Krate { krate, .. } = package {
-                    tracing::error!("{}", krate.name());
-                }
-            }
-        }
-
-        let kid = found.ok_or_else(|| anyhow::anyhow!("Failed to find package {package}"))?;
-
-        return Ok(krates.nid_for_kid(kid).unwrap());
-    };
-
-    // Otherwise find the package that is the closest parent of the current directory
-    let current_dir = std::env::current_dir()?;
-    let current_dir = current_dir.as_path();
-
-    // Go through each member and find the path that is a parent of the current directory
-    let mut closest_parent = None;
-    for member in krates.workspace_members() {
-        if let krates::Node::Krate { id, krate, .. } = member {
-            let member_path = krate.manifest_path.parent().unwrap();
-            if let Ok(path) = current_dir.strip_prefix(member_path.as_std_path()) {
-                let len = path.components().count();
-                match closest_parent {
-                    Some((_, closest_parent_len)) => {
-                        if len < closest_parent_len {
-                            closest_parent = Some((id, len));
-                        }
-                    }
-                    None => {
-                        closest_parent = Some((id, len));
-                    }
-                }
-            }
-        }
-    }
-
-    let kid = closest_parent
-        .map(|(id, _)| id)
-        .with_context(|| {
-            let bin_targets = krates.workspace_members().filter_map(|krate|match krate {
-                krates::Node::Krate { krate, .. } if krate.targets.iter().any(|t| t.kind.contains(&krates::cm::TargetKind::Bin))=> {
-                    Some(format!("- {}", krate.name))
-                }
-                _ => None
-            }).collect::<Vec<_>>();
-            format!("Failed to find binary package to build.\nYou need to either run dx from inside a binary crate or specify a binary package to build with the `--package` flag. Try building again with one of the binary packages in the workspace:\n{}", bin_targets.join("\n"))
-        })?;
-
-    let package = krates.nid_for_kid(kid).unwrap();
-    Ok(package)
-}
-
-fn var_or_debug(name: &str) -> Option<PathBuf> {
-    use std::env::var;
-    use tracing::debug;
-
-    var(name)
-        .inspect_err(|_| debug!("{name} not set"))
-        .ok()
-        .map(PathBuf::from)
-}

packages/cli/src/error.rs

@@ -1,4 +1,4 @@
-use crate::metadata::CargoError;
+use std::fmt::Debug;
 use thiserror::Error as ThisError;
 
 pub(crate) type Result<T, E = Error> = std::result::Result<T, E>;
@@ -22,7 +22,7 @@ pub(crate) enum Error {
     Runtime(String),
 
     #[error("Cargo Error: {0}")]
-    Cargo(#[from] CargoError),
+    Cargo(String),
 
     #[error("Invalid proxy URL: {0}")]
     InvalidProxy(#[from] hyper::http::uri::InvalidUri),
@@ -33,9 +33,11 @@ pub(crate) enum Error {
     #[error("Failed to bundle project: {0}")]
     BundleFailed(#[from] tauri_bundler::Error),
 
-    #[allow(unused)]
-    #[error("Unsupported feature: {0}")]
-    UnsupportedFeature(String),
+    #[error("Failed to perform hotpatch: {0}")]
+    PatchingFailed(#[from] crate::build::PatchError),
+
+    #[error("{0}")]
+    CapturedPanic(String),
 
     #[error("Failed to render template: {0}")]
     TemplateParse(#[from] handlebars::RenderError),

packages/cli/src/filemap.rs

@@ -1,168 +0,0 @@
-use dioxus_core::internal::{
-    HotReloadTemplateWithLocation, HotReloadedTemplate, TemplateGlobalKey,
-};
-use dioxus_core_types::HotReloadingContext;
-use dioxus_rsx::CallBody;
-use dioxus_rsx_hotreload::{ChangedRsx, HotReloadResult};
-use std::path::PathBuf;
-use std::{collections::HashMap, path::Path};
-use syn::spanned::Spanned;
-
-/// A struct that stores state of rsx! files and their parsed bodies.
-///
-/// This keeps track of changes to rsx files and helps determine if a file can be hotreloaded or if
-/// the project needs to be rebuilt.
-pub(crate) struct HotreloadFilemap {
-    /// Map of rust files to their contents
-    ///
-    /// Once this is created, we won't change the contents, to preserve the ability to hotreload
-    /// from the original source mapping, unless the file change results in a full rebuild.
-    map: HashMap<PathBuf, CachedFile>,
-}
-
-struct CachedFile {
-    contents: String,
-    most_recent: Option<String>,
-    templates: HashMap<TemplateGlobalKey, HotReloadedTemplate>,
-}
-
-pub enum HotreloadResult {
-    Rsx(Vec<HotReloadTemplateWithLocation>),
-    Notreloadable,
-    NotParseable,
-}
-
-impl HotreloadFilemap {
-    /// Create a new empty filemap.
-    ///
-    /// Make sure to fill the filemap, either automatically with `fill_from_filesystem` or manually with `add_file`;
-    pub fn new() -> Self {
-        Self {
-            map: Default::default(),
-        }
-    }
-
-    /// Add a file to the filemap.
-    pub(crate) fn add_file(&mut self, path: PathBuf, contents: String) {
-        self.map.insert(
-            path,
-            CachedFile {
-                contents,
-                most_recent: None,
-                templates: Default::default(),
-            },
-        );
-    }
-
-    /// Commit the changes to the filemap, overwriting the contents of the files
-    ///
-    /// Removes any cached templates and replaces the contents of the files with the most recent
-    ///
-    /// todo: we should-reparse the contents so we never send a new version, ever
-    pub fn force_rebuild(&mut self) {
-        for cached_file in self.map.values_mut() {
-            if let Some(most_recent) = cached_file.most_recent.take() {
-                cached_file.contents = most_recent;
-            }
-            cached_file.templates.clear();
-        }
-    }
-
-    /// Try to update the rsx in a file, returning the templates that were hotreloaded
-    ///
-    /// If the templates could not be hotreloaded, this will return an error. This error isn't fatal, per se,
-    /// but it does mean that we could not successfully hotreload the file in-place.
-    ///
-    /// It's expected that the file path you pass in is relative the crate root. We have no way of
-    /// knowing if it's *not*, so we'll assume it is.
-    ///
-    /// This does not do any caching on what intermediate state, like previous hotreloads, so you need
-    /// to do that yourself.
-    pub(crate) fn update_rsx<Ctx: HotReloadingContext>(
-        &mut self,
-        path: &Path,
-        new_contents: String,
-    ) -> HotreloadResult {
-        // Get the cached file if it exists
-        let Some(cached_file) = self.map.get_mut(path) else {
-            return HotreloadResult::NotParseable;
-        };
-
-        // We assume we can parse the old file and the new file
-        // We should just ignore hotreloading files that we can't parse
-        // todo(jon): we could probably keep the old `File` around instead of re-parsing on every hotreload
-        let (Ok(old_file), Ok(new_file)) = (
-            syn::parse_file(&cached_file.contents),
-            syn::parse_file(&new_contents),
-        ) else {
-            tracing::debug!("Diff rsx returned not parseable");
-            return HotreloadResult::NotParseable;
-        };
-
-        // Update the most recent version of the file, so when we force a rebuild, we keep operating on the most recent version
-        cached_file.most_recent = Some(new_contents);
-
-        // todo(jon): allow server-fn hotreloading
-        // also whyyyyyyyyy is this (new, old) instead of (old, new)? smh smh smh
-        let Some(changed_rsx) = dioxus_rsx_hotreload::diff_rsx(&new_file, &old_file) else {
-            tracing::debug!("Diff rsx returned notreladable");
-            return HotreloadResult::Notreloadable;
-        };
-
-        let mut out_templates = vec![];
-        for ChangedRsx { old, new } in changed_rsx {
-            let old_start = old.span().start();
-
-            let old_parsed = syn::parse2::<CallBody>(old.tokens);
-            let new_parsed = syn::parse2::<CallBody>(new.tokens);
-            let (Ok(old_call_body), Ok(new_call_body)) = (old_parsed, new_parsed) else {
-                continue;
-            };
-
-            // Format the template location, normalizing the path
-            let file_name: String = path
-                .components()
-                .map(|c| c.as_os_str().to_string_lossy())
-                .collect::<Vec<_>>()
-                .join("/");
-
-            // Returns a list of templates that are hotreloadable
-            let results = HotReloadResult::new::<Ctx>(
-                &old_call_body.body,
-                &new_call_body.body,
-                file_name.clone(),
-            );
-
-            // If no result is returned, we can't hotreload this file and need to keep the old file
-            let Some(results) = results else {
-                return HotreloadResult::Notreloadable;
-            };
-
-            // Only send down templates that have roots, and ideally ones that have changed
-            // todo(jon): maybe cache these and don't send them down if they're the same
-            for (index, template) in results.templates {
-                if template.roots.is_empty() {
-                    continue;
-                }
-
-                // Create the key we're going to use to identify this template
-                let key = TemplateGlobalKey {
-                    file: file_name.clone(),
-                    line: old_start.line,
-                    column: old_start.column + 1,
-                    index,
-                };
-
-                // if the template is the same, don't send its
-                if cached_file.templates.get(&key) == Some(&template) {
-                    continue;
-                };
-
-                cached_file.templates.insert(key.clone(), template.clone());
-                out_templates.push(HotReloadTemplateWithLocation { template, key });
-            }
-        }
-
-        HotreloadResult::Rsx(out_templates)
-    }
-}

packages/cli/src/logging.rs

@@ -69,11 +69,11 @@ impl TraceController {
             EnvFilter::from_env(LOG_ENV)
         } else if matches!(args.action, Commands::Serve(_)) {
             EnvFilter::new(
-                "error,dx=trace,dioxus_cli=trace,manganis_cli_support=trace,wasm_split_cli=trace",
+                "error,dx=trace,dioxus_cli=trace,manganis_cli_support=trace,wasm_split_cli=trace,subsecond_cli_support=trace",
             )
         } else {
             EnvFilter::new(format!(
-                "error,dx={our_level},dioxus_cli={our_level},manganis_cli_support={our_level},,wasm_split_cli={our_level}",
+                "error,dx={our_level},dioxus_cli={our_level},manganis_cli_support={our_level},wasm_split_cli={our_level},subsecond_cli_support={our_level}",
                 our_level = if args.verbosity.verbose {
                     "debug"
                 } else {
@@ -154,19 +154,23 @@ impl TraceController {
 
         ServeUpdate::TracingLog { log }
     }
-}
 
-impl Drop for TraceController {
-    fn drop(&mut self) {
+    pub(crate) fn shutdown_panic(&mut self) {
         TUI_ACTIVE.store(false, Ordering::Relaxed);
 
         // re-emit any remaining messages
         while let Ok(Some(msg)) = self.tui_rx.try_next() {
-            let contents = match msg.content {
+            let content = match msg.content {
                 TraceContent::Text(text) => text,
                 TraceContent::Cargo(msg) => msg.message.to_string(),
             };
-            tracing::error!("{}", contents);
+            match msg.level {
+                Level::ERROR => tracing::error!("{content}"),
+                Level::WARN => tracing::warn!("{content}"),
+                Level::INFO => tracing::info!("{content}"),
+                Level::DEBUG => tracing::debug!("{content}"),
+                Level::TRACE => tracing::trace!("{content}"),
+            }
         }
     }
 }

packages/cli/src/main.rs

@@ -2,58 +2,61 @@
 #![doc(html_logo_url = "https://avatars.githubusercontent.com/u/79236386")]
 #![doc(html_favicon_url = "https://avatars.githubusercontent.com/u/79236386")]
 #![cfg_attr(docsrs, feature(doc_cfg))]
+#![allow(clippy::doc_overindented_list_items)]
 
 mod build;
 mod bundle_utils;
 mod cli;
 mod config;
-mod dioxus_crate;
+mod devcfg;
 mod dx_build_info;
 mod error;
 mod fastfs;
-mod filemap;
 mod logging;
-mod metadata;
 mod platform;
-mod rustc;
+mod rustcwrapper;
 mod serve;
 mod settings;
 mod wasm_bindgen;
 mod wasm_opt;
+mod workspace;
 
 pub(crate) use build::*;
 pub(crate) use cli::*;
 pub(crate) use config::*;
-pub(crate) use dioxus_crate::*;
 pub(crate) use dioxus_dx_wire_format::*;
 pub(crate) use error::*;
-pub(crate) use filemap::*;
+pub(crate) use link::*;
 pub(crate) use logging::*;
 pub(crate) use platform::*;
-pub(crate) use rustc::*;
+pub(crate) use rustcwrapper::*;
 pub(crate) use settings::*;
+pub(crate) use wasm_bindgen::*;
+pub(crate) use workspace::*;
 
 #[tokio::main]
 async fn main() {
+    // The CLI uses dx as a rustcwrapper in some instances (like binary patching)
+    if rustcwrapper::is_wrapping_rustc() {
+        return rustcwrapper::run_rustc().await;
+    }
+
     // If we're being ran as a linker (likely from ourselves), we want to act as a linker instead.
-    if let Some(link_action) = link::LinkAction::from_env() {
-        return link_action.run();
+    if let Some(link_args) = link::LinkAction::from_env() {
+        return link_args.run_link().await;
     }
 
     let args = TraceController::initialize();
 
-    #[cfg(debug_assertions)]
-    tracing::warn!("CLI was built with debug profile. Commands will run slower.");
-
     let result = match args.action {
         Commands::Translate(opts) => opts.translate(),
         Commands::New(opts) => opts.create(),
         Commands::Init(opts) => opts.init(),
-        Commands::Config(opts) => opts.config(),
-        Commands::Autoformat(opts) => opts.autoformat(),
+        Commands::Config(opts) => opts.config().await,
+        Commands::Autoformat(opts) => opts.autoformat().await,
         Commands::Check(opts) => opts.check().await,
         Commands::Clean(opts) => opts.clean().await,
-        Commands::Build(opts) => opts.run_cmd().await,
+        Commands::Build(opts) => opts.build().await,
         Commands::Serve(opts) => opts.serve().await,
         Commands::Bundle(opts) => opts.bundle().await,
         Commands::Run(opts) => opts.run().await,
@@ -66,8 +69,9 @@ async fn main() {
             tracing::debug!(json = ?output);
         }
         Err(err) => {
+            eprintln!("{err}");
+
             tracing::error!(
-                ?err,
                 json = ?StructuredOutput::Error {
                     message: format!("{err:?}"),
                 },

packages/cli/src/metadata.rs

@@ -1,79 +0,0 @@
-//! Utilities for working with cargo and rust files
-use std::error::Error;
-use std::{
-    env,
-    ffi::OsStr,
-    fmt::{Display, Formatter},
-    fs,
-    path::{Path, PathBuf},
-};
-
-#[derive(Debug, Clone)]
-pub(crate) struct CargoError {
-    msg: String,
-}
-
-impl CargoError {
-    pub(crate) fn new(msg: String) -> Self {
-        Self { msg }
-    }
-}
-
-impl Display for CargoError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "CargoError: {}", self.msg)
-    }
-}
-
-impl Error for CargoError {}
-
-/// How many parent folders are searched for a `Cargo.toml`
-const MAX_ANCESTORS: u32 = 10;
-
-/// Returns the root of the crate that the command is run from
-///
-/// If the command is run from the workspace root, this will return the top-level Cargo.toml
-pub(crate) fn crate_root() -> Result<PathBuf, CargoError> {
-    // From the current directory we work our way up, looking for `Cargo.toml`
-    env::current_dir()
-        .ok()
-        .and_then(|mut wd| {
-            for _ in 0..MAX_ANCESTORS {
-                if contains_manifest(&wd) {
-                    return Some(wd);
-                }
-                if !wd.pop() {
-                    break;
-                }
-            }
-            None
-        })
-        .ok_or_else(|| {
-            CargoError::new("Failed to find directory containing Cargo.toml".to_string())
-        })
-}
-
-/// Checks if the directory contains `Cargo.toml`
-fn contains_manifest(path: &Path) -> bool {
-    fs::read_dir(path)
-        .map(|entries| {
-            entries
-                .filter_map(Result::ok)
-                .any(|ent| &ent.file_name() == "Cargo.toml")
-        })
-        .unwrap_or(false)
-}
-
-/// Collects all `.rs` files in the provided directory, respecting files to ignore (e.g. `.gitignore`)
-pub(crate) fn collect_rs_files(dir: impl AsRef<Path>) -> Vec<PathBuf> {
-    let mut files = Vec::new();
-    for result in ignore::Walk::new(dir) {
-        let path = result.unwrap().into_path();
-        if let Some(ext) = path.extension() {
-            if ext == OsStr::new("rs") {
-                files.push(path);
-            }
-        }
-    }
-    files
-}

packages/cli/src/rustc.rs

@@ -1,40 +0,0 @@
-use crate::Result;
-use anyhow::Context;
-use std::path::PathBuf;
-use tokio::process::Command;
-
-#[derive(Debug, Default)]
-pub struct RustcDetails {
-    pub sysroot: PathBuf,
-    pub version: String,
-}
-
-impl RustcDetails {
-    /// Find the current sysroot location using the CLI
-    pub async fn from_cli() -> Result<RustcDetails> {
-        let sysroot = Command::new("rustc")
-            .args(["--print", "sysroot"])
-            .output()
-            .await
-            .map(|out| String::from_utf8(out.stdout))?
-            .context("Failed to extract rustc sysroot output")?;
-
-        let rustc_version = Command::new("rustc")
-            .args(["--version"])
-            .output()
-            .await
-            .map(|out| String::from_utf8(out.stdout))?
-            .context("Failed to extract rustc version output")?;
-
-        Ok(Self {
-            sysroot: sysroot.trim().into(),
-            version: rustc_version.trim().into(),
-        })
-    }
-
-    pub fn has_wasm32_unknown_unknown(&self) -> bool {
-        self.sysroot
-            .join("lib/rustlib/wasm32-unknown-unknown")
-            .exists()
-    }
-}

packages/cli/src/rustcwrapper.rs

@@ -0,0 +1,77 @@
+use serde::{Deserialize, Serialize};
+use std::{
+    env::{args, vars},
+    path::PathBuf,
+};
+
+/// The environment variable indicating where the args file is located.
+///
+/// When `dx-rustc` runs, it writes its arguments to this file.
+pub const DX_RUSTC_WRAPPER_ENV_VAR: &str = "DX_RUSTC";
+
+/// Is `dx` being used as a rustc wrapper?
+///
+/// This is primarily used to intercept cargo, enabling fast hot-patching by caching the environment
+/// cargo setups up for the user's current project.
+///
+/// In a differenet world we could simply rely on cargo printing link args and the rustc command, but
+/// it doesn't seem to output that in a reliable, parseable, cross-platform format (ie using command
+/// files on windows...), so we're forced to do this interception nonsense.
+pub fn is_wrapping_rustc() -> bool {
+    std::env::var(DX_RUSTC_WRAPPER_ENV_VAR).is_ok()
+}
+
+#[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RustcArgs {
+    pub args: Vec<String>,
+    pub envs: Vec<(String, String)>,
+}
+
+/// Run rustc directly, but output the result to a file.
+///
+/// https://doc.rust-lang.org/cargo/reference/config.html#buildrustc
+pub async fn run_rustc() {
+    // if we happen to be both a rustc wrapper and a linker, we want to run the linker if the arguments seem linker-y
+    // this is a stupid hack
+    if std::env::args()
+        .take(5)
+        .any(|arg| arg.ends_with(".o") || arg == "-flavor" || arg.starts_with("@"))
+    {
+        return crate::link::LinkAction::from_env()
+            .expect("Linker action not found")
+            .run_link()
+            .await;
+    }
+
+    let var_file: PathBuf = std::env::var(DX_RUSTC_WRAPPER_ENV_VAR)
+        .expect("DX_RUSTC not set")
+        .into();
+
+    let rustc_args = RustcArgs {
+        args: args().skip(1).collect::<Vec<_>>(),
+        envs: vars().collect::<_>(),
+    };
+
+    std::fs::create_dir_all(var_file.parent().expect("Failed to get parent dir"))
+        .expect("Failed to create parent dir");
+    std::fs::write(
+        &var_file,
+        serde_json::to_string(&rustc_args).expect("Failed to serialize rustc args"),
+    )
+    .expect("Failed to write rustc args to file");
+
+    // Run the actual rustc command
+    // We want all stdout/stderr to be inherited, so the running process can see the output
+    //
+    // Note that the args format we get from the wrapper includes the `rustc` command itself, so we
+    // need to skip that - we already skipped the first arg when we created the args struct.
+    let mut cmd = std::process::Command::new("rustc");
+    cmd.args(rustc_args.args.iter().skip(1));
+    cmd.envs(rustc_args.envs);
+    cmd.stdout(std::process::Stdio::inherit());
+    cmd.stderr(std::process::Stdio::inherit());
+    cmd.current_dir(std::env::current_dir().expect("Failed to get current dir"));
+
+    // Propagate the exit code
+    std::process::exit(cmd.status().unwrap().code().unwrap())
+}

packages/cli/src/serve/detect.rs

@@ -1,32 +0,0 @@
-/// Detects if `dx` is being ran in a WSL environment.
-///
-/// We determine this based on whether the keyword `microsoft` or `wsl` is contained within the [`WSL_1`] or [`WSL_2`] files.
-/// This may fail in the future as it isn't guaranteed by Microsoft.
-/// See https://github.com/microsoft/WSL/issues/423#issuecomment-221627364
-pub(crate) fn is_wsl() -> bool {
-    const WSL_1: &str = "/proc/sys/kernel/osrelease";
-    const WSL_2: &str = "/proc/version";
-    const WSL_KEYWORDS: [&str; 2] = ["microsoft", "wsl"];
-
-    // Test 1st File
-    if let Ok(content) = std::fs::read_to_string(WSL_1) {
-        let lowercase = content.to_lowercase();
-        for keyword in WSL_KEYWORDS {
-            if lowercase.contains(keyword) {
-                return true;
-            }
-        }
-    }
-
-    // Test 2nd File
-    if let Ok(content) = std::fs::read_to_string(WSL_2) {
-        let lowercase = content.to_lowercase();
-        for keyword in WSL_KEYWORDS {
-            if lowercase.contains(keyword) {
-                return true;
-            }
-        }
-    }
-
-    false
-}

packages/cli/src/serve/handle.rs

@@ -1,856 +0,0 @@
-use crate::{AppBundle, DioxusCrate, Platform, Result};
-use anyhow::Context;
-use dioxus_cli_opt::process_file_to;
-use std::{
-    env,
-    net::SocketAddr,
-    path::{Path, PathBuf},
-    process::Stdio,
-};
-use tokio::{
-    io::{AsyncBufReadExt, BufReader, Lines},
-    process::{Child, ChildStderr, ChildStdout, Command},
-};
-
-/// A handle to a running app.
-///
-/// Also includes a handle to its server if it exists.
-/// The actual child processes might not be present (web) or running (died/killed).
-///
-/// The purpose of this struct is to accumulate state about the running app and its server, like
-/// any runtime information needed to hotreload the app or send it messages.
-///
-/// We might want to bring in websockets here too, so we know the exact channels the app is using to
-/// communicate with the devserver. Currently that's a broadcast-type system, so this struct isn't super
-/// duper useful.
-///
-/// todo: restructure this such that "open" is a running task instead of blocking the main thread
-pub(crate) struct AppHandle {
-    pub(crate) app: AppBundle,
-
-    // These might be None if the app died or the user did not specify a server
-    pub(crate) app_child: Option<Child>,
-    pub(crate) server_child: Option<Child>,
-
-    // stdio for the app so we can read its stdout/stderr
-    // we don't map stdin today (todo) but most apps don't need it
-    pub(crate) app_stdout: Option<Lines<BufReader<ChildStdout>>>,
-    pub(crate) app_stderr: Option<Lines<BufReader<ChildStderr>>>,
-    pub(crate) server_stdout: Option<Lines<BufReader<ChildStdout>>>,
-    pub(crate) server_stderr: Option<Lines<BufReader<ChildStderr>>>,
-
-    /// The executables but with some extra entropy in their name so we can run two instances of the
-    /// same app without causing collisions on the filesystem.
-    pub(crate) entropy_app_exe: Option<PathBuf>,
-    pub(crate) entropy_server_exe: Option<PathBuf>,
-
-    /// The virtual directory that assets will be served from
-    /// Used mostly for apk/ipa builds since they live in simulator
-    pub(crate) runtime_asst_dir: Option<PathBuf>,
-}
-
-impl AppHandle {
-    pub async fn new(app: AppBundle) -> Result<Self> {
-        Ok(AppHandle {
-            app,
-            runtime_asst_dir: None,
-            app_child: None,
-            app_stderr: None,
-            app_stdout: None,
-            server_child: None,
-            server_stdout: None,
-            server_stderr: None,
-            entropy_app_exe: None,
-            entropy_server_exe: None,
-        })
-    }
-
-    pub(crate) async fn open(
-        &mut self,
-        devserver_ip: SocketAddr,
-        open_address: Option<SocketAddr>,
-        start_fullstack_on_address: Option<SocketAddr>,
-        open_browser: bool,
-    ) -> Result<()> {
-        let krate = &self.app.build.krate;
-
-        // Set the env vars that the clients will expect
-        // These need to be stable within a release version (ie 0.6.0)
-        let mut envs = vec![
-            (dioxus_cli_config::CLI_ENABLED_ENV, "true".to_string()),
-            (
-                dioxus_cli_config::ALWAYS_ON_TOP_ENV,
-                krate.settings.always_on_top.unwrap_or(true).to_string(),
-            ),
-            (
-                dioxus_cli_config::APP_TITLE_ENV,
-                krate.config.web.app.title.clone(),
-            ),
-            ("RUST_BACKTRACE", "1".to_string()),
-            (
-                dioxus_cli_config::DEVSERVER_IP_ENV,
-                devserver_ip.ip().to_string(),
-            ),
-            (
-                dioxus_cli_config::DEVSERVER_PORT_ENV,
-                devserver_ip.port().to_string(),
-            ),
-            // unset the cargo dirs in the event we're running `dx` locally
-            // since the child process will inherit the env vars, we don't want to confuse the downstream process
-            ("CARGO_MANIFEST_DIR", "".to_string()),
-            (
-                dioxus_cli_config::SESSION_CACHE_DIR,
-                self.app
-                    .build
-                    .krate
-                    .session_cache_dir()
-                    .display()
-                    .to_string(),
-            ),
-        ];
-
-        if let Some(base_path) = &krate.config.web.app.base_path {
-            envs.push((dioxus_cli_config::ASSET_ROOT_ENV, base_path.clone()));
-        }
-
-        if let Some(env_filter) = env::var_os("RUST_LOG").and_then(|e| e.into_string().ok()) {
-            envs.push(("RUST_LOG", env_filter));
-        }
-
-        // Launch the server if we were given an address to start it on, and the build includes a server. After we
-        // start the server, consume its stdout/stderr.
-        if let (Some(addr), Some(server)) = (start_fullstack_on_address, self.server_exe()) {
-            tracing::debug!("Proxying fullstack server from port {:?}", addr);
-            envs.push((dioxus_cli_config::SERVER_IP_ENV, addr.ip().to_string()));
-            envs.push((dioxus_cli_config::SERVER_PORT_ENV, addr.port().to_string()));
-            tracing::debug!("Launching server from path: {server:?}");
-            let mut child = Command::new(server)
-                .envs(envs.clone())
-                .stderr(Stdio::piped())
-                .stdout(Stdio::piped())
-                .kill_on_drop(true)
-                .spawn()?;
-            let stdout = BufReader::new(child.stdout.take().unwrap());
-            let stderr = BufReader::new(child.stderr.take().unwrap());
-            self.server_stdout = Some(stdout.lines());
-            self.server_stderr = Some(stderr.lines());
-            self.server_child = Some(child);
-        }
-
-        // We try to use stdin/stdout to communicate with the app
-        let running_process = match self.app.build.build.platform() {
-            // Unfortunately web won't let us get a proc handle to it (to read its stdout/stderr) so instead
-            // use use the websocket to communicate with it. I wish we could merge the concepts here,
-            // like say, opening the socket as a subprocess, but alas, it's simpler to do that somewhere else.
-            Platform::Web => {
-                // Only the first build we open the web app, after that the user knows it's running
-                if open_browser {
-                    self.open_web(open_address.unwrap_or(devserver_ip));
-                }
-
-                None
-            }
-
-            Platform::Ios => Some(self.open_ios_sim(envs).await?),
-
-            // https://developer.android.com/studio/run/emulator-commandline
-            Platform::Android => {
-                self.open_android_sim(devserver_ip, envs).await;
-                None
-            }
-
-            // These are all just basically running the main exe, but with slightly different resource dir paths
-            Platform::Server
-            | Platform::MacOS
-            | Platform::Windows
-            | Platform::Linux
-            | Platform::Liveview => Some(self.open_with_main_exe(envs)?),
-        };
-
-        // If we have a running process, we need to attach to it and wait for its outputs
-        if let Some(mut child) = running_process {
-            let stdout = BufReader::new(child.stdout.take().unwrap());
-            let stderr = BufReader::new(child.stderr.take().unwrap());
-            self.app_stdout = Some(stdout.lines());
-            self.app_stderr = Some(stderr.lines());
-            self.app_child = Some(child);
-        }
-
-        Ok(())
-    }
-
-    /// Gracefully kill the process and all of its children
-    ///
-    /// Uses the `SIGTERM` signal on unix and `taskkill` on windows.
-    /// This complex logic is necessary for things like window state preservation to work properly.
-    ///
-    /// Also wipes away the entropy executables if they exist.
-    pub(crate) async fn cleanup(&mut self) {
-        // Soft-kill the process by sending a sigkill, allowing the process to clean up
-        self.soft_kill().await;
-
-        // Wipe out the entropy executables if they exist
-        if let Some(entropy_app_exe) = self.entropy_app_exe.take() {
-            _ = std::fs::remove_file(entropy_app_exe);
-        }
-
-        if let Some(entropy_server_exe) = self.entropy_server_exe.take() {
-            _ = std::fs::remove_file(entropy_server_exe);
-        }
-    }
-
-    /// Kill the app and server exes
-    pub(crate) async fn soft_kill(&mut self) {
-        use futures_util::FutureExt;
-
-        // Kill any running executables on Windows
-        let server_process = self.server_child.take();
-        let client_process = self.app_child.take();
-        let processes = [server_process, client_process]
-            .into_iter()
-            .flatten()
-            .collect::<Vec<_>>();
-
-        for mut process in processes {
-            let Some(pid) = process.id() else {
-                _ = process.kill().await;
-                continue;
-            };
-
-            // on unix, we can send a signal to the process to shut down
-            #[cfg(unix)]
-            {
-                _ = Command::new("kill")
-                    .args(["-s", "TERM", &pid.to_string()])
-                    .spawn();
-            }
-
-            // on windows, use the `taskkill` command
-            #[cfg(windows)]
-            {
-                _ = Command::new("taskkill")
-                    .args(["/F", "/PID", &pid.to_string()])
-                    .spawn();
-            }
-
-            // join the wait with a 100ms timeout
-            futures_util::select! {
-                _ = process.wait().fuse() => {}
-                _ = tokio::time::sleep(std::time::Duration::from_millis(1000)).fuse() => {}
-            };
-        }
-    }
-
-    /// Hotreload an asset in the running app.
-    ///
-    /// This will modify the build dir in place! Be careful! We generally assume you want all bundles
-    /// to reflect the latest changes, so we will modify the bundle.
-    ///
-    /// However, not all platforms work like this, so we might also need to update a separate asset
-    /// dir that the system simulator might be providing. We know this is the case for ios simulators
-    /// and haven't yet checked for android.
-    ///
-    /// This will return the bundled name of the asset such that we can send it to the clients letting
-    /// them know what to reload. It's not super important that this is robust since most clients will
-    /// kick all stylsheets without necessarily checking the name.
-    pub(crate) async fn hotreload_bundled_asset(&self, changed_file: &PathBuf) -> Option<PathBuf> {
-        let mut bundled_name = None;
-
-        // Use the build dir if there's no runtime asset dir as the override. For the case of ios apps,
-        // we won't actually be using the build dir.
-        let asset_dir = match self.runtime_asst_dir.as_ref() {
-            Some(dir) => dir.to_path_buf().join("assets/"),
-            None => self.app.build.asset_dir(),
-        };
-
-        tracing::debug!("Hotreloading asset {changed_file:?} in target {asset_dir:?}");
-
-        // If the asset shares the same name in the bundle, reload that
-        if let Some(legacy_asset_dir) = self.app.build.krate.legacy_asset_dir() {
-            if changed_file.starts_with(&legacy_asset_dir) {
-                tracing::debug!("Hotreloading legacy asset {changed_file:?}");
-                let trimmed = changed_file.strip_prefix(legacy_asset_dir).unwrap();
-                let res = std::fs::copy(changed_file, asset_dir.join(trimmed));
-                bundled_name = Some(trimmed.to_path_buf());
-                if let Err(e) = res {
-                    tracing::debug!("Failed to hotreload legacy asset {e}");
-                }
-            }
-        }
-
-        // Canonicalize the path as Windows may use long-form paths "\\\\?\\C:\\".
-        let changed_file = dunce::canonicalize(changed_file)
-            .inspect_err(|e| tracing::debug!("Failed to canonicalize hotreloaded asset: {e}"))
-            .ok()?;
-
-        // The asset might've been renamed thanks to the manifest, let's attempt to reload that too
-        if let Some(resource) = self.app.app.assets.assets.get(&changed_file).as_ref() {
-            let output_path = asset_dir.join(resource.bundled_path());
-            // Remove the old asset if it exists
-            _ = std::fs::remove_file(&output_path);
-            // And then process the asset with the options into the **old** asset location. If we recompiled,
-            // the asset would be in a new location because the contents and hash have changed. Since we are
-            // hotreloading, we need to use the old asset location it was originally written to.
-            let options = *resource.options();
-            let res = process_file_to(&options, &changed_file, &output_path);
-            bundled_name = Some(PathBuf::from(resource.bundled_path()));
-            if let Err(e) = res {
-                tracing::debug!("Failed to hotreload asset {e}");
-            }
-        }
-
-        // If the emulator is android, we need to copy the asset to the device with `adb push asset /data/local/tmp/dx/assets/filename.ext`
-        if self.app.build.build.platform() == Platform::Android {
-            if let Some(bundled_name) = bundled_name.as_ref() {
-                let target = dioxus_cli_config::android_session_cache_dir().join(bundled_name);
-                tracing::debug!("Pushing asset to device: {target:?}");
-                let res = tokio::process::Command::new(DioxusCrate::android_adb())
-                    .arg("push")
-                    .arg(&changed_file)
-                    .arg(target)
-                    .output()
-                    .await
-                    .context("Failed to push asset to device");
-
-                if let Err(e) = res {
-                    tracing::debug!("Failed to push asset to device: {e}");
-                }
-            }
-        }
-
-        // Now we can return the bundled asset name to send to the hotreload engine
-        bundled_name
-    }
-
-    /// Open the native app simply by running its main exe
-    ///
-    /// Eventually, for mac, we want to run the `.app` with `open` to fix issues with `dylib` paths,
-    /// but for now, we just run the exe directly. Very few users should be caring about `dylib` search
-    /// paths right now, but they will when we start to enable things like swift integration.
-    ///
-    /// Server/liveview/desktop are all basically the same, though
-    fn open_with_main_exe(&mut self, envs: Vec<(&str, String)>) -> Result<Child> {
-        // Create a new entropy app exe if we need to
-        let main_exe = self.app_exe();
-        let child = Command::new(main_exe)
-            .envs(envs)
-            .stderr(Stdio::piped())
-            .stdout(Stdio::piped())
-            .kill_on_drop(true)
-            .spawn()?;
-
-        Ok(child)
-    }
-
-    /// Open the web app by opening the browser to the given address.
-    /// Check if we need to use https or not, and if so, add the protocol.
-    /// Go to the basepath if that's set too.
-    fn open_web(&self, address: SocketAddr) {
-        let base_path = self.app.build.krate.config.web.app.base_path.clone();
-        let https = self
-            .app
-            .build
-            .krate
-            .config
-            .web
-            .https
-            .enabled
-            .unwrap_or_default();
-        let protocol = if https { "https" } else { "http" };
-        let base_path = match base_path.as_deref() {
-            Some(base_path) => format!("/{}", base_path.trim_matches('/')),
-            None => "".to_owned(),
-        };
-        _ = open::that_detached(format!("{protocol}://{address}{base_path}"));
-    }
-
-    /// Use `xcrun` to install the app to the simulator
-    /// With simulators, we're free to basically do anything, so we don't need to do any fancy codesigning
-    /// or entitlements, or anything like that.
-    ///
-    /// However, if there's no simulator running, this *might* fail.
-    ///
-    /// TODO(jon): we should probably check if there's a simulator running before trying to install,
-    /// and open the simulator if we have to.
-    async fn open_ios_sim(&mut self, envs: Vec<(&str, String)>) -> Result<Child> {
-        tracing::debug!(
-            "Installing app to simulator {:?}",
-            self.app.build.root_dir()
-        );
-
-        let res = Command::new("xcrun")
-            .arg("simctl")
-            .arg("install")
-            .arg("booted")
-            .arg(self.app.build.root_dir())
-            .stderr(Stdio::piped())
-            .stdout(Stdio::piped())
-            .output()
-            .await?;
-
-        tracing::debug!("Installed app to simulator with exit code: {res:?}");
-
-        // Remap the envs to the correct simctl env vars
-        // iOS sim lets you pass env vars but they need to be in the format "SIMCTL_CHILD_XXX=XXX"
-        let ios_envs = envs
-            .iter()
-            .map(|(k, v)| (format!("SIMCTL_CHILD_{k}"), v.clone()));
-
-        let child = Command::new("xcrun")
-            .arg("simctl")
-            .arg("launch")
-            .arg("--console")
-            .arg("booted")
-            .arg(self.app.build.krate.bundle_identifier())
-            .envs(ios_envs)
-            .stderr(Stdio::piped())
-            .stdout(Stdio::piped())
-            .kill_on_drop(true)
-            .spawn()?;
-
-        Ok(child)
-    }
-
-    /// We have this whole thing figured out, but we don't actually use it yet.
-    ///
-    /// Launching on devices is more complicated and requires us to codesign the app, which we don't
-    /// currently do.
-    ///
-    /// Converting these commands shouldn't be too hard, but device support would imply we need
-    /// better support for codesigning and entitlements.
-    #[allow(unused)]
-    async fn open_ios_device(&self) -> Result<()> {
-        use serde_json::Value;
-        let app_path = self.app.build.root_dir();
-
-        install_app(&app_path).await?;
-
-        // 2. Determine which device the app was installed to
-        let device_uuid = get_device_uuid().await?;
-
-        // 3. Get the installation URL of the app
-        let installation_url = get_installation_url(&device_uuid, &app_path).await?;
-
-        // 4. Launch the app into the background, paused
-        launch_app_paused(&device_uuid, &installation_url).await?;
-
-        // 5. Pick up the paused app and resume it
-        resume_app(&device_uuid).await?;
-
-        async fn install_app(app_path: &PathBuf) -> Result<()> {
-            let output = Command::new("xcrun")
-                .args(["simctl", "install", "booted"])
-                .arg(app_path)
-                .output()
-                .await?;
-
-            if !output.status.success() {
-                return Err(format!("Failed to install app: {:?}", output).into());
-            }
-
-            Ok(())
-        }
-
-        async fn get_device_uuid() -> Result<String> {
-            let output = Command::new("xcrun")
-                .args([
-                    "devicectl",
-                    "list",
-                    "devices",
-                    "--json-output",
-                    "target/deviceid.json",
-                ])
-                .output()
-                .await?;
-
-            let json: Value =
-                serde_json::from_str(&std::fs::read_to_string("target/deviceid.json")?)
-                    .context("Failed to parse xcrun output")?;
-            let device_uuid = json["result"]["devices"][0]["identifier"]
-                .as_str()
-                .ok_or("Failed to extract device UUID")?
-                .to_string();
-
-            Ok(device_uuid)
-        }
-
-        async fn get_installation_url(device_uuid: &str, app_path: &Path) -> Result<String> {
-            // xcrun devicectl device install app --device <uuid> --path <path> --json-output
-            let output = Command::new("xcrun")
-                .args([
-                    "devicectl",
-                    "device",
-                    "install",
-                    "app",
-                    "--device",
-                    device_uuid,
-                    &app_path.display().to_string(),
-                    "--json-output",
-                    "target/xcrun.json",
-                ])
-                .output()
-                .await?;
-
-            if !output.status.success() {
-                return Err(format!("Failed to install app: {:?}", output).into());
-            }
-
-            let json: Value = serde_json::from_str(&std::fs::read_to_string("target/xcrun.json")?)
-                .context("Failed to parse xcrun output")?;
-            let installation_url = json["result"]["installedApplications"][0]["installationURL"]
-                .as_str()
-                .ok_or("Failed to extract installation URL")?
-                .to_string();
-
-            Ok(installation_url)
-        }
-
-        async fn launch_app_paused(device_uuid: &str, installation_url: &str) -> Result<()> {
-            let output = Command::new("xcrun")
-                .args([
-                    "devicectl",
-                    "device",
-                    "process",
-                    "launch",
-                    "--no-activate",
-                    "--verbose",
-                    "--device",
-                    device_uuid,
-                    installation_url,
-                    "--json-output",
-                    "target/launch.json",
-                ])
-                .output()
-                .await?;
-
-            if !output.status.success() {
-                return Err(format!("Failed to launch app: {:?}", output).into());
-            }
-
-            Ok(())
-        }
-
-        async fn resume_app(device_uuid: &str) -> Result<()> {
-            let json: Value = serde_json::from_str(&std::fs::read_to_string("target/launch.json")?)
-                .context("Failed to parse xcrun output")?;
-
-            let status_pid = json["result"]["process"]["processIdentifier"]
-                .as_u64()
-                .ok_or("Failed to extract process identifier")?;
-
-            let output = Command::new("xcrun")
-                .args([
-                    "devicectl",
-                    "device",
-                    "process",
-                    "resume",
-                    "--device",
-                    device_uuid,
-                    "--pid",
-                    &status_pid.to_string(),
-                ])
-                .output()
-                .await?;
-
-            if !output.status.success() {
-                return Err(format!("Failed to resume app: {:?}", output).into());
-            }
-
-            Ok(())
-        }
-
-        unimplemented!("dioxus-cli doesn't support ios devices yet.")
-    }
-
-    #[allow(unused)]
-    async fn codesign_ios(&self) -> Result<()> {
-        const CODESIGN_ERROR: &str = r#"This is likely because you haven't
-- Created a provisioning profile before
-- Accepted the Apple Developer Program License Agreement
-
-The agreement changes frequently and might need to be accepted again.
-To accept the agreement, go to https://developer.apple.com/account
-
-To create a provisioning profile, follow the instructions here:
-https://developer.apple.com/documentation/xcode/sharing-your-teams-signing-certificates"#;
-
-        let profiles_folder = dirs::home_dir()
-            .context("Your machine has no home-dir")?
-            .join("Library/MobileDevice/Provisioning Profiles");
-
-        if !profiles_folder.exists() || profiles_folder.read_dir()?.next().is_none() {
-            tracing::error!(
-                r#"No provisioning profiles found when trying to codesign the app.
-We checked the folder: {}
-
-{CODESIGN_ERROR}
-"#,
-                profiles_folder.display()
-            )
-        }
-
-        let identities = Command::new("security")
-            .args(["find-identity", "-v", "-p", "codesigning"])
-            .output()
-            .await
-            .context("Failed to run `security find-identity -v -p codesigning`")
-            .map(|e| {
-                String::from_utf8(e.stdout)
-                    .context("Failed to parse `security find-identity -v -p codesigning`")
-            })??;
-
-        // Parsing this:
-        // 51ADE4986E0033A5DB1C794E0D1473D74FD6F871 "Apple Development: jkelleyrtp@gmail.com (XYZYZY)"
-        let app_dev_name = regex::Regex::new(r#""Apple Development: (.+)""#)
-            .unwrap()
-            .captures(&identities)
-            .and_then(|caps| caps.get(1))
-            .map(|m| m.as_str())
-            .context(
-                "Failed to find Apple Development in `security find-identity -v -p codesigning`",
-            )?;
-
-        // Acquire the provision file
-        let provision_file = profiles_folder
-            .read_dir()?
-            .flatten()
-            .find(|entry| {
-                entry
-                    .file_name()
-                    .to_str()
-                    .map(|s| s.contains("mobileprovision"))
-                    .unwrap_or_default()
-            })
-            .context("Failed to find a provisioning profile. \n\n{CODESIGN_ERROR}")?;
-
-        // The .mobileprovision file has some random binary thrown into into, but it's still basically a plist
-        // Let's use the plist markers to find the start and end of the plist
-        fn cut_plist(bytes: &[u8], byte_match: &[u8]) -> Option<usize> {
-            bytes
-                .windows(byte_match.len())
-                .enumerate()
-                .rev()
-                .find(|(_, slice)| *slice == byte_match)
-                .map(|(i, _)| i + byte_match.len())
-        }
-        let bytes = std::fs::read(provision_file.path())?;
-        let cut1 = cut_plist(&bytes, b"<plist").context("Failed to parse .mobileprovision file")?;
-        let cut2 = cut_plist(&bytes, r#"</dict>"#.as_bytes())
-            .context("Failed to parse .mobileprovision file")?;
-        let sub_bytes = &bytes[(cut1 - 6)..cut2];
-        let mbfile: ProvisioningProfile =
-            plist::from_bytes(sub_bytes).context("Failed to parse .mobileprovision file")?;
-
-        #[derive(serde::Deserialize, Debug)]
-        struct ProvisioningProfile {
-            #[serde(rename = "TeamIdentifier")]
-            team_identifier: Vec<String>,
-            #[serde(rename = "ApplicationIdentifierPrefix")]
-            application_identifier_prefix: Vec<String>,
-            #[serde(rename = "Entitlements")]
-            entitlements: Entitlements,
-        }
-
-        #[derive(serde::Deserialize, Debug)]
-        struct Entitlements {
-            #[serde(rename = "application-identifier")]
-            application_identifier: String,
-            #[serde(rename = "keychain-access-groups")]
-            keychain_access_groups: Vec<String>,
-        }
-
-        let entielements_xml = format!(
-            r#"
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0"><dict>
-    <key>application-identifier</key>
-    <string>{APPLICATION_IDENTIFIER}</string>
-    <key>keychain-access-groups</key>
-    <array>
-        <string>{APP_ID_ACCESS_GROUP}.*</string>
-    </array>
-    <key>get-task-allow</key>
-    <true/>
-    <key>com.apple.developer.team-identifier</key>
-    <string>{TEAM_IDENTIFIER}</string>
-</dict></plist>
-        "#,
-            APPLICATION_IDENTIFIER = mbfile.entitlements.application_identifier,
-            APP_ID_ACCESS_GROUP = mbfile.entitlements.keychain_access_groups[0],
-            TEAM_IDENTIFIER = mbfile.team_identifier[0],
-        );
-
-        // write to a temp file
-        let temp_file = tempfile::NamedTempFile::new()?;
-        std::fs::write(temp_file.path(), entielements_xml)?;
-
-        // codesign the app
-        let output = Command::new("codesign")
-            .args([
-                "--force",
-                "--entitlements",
-                temp_file.path().to_str().unwrap(),
-                "--sign",
-                app_dev_name,
-            ])
-            .arg(self.app.build.root_dir())
-            .output()
-            .await
-            .context("Failed to codesign the app")?;
-
-        if !output.status.success() {
-            let stderr = String::from_utf8(output.stderr).unwrap_or_default();
-            return Err(format!("Failed to codesign the app: {stderr}").into());
-        }
-
-        Ok(())
-    }
-
-    async fn open_android_sim(
-        &self,
-        devserver_socket: SocketAddr,
-        envs: Vec<(&'static str, String)>,
-    ) {
-        let apk_path = self.app.apk_path();
-        let session_cache = self.app.build.krate.session_cache_dir();
-        let full_mobile_app_name = self.app.build.krate.full_mobile_app_name();
-
-        // Start backgrounded since .open() is called while in the arm of the top-level match
-        tokio::task::spawn(async move {
-            let port = devserver_socket.port();
-            if let Err(e) = Command::new("adb")
-                .arg("reverse")
-                .arg(format!("tcp:{}", port))
-                .arg(format!("tcp:{}", port))
-                .stderr(Stdio::piped())
-                .stdout(Stdio::piped())
-                .output()
-                .await
-            {
-                tracing::error!("failed to forward port {port}: {e}");
-            }
-
-            // Install
-            // adb install -r app-debug.apk
-            if let Err(e) = Command::new(DioxusCrate::android_adb())
-                .arg("install")
-                .arg("-r")
-                .arg(apk_path)
-                .stderr(Stdio::piped())
-                .stdout(Stdio::piped())
-                .output()
-                .await
-            {
-                tracing::error!("Failed to install apk with `adb`: {e}");
-            };
-
-            // Write the env vars to a .env file in our session cache
-            let env_file = session_cache.join(".env");
-            let contents: String = envs
-                .iter()
-                .map(|(key, value)| format!("{key}={value}"))
-                .collect::<Vec<_>>()
-                .join("\n");
-            _ = std::fs::write(&env_file, contents);
-
-            // Push the env file to the device
-            if let Err(e) = tokio::process::Command::new(DioxusCrate::android_adb())
-                .arg("push")
-                .arg(env_file)
-                .arg(dioxus_cli_config::android_session_cache_dir().join(".env"))
-                .output()
-                .await
-                .context("Failed to push asset to device")
-            {
-                tracing::error!("Failed to push .env file to device: {e}");
-            }
-
-            // eventually, use the user's MainActivity, not our MainActivity
-            // adb shell am start -n dev.dioxus.main/dev.dioxus.main.MainActivity
-            let activity_name = format!("{}/dev.dioxus.main.MainActivity", full_mobile_app_name,);
-
-            if let Err(e) = Command::new(DioxusCrate::android_adb())
-                .arg("shell")
-                .arg("am")
-                .arg("start")
-                .arg("-n")
-                .arg(activity_name)
-                .stderr(Stdio::piped())
-                .stdout(Stdio::piped())
-                .output()
-                .await
-            {
-                tracing::error!("Failed to start app with `adb`: {e}");
-            };
-        });
-    }
-
-    fn make_entropy_path(exe: &PathBuf) -> PathBuf {
-        let id = uuid::Uuid::new_v4();
-        let name = id.to_string();
-        let some_entropy = name.split('-').next().unwrap();
-
-        // Make a copy of the server exe with a new name
-        let entropy_server_exe = exe.with_file_name(format!(
-            "{}-{}",
-            exe.file_name().unwrap().to_str().unwrap(),
-            some_entropy
-        ));
-
-        std::fs::copy(exe, &entropy_server_exe).unwrap();
-
-        entropy_server_exe
-    }
-
-    fn server_exe(&mut self) -> Option<PathBuf> {
-        let mut server = self.app.server_exe()?;
-
-        // Create a new entropy server exe if we need to
-        if cfg!(target_os = "windows") || cfg!(target_os = "linux") {
-            // If we already have an entropy server exe, return it - this is useful for re-opening the same app
-            if let Some(existing_server) = self.entropy_server_exe.clone() {
-                return Some(existing_server);
-            }
-
-            // Otherwise, create a new entropy server exe and save it for re-opning
-            let entropy_server_exe = Self::make_entropy_path(&server);
-            self.entropy_server_exe = Some(entropy_server_exe.clone());
-            server = entropy_server_exe;
-        }
-
-        Some(server)
-    }
-
-    fn app_exe(&mut self) -> PathBuf {
-        let mut main_exe = self.app.main_exe();
-
-        // The requirement here is based on the platform, not necessarily our current architecture.
-        let requires_entropy = match self.app.build.build.platform() {
-            // When running "bundled", we don't need entropy
-            Platform::Web => false,
-            Platform::MacOS => false,
-            Platform::Ios => false,
-            Platform::Android => false,
-
-            // But on platforms that aren't running as "bundled", we do.
-            Platform::Windows => true,
-            Platform::Linux => true,
-            Platform::Server => true,
-            Platform::Liveview => true,
-        };
-
-        if requires_entropy || std::env::var("DIOXUS_ENTROPY").is_ok() {
-            // If we already have an entropy app exe, return it - this is useful for re-opening the same app
-            if let Some(existing_app_exe) = self.entropy_app_exe.clone() {
-                return existing_app_exe;
-            }
-
-            let entropy_app_exe = Self::make_entropy_path(&main_exe);
-            self.entropy_app_exe = Some(entropy_app_exe.clone());
-            main_exe = entropy_app_exe;
-        }
-
-        main_exe
-    }
-}

packages/cli/src/serve/mod.rs

@@ -1,21 +1,16 @@
-use crate::{BuildUpdate, Builder, Error, Platform, Result, ServeArgs, TraceController, TraceSrc};
+use crate::{AppBuilder, BuildId, BuildMode, BuilderUpdate, Result, ServeArgs, TraceController};
 
 mod ansi_buffer;
-mod detect;
-mod handle;
 mod output;
 mod proxy;
 mod runner;
 mod server;
 mod update;
-mod watcher;
 
-pub(crate) use handle::*;
 pub(crate) use output::*;
 pub(crate) use runner::*;
 pub(crate) use server::*;
 pub(crate) use update::*;
-pub(crate) use watcher::*;
 
 /// For *all* builds, the CLI spins up a dedicated webserver, file watcher, and build infrastructure to serve the project.
 ///
@@ -23,11 +18,11 @@ pub(crate) use watcher::*;
 ///
 /// Platform specifics:
 /// -------------------
-/// - Web: we need to attach a filesystem server to our devtools webserver to serve the project. We
-///   want to emulate GithubPages here since most folks are deploying there and expect things like
-///   basepath to match.
-/// - Desktop: We spin up the dev server but without a filesystem server.
-/// - Mobile: Basically the same as desktop.
+/// - Web:         We need to attach a filesystem server to our devtools webserver to serve the project. We
+///                want to emulate GithubPages here since most folks are deploying there and expect things like
+///                basepath to match.
+/// - Desktop:     We spin up the dev server but without a filesystem server.
+/// - Mobile:      Basically the same as desktop.
 ///
 /// When fullstack is enabled, we'll also build for the `server` target and then hotreload the server.
 /// The "server" is special here since "fullstack" is functionally just an addition to the regular client
@@ -37,19 +32,11 @@ pub(crate) use watcher::*;
 /// - I'd love to be able to configure the CLI while it's running so we can change settings on the fly.
 /// - 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(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
-    // Redirect all logging the cli logger
-    let mut tracer = TraceController::redirect(args.is_interactive_tty());
-
-    // Load the krate and resolve the server args against it - this might log so do it after we turn on the tracer first
-    let krate = args.load_krate().await?;
-
-    // Note that starting the builder will queue up a build immediately
-    let mut screen = Output::start(&args).await?;
-    let mut builder = Builder::start(&krate, args.build_args())?;
-    let mut devserver = WebServer::start(&krate, &args)?;
-    let mut watcher = Watcher::start(&krate, &args);
-    let mut runner = AppRunner::start(&krate);
+pub(crate) async fn serve_all(args: ServeArgs, tracer: &mut TraceController) -> Result<()> {
+    // Load the args into a plan, resolving all tooling, build dirs, arguments, decoding the multi-target, etc
+    let mut builder = AppServer::start(args).await?;
+    let mut devserver = WebServer::start(&builder)?;
+    let mut screen = Output::start(builder.interactive).await?;
 
     // This is our default splash screen. We might want to make this a fancier splash screen in the future
     // Also, these commands might not be the most important, but it's all we've got enabled right now
@@ -63,166 +50,137 @@ pub(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
                 • Press `/` for more commands and shortcuts
                 Learn more at https://dioxuslabs.com/learn/0.6/getting_started
                ----------------------------------------------------------------"#,
-        krate.executable_name()
+        builder.app_name()
     );
 
-    let err: Result<(), Error> = loop {
+    loop {
         // Draw the state of the server to the screen
-        screen.render(&args, &krate, &builder, &devserver, &watcher);
+        screen.render(&builder, &devserver);
 
         // And then wait for any updates before redrawing
         let msg = tokio::select! {
-            msg = builder.wait() => ServeUpdate::BuildUpdate(msg),
-            msg = watcher.wait() => msg,
+            msg = builder.wait() => msg,
             msg = devserver.wait() => msg,
             msg = screen.wait() => msg,
-            msg = runner.wait() => msg,
             msg = tracer.wait() => msg,
         };
 
         match msg {
             ServeUpdate::FilesChanged { files } => {
-                if files.is_empty() || !args.should_hotreload() {
+                if files.is_empty() || !builder.hot_reload {
                     continue;
                 }
 
-                let file = files[0].display().to_string();
-                let file = file.trim_start_matches(&krate.crate_dir().display().to_string());
-
-                // if change is hotreloadable, hotreload it
-                // and then send that update to all connected clients
-                if let Some(hr) = runner.attempt_hot_reload(files).await {
-                    // Only send a hotreload message for templates and assets - otherwise we'll just get a full rebuild
-                    //
-                    // Also make sure the builder isn't busy since that might cause issues with hotreloads
-                    // https://github.com/DioxusLabs/dioxus/issues/3361
-                    if hr.is_empty() || !builder.can_receive_hotreloads() {
-                        tracing::debug!(dx_src = ?TraceSrc::Dev, "Ignoring file change: {}", file);
-                        continue;
-                    }
-
-                    tracing::info!(dx_src = ?TraceSrc::Dev, "Hotreloading: {}", file);
-
-                    devserver.send_hotreload(hr).await;
-                } else if runner.should_full_rebuild {
-                    tracing::info!(dx_src = ?TraceSrc::Dev, "Full rebuild: {}", file);
-
-                    // We're going to kick off a new build, interrupting the current build if it's ongoing
-                    builder.rebuild(args.build_arguments.clone());
-
-                    // Clear the hot reload changes so we don't have out-of-sync issues with changed UI
-                    runner.clear_hot_reload_changes();
-                    runner.file_map.force_rebuild();
+                tracing::debug!("Starting hotpatching: {:?}", files);
+                builder.handle_file_change(&files, &mut devserver).await;
+            }
 
-                    // Tell the server to show a loading page for any new requests
-                    devserver.send_reload_start().await;
-                    devserver.start_build().await;
-                } else {
-                    tracing::warn!(
-                        "Rebuild required but is currently paused - press `r` to rebuild manually"
-                    )
-                }
+            ServeUpdate::RequestRebuild => {
+                // The spacing here is important-ish: we want
+                // `Full rebuild:` to line up with
+                // `Hotreloading:` to keep the alignment during long edit sessions
+                // `Hot-patching:` to keep the alignment during long edit sessions
+                tracing::info!("Full rebuild: triggered manually");
+                builder.full_rebuild().await;
+                devserver.send_reload_start().await;
+                devserver.start_build().await;
             }
 
             // Run the server in the background
             // Waiting for updates here lets us tap into when clients are added/removed
-            ServeUpdate::NewConnection => {
+            ServeUpdate::NewConnection { id, aslr_reference } => {
+                // Send the client
                 devserver
-                    .send_hotreload(runner.applied_hot_reload_changes())
+                    .send_hotreload(builder.applied_hot_reload_changes(BuildId::CLIENT))
                     .await;
 
-                runner.client_connected().await;
+                if builder.server.is_some() {
+                    devserver
+                        .send_hotreload(builder.applied_hot_reload_changes(BuildId::SERVER))
+                        .await;
+                }
+
+                builder.client_connected(id, aslr_reference).await;
             }
 
             // Received a message from the devtools server - currently we only use this for
             // logging, so we just forward it the tui
-            ServeUpdate::WsMessage(msg) => {
-                screen.push_ws_message(Platform::Web, msg);
+            ServeUpdate::WsMessage { msg, platform } => {
+                screen.push_ws_message(platform, &msg);
             }
 
             // Wait for logs from the build engine
             // These will cause us to update the screen
             // We also can check the status of the builds here in case we have multiple ongoing builds
-            ServeUpdate::BuildUpdate(update) => {
+            ServeUpdate::BuilderUpdate { id, update } => {
+                let platform = builder.get_build(id).unwrap().build.platform;
+
                 // Queue any logs to be printed if need be
                 screen.new_build_update(&update);
 
                 // And then update the websocketed clients with the new build status in case they want it
-                devserver.new_build_update(&update, &builder).await;
+                devserver.new_build_update(&update).await;
 
                 // And then open the app if it's ready
-                // todo: there might be more things to do here that require coordination with other pieces of the CLI
-                // todo: maybe we want to shuffle the runner around to send an "open" command instead of doing that
                 match update {
-                    BuildUpdate::Progress { .. } => {}
-                    BuildUpdate::CompilerMessage { message } => {
+                    BuilderUpdate::Progress { .. } => {}
+                    BuilderUpdate::CompilerMessage { message } => {
                         screen.push_cargo_log(message);
                     }
-                    BuildUpdate::BuildFailed { err } => {
-                        tracing::error!("Build failed: {:?}", err);
+                    BuilderUpdate::BuildFailed { err } => {
+                        tracing::error!("Build failed: {:#?}", err);
                     }
-                    BuildUpdate::BuildReady { bundle } => {
-                        let handle = runner
-                            .open(
-                                bundle,
-                                devserver.devserver_address(),
-                                devserver.displayed_address(),
-                                devserver.proxied_server_address(),
-                                args.open.unwrap_or(false),
-                            )
-                            .await;
-
-                        match handle {
-                            // Update the screen + devserver with the new handle info
-                            Ok(_handle) => {
-                                devserver.send_reload_command().await;
+                    BuilderUpdate::BuildReady { bundle } => match bundle.mode {
+                        BuildMode::Thin { ref cache, .. } => {
+                            let elapsed =
+                                bundle.time_end.duration_since(bundle.time_start).unwrap();
+                            match builder.hotpatch(&bundle, id, cache).await {
+                                Ok(jumptable) => devserver.send_patch(jumptable, elapsed, id).await,
+                                Err(err) => {
+                                    tracing::error!("Failed to hot-patch app: {err}");
+
+                                    if matches!(err, crate::Error::PatchingFailed(_)) {
+                                        tracing::info!("Starting full rebuild: {err}");
+                                        builder.full_rebuild().await;
+                                        devserver.send_reload_start().await;
+                                        devserver.start_build().await;
+                                    }
+                                }
                             }
-
-                            Err(e) => tracing::error!("Failed to open app: {}", e),
+                        }
+                        BuildMode::Base | BuildMode::Fat => {
+                            _ = builder
+                                .open(bundle, &mut devserver)
+                                .await
+                                .inspect_err(|e| tracing::error!("Failed to open app: {}", e));
+                        }
+                    },
+                    BuilderUpdate::StdoutReceived { msg } => {
+                        screen.push_stdio(platform, msg, tracing::Level::INFO);
+                    }
+                    BuilderUpdate::StderrReceived { msg } => {
+                        screen.push_stdio(platform, msg, tracing::Level::ERROR);
+                    }
+                    BuilderUpdate::ProcessExited { status } => {
+                        if status.success() {
+                            tracing::info!(
+                                r#"Application [{platform}] exited gracefully.
+               • To restart the app, press `r` to rebuild or `o` to open
+               • To exit the server, press `ctrl+c`"#
+                            );
+                        } else {
+                            tracing::error!("Application [{platform}] exited with error: {status}");
                         }
                     }
                 }
             }
 
-            // If the process exited *cleanly*, we can exit
-            ServeUpdate::ProcessExited { status, platform } => {
-                if !status.success() {
-                    tracing::error!("Application [{platform}] exited with error: {status}");
-                } else {
-                    tracing::info!(
-                        r#"Application [{platform}] exited gracefully.
-               - To restart the app, press `r` to rebuild or `o` to open
-               - To exit the server, press `ctrl+c`"#
-                    );
-                }
-            }
-
-            ServeUpdate::StdoutReceived { platform, msg } => {
-                screen.push_stdio(platform, msg, tracing::Level::INFO);
-            }
-
-            ServeUpdate::StderrReceived { platform, msg } => {
-                screen.push_stdio(platform, msg, tracing::Level::ERROR);
-            }
-
             ServeUpdate::TracingLog { log } => {
                 screen.push_log(log);
             }
 
-            ServeUpdate::RequestRebuild => {
-                // The spacing here is important-ish: we want
-                // `Full rebuild:` to line up with
-                // `Hotreloading:` to keep the alignment during long edit sessions
-                tracing::info!("Full rebuild: triggered manually");
-
-                builder.rebuild(args.build_arguments.clone());
-                runner.file_map.force_rebuild();
-                devserver.send_reload_start().await;
-                devserver.start_build().await
-            }
-
             ServeUpdate::OpenApp => {
-                if let Err(err) = runner.open_existing(&devserver).await {
+                if let Err(err) = builder.open_all(&devserver, true).await {
                     tracing::error!("Failed to open app: {err}")
                 }
             }
@@ -232,10 +190,10 @@ pub(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
             }
 
             ServeUpdate::ToggleShouldRebuild => {
-                runner.should_full_rebuild = !runner.should_full_rebuild;
+                builder.automatic_rebuilds = !builder.automatic_rebuilds;
                 tracing::info!(
                     "Automatic rebuilds are currently: {}",
-                    if runner.should_full_rebuild {
+                    if builder.automatic_rebuilds {
                         "enabled"
                     } else {
                         "disabled"
@@ -243,21 +201,16 @@ pub(crate) async fn serve_all(mut args: ServeArgs) -> Result<()> {
                 )
             }
 
-            ServeUpdate::Exit { error } => match error {
-                Some(err) => break Err(anyhow::anyhow!("{}", err).into()),
-                None => break Ok(()),
-            },
-        }
-    };
+            ServeUpdate::Exit { error } => {
+                _ = builder.cleanup_all().await;
+                _ = devserver.shutdown().await;
+                _ = screen.shutdown();
 
-    _ = runner.cleanup().await;
-    _ = devserver.shutdown().await;
-    builder.abort_all();
-    _ = screen.shutdown();
-
-    if let Err(err) = err {
-        eprintln!("Exiting with error: {}", err);
+                match error {
+                    Some(err) => return Err(anyhow::anyhow!("{}", err).into()),
+                    None => return Ok(()),
+                }
+            }
+        }
     }
-
-    Ok(())
 }

packages/cli/src/serve/output.rs

@@ -1,7 +1,6 @@
 use crate::{
-    serve::{ansi_buffer::AnsiStringLine, Builder, ServeUpdate, Watcher, WebServer},
-    BuildStage, BuildUpdate, DioxusCrate, Platform, RustcDetails, ServeArgs, TraceContent,
-    TraceMsg, TraceSrc,
+    serve::{ansi_buffer::AnsiStringLine, ServeUpdate, WebServer},
+    BuildStage, BuilderUpdate, Platform, TraceContent, TraceMsg, TraceSrc,
 };
 use crossterm::{
     cursor::{Hide, Show},
@@ -26,6 +25,8 @@ use std::{
 };
 use tracing::Level;
 
+use super::AppServer;
+
 const TICK_RATE_MS: u64 = 100;
 const VIEWPORT_MAX_WIDTH: u16 = 100;
 const VIEWPORT_HEIGHT_SMALL: u16 = 5;
@@ -46,7 +47,6 @@ pub struct Output {
     // A list of all messages from build, dev, app, and more.
     more_modal_open: bool,
     interactive: bool,
-    platform: Platform,
 
     // Whether to show verbose logs or not
     // We automatically hide "debug" logs if verbose is false (only showing "info" / "warn" / "error")
@@ -64,31 +64,24 @@ pub struct Output {
     // ! needs to be wrapped in an &mut since `render stateful widget` requires &mut... but our
     // "render" method only borrows &self (for no particular reason at all...)
     throbber: RefCell<throbber_widgets_tui::ThrobberState>,
-
-    rustc_details: RustcDetails,
 }
 
-#[allow(unused)]
 #[derive(Clone, Copy)]
 struct RenderState<'a> {
-    opts: &'a ServeArgs,
-    krate: &'a DioxusCrate,
-    build_engine: &'a Builder,
+    runner: &'a AppServer,
     server: &'a WebServer,
-    watcher: &'a Watcher,
 }
 
 impl Output {
-    pub(crate) async fn start(cfg: &ServeArgs) -> crate::Result<Self> {
+    pub(crate) async fn start(interactive: bool) -> crate::Result<Self> {
         let mut output = Self {
+            interactive,
             term: Rc::new(RefCell::new(None)),
-            interactive: cfg.is_interactive_tty(),
             dx_version: format!(
                 "{}-{}",
                 env!("CARGO_PKG_VERSION"),
                 crate::dx_build_info::GIT_COMMIT_HASH_SHORT.unwrap_or("main")
             ),
-            platform: cfg.build_arguments.platform.expect("To be resolved by now"),
             events: None,
             more_modal_open: false,
             pending_logs: VecDeque::new(),
@@ -101,7 +94,6 @@ impl Output {
                 interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
                 interval
             },
-            rustc_details: RustcDetails::from_cli().await?,
         };
 
         output.startup()?;
@@ -113,15 +105,6 @@ impl Output {
     /// This is meant to be paired with "shutdown" to restore the terminal to its original state.
     fn startup(&mut self) -> io::Result<()> {
         if self.interactive {
-            // set the panic hook to fix the terminal in the event of a panic
-            // The terminal might be left in a wonky state if a panic occurs, and we don't want it to be completely broken
-            let original_hook = std::panic::take_hook();
-            std::panic::set_hook(Box::new(move |info| {
-                _ = disable_raw_mode();
-                _ = stdout().execute(Show);
-                original_hook(info);
-            }));
-
             // Check if writing the terminal is going to block infinitely.
             // If it does, we should disable interactive mode. This ensures we work with programs like `bg`
             // which suspend the process and cause us to block when writing output.
@@ -183,7 +166,12 @@ impl Output {
     /// Call the shutdown functions that might mess with the terminal settings - see the related code
     /// in "startup" for more details about what we need to unset
     pub(crate) fn shutdown(&self) -> io::Result<()> {
-        if self.interactive {
+        Self::remote_shutdown(self.interactive)?;
+        Ok(())
+    }
+
+    pub(crate) fn remote_shutdown(interactive: bool) -> io::Result<()> {
+        if interactive {
             stdout()
                 .execute(Show)?
                 .execute(DisableFocusChange)?
@@ -329,7 +317,7 @@ impl Output {
     }
 
     /// Push a message from the websocket to the logs
-    pub fn push_ws_message(&mut self, platform: Platform, message: axum::extract::ws::Message) {
+    pub fn push_ws_message(&mut self, platform: Platform, message: &axum::extract::ws::Message) {
         use dioxus_devtools_types::ClientMsg;
 
         // We can only handle text messages from the websocket...
@@ -341,14 +329,18 @@ impl Output {
         let res = serde_json::from_str::<ClientMsg>(text.as_str());
 
         // Client logs being errors aren't fatal, but we should still report them them
-        let ClientMsg::Log { level, messages } = match res {
+        let msg = match res {
             Ok(msg) => msg,
             Err(err) => {
-                tracing::error!(dx_src = ?TraceSrc::Dev, "Error parsing message from {}: {}", platform, err);
+                tracing::error!(dx_src = ?TraceSrc::Dev, "Error parsing message from {}: {} -> {:?}", platform, err, text.as_str());
                 return;
             }
         };
 
+        let ClientMsg::Log { level, messages } = msg else {
+            return;
+        };
+
         // FIXME(jon): why are we pulling only the first message here?
         let content = messages.first().unwrap_or(&String::new()).clone();
 
@@ -373,26 +365,19 @@ impl Output {
     /// approach, but then we'd need to do that *everywhere* instead of simply performing a react-like
     /// re-render when external state changes. Ratatui will diff the intermediate buffer, so we at least
     /// we won't be drawing it.
-    pub(crate) fn new_build_update(&mut self, update: &BuildUpdate) {
+    pub(crate) fn new_build_update(&mut self, update: &BuilderUpdate) {
         match update {
-            BuildUpdate::Progress {
+            BuilderUpdate::Progress {
                 stage: BuildStage::Starting { .. },
             } => self.tick_animation = true,
-            BuildUpdate::BuildReady { .. } => self.tick_animation = false,
-            BuildUpdate::BuildFailed { .. } => self.tick_animation = false,
+            BuilderUpdate::BuildReady { .. } => self.tick_animation = false,
+            BuilderUpdate::BuildFailed { .. } => self.tick_animation = false,
             _ => {}
         }
     }
 
     /// Render the current state of everything to the console screen
-    pub fn render(
-        &mut self,
-        opts: &ServeArgs,
-        config: &DioxusCrate,
-        build_engine: &Builder,
-        server: &WebServer,
-        watcher: &Watcher,
-    ) {
+    pub fn render(&mut self, runner: &AppServer, server: &WebServer) {
         if !self.interactive {
             return;
         }
@@ -409,16 +394,7 @@ impl Output {
 
         // Then, draw the frame, passing along all the state of the TUI so we can render it properly
         _ = term.draw(|frame| {
-            self.render_frame(
-                frame,
-                RenderState {
-                    opts,
-                    krate: config,
-                    build_engine,
-                    server,
-                    watcher,
-                },
-            );
+            self.render_frame(frame, RenderState { runner, server });
         });
     }
 
@@ -488,39 +464,46 @@ impl Output {
         ])
         .areas(gauge_area);
 
+        let client = &state.runner.client();
         self.render_single_gauge(
             frame,
             app_progress,
-            state.build_engine.compile_progress(),
+            client.compile_progress(),
             "App:    ",
             state,
-            state.build_engine.compile_duration(),
+            client.compile_duration(),
         );
 
-        if state.build_engine.request.build.fullstack() {
+        if state.runner.is_fullstack() {
             self.render_single_gauge(
                 frame,
                 second_progress,
-                state.build_engine.server_compile_progress(),
+                state.runner.server_compile_progress(),
                 "Server: ",
                 state,
-                state.build_engine.compile_duration(),
+                client.compile_duration(),
             );
         } else {
             self.render_single_gauge(
                 frame,
                 second_progress,
-                state.build_engine.bundle_progress(),
+                client.bundle_progress(),
                 "Bundle: ",
                 state,
-                state.build_engine.bundle_duration(),
+                client.bundle_duration(),
             );
         }
 
         let mut lines = vec!["Status:  ".white()];
-        match &state.build_engine.stage {
+        match &client.stage {
             BuildStage::Initializing => lines.push("Initializing".yellow()),
-            BuildStage::Starting { .. } => lines.push("Starting build".yellow()),
+            BuildStage::Starting { patch, .. } => {
+                if *patch {
+                    lines.push("Hot-patching...".yellow())
+                } else {
+                    lines.push("Starting build".yellow())
+                }
+            }
             BuildStage::InstallingTooling => lines.push("Installing tooling".yellow()),
             BuildStage::Compiling {
                 current,
@@ -535,7 +518,6 @@ impl Output {
             BuildStage::OptimizingWasm => lines.push("Optimizing wasm".yellow()),
             BuildStage::SplittingBundle => lines.push("Splitting bundle".yellow()),
             BuildStage::CompressingAssets => lines.push("Compressing assets".yellow()),
-            BuildStage::PrerenderingRoutes => lines.push("Prerendering static routes".yellow()),
             BuildStage::RunningBindgen => lines.push("Running wasm-bindgen".yellow()),
             BuildStage::RunningGradle => lines.push("Running gradle assemble".yellow()),
             BuildStage::Bundling => lines.push("Bundling app".yellow()),
@@ -552,15 +534,18 @@ impl Output {
             }
             BuildStage::Success => {
                 lines.push("Serving ".yellow());
-                lines.push(state.krate.executable_name().white());
+                lines.push(client.build.executable_name().white());
                 lines.push(" 🚀 ".green());
-                if let Some(comp_time) = state.build_engine.total_build_time() {
+                if let Some(comp_time) = client.total_build_time() {
                     lines.push(format!("{:.1}s", comp_time.as_secs_f32()).dark_gray());
                 }
             }
             BuildStage::Failed => lines.push("Failed".red()),
             BuildStage::Aborted => lines.push("Aborted".red()),
             BuildStage::Restarting => lines.push("Restarting".yellow()),
+            BuildStage::Linking => lines.push("Linking".yellow()),
+            BuildStage::Hotpatching => lines.push("Hot-patching...".yellow()),
+            BuildStage::ExtractingAssets => lines.push("Extracting assets".yellow()),
             _ => {}
         };
 
@@ -576,7 +561,7 @@ impl Output {
         state: RenderState,
         time_taken: Option<Duration>,
     ) {
-        let failed = state.build_engine.stage == BuildStage::Failed;
+        let failed = state.runner.client.stage == BuildStage::Failed;
         let value = if failed { 1.0 } else { value.clamp(0.0, 1.0) };
 
         let [gauge_row, _, icon] = Layout::horizontal([
@@ -647,11 +632,12 @@ impl Output {
         ])
         .areas(area);
 
+        let client = &state.runner.client();
         frame.render_widget(
             Paragraph::new(Line::from(vec![
                 "Platform: ".gray(),
-                self.platform.expected_name().yellow(),
-                if state.opts.build_arguments.fullstack() {
+                client.build.platform.expected_name().yellow(),
+                if state.runner.is_fullstack() {
                     " + fullstack".yellow()
                 } else {
                     " ".dark_gray()
@@ -671,7 +657,7 @@ impl Output {
 
         frame.render_widget_ref(
             Paragraph::new(Line::from(vec![
-                if self.platform == Platform::Web {
+                if client.build.platform == Platform::Web {
                     "Serving at: ".gray()
                 } else {
                     "ServerFns at: ".gray()
@@ -688,7 +674,7 @@ impl Output {
             Paragraph::new(Line::from({
                 let mut lines = vec!["App features: ".gray(), "[".yellow()];
 
-                let feature_list: Vec<String> = state.build_engine.request.all_target_features();
+                let feature_list: Vec<String> = state.runner.client().build.all_target_features();
                 let num_features = feature_list.len();
 
                 for (idx, feature) in feature_list.into_iter().enumerate() {
@@ -737,7 +723,7 @@ impl Output {
         frame.render_widget(
             Paragraph::new(Line::from(vec![
                 "rustc: ".gray(),
-                self.rustc_details.version.as_str().yellow(),
+                state.runner.workspace.rustc_version.as_str().yellow(),
             ])),
             meta_list[2],
         );
@@ -869,8 +855,8 @@ impl Output {
             .iter()
             .map(|line| {
                 // Very important to strip ansi codes before counting graphemes - the ansi codes count as multiple graphemes!
-                let grapheme_count = console::strip_ansi_codes(line).graphemes(true).count() as u16;
-                grapheme_count.max(1).div_ceil(term_size.width)
+                let grapheme_count = console::strip_ansi_codes(line).graphemes(true).count();
+                grapheme_count.max(1).div_ceil(term_size.width as usize) as u16
             })
             .sum::<u16>();
 
@@ -1005,7 +991,11 @@ impl Output {
 
                 // Create the ansi -> raw string line with a width of either the viewport width or the max width
                 let line_length = line.styled_graphemes(Style::default()).count();
-                lines.push(AnsiStringLine::new(line_length as _).render(&line));
+                if line_length < u16::MAX as usize {
+                    lines.push(AnsiStringLine::new(line_length as _).render(&line));
+                } else {
+                    lines.push(line.to_string())
+                }
             }
         }
 

packages/cli/src/serve/runner.rs

@@ -1,252 +1,654 @@
-use super::{AppHandle, ServeUpdate, WebServer};
+use super::{AppBuilder, ServeUpdate, WebServer};
 use crate::{
-    AppBundle, DioxusCrate, HotreloadFilemap, HotreloadResult, Platform, Result, TraceSrc,
+    BuildArtifacts, BuildId, BuildMode, BuildTargets, Error, HotpatchModuleCache, Platform, Result,
+    ServeArgs, TraceSrc, Workspace,
+};
+use anyhow::Context;
+use dioxus_core::internal::{
+    HotReloadTemplateWithLocation, HotReloadedTemplate, TemplateGlobalKey,
 };
-use dioxus_core::internal::TemplateGlobalKey;
 use dioxus_devtools_types::HotReloadMsg;
+use dioxus_dx_wire_format::BuildStage;
 use dioxus_html::HtmlCtx;
+use dioxus_rsx::CallBody;
+use dioxus_rsx_hotreload::{ChangedRsx, HotReloadResult};
+use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
 use futures_util::future::OptionFuture;
-use ignore::gitignore::Gitignore;
+use futures_util::StreamExt;
+use krates::NodeId;
+use notify::{
+    event::{MetadataKind, ModifyKind},
+    Config, EventKind, RecursiveMode, Watcher as NotifyWatcher,
+};
 use std::{
     collections::{HashMap, HashSet},
-    net::SocketAddr,
+    net::{IpAddr, TcpListener},
     path::PathBuf,
+    sync::Arc,
+    time::Duration,
 };
+use subsecond_types::JumpTable;
+use syn::spanned::Spanned;
+use tokio::process::Command;
+
+/// This is the primary "state" object that holds the builds and handles for the running apps.
+///
+/// It also holds the watcher which is used to watch for changes in the filesystem and trigger rebuilds,
+/// hotreloads, asset updates, etc.
+///
+/// Since we resolve the build request before initializing the CLI, it also serves as a place to store
+/// resolved "serve" arguments, which is why it takes ServeArgs instead of BuildArgs. Simply wrap the
+/// BuildArgs in a default ServeArgs and pass it in.
+pub(crate) struct AppServer {
+    /// the platform of the "primary" crate (ie the first)
+    pub(crate) workspace: Arc<Workspace>,
+
+    pub(crate) client: AppBuilder,
+    pub(crate) server: Option<AppBuilder>,
+
+    // Related to to the filesystem watcher
+    pub(crate) watcher: Box<dyn notify::Watcher>,
+    pub(crate) _watcher_tx: UnboundedSender<notify::Event>,
+    pub(crate) watcher_rx: UnboundedReceiver<notify::Event>,
 
-pub(crate) struct AppRunner {
-    pub(crate) running: Option<AppHandle>,
-    pub(crate) krate: DioxusCrate,
-    pub(crate) file_map: HotreloadFilemap,
-    pub(crate) ignore: Gitignore,
+    // Tracked state related to open builds and hot reloading
     pub(crate) applied_hot_reload_message: HotReloadMsg,
-    pub(crate) builds_opened: usize,
-    pub(crate) should_full_rebuild: bool,
+    pub(crate) file_map: HashMap<PathBuf, CachedFile>,
+
+    // Resolved args related to how we go about processing the rebuilds and logging
+    pub(crate) use_hotpatch_engine: bool,
+    pub(crate) automatic_rebuilds: bool,
+    pub(crate) interactive: bool,
+    pub(crate) _force_sequential: bool,
+    pub(crate) hot_reload: bool,
+    pub(crate) open_browser: bool,
+    pub(crate) _wsl_file_poll_interval: u16,
+    pub(crate) always_on_top: bool,
+    pub(crate) fullstack: bool,
+    pub(crate) watch_fs: bool,
+
+    // resolve args related to the webserver
+    pub(crate) devserver_port: u16,
+    pub(crate) devserver_bind_ip: IpAddr,
+    pub(crate) proxied_port: Option<u16>,
+    pub(crate) cross_origin_policy: bool,
 }
 
-impl AppRunner {
+pub(crate) struct CachedFile {
+    contents: String,
+    most_recent: Option<String>,
+    templates: HashMap<TemplateGlobalKey, HotReloadedTemplate>,
+}
+
+impl AppServer {
     /// Create the AppRunner and then initialize the filemap with the crate directory.
-    pub(crate) fn start(krate: &DioxusCrate) -> Self {
+    pub(crate) async fn start(args: ServeArgs) -> Result<Self> {
+        let workspace = Workspace::current().await?;
+
+        // Resolve the simpler args
+        let interactive = args.is_interactive_tty();
+        let force_sequential = args.force_sequential;
+        let cross_origin_policy = args.cross_origin_policy;
+
+        // These come from the args but also might come from the workspace settings
+        // We opt to use the manually specified args over the workspace settings
+        let hot_reload = args
+            .hot_reload
+            .unwrap_or_else(|| workspace.settings.always_hot_reload.unwrap_or(true));
+
+        let open_browser = args
+            .open
+            .unwrap_or_else(|| workspace.settings.always_open_browser.unwrap_or_default());
+
+        let wsl_file_poll_interval = args
+            .wsl_file_poll_interval
+            .unwrap_or_else(|| workspace.settings.wsl_file_poll_interval.unwrap_or(2));
+
+        let always_on_top = args
+            .always_on_top
+            .unwrap_or_else(|| workspace.settings.always_on_top.unwrap_or(true));
+
+        // Use 127.0.0.1 as the default address if none is specified.
+        // If the user wants to export on the network, they can use `0.0.0.0` instead.
+        let devserver_bind_ip = args.address.addr.unwrap_or(WebServer::SELF_IP);
+
+        // If the user specified a port, use that, otherwise use any available port, preferring 8080
+        let devserver_port = args
+            .address
+            .port
+            .unwrap_or_else(|| get_available_port(devserver_bind_ip, Some(8080)).unwrap_or(8080));
+
+        // Spin up the file watcher
+        let (watcher_tx, watcher_rx) = futures_channel::mpsc::unbounded();
+        let watcher = create_notify_watcher(watcher_tx.clone(), wsl_file_poll_interval as u64);
+
+        let BuildTargets { client, server } = args.targets.into_targets().await?;
+
+        // All servers will end up behind us (the devserver) but on a different port
+        // This is so we can serve a loading screen as well as devtools without anything particularly fancy
+        let fullstack = server.is_some();
+        let should_proxy_port = match client.platform {
+            Platform::Server => true,
+            _ => fullstack,
+        };
+
+        let proxied_port = should_proxy_port
+            .then(|| get_available_port(devserver_bind_ip, None))
+            .flatten();
+
+        let watch_fs = args.watch.unwrap_or(true);
+        let use_hotpatch_engine = args.hot_patch;
+        let build_mode = match use_hotpatch_engine {
+            true => BuildMode::Fat,
+            false => BuildMode::Base,
+        };
+
+        let client = AppBuilder::start(&client, build_mode.clone())?;
+        let server = server
+            .map(|server| AppBuilder::start(&server, build_mode))
+            .transpose()?;
+
+        tracing::debug!("Proxied port: {:?}", proxied_port);
+
+        // Create the runner
         let mut runner = Self {
-            running: Default::default(),
-            file_map: HotreloadFilemap::new(),
+            file_map: Default::default(),
             applied_hot_reload_message: Default::default(),
-            ignore: krate.workspace_gitignore(),
-            krate: krate.clone(),
-            builds_opened: 0,
-            should_full_rebuild: true,
+            automatic_rebuilds: true,
+            watch_fs,
+            use_hotpatch_engine,
+            client,
+            server,
+            hot_reload,
+            open_browser,
+            _wsl_file_poll_interval: wsl_file_poll_interval,
+            always_on_top,
+            workspace,
+            devserver_port,
+            devserver_bind_ip,
+            proxied_port,
+            watcher,
+            watcher_rx,
+            _watcher_tx: watcher_tx,
+            interactive,
+            _force_sequential: force_sequential,
+            cross_origin_policy,
+            fullstack,
         };
 
-        // todo(jon): this might take a while so we should try and background it, or make it lazy somehow
-        // we could spawn a thread to search the FS and then when it returns we can fill the filemap
-        // in testing, if this hits a massive directory, it might take several seconds with no feedback.
-        for krate in krate.all_watched_crates() {
-            runner.fill_filemap(krate);
-        }
+        // Only register the hot-reload stuff if we're watching the filesystem
+        if runner.watch_fs {
+            // Spin up the notify watcher
+            // When builds load though, we're going to parse their depinfo and add the paths to the watcher
+            runner.watch_filesystem();
 
-        // Ensure the session cache dir exists and is empty
-        runner.flush_session_cache();
+            // todo(jon): this might take a while so we should try and background it, or make it lazy somehow
+            // we could spawn a thread to search the FS and then when it returns we can fill the filemap
+            // in testing, if this hits a massive directory, it might take several seconds with no feedback.
+            // really, we should be using depinfo to get the files that are actually used, but the depinfo file might not be around yet
+            // todo(jon): see if we can just guess the depinfo file before it generates. might be stale but at least it catches most of the files
+            runner.load_rsx_filemap();
+        }
 
-        runner
+        Ok(runner)
     }
 
     pub(crate) async fn wait(&mut self) -> ServeUpdate {
-        // If there are no running apps, we can just return pending to avoid deadlocking
-        let Some(handle) = self.running.as_mut() else {
-            return futures_util::future::pending().await;
-        };
+        let client = &mut self.client;
+        let server = self.server.as_mut();
+
+        let client_wait = client.wait();
+        let server_wait = OptionFuture::from(server.map(|s| s.wait()));
+        let watcher_wait = self.watcher_rx.next();
 
-        use ServeUpdate::*;
-        let platform = handle.app.build.build.platform();
         tokio::select! {
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.app_stdout.as_mut().map(|f| f.next_line())) => {
-                StdoutReceived { platform, msg }
-            },
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.app_stderr.as_mut().map(|f| f.next_line())) => {
-                StderrReceived { platform, msg }
-            },
-            Some(status) = OptionFuture::from(handle.app_child.as_mut().map(|f| f.wait())) => {
-                match status {
-                    Ok(status) => {
-                        handle.app_child = None;
-                        ProcessExited { status, platform }
-                    },
-                    Err(_err) => todo!("handle error in process joining?"),
+            // Wait for the client to finish
+            client_update = client_wait => {
+                ServeUpdate::BuilderUpdate {
+                    id: BuildId::CLIENT,
+                    update: client_update,
                 }
             }
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.server_stdout.as_mut().map(|f| f.next_line())) => {
-                StdoutReceived { platform: Platform::Server, msg }
-            },
-            Some(Ok(Some(msg))) = OptionFuture::from(handle.server_stderr.as_mut().map(|f| f.next_line())) => {
-                StderrReceived { platform: Platform::Server, msg }
-            },
-            Some(status) = OptionFuture::from(handle.server_child.as_mut().map(|f| f.wait())) => {
-                match status {
-                    Ok(status) => {
-                        handle.server_child = None;
-                        ProcessExited { status, platform }
-                    },
-                    Err(_err) => todo!("handle error in process joining?"),
+
+            Some(server_update) = server_wait => {
+                ServeUpdate::BuilderUpdate {
+                    id: BuildId::SERVER,
+                    update: server_update,
                 }
             }
-            else => futures_util::future::pending().await
-        }
-    }
 
-    /// Finally "bundle" this app and return a handle to it
-    pub(crate) async fn open(
-        &mut self,
-        app: AppBundle,
-        devserver_ip: SocketAddr,
-        open_address: Option<SocketAddr>,
-        fullstack_address: Option<SocketAddr>,
-        should_open_web: bool,
-    ) -> Result<&AppHandle> {
-        // Drop the old handle
-        // This is a more forceful kill than soft_kill since the app entropy will be wiped
-        self.cleanup().await;
-
-        // Add some cute logging
-        if self.builds_opened == 0 {
-            tracing::info!(
-                "Build completed successfully in {:?}ms, launching app! 💫",
-                app.app.time_taken.as_millis()
-            );
-        } else {
-            tracing::info!("Build completed in {:?}ms", app.app.time_taken.as_millis());
-        }
+            // Wait for the watcher to send us an event
+            event = watcher_wait => {
+                let mut changes: Vec<_> = event.into_iter().collect();
 
-        // Start the new app before we kill the old one to give it a little bit of time
-        let mut handle = AppHandle::new(app).await?;
-        handle
-            .open(
-                devserver_ip,
-                open_address,
-                fullstack_address,
-                self.builds_opened == 0 && should_open_web,
-            )
-            .await?;
+                // Dequeue in bulk if we can, we might've received a lot of events in one go
+                while let Some(event) = self.watcher_rx.try_next().ok().flatten() {
+                    changes.push(event);
+                }
 
-        self.builds_opened += 1;
-        self.running = Some(handle);
+                // Filter the changes
+                let mut files: Vec<PathBuf> = vec![];
 
-        Ok(self.running.as_ref().unwrap())
-    }
+                // Decompose the events into a list of all the files that have changed
+                for event in changes.drain(..) {
+                    // Make sure we add new folders to the watch list, provided they're not matched by the ignore list
+                    // We'll only watch new folders that are found under the crate, and then update our watcher to watch them
+                    // This unfortunately won't pick up new krates added "at a distance" - IE krates not within the workspace.
+                    if let EventKind::Create(_create_kind) = event.kind {
+                        // If it's a new folder, watch it
+                        // If it's a new cargo.toml (ie dep on the fly),
+                        // todo(jon) support new folders on the fly
+                    }
 
-    /// Open an existing app bundle, if it exists
-    pub(crate) async fn open_existing(&mut self, devserver: &WebServer) -> Result<()> {
-        let fullstack_address = devserver.proxied_server_address();
+                    for path in event.paths {
+                        // Workaround for notify and vscode-like editor:
+                        // - when edit & save a file in vscode, there will be two notifications,
+                        // - the first one is a file with empty content.
+                        // - filter the empty file notification to avoid false rebuild during hot-reload
+                        if let Ok(metadata) = std::fs::metadata(&path) {
+                            if metadata.len() == 0 {
+                                continue;
+                            }
+                        }
 
-        if let Some(runner) = self.running.as_mut() {
-            runner.soft_kill().await;
-            runner
-                .open(
-                    devserver.devserver_address(),
-                    devserver.displayed_address(),
-                    fullstack_address,
-                    true,
-                )
-                .await?;
-        }
+                        files.push(path);
+                    }
+                }
 
-        Ok(())
-    }
+                ServeUpdate::FilesChanged { files }
+            }
 
-    /// Shutdown all the running processes
-    pub(crate) async fn cleanup(&mut self) {
-        if let Some(mut process) = self.running.take() {
-            process.cleanup().await;
         }
     }
 
-    pub(crate) async fn attempt_hot_reload(
-        &mut self,
-        modified_files: Vec<PathBuf>,
-    ) -> Option<HotReloadMsg> {
+    /// Handle the list of changed files from the file watcher, attempting to aggressively prevent
+    /// full rebuilds by hot-reloading RSX and hot-patching Rust code.
+    ///
+    /// This will also handle any assets that are linked in the files, and copy them to the bundle
+    /// and send them to the client.
+    pub(crate) async fn handle_file_change(&mut self, files: &[PathBuf], server: &mut WebServer) {
+        // We can attempt to hotpatch if the build is in a bad state, since this patch might be a recovery.
+        if !matches!(
+            self.client.stage,
+            BuildStage::Failed | BuildStage::Aborted | BuildStage::Success
+        ) {
+            tracing::debug!(
+                "Ignoring file change: client is not ready to receive hotreloads. Files: {:#?}",
+                files
+            );
+            return;
+        }
+
         // If we have any changes to the rust files, we need to update the file map
         let mut templates = vec![];
 
         // Prepare the hotreload message we need to send
-        let mut edited_rust_files = Vec::new();
         let mut assets = Vec::new();
+        let mut needs_full_rebuild = false;
 
-        for path in modified_files {
+        // We attempt to hotreload rsx blocks without a full rebuild
+        for path in files {
             // for various assets that might be linked in, we just try to hotreloading them forcefully
             // That is, unless they appear in an include! macro, in which case we need to a full rebuild....
             let Some(ext) = path.extension().and_then(|v| v.to_str()) else {
                 continue;
             };
 
+            // If it's an asset, we want to hotreload it
+            // todo(jon): don't hardcode this here
+            if let Some(bundled_name) = self.client.hotreload_bundled_asset(path).await {
+                assets.push(PathBuf::from("/assets/").join(bundled_name));
+            }
+
             // If it's a rust file, we want to hotreload it using the filemap
             if ext == "rs" {
-                edited_rust_files.push(path);
-                continue;
+                // And grabout the contents
+                let Ok(new_contents) = std::fs::read_to_string(path) else {
+                    tracing::debug!("Failed to read rust file while hotreloading: {:?}", path);
+                    continue;
+                };
+
+                // Get the cached file if it exists - ignoring if it doesn't exist
+                let Some(cached_file) = self.file_map.get_mut(path) else {
+                    tracing::debug!("No entry for file in filemap: {:?}", path);
+                    tracing::debug!("Filemap: {:#?}", self.file_map.keys());
+                    continue;
+                };
+
+                let Ok(local_path) = path.strip_prefix(self.workspace.workspace_root()) else {
+                    tracing::debug!("Skipping file outside workspace dir: {:?}", path);
+                    continue;
+                };
+
+                // We assume we can parse the old file and the new file, ignoring untracked rust files
+                let old_syn = syn::parse_file(&cached_file.contents);
+                let new_syn = syn::parse_file(&new_contents);
+                let (Ok(old_file), Ok(new_file)) = (old_syn, new_syn) else {
+                    tracing::debug!("Diff rsx returned not parseable");
+                    continue;
+                };
+
+                // This assumes the two files are structured similarly. If they're not, we can't diff them
+                let Some(changed_rsx) = dioxus_rsx_hotreload::diff_rsx(&new_file, &old_file) else {
+                    needs_full_rebuild = true;
+                    break;
+                };
+
+                // Update the most recent version of the file, so when we force a rebuild, we keep operating on the most recent version
+                cached_file.most_recent = Some(new_contents);
+
+                for ChangedRsx { old, new } in changed_rsx {
+                    let old_start = old.span().start();
+
+                    let old_parsed = syn::parse2::<CallBody>(old.tokens);
+                    let new_parsed = syn::parse2::<CallBody>(new.tokens);
+                    let (Ok(old_call_body), Ok(new_call_body)) = (old_parsed, new_parsed) else {
+                        continue;
+                    };
+
+                    // Format the template location, normalizing the path
+                    let file_name: String = local_path
+                        .components()
+                        .map(|c| c.as_os_str().to_string_lossy())
+                        .collect::<Vec<_>>()
+                        .join("/");
+
+                    // Returns a list of templates that are hotreloadable
+                    let results = HotReloadResult::new::<HtmlCtx>(
+                        &old_call_body.body,
+                        &new_call_body.body,
+                        file_name.clone(),
+                    );
+
+                    // If no result is returned, we can't hotreload this file and need to keep the old file
+                    let Some(results) = results else {
+                        needs_full_rebuild = true;
+                        break;
+                    };
+
+                    // Only send down templates that have roots, and ideally ones that have changed
+                    // todo(jon): maybe cache these and don't send them down if they're the same
+                    for (index, template) in results.templates {
+                        if template.roots.is_empty() {
+                            continue;
+                        }
+
+                        // Create the key we're going to use to identify this template
+                        let key = TemplateGlobalKey {
+                            file: file_name.clone(),
+                            line: old_start.line,
+                            column: old_start.column + 1,
+                            index,
+                        };
+
+                        // if the template is the same, don't send its
+                        if cached_file.templates.get(&key) == Some(&template) {
+                            continue;
+                        };
+
+                        cached_file.templates.insert(key.clone(), template.clone());
+                        templates.push(HotReloadTemplateWithLocation { template, key });
+                    }
+                }
+            }
+        }
+
+        // We decided to make the hotpatch engine drive *all* hotreloads, even if they are just RSX
+        // hot-reloads. This is a temporary measure to thoroughly test the hotpatch engine until
+        // we're comfortable with both co-existing. Keeping both would lead to two potential sources
+        // of errors, and we want to avoid that for now.
+        if needs_full_rebuild || self.use_hotpatch_engine {
+            if self.use_hotpatch_engine {
+                self.client.patch_rebuild(files.to_vec());
+                if let Some(server) = self.server.as_mut() {
+                    server.patch_rebuild(files.to_vec());
+                }
+                self.clear_hot_reload_changes();
+                self.clear_cached_rsx();
+                server.send_patch_start().await;
+            } else {
+                self.client.start_rebuild(BuildMode::Base);
+                if let Some(server) = self.server.as_mut() {
+                    server.start_rebuild(BuildMode::Base);
+                }
+                self.clear_hot_reload_changes();
+                self.clear_cached_rsx();
+                server.send_reload_start().await;
             }
+        } else {
+            let msg = HotReloadMsg {
+                templates,
+                assets,
+                ms_elapsed: 0,
+                jump_table: Default::default(),
+                for_build_id: None,
+            };
+
+            self.add_hot_reload_message(&msg);
+
+            let file = files[0].display().to_string();
+            let file =
+                file.trim_start_matches(&self.client.build.crate_dir().display().to_string());
 
-            // Special-case the Cargo.toml file - we want updates here to cause a full rebuild
-            if path.file_name().and_then(|v| v.to_str()) == Some("Cargo.toml") {
-                return None;
+            // Only send a hotreload message for templates and assets - otherwise we'll just get a full rebuild
+            //
+            // todo: move the android file uploading out of hotreload_bundled_asset and
+            //
+            // Also make sure the builder isn't busy since that might cause issues with hotreloads
+            // https://github.com/DioxusLabs/dioxus/issues/3361
+            if !msg.is_empty() && self.client.can_receive_hotreloads() {
+                tracing::info!(dx_src = ?TraceSrc::Dev, "Hotreloading: {}", file);
+                server.send_hotreload(msg).await;
+            } else {
+                tracing::debug!(dx_src = ?TraceSrc::Dev, "Ignoring file change: {}", file);
             }
+        }
+    }
 
-            // Otherwise, it might be an asset and we should look for it in all the running apps
-            if let Some(runner) = self.running.as_mut() {
-                if let Some(bundled_name) = runner.hotreload_bundled_asset(&path).await {
-                    // todo(jon): don't hardcode this here
-                    let asset_relative = PathBuf::from("/assets/").join(bundled_name);
-                    assets.push(asset_relative);
+    /// Finally "bundle" this app and return a handle to it
+    pub(crate) async fn open(
+        &mut self,
+        artifacts: BuildArtifacts,
+        devserver: &mut WebServer,
+    ) -> Result<()> {
+        // Make sure to save artifacts regardless of if we're opening the app or not
+        match artifacts.platform {
+            Platform::Server => {
+                if let Some(server) = self.server.as_mut() {
+                    server.artifacts = Some(artifacts.clone());
                 }
             }
+            _ => self.client.artifacts = Some(artifacts.clone()),
         }
 
-        // Multiple runners might have queued the same asset, so dedup them
-        assets.dedup();
+        let should_open = self.client.stage == BuildStage::Success
+            && (self.server.as_ref().map(|s| s.stage == BuildStage::Success)).unwrap_or(true);
 
-        // Process the rust files
-        for rust_file in edited_rust_files {
-            // Strip the prefix before sending it to the filemap
-            let Ok(path) = rust_file.strip_prefix(self.krate.workspace_dir()) else {
-                tracing::error!(
-                    "Hotreloading file outside of the crate directory: {:?}",
-                    rust_file
-                );
-                continue;
-            };
+        if should_open {
+            let time_taken = artifacts
+                .time_end
+                .duration_since(artifacts.time_start)
+                .unwrap();
 
-            // And grabout the contents
-            let Ok(contents) = std::fs::read_to_string(&rust_file) else {
-                tracing::debug!(
-                    "Failed to read rust file while hotreloading: {:?}",
-                    rust_file
+            if self.client.builds_opened == 0 {
+                tracing::info!(
+                    "Build completed successfully in {:?}ms, launching app! 💫",
+                    time_taken.as_millis()
                 );
-                continue;
-            };
+            } else {
+                tracing::info!("Build completed in {:?}ms", time_taken.as_millis());
+            }
 
-            match self.file_map.update_rsx::<HtmlCtx>(path, contents) {
-                HotreloadResult::Rsx(new) => templates.extend(new),
+            let open_browser = self.client.builds_opened == 0 && self.open_browser;
+            self.open_all(devserver, open_browser).await?;
 
-                // The rust file may have failed to parse, but that is most likely
-                // because the user is in the middle of adding new code
-                // We just ignore the error and let Rust analyzer warn about the problem
-                HotreloadResult::Notreloadable => return None,
-                HotreloadResult::NotParseable => {
-                    tracing::debug!(dx_src = ?TraceSrc::Dev, "Error hotreloading file - not parseable {rust_file:?}")
-                }
+            // Give a second for the server to boot
+            tokio::time::sleep(Duration::from_millis(300)).await;
+
+            // Update the screen + devserver with the new handle info
+            devserver.send_reload_command().await
+        }
+
+        Ok(())
+    }
+
+    /// Open an existing app bundle, if it exists
+    ///
+    /// Will attempt to open the server and client together, in a coordinated way such that the server
+    /// opens first, initializes, and then the client opens.
+    ///
+    /// There's a number of issues we need to be careful to work around:
+    /// - The server failing to boot or crashing on startup (and entering a boot loop)
+    /// -
+    pub(crate) async fn open_all(
+        &mut self,
+        devserver: &WebServer,
+        open_browser: bool,
+    ) -> Result<()> {
+        let devserver_ip = devserver.devserver_address();
+        let fullstack_address = devserver.proxied_server_address();
+        let displayed_address = devserver.displayed_address();
+
+        // Always open the server first after the client has been built
+        if let Some(server) = self.server.as_mut() {
+            tracing::debug!("Opening server build");
+            server.soft_kill().await;
+            server
+                .open(
+                    devserver_ip,
+                    displayed_address,
+                    fullstack_address,
+                    false,
+                    false,
+                    BuildId::SERVER,
+                )
+                .await?;
+        }
+
+        // Start the new app before we kill the old one to give it a little bit of time
+        self.client.soft_kill().await;
+        self.client
+            .open(
+                devserver_ip,
+                displayed_address,
+                fullstack_address,
+                open_browser,
+                self.always_on_top,
+                BuildId::CLIENT,
+            )
+            .await?;
+
+        Ok(())
+    }
+
+    /// Shutdown all the running processes
+    pub(crate) async fn cleanup_all(&mut self) -> Result<()> {
+        self.client.soft_kill().await;
+
+        if let Some(server) = self.server.as_mut() {
+            server.soft_kill().await;
+        }
+
+        // If the client is running on Android, we need to remove the port forwarding
+        // todo: use the android tools "adb"
+        if matches!(self.client.build.platform, Platform::Android) {
+            if let Err(err) = Command::new(&self.workspace.android_tools()?.adb)
+                .arg("reverse")
+                .arg("--remove")
+                .arg(format!("tcp:{}", self.devserver_port))
+                .output()
+                .await
+            {
+                tracing::error!(
+                    "failed to remove forwarded port {}: {err}",
+                    self.devserver_port
+                );
             }
         }
 
-        let msg = HotReloadMsg {
-            templates,
-            assets,
-            unknown_files: vec![],
+        Ok(())
+    }
+
+    /// Perform a full rebuild of the app, equivalent to `cargo rustc` from scratch with no incremental
+    /// hot-patch engine integration.
+    pub(crate) async fn full_rebuild(&mut self) {
+        let build_mode = match self.use_hotpatch_engine {
+            true => BuildMode::Fat,
+            false => BuildMode::Base,
         };
 
-        self.add_hot_reload_message(&msg);
+        self.client.start_rebuild(build_mode.clone());
+        if let Some(s) = self.server.as_mut() {
+            s.start_rebuild(build_mode)
+        }
+
+        self.clear_hot_reload_changes();
+        self.clear_cached_rsx();
+        self.clear_patches();
+    }
+
+    pub(crate) async fn hotpatch(
+        &mut self,
+        res: &BuildArtifacts,
+        id: BuildId,
+        cache: &HotpatchModuleCache,
+    ) -> Result<JumpTable> {
+        let jump_table = match id {
+            BuildId::CLIENT => self.client.hotpatch(res, cache).await,
+            BuildId::SERVER => {
+                self.server
+                    .as_mut()
+                    .context("Server not found")?
+                    .hotpatch(res, cache)
+                    .await
+            }
+            _ => return Err(Error::Runtime("Invalid build id".into())),
+        }?;
+
+        if id == BuildId::CLIENT {
+            self.applied_hot_reload_message.jump_table = self.client.patches.last().cloned();
+        }
+
+        Ok(jump_table)
+    }
+
+    pub(crate) fn get_build(&self, id: BuildId) -> Option<&AppBuilder> {
+        match id {
+            BuildId::CLIENT => Some(&self.client),
+            BuildId::SERVER => self.server.as_ref(),
+            _ => None,
+        }
+    }
 
-        Some(msg)
+    pub(crate) fn client(&self) -> &AppBuilder {
+        &self.client
+    }
+
+    /// The name of the app being served, to display
+    pub(crate) fn app_name(&self) -> &str {
+        self.client.build.executable_name()
     }
 
     /// Get any hot reload changes that have been applied since the last full rebuild
-    pub(crate) fn applied_hot_reload_changes(&mut self) -> HotReloadMsg {
-        self.applied_hot_reload_message.clone()
+    pub(crate) fn applied_hot_reload_changes(&mut self, build: BuildId) -> HotReloadMsg {
+        let mut msg = self.applied_hot_reload_message.clone();
+
+        if build == BuildId::CLIENT {
+            msg.jump_table = self.client.patches.last().cloned();
+            msg.for_build_id = Some(BuildId::CLIENT.0 as _);
+            if let Some(lib) = msg.jump_table.as_mut() {
+                lib.lib = PathBuf::from("/").join(lib.lib.clone());
+            }
+        }
+
+        if build == BuildId::SERVER {
+            if let Some(server) = self.server.as_mut() {
+                msg.jump_table = server.patches.last().cloned();
+                msg.for_build_id = Some(BuildId::SERVER.0 as _);
+            }
+        }
+
+        msg
     }
 
     /// Clear the hot reload changes. This should be called any time a new build is starting
@@ -254,44 +656,44 @@ impl AppRunner {
         self.applied_hot_reload_message = Default::default();
     }
 
-    /// Store the hot reload changes for any future clients that connect
-    fn add_hot_reload_message(&mut self, msg: &HotReloadMsg) {
-        let applied = &mut self.applied_hot_reload_message;
-
-        // Merge the assets, unknown files, and templates
-        // We keep the newer change if there is both a old and new change
-        let mut templates: HashMap<TemplateGlobalKey, _> = std::mem::take(&mut applied.templates)
-            .into_iter()
-            .map(|template| (template.key.clone(), template))
-            .collect();
-        let mut assets: HashSet<PathBuf> =
-            std::mem::take(&mut applied.assets).into_iter().collect();
-        let mut unknown_files: HashSet<PathBuf> = std::mem::take(&mut applied.unknown_files)
-            .into_iter()
-            .collect();
-        for template in &msg.templates {
-            templates.insert(template.key.clone(), template.clone());
+    pub(crate) fn clear_patches(&mut self) {
+        self.client.patches.clear();
+        if let Some(server) = self.server.as_mut() {
+            server.patches.clear();
         }
-        assets.extend(msg.assets.iter().cloned());
-        unknown_files.extend(msg.unknown_files.iter().cloned());
-        applied.templates = templates.into_values().collect();
-        applied.assets = assets.into_iter().collect();
-        applied.unknown_files = unknown_files.into_iter().collect();
     }
 
-    pub(crate) async fn client_connected(&mut self) {
-        let Some(handle) = self.running.as_mut() else {
-            return;
-        };
+    pub(crate) async fn client_connected(
+        &mut self,
+        build_id: BuildId,
+        aslr_reference: Option<u64>,
+    ) {
+        match build_id {
+            BuildId::CLIENT => {
+                // multiple tabs on web can cause this to be called incorrectly, and it doesn't
+                // make any sense anyways
+                if self.client.build.platform != Platform::Web {
+                    if let Some(aslr_reference) = aslr_reference {
+                        self.client.aslr_reference = Some(aslr_reference);
+                    }
+                }
+            }
+            BuildId::SERVER => {
+                if let Some(server) = self.server.as_mut() {
+                    server.aslr_reference = aslr_reference;
+                }
+            }
+            _ => {}
+        }
 
         // Assign the runtime asset dir to the runner
-        if handle.app.build.build.platform() == Platform::Ios {
+        if self.client.build.platform == Platform::Ios {
             // xcrun simctl get_app_container booted com.dioxuslabs
-            let res = tokio::process::Command::new("xcrun")
+            let res = Command::new("xcrun")
                 .arg("simctl")
                 .arg("get_app_container")
                 .arg("booted")
-                .arg(handle.app.build.krate.bundle_identifier())
+                .arg(self.client.build.bundle_identifier())
                 .output()
                 .await;
 
@@ -302,12 +704,54 @@ impl AppRunner {
                     let out = out.trim();
 
                     tracing::trace!("Setting Runtime asset dir: {out:?}");
-                    handle.runtime_asst_dir = Some(PathBuf::from(out));
+                    self.client.runtime_asset_dir = Some(PathBuf::from(out));
                 }
             }
         }
     }
 
+    /// Store the hot reload changes for any future clients that connect
+    fn add_hot_reload_message(&mut self, msg: &HotReloadMsg) {
+        let applied = &mut self.applied_hot_reload_message;
+
+        // Merge the assets, unknown files, and templates
+        // We keep the newer change if there is both a old and new change
+        let mut templates: HashMap<TemplateGlobalKey, _> = std::mem::take(&mut applied.templates)
+            .into_iter()
+            .map(|template| (template.key.clone(), template))
+            .collect();
+        let mut assets: HashSet<PathBuf> =
+            std::mem::take(&mut applied.assets).into_iter().collect();
+        for template in &msg.templates {
+            templates.insert(template.key.clone(), template.clone());
+        }
+        assets.extend(msg.assets.iter().cloned());
+        applied.templates = templates.into_values().collect();
+        applied.assets = assets.into_iter().collect();
+        applied.jump_table = self.client.patches.last().cloned();
+    }
+
+    /// Register the files from the workspace into our file watcher.
+    ///
+    /// This very simply looks for all Rust files in the workspace and adds them to the filemap.
+    ///
+    /// Once the builds complete we'll use the depinfo files to get the actual files that are used,
+    /// making our watcher more accurate. Filling the filemap here is intended to catch any file changes
+    /// in between the first build and the depinfo file being generated.
+    ///
+    /// We don't want watch any registry files since that generally causes a huge performance hit -
+    /// we mostly just care about workspace files and local dependencies.
+    ///
+    /// Dep-info file background:
+    /// https://doc.rust-lang.org/stable/nightly-rustc/cargo/core/compiler/fingerprint/index.html#dep-info-files
+    fn load_rsx_filemap(&mut self) {
+        self.fill_filemap_from_krate(self.client.build.crate_dir());
+
+        for krate in self.all_watched_crates() {
+            self.fill_filemap_from_krate(krate);
+        }
+    }
+
     /// Fill the filemap with files from the filesystem, using the given filter to determine which files to include.
     ///
     /// You can use the filter with something like a gitignore to only include files that are relevant to your project.
@@ -317,34 +761,301 @@ impl AppRunner {
     /// Generally this will only be .rs files
     ///
     /// If a file couldn't be parsed, we don't fail. Instead, we save the error.
-    pub fn fill_filemap(&mut self, path: PathBuf) {
-        if self.ignore.matched(&path, path.is_dir()).is_ignore() {
-            return;
+    ///
+    /// todo: There are known bugs here when handling gitignores.
+    fn fill_filemap_from_krate(&mut self, crate_dir: PathBuf) {
+        for entry in walkdir::WalkDir::new(crate_dir).into_iter().flatten() {
+            if self
+                .workspace
+                .ignore
+                .matched(entry.path(), entry.file_type().is_dir())
+                .is_ignore()
+            {
+                continue;
+            }
+
+            let path = entry.path();
+            if path.extension().and_then(|s| s.to_str()) == Some("rs") {
+                if let Ok(contents) = std::fs::read_to_string(path) {
+                    self.file_map.insert(
+                        path.to_path_buf(),
+                        CachedFile {
+                            contents,
+                            most_recent: None,
+                            templates: Default::default(),
+                        },
+                    );
+                }
+            }
+        }
+    }
+
+    /// Commit the changes to the filemap, overwriting the contents of the files
+    ///
+    /// Removes any cached templates and replaces the contents of the files with the most recent
+    ///
+    /// todo: we should-reparse the contents so we never send a new version, ever
+    fn clear_cached_rsx(&mut self) {
+        for cached_file in self.file_map.values_mut() {
+            if let Some(most_recent) = cached_file.most_recent.take() {
+                cached_file.contents = most_recent;
+            }
+            cached_file.templates.clear();
+        }
+    }
+
+    fn watch_filesystem(&mut self) {
+        // Watch the folders of the crates that we're interested in
+        for path in self.watch_paths(
+            self.client.build.crate_dir(),
+            self.client.build.crate_package,
+        ) {
+            tracing::trace!("Watching path {path:?}");
+
+            if let Err(err) = self.watcher.watch(&path, RecursiveMode::Recursive) {
+                handle_notify_error(err);
+            }
+        }
+
+        // Also watch the crates themselves, but not recursively, such that we can pick up new folders
+        for krate in self.all_watched_crates() {
+            tracing::trace!("Watching path {krate:?}");
+            if let Err(err) = self.watcher.watch(&krate, RecursiveMode::NonRecursive) {
+                handle_notify_error(err);
+            }
         }
 
-        // If the file is a .rs file, add it to the filemap
-        if path.extension().and_then(|s| s.to_str()) == Some("rs") {
-            if let Ok(contents) = std::fs::read_to_string(&path) {
-                if let Ok(path) = path.strip_prefix(self.krate.workspace_dir()) {
-                    self.file_map.add_file(path.to_path_buf(), contents);
+        // Also watch the workspace dir, non recursively, such that we can pick up new folders there too
+        if let Err(err) = self.watcher.watch(
+            self.workspace.krates.workspace_root().as_std_path(),
+            RecursiveMode::NonRecursive,
+        ) {
+            handle_notify_error(err);
+        }
+    }
+
+    /// Return the list of paths that we should watch for changes.
+    fn watch_paths(&self, crate_dir: PathBuf, crate_package: NodeId) -> Vec<PathBuf> {
+        let mut watched_paths = vec![];
+
+        // Get a list of *all* the crates with Rust code that we need to watch.
+        // This will end up being dependencies in the workspace and non-workspace dependencies on the user's computer.
+        let mut watched_crates = self.local_dependencies(crate_package);
+        watched_crates.push(crate_dir);
+
+        // Now, watch all the folders in the crates, but respecting their respective ignore files
+        for krate_root in watched_crates {
+            // Build the ignore builder for this crate, but with our default ignore list as well
+            let ignore = self.workspace.ignore_for_krate(&krate_root);
+
+            for entry in krate_root.read_dir().into_iter().flatten() {
+                let Ok(entry) = entry else {
+                    continue;
+                };
+
+                if ignore
+                    .matched(entry.path(), entry.path().is_dir())
+                    .is_ignore()
+                {
+                    continue;
                 }
+
+                watched_paths.push(entry.path().to_path_buf());
             }
-            return;
         }
 
-        // If it's not, we'll try to read the directory
-        if path.is_dir() {
-            if let Ok(read_dir) = std::fs::read_dir(&path) {
-                for entry in read_dir.flatten() {
-                    self.fill_filemap(entry.path());
+        watched_paths.dedup();
+
+        watched_paths
+    }
+
+    /// Get all the Manifest paths for dependencies that we should watch. Will not return anything
+    /// in the `.cargo` folder - only local dependencies will be watched.
+    ///
+    /// This returns a list of manifest paths
+    ///
+    /// Extend the watch path to include:
+    ///
+    /// - the assets directory - this is so we can hotreload CSS and other assets by default
+    /// - the Cargo.toml file - this is so we can hotreload the project if the user changes dependencies
+    /// - the Dioxus.toml file - this is so we can hotreload the project if the user changes the Dioxus config
+    fn local_dependencies(&self, crate_package: NodeId) -> Vec<PathBuf> {
+        let mut paths = vec![];
+
+        for (dependency, _edge) in self.workspace.krates.get_deps(crate_package) {
+            let krate = match dependency {
+                krates::Node::Krate { krate, .. } => krate,
+                krates::Node::Feature { krate_index, .. } => {
+                    &self.workspace.krates[krate_index.index()]
                 }
+            };
+
+            if krate
+                .manifest_path
+                .components()
+                .any(|c| c.as_str() == ".cargo")
+            {
+                continue;
             }
+
+            paths.push(
+                krate
+                    .manifest_path
+                    .parent()
+                    .unwrap()
+                    .to_path_buf()
+                    .into_std_path_buf(),
+            );
         }
+
+        paths
+    }
+
+    // todo: we need to make sure we merge this for all the running packages
+    fn all_watched_crates(&self) -> Vec<PathBuf> {
+        let crate_package = self.client().build.crate_package;
+        let crate_dir = self.client().build.crate_dir();
+
+        let mut krates: Vec<PathBuf> = self
+            .local_dependencies(crate_package)
+            .into_iter()
+            .map(|p| {
+                p.parent()
+                    .expect("Local manifest to exist and have a parent")
+                    .to_path_buf()
+            })
+            .chain(Some(crate_dir))
+            .collect();
+
+        krates.dedup();
+
+        krates
     }
 
-    fn flush_session_cache(&self) {
-        let cache_dir = self.krate.session_cache_dir();
-        _ = std::fs::remove_dir_all(&cache_dir);
-        _ = std::fs::create_dir_all(&cache_dir);
+    /// Check if this is a fullstack build. This means that there is an additional build with the `server` platform.
+    pub(crate) fn is_fullstack(&self) -> bool {
+        self.fullstack
     }
+
+    /// Return a number between 0 and 1 representing the progress of the server build
+    pub(crate) fn server_compile_progress(&self) -> f64 {
+        let Some(server) = self.server.as_ref() else {
+            return 0.0;
+        };
+
+        server.compiled_crates as f64 / server.expected_crates as f64
+    }
+}
+
+/// Bind a listener to any point and return it
+/// When the listener is dropped, the socket will be closed, but we'll still have a port that we
+/// can bind our proxy to.
+///
+/// Todo: we might want to do this on every new build in case the OS tries to bind things to this port
+/// and we don't already have something bound to it. There's no great way of "reserving" a port.
+fn get_available_port(address: IpAddr, prefer: Option<u16>) -> Option<u16> {
+    // First, try to bind to the preferred port
+    if let Some(port) = prefer {
+        if let Ok(_listener) = TcpListener::bind((address, port)) {
+            return Some(port);
+        }
+    }
+
+    // Otherwise, try to bind to any port and return the first one we can
+    TcpListener::bind((address, 0))
+        .and_then(|listener| listener.local_addr().map(|f| f.port()))
+        .ok()
+}
+
+fn create_notify_watcher(
+    tx: UnboundedSender<notify::Event>,
+    wsl_poll_interval: u64,
+) -> Box<dyn NotifyWatcher> {
+    // Build the event handler for notify.
+    // This has been known to be a source of many problems, unfortunately, since notify handling seems to be flakey across platforms
+    let handler = move |info: notify::Result<notify::Event>| {
+        let Ok(event) = info else {
+            return;
+        };
+
+        let is_allowed_notify_event = match event.kind {
+            EventKind::Modify(ModifyKind::Data(_)) => true,
+            EventKind::Modify(ModifyKind::Name(_)) => true,
+            // The primary modification event on WSL's poll watcher.
+            EventKind::Modify(ModifyKind::Metadata(MetadataKind::WriteTime)) => true,
+            // Catch-all for unknown event types (windows)
+            EventKind::Modify(ModifyKind::Any) => true,
+            EventKind::Modify(ModifyKind::Metadata(_)) => false,
+            // Don't care about anything else.
+            EventKind::Create(_) => true,
+            EventKind::Remove(_) => true,
+            _ => false,
+        };
+
+        if is_allowed_notify_event {
+            _ = tx.unbounded_send(event);
+        }
+    };
+
+    const NOTIFY_ERROR_MSG: &str = "Failed to create file watcher.\nEnsure you have the required permissions to watch the specified directories.";
+
+    // On wsl, we need to poll the filesystem for changes
+    if is_wsl() {
+        return Box::new(
+            notify::PollWatcher::new(
+                handler,
+                Config::default().with_poll_interval(Duration::from_secs(wsl_poll_interval)),
+            )
+            .expect(NOTIFY_ERROR_MSG),
+        );
+    }
+
+    // Otherwise we can use the recommended watcher
+    Box::new(notify::recommended_watcher(handler).expect(NOTIFY_ERROR_MSG))
+}
+
+fn handle_notify_error(err: notify::Error) {
+    tracing::debug!("Failed to watch path: {}", err);
+    match err.kind {
+        notify::ErrorKind::Io(error) if error.kind() == std::io::ErrorKind::PermissionDenied => {
+            tracing::error!("Failed to watch path: permission denied. {:?}", err.paths)
+        }
+        notify::ErrorKind::MaxFilesWatch => {
+            tracing::error!("Failed to set up file watcher: too many files to watch")
+        }
+        _ => {}
+    }
+}
+
+/// Detects if `dx` is being ran in a WSL environment.
+///
+/// We determine this based on whether the keyword `microsoft` or `wsl` is contained within the [`WSL_1`] or [`WSL_2`] files.
+/// This may fail in the future as it isn't guaranteed by Microsoft.
+/// See https://github.com/microsoft/WSL/issues/423#issuecomment-221627364
+fn is_wsl() -> bool {
+    const WSL_1: &str = "/proc/sys/kernel/osrelease";
+    const WSL_2: &str = "/proc/version";
+    const WSL_KEYWORDS: [&str; 2] = ["microsoft", "wsl"];
+
+    // Test 1st File
+    if let Ok(content) = std::fs::read_to_string(WSL_1) {
+        let lowercase = content.to_lowercase();
+        for keyword in WSL_KEYWORDS {
+            if lowercase.contains(keyword) {
+                return true;
+            }
+        }
+    }
+
+    // Test 2nd File
+    if let Ok(content) = std::fs::read_to_string(WSL_2) {
+        let lowercase = content.to_lowercase();
+        for keyword in WSL_KEYWORDS {
+            if lowercase.contains(keyword) {
+                return true;
+            }
+        }
+    }
+
+    false
 }

packages/cli/src/serve/server.rs

@@ -1,14 +1,13 @@
 use crate::{
-    config::WebHttpsConfig,
-    serve::{ServeArgs, ServeUpdate},
-    BuildStage, BuildUpdate, DioxusCrate, Platform, Result, TraceSrc,
+    config::WebHttpsConfig, serve::ServeUpdate, BuildId, BuildStage, BuilderUpdate, Platform,
+    Result, TraceSrc,
 };
 use anyhow::Context;
 use axum::{
     body::Body,
     extract::{
         ws::{Message, WebSocket},
-        Request, State, WebSocketUpgrade,
+        Query, Request, State, WebSocketUpgrade,
     },
     http::{
         header::{HeaderName, HeaderValue, CACHE_CONTROL, EXPIRES, PRAGMA},
@@ -34,13 +33,18 @@ use std::{
     net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener},
     path::Path,
     sync::{Arc, RwLock},
+    time::Duration,
 };
+use subsecond_types::JumpTable;
+use tokio::process::Command;
 use tower_http::{
     cors::Any,
     services::fs::{ServeDir, ServeFileSystemResponseBody},
     ServiceBuilderExt,
 };
 
+use super::AppServer;
+
 /// The webserver that serves statics assets (if fullstack isn't already doing that) and the websocket
 /// communication layer that we use to send status updates and hotreloads to the client.
 ///
@@ -52,46 +56,40 @@ pub(crate) struct WebServer {
     devserver_bind_ip: IpAddr,
     devserver_port: u16,
     proxied_port: Option<u16>,
-    hot_reload_sockets: Vec<WebSocket>,
-    build_status_sockets: Vec<WebSocket>,
-    new_hot_reload_sockets: UnboundedReceiver<WebSocket>,
-    new_build_status_sockets: UnboundedReceiver<WebSocket>,
+    hot_reload_sockets: Vec<ConnectedWsClient>,
+    build_status_sockets: Vec<ConnectedWsClient>,
+    new_hot_reload_sockets: UnboundedReceiver<ConnectedWsClient>,
+    new_build_status_sockets: UnboundedReceiver<ConnectedWsClient>,
     build_status: SharedStatus,
     application_name: String,
     platform: Platform,
 }
 
+pub(crate) struct ConnectedWsClient {
+    socket: WebSocket,
+    build_id: Option<BuildId>,
+    aslr_reference: Option<u64>,
+}
+
 impl WebServer {
+    pub const SELF_IP: IpAddr = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
+
     /// Start the development server.
     /// This will set up the default http server if there's no server specified (usually via fullstack).
     ///
     /// This will also start the websocket server that powers the devtools. If you want to communicate
     /// with connected devtools clients, this is the place to do it.
-    pub(crate) fn start(krate: &DioxusCrate, args: &ServeArgs) -> Result<Self> {
+    pub(crate) fn start(runner: &AppServer) -> Result<Self> {
         let (hot_reload_sockets_tx, hot_reload_sockets_rx) = futures_channel::mpsc::unbounded();
         let (build_status_sockets_tx, build_status_sockets_rx) = futures_channel::mpsc::unbounded();
 
-        const SELF_IP: IpAddr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
-
-        // Use 0.0.0.0 as the default address if none is specified - this will let us expose the
-        // devserver to the network (for other devices like phones/embedded)
-        let devserver_bind_ip = args.address.addr.unwrap_or(SELF_IP);
-
-        // If the user specified a port, use that, otherwise use any available port, preferring 8080
-        let devserver_port = args
-            .address
-            .port
-            .unwrap_or_else(|| get_available_port(devserver_bind_ip, Some(8080)).unwrap_or(8080));
-
-        // All servers will end up behind us (the devserver) but on a different port
-        // This is so we can serve a loading screen as well as devtools without anything particularly fancy
-        let proxied_port = args
-            .should_proxy_build()
-            .then(|| get_available_port(devserver_bind_ip, None))
-            .flatten();
-
         // Create the listener that we'll pass into the devserver, but save its IP here so
         // we can display it to the user in the tui
+        let devserver_bind_ip = runner.devserver_bind_ip;
+        let devserver_port = runner.devserver_port;
+        let proxied_port = runner.proxied_port;
+        let devserver_exposed_ip = devserver_bind_ip;
+
         let devserver_bind_address = SocketAddr::new(devserver_bind_ip, devserver_port);
         let listener = std::net::TcpListener::bind(devserver_bind_address).with_context(|| {
             anyhow::anyhow!(
@@ -99,21 +97,12 @@ impl WebServer {
             )
         })?;
 
-        // If the IP is 0.0.0.0, we need to get the actual IP of the machine
-        // This will let ios/android/network clients connect to the devserver
-        let devserver_exposed_ip = if devserver_bind_ip == SELF_IP {
-            local_ip_address::local_ip().unwrap_or(devserver_bind_ip)
-        } else {
-            devserver_bind_ip
-        };
-
         let proxied_address = proxied_port.map(|port| SocketAddr::new(devserver_exposed_ip, port));
 
         // Set up the router with some shared state that we'll update later to reflect the current state of the build
         let build_status = SharedStatus::new_with_starting_build();
         let router = build_devserver_router(
-            args,
-            krate,
+            runner,
             hot_reload_sockets_tx,
             build_status_sockets_tx,
             proxied_address,
@@ -122,7 +111,7 @@ impl WebServer {
 
         // And finally, start the server mainloop
         tokio::spawn(devserver_mainloop(
-            krate.config.web.https.clone(),
+            runner.client().build.config.web.https.clone(),
             listener,
             router,
         ));
@@ -137,8 +126,8 @@ impl WebServer {
             build_status_sockets: Default::default(),
             new_hot_reload_sockets: hot_reload_sockets_rx,
             new_build_status_sockets: build_status_sockets_rx,
-            application_name: krate.executable_name().to_string(),
-            platform: args.build_arguments.platform(),
+            application_name: runner.app_name().to_string(),
+            platform: runner.client.build.platform,
         })
     }
 
@@ -150,15 +139,19 @@ impl WebServer {
             .hot_reload_sockets
             .iter_mut()
             .enumerate()
-            .map(|(idx, socket)| async move { (idx, socket.next().await) })
+            .map(|(idx, socket)| async move { (idx, socket.socket.next().await) })
             .collect::<FuturesUnordered<_>>();
 
         tokio::select! {
             new_hot_reload_socket = &mut new_hot_reload_socket => {
                 if let Some(new_socket) = new_hot_reload_socket {
+                    let aslr_reference = new_socket.aslr_reference;
+                    let id = new_socket.build_id.unwrap_or(BuildId::CLIENT);
+
                     drop(new_message);
                     self.hot_reload_sockets.push(new_socket);
-                    return ServeUpdate::NewConnection;
+
+                    return ServeUpdate::NewConnection { aslr_reference, id };
                 } else {
                     panic!("Could not receive a socket - the devtools could not boot - the port is likely already in use");
                 }
@@ -169,8 +162,8 @@ impl WebServer {
 
                     // Update the socket with project info and current build status
                     let project_info = SharedStatus::new(Status::ClientInit { application_name: self.application_name.clone(), platform: self.platform });
-                    if project_info.send_to(&mut new_socket).await.is_ok() {
-                        _ = self.build_status.send_to(&mut new_socket).await;
+                    if project_info.send_to(&mut new_socket.socket).await.is_ok() {
+                        _ = self.build_status.send_to(&mut new_socket.socket).await;
                         self.build_status_sockets.push(new_socket);
                     }
                     return future::pending::<ServeUpdate>().await;
@@ -180,7 +173,7 @@ impl WebServer {
             }
             Some((idx, message)) = new_message.next() => {
                 match message {
-                    Some(Ok(message)) => return ServeUpdate::WsMessage(message),
+                    Some(Ok(msg)) => return ServeUpdate::WsMessage { msg, platform: Platform::Web },
                     _ => {
                         drop(new_message);
                         _ = self.hot_reload_sockets.remove(idx);
@@ -193,26 +186,9 @@ impl WebServer {
     }
 
     pub(crate) async fn shutdown(&mut self) {
-        if matches!(self.platform, Platform::Android) {
-            use std::process::{Command, Stdio};
-            if let Err(err) = Command::new("adb")
-                .arg("reverse")
-                .arg("--remove")
-                .arg(format!("tcp:{}", self.devserver_port))
-                .stderr(Stdio::piped())
-                .stdout(Stdio::piped())
-                .output()
-            {
-                tracing::error!(
-                    "failed to remove forwarded port {}: {err}",
-                    self.devserver_port
-                );
-            }
-        }
-
         self.send_shutdown().await;
         for mut socket in self.hot_reload_sockets.drain(..) {
-            _ = socket.send(Message::Close(None)).await;
+            _ = socket.socket.send(Message::Close(None)).await;
         }
     }
 
@@ -221,7 +197,7 @@ impl WebServer {
         let mut i = 0;
         while i < self.build_status_sockets.len() {
             let socket = &mut self.build_status_sockets[i];
-            if self.build_status.send_to(socket).await.is_err() {
+            if self.build_status.send_to(&mut socket.socket).await.is_err() {
                 self.build_status_sockets.remove(i);
             } else {
                 i += 1;
@@ -239,13 +215,9 @@ impl WebServer {
     }
 
     /// Sends an updated build status to all clients.
-    pub(crate) async fn new_build_update(
-        &mut self,
-        update: &BuildUpdate,
-        builder: &super::Builder,
-    ) {
+    pub(crate) async fn new_build_update(&mut self, update: &BuilderUpdate) {
         match update {
-            BuildUpdate::Progress { stage } => {
+            BuilderUpdate::Progress { stage } => {
                 // Todo(miles): wire up more messages into the splash screen UI
                 match stage {
                     BuildStage::Success => {}
@@ -259,7 +231,10 @@ impl WebServer {
                         krate,
                         ..
                     } => {
-                        if !builder.is_finished() {
+                        if !matches!(
+                            self.build_status.get(),
+                            Status::Ready | Status::BuildError { .. }
+                        ) {
                             self.build_status.set(Status::Building {
                                 progress: (*current as f64 / *total as f64).clamp(0.0, 1.0),
                                 build_message: format!("{krate} compiling"),
@@ -273,9 +248,9 @@ impl WebServer {
                     _ => {}
                 }
             }
-            BuildUpdate::CompilerMessage { .. } => {}
-            BuildUpdate::BuildReady { .. } => {}
-            BuildUpdate::BuildFailed { err } => {
+            BuilderUpdate::CompilerMessage { .. } => {}
+            BuilderUpdate::BuildReady { .. } => {}
+            BuilderUpdate::BuildFailed { err } => {
                 let error = err.to_string();
                 self.build_status.set(Status::BuildError {
                     error: ansi_to_html::convert(&error).unwrap_or(error),
@@ -283,6 +258,9 @@ impl WebServer {
                 self.send_reload_failed().await;
                 self.send_build_status().await;
             }
+            BuilderUpdate::StdoutReceived { .. } => {}
+            BuilderUpdate::StderrReceived { .. } => {}
+            BuilderUpdate::ProcessExited { .. } => {}
         }
     }
 
@@ -292,7 +270,6 @@ impl WebServer {
             return;
         }
 
-        #[cfg(debug_assertions)]
         tracing::trace!("Sending hotreload to clients {:?}", reload);
 
         let msg = DevserverMsg::HotReload(reload);
@@ -303,6 +280,7 @@ impl WebServer {
         while i < self.hot_reload_sockets.len() {
             let socket = &mut self.hot_reload_sockets[i];
             if socket
+                .socket
                 .send(Message::Text(msg.clone().into()))
                 .await
                 .is_err()
@@ -314,15 +292,37 @@ impl WebServer {
         }
     }
 
+    pub(crate) async fn send_patch(
+        &mut self,
+        jump_table: JumpTable,
+        time_taken: Duration,
+        build: BuildId,
+    ) {
+        let msg = DevserverMsg::HotReload(HotReloadMsg {
+            jump_table: Some(jump_table),
+            ms_elapsed: time_taken.as_millis() as u64,
+            templates: vec![],
+            assets: vec![],
+            for_build_id: Some(build.0 as _),
+        });
+        self.send_devserver_message_to_all(msg).await;
+    }
+
+    /// Tells all clients that a hot patch has started.
+    pub(crate) async fn send_patch_start(&mut self) {
+        self.send_devserver_message_to_all(DevserverMsg::HotPatchStart)
+            .await;
+    }
+
     /// Tells all clients that a full rebuild has started.
     pub(crate) async fn send_reload_start(&mut self) {
-        self.send_devserver_message(DevserverMsg::FullReloadStart)
+        self.send_devserver_message_to_all(DevserverMsg::FullReloadStart)
             .await;
     }
 
     /// Tells all clients that a full rebuild has failed.
     pub(crate) async fn send_reload_failed(&mut self) {
-        self.send_devserver_message(DevserverMsg::FullReloadFailed)
+        self.send_devserver_message_to_all(DevserverMsg::FullReloadFailed)
             .await;
     }
 
@@ -334,19 +334,21 @@ impl WebServer {
 
         self.build_status.set(Status::Ready);
         self.send_build_status().await;
-        self.send_devserver_message(DevserverMsg::FullReloadCommand)
+        self.send_devserver_message_to_all(DevserverMsg::FullReloadCommand)
             .await;
     }
 
     /// Send a shutdown message to all connected clients.
     pub(crate) async fn send_shutdown(&mut self) {
-        self.send_devserver_message(DevserverMsg::Shutdown).await;
+        self.send_devserver_message_to_all(DevserverMsg::Shutdown)
+            .await;
     }
 
     /// Sends a devserver message to all connected clients.
-    async fn send_devserver_message(&mut self, msg: DevserverMsg) {
+    async fn send_devserver_message_to_all(&mut self, msg: DevserverMsg) {
         for socket in self.hot_reload_sockets.iter_mut() {
             _ = socket
+                .socket
                 .send(Message::Text(serde_json::to_string(&msg).unwrap().into()))
                 .await;
         }
@@ -424,23 +426,24 @@ async fn devserver_mainloop(
 /// - Setting up the file serve service
 /// - Setting up the websocket endpoint for devtools
 fn build_devserver_router(
-    args: &ServeArgs,
-    krate: &DioxusCrate,
-    hot_reload_sockets: UnboundedSender<WebSocket>,
-    build_status_sockets: UnboundedSender<WebSocket>,
+    runner: &AppServer,
+    hot_reload_sockets: UnboundedSender<ConnectedWsClient>,
+    build_status_sockets: UnboundedSender<ConnectedWsClient>,
     fullstack_address: Option<SocketAddr>,
     build_status: SharedStatus,
 ) -> Result<Router> {
     let mut router = Router::new();
+    let build = runner.client();
 
     // Setup proxy for the endpoint specified in the config
-    for proxy_config in krate.config.web.proxy.iter() {
+    for proxy_config in build.build.config.web.proxy.iter() {
         router = super::proxy::add_proxy(router, proxy_config)?;
     }
 
-    if args.should_proxy_build() {
-        // For fullstack, liveview, and server, forward all requests to the inner server
-        let address = fullstack_address.unwrap();
+    // For fullstack, liveview, and server, forward all requests to the inner server
+    if runner.proxied_port.is_some() {
+        tracing::debug!("Proxying requests to fullstack server at {fullstack_address:?}");
+        let address = fullstack_address.context("No fullstack address specified")?;
         tracing::debug!("Proxying requests to fullstack server at {address}");
         router = router.fallback_service(super::proxy::proxy_to(
             format!("http://{address}").parse().unwrap(),
@@ -460,7 +463,9 @@ fn build_devserver_router(
         // Route file service to output the .wasm and assets if this is a web build
         let base_path = format!(
             "/{}",
-            krate
+            runner
+                .client()
+                .build
                 .config
                 .web
                 .app
@@ -470,9 +475,9 @@ fn build_devserver_router(
                 .trim_matches('/')
         );
         if base_path == "/" {
-            router = router.fallback_service(build_serve_dir(args, krate));
+            router = router.fallback_service(build_serve_dir(runner));
         } else {
-            router = router.nest_service(&base_path, build_serve_dir(args, krate));
+            router = router.nest_service(&base_path, build_serve_dir(runner));
         }
     }
 
@@ -482,6 +487,12 @@ fn build_devserver_router(
         build_status_middleware,
     ));
 
+    #[derive(Deserialize, Debug)]
+    struct ConnectionQuery {
+        aslr_reference: Option<u64>,
+        build_id: Option<BuildId>,
+    }
+
     // Setup websocket endpoint - and pass in the extension layer immediately after
     router = router.nest(
         "/_dioxus",
@@ -489,9 +500,9 @@ fn build_devserver_router(
             .route(
                 "/",
                 get(
-                    |ws: WebSocketUpgrade, ext: Extension<UnboundedSender<WebSocket>>| async move {
-                        tracing::debug!("New devtool websocket connection");
-                        ws.on_upgrade(move |socket| async move { _ = ext.0.unbounded_send(socket) })
+                    |ws: WebSocketUpgrade, ext: Extension<UnboundedSender<ConnectedWsClient>>, query: Query<ConnectionQuery>| async move {
+                        tracing::debug!("New devtool websocket connection: {:?}", query);
+                        ws.on_upgrade(move |socket| async move { _ = ext.0.unbounded_send(ConnectedWsClient { socket, aslr_reference: query.aslr_reference, build_id: query.build_id }) })
                     },
                 ),
             )
@@ -499,8 +510,8 @@ fn build_devserver_router(
             .route(
                 "/build_status",
                 get(
-                    |ws: WebSocketUpgrade, ext: Extension<UnboundedSender<WebSocket>>| async move {
-                        ws.on_upgrade(move |socket| async move { _ = ext.0.unbounded_send(socket) })
+                    |ws: WebSocketUpgrade, ext: Extension<UnboundedSender<ConnectedWsClient>>| async move {
+                        ws.on_upgrade(move |socket| async move { _ = ext.0.unbounded_send(ConnectedWsClient { socket, aslr_reference: None, build_id: None }) })
                     },
                 ),
             )
@@ -520,7 +531,7 @@ fn build_devserver_router(
     Ok(router)
 }
 
-fn build_serve_dir(args: &ServeArgs, cfg: &DioxusCrate) -> axum::routing::MethodRouter {
+fn build_serve_dir(runner: &AppServer) -> axum::routing::MethodRouter {
     use tower::ServiceBuilder;
 
     static CORS_UNSAFE: (HeaderValue, HeaderValue) = (
@@ -533,15 +544,19 @@ fn build_serve_dir(args: &ServeArgs, cfg: &DioxusCrate) -> axum::routing::Method
         HeaderValue::from_static("same-origin"),
     );
 
-    let (coep, coop) = match args.cross_origin_policy {
+    let (coep, coop) = match runner.cross_origin_policy {
         true => CORS_REQUIRE.clone(),
         false => CORS_UNSAFE.clone(),
     };
 
-    let out_dir = cfg
-        .build_dir(Platform::Web, args.build_arguments.release)
+    let app = &runner.client;
+    let cfg = &runner.client.build.config;
+
+    let out_dir = app
+        .build
+        .build_dir(Platform::Web, app.build.release)
         .join("public");
-    let index_on_404 = cfg.config.web.watcher.index_on_404;
+    let index_on_404: bool = cfg.web.watcher.index_on_404;
 
     get_service(
         ServiceBuilder::new()
@@ -641,7 +656,7 @@ async fn get_rustls(web_config: &WebHttpsConfig) -> Result<(String, String)> {
         _ = fs::create_dir("ssl");
     }
 
-    let cmd = tokio::process::Command::new("mkcert")
+    let cmd = Command::new("mkcert")
         .args([
             "-install",
             "-key-file",
@@ -673,25 +688,6 @@ async fn get_rustls(web_config: &WebHttpsConfig) -> Result<(String, String)> {
 
     Ok((cert_path, key_path))
 }
-/// Bind a listener to any point and return it
-/// When the listener is dropped, the socket will be closed, but we'll still have a port that we
-/// can bind our proxy to.
-///
-/// Todo: we might want to do this on every new build in case the OS tries to bind things to this port
-/// and we don't already have something bound to it. There's no great way of "reserving" a port.
-fn get_available_port(address: IpAddr, prefer: Option<u16>) -> Option<u16> {
-    // First, try to bind to the preferred port
-    if let Some(port) = prefer {
-        if let Ok(_listener) = TcpListener::bind((address, port)) {
-            return Some(port);
-        }
-    }
-
-    // Otherwise, try to bind to any port and return the first one we can
-    TcpListener::bind((address, 0))
-        .map(|listener| listener.local_addr().unwrap().port())
-        .ok()
-}
 
 /// Middleware that intercepts html requests if the status is "Building" and returns a loading page instead
 async fn build_status_middleware(
@@ -708,7 +704,7 @@ async fn build_status_middleware(
     if let Some(true) = accepts_html {
         let status = state.get();
         if status != Status::Ready {
-            let html = include_str!("../../assets/web/loading.html");
+            let html = include_str!("../../assets/web/dev.loading.html");
             return axum::response::Response::builder()
                 .status(StatusCode::OK)
                 // Load the html loader then keep loading forever

packages/cli/src/serve/update.rs

@@ -1,46 +1,31 @@
-use crate::{BuildUpdate, Platform, TraceMsg};
+use crate::{BuildId, BuilderUpdate, Platform, TraceMsg};
 use axum::extract::ws::Message as WsMessage;
-use std::{path::PathBuf, process::ExitStatus};
+use std::path::PathBuf;
 
 /// One fat enum to rule them all....
 ///
 /// Thanks to libraries like winit for the inspiration
 #[allow(clippy::large_enum_variant)]
 pub(crate) enum ServeUpdate {
-    NewConnection,
-    WsMessage(WsMessage),
-
-    /// A build update from the build engine
-    BuildUpdate(BuildUpdate),
-
-    /// A running process has received a stdout.
-    /// May or may not be a complete line - do not treat it as a line. It will include a line if it is a complete line.
-    ///
-    /// We will poll lines and any content in a 50ms interval
-    StdoutReceived {
-        platform: Platform,
-        msg: String,
+    NewConnection {
+        id: BuildId,
+        aslr_reference: Option<u64>,
     },
-
-    /// A running process has received a stderr.
-    /// May or may not be a complete line - do not treat it as a line. It will include a line if it is a complete line.
-    ///
-    /// We will poll lines and any content in a 50ms interval
-    StderrReceived {
+    WsMessage {
         platform: Platform,
-        msg: String,
+        msg: WsMessage,
     },
 
-    ProcessExited {
-        platform: Platform,
-        status: ExitStatus,
+    /// An update regarding the state of the build and running app from an AppBuilder
+    BuilderUpdate {
+        id: BuildId,
+        update: BuilderUpdate,
     },
 
     FilesChanged {
         files: Vec<PathBuf>,
     },
 
-    /// Open an existing app bundle, if it exists
     OpenApp,
 
     RequestRebuild,

packages/cli/src/serve/watcher.rs

@@ -1,165 +0,0 @@
-use super::detect::is_wsl;
-use super::update::ServeUpdate;
-use crate::{cli::serve::ServeArgs, dioxus_crate::DioxusCrate};
-use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
-use futures_util::StreamExt;
-use notify::{
-    event::{MetadataKind, ModifyKind},
-    Config, EventKind, RecursiveMode, Watcher as NotifyWatcher,
-};
-use std::{path::PathBuf, time::Duration};
-
-/// This struct stores the file watcher and the filemap for the project.
-///
-/// This is where we do workspace discovery and recursively listen for changes in Rust files and asset
-/// directories.
-pub(crate) struct Watcher {
-    rx: UnboundedReceiver<notify::Event>,
-    krate: DioxusCrate,
-    _tx: UnboundedSender<notify::Event>,
-    watcher: Box<dyn notify::Watcher>,
-}
-
-impl Watcher {
-    pub(crate) fn start(krate: &DioxusCrate, serve: &ServeArgs) -> Self {
-        let (tx, rx) = futures_channel::mpsc::unbounded();
-
-        let mut watcher = Self {
-            watcher: create_notify_watcher(serve, tx.clone()),
-            _tx: tx,
-            krate: krate.clone(),
-            rx,
-        };
-
-        watcher.watch_filesystem();
-
-        watcher
-    }
-
-    /// Wait for changed files to be detected
-    pub(crate) async fn wait(&mut self) -> ServeUpdate {
-        // Wait for the next file to change
-        let mut changes: Vec<_> = self.rx.next().await.into_iter().collect();
-
-        // Dequeue in bulk if we can, we might've received a lot of events in one go
-        while let Some(event) = self.rx.try_next().ok().flatten() {
-            changes.push(event);
-        }
-
-        // Filter the changes
-        let mut files: Vec<PathBuf> = vec![];
-
-        // Decompose the events into a list of all the files that have changed
-        for event in changes.drain(..) {
-            // Make sure we add new folders to the watch list, provided they're not matched by the ignore list
-            // We'll only watch new folders that are found under the crate, and then update our watcher to watch them
-            // This unfortunately won't pick up new krates added "at a distance" - IE krates not within the workspace.
-            if let EventKind::Create(_create_kind) = event.kind {
-                // If it's a new folder, watch it
-                // If it's a new cargo.toml (ie dep on the fly),
-                // todo(jon) support new folders on the fly
-            }
-
-            for path in event.paths {
-                // Workaround for notify and vscode-like editor:
-                // when edit & save a file in vscode, there will be two notifications,
-                // the first one is a file with empty content.
-                // filter the empty file notification to avoid false rebuild during hot-reload
-                if let Ok(metadata) = std::fs::metadata(&path) {
-                    if metadata.len() == 0 {
-                        continue;
-                    }
-                }
-
-                files.push(path);
-            }
-        }
-
-        tracing::debug!("Files changed: {files:?}");
-
-        ServeUpdate::FilesChanged { files }
-    }
-
-    fn watch_filesystem(&mut self) {
-        // Watch the folders of the crates that we're interested in
-        for path in self.krate.watch_paths() {
-            tracing::debug!("Watching path {path:?}");
-
-            if let Err(err) = self.watcher.watch(&path, RecursiveMode::Recursive) {
-                handle_notify_error(err);
-            }
-        }
-
-        // Also watch the crates themselves, but not recursively, such that we can pick up new folders
-        for krate in self.krate.all_watched_crates() {
-            tracing::debug!("Watching path {krate:?}");
-            if let Err(err) = self.watcher.watch(&krate, RecursiveMode::NonRecursive) {
-                handle_notify_error(err);
-            }
-        }
-
-        // Also watch the workspace dir, non recursively, such that we can pick up new folders there too
-        if let Err(err) = self
-            .watcher
-            .watch(&self.krate.workspace_dir(), RecursiveMode::NonRecursive)
-        {
-            handle_notify_error(err);
-        }
-    }
-}
-
-fn handle_notify_error(err: notify::Error) {
-    tracing::debug!("Failed to watch path: {}", err);
-    match err.kind {
-        notify::ErrorKind::Io(error) if error.kind() == std::io::ErrorKind::PermissionDenied => {
-            tracing::error!("Failed to watch path: permission denied. {:?}", err.paths)
-        }
-        notify::ErrorKind::MaxFilesWatch => {
-            tracing::error!("Failed to set up file watcher: too many files to watch")
-        }
-        _ => {}
-    }
-}
-
-fn create_notify_watcher(
-    serve: &ServeArgs,
-    tx: UnboundedSender<notify::Event>,
-) -> Box<dyn NotifyWatcher> {
-    // Build the event handler for notify.
-    let handler = move |info: notify::Result<notify::Event>| {
-        let Ok(event) = info else {
-            return;
-        };
-
-        let is_allowed_notify_event = match event.kind {
-            EventKind::Modify(ModifyKind::Data(_)) => true,
-            EventKind::Modify(ModifyKind::Name(_)) => true,
-            // The primary modification event on WSL's poll watcher.
-            EventKind::Modify(ModifyKind::Metadata(MetadataKind::WriteTime)) => true,
-            // Catch-all for unknown event types (windows)
-            EventKind::Modify(ModifyKind::Any) => true,
-            EventKind::Modify(ModifyKind::Metadata(_)) => false,
-            // Don't care about anything else.
-            EventKind::Create(_) => true,
-            EventKind::Remove(_) => true,
-            _ => false,
-        };
-
-        if is_allowed_notify_event {
-            _ = tx.unbounded_send(event);
-        }
-    };
-
-    const NOTIFY_ERROR_MSG: &str = "Failed to create file watcher.\nEnsure you have the required permissions to watch the specified directories.";
-
-    if !is_wsl() {
-        return Box::new(notify::recommended_watcher(handler).expect(NOTIFY_ERROR_MSG));
-    }
-
-    let poll_interval = Duration::from_secs(serve.wsl_file_poll_interval.unwrap_or(2) as u64);
-
-    Box::new(
-        notify::PollWatcher::new(handler, Config::default().with_poll_interval(poll_interval))
-            .expect(NOTIFY_ERROR_MSG),
-    )
-}

packages/cli/src/settings.rs

@@ -32,10 +32,14 @@ impl CliSettings {
     /// Load the settings from the local, global, or default config in that order
     pub(crate) fn load() -> Arc<Self> {
         static SETTINGS: Lazy<Arc<CliSettings>> =
-            Lazy::new(|| Arc::new(CliSettings::from_global().unwrap_or_default()));
+            Lazy::new(|| Arc::new(CliSettings::global_or_default()));
         SETTINGS.clone()
     }
 
+    pub fn global_or_default() -> Self {
+        CliSettings::from_global().unwrap_or_default()
+    }
+
     /// Get the current settings structure from global.
     pub(crate) fn from_global() -> Option<Self> {
         let Some(path) = dirs::data_local_dir() else {
@@ -124,7 +128,7 @@ impl CliSettings {
             return true;
         }
 
-        if std::env::var("NO_DOWNLOADS").is_ok() {
+        if crate::devcfg::no_downloads() {
             return true;
         }
 

packages/cli/src/wasm_bindgen.rs

@@ -1,8 +1,7 @@
 use crate::{CliSettings, Result};
 use anyhow::{anyhow, Context};
 use flate2::read::GzDecoder;
-use std::path::PathBuf;
-use std::{path::Path, process::Stdio};
+use std::path::{Path, PathBuf};
 use tar::Archive;
 use tempfile::TempDir;
 use tokio::{fs, process::Command};
@@ -100,7 +99,7 @@ impl WasmBindgen {
     }
 
     /// Run the bindgen command with the current settings
-    pub(crate) async fn run(&self) -> Result<()> {
+    pub(crate) async fn run(&self) -> Result<std::process::Output> {
         let binary = self.get_binary_path().await?;
 
         let mut args = Vec::new();
@@ -160,14 +159,24 @@ impl WasmBindgen {
         tracing::debug!("wasm-bindgen args: {:#?}", args);
 
         // Run bindgen
-        Command::new(binary)
-            .args(args)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .output()
-            .await?;
+        let output = Command::new(binary).args(args).output().await?;
+
+        // Check for errors
+        if !output.stderr.is_empty() {
+            if output.status.success() {
+                tracing::debug!(
+                    "wasm-bindgen warnings: {}",
+                    String::from_utf8_lossy(&output.stderr)
+                );
+            } else {
+                tracing::error!(
+                    "wasm-bindgen error: {}",
+                    String::from_utf8_lossy(&output.stderr)
+                );
+            }
+        }
 
-        Ok(())
+        Ok(output)
     }
 
     /// Verify the installed version of wasm-bindgen-cli
@@ -288,8 +297,6 @@ impl WasmBindgen {
                 "--install-path",
             ])
             .arg(tempdir.path())
-            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::piped())
             .output()
             .await?;
 
@@ -322,8 +329,6 @@ impl WasmBindgen {
                 "--root",
             ])
             .arg(tempdir.path())
-            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::piped())
             .output()
             .await
             .context("failed to install wasm-bindgen-cli from cargo-install")?;
@@ -455,7 +460,7 @@ mod test {
     /// Test the github installer.
     #[tokio::test]
     async fn test_github_install() {
-        if std::env::var("TEST_INSTALLS").is_err() {
+        if !crate::devcfg::test_installs() {
             return;
         }
         let binary = WasmBindgen::new(VERSION);
@@ -468,7 +473,7 @@ mod test {
     /// Test the cargo installer.
     #[tokio::test]
     async fn test_cargo_install() {
-        if std::env::var("TEST_INSTALLS").is_err() {
+        if !crate::devcfg::test_installs() {
             return;
         }
         let binary = WasmBindgen::new(VERSION);
@@ -482,7 +487,7 @@ mod test {
     // Test the binstall installer
     #[tokio::test]
     async fn test_binstall_install() {
-        if std::env::var("TEST_INSTALLS").is_err() {
+        if !crate::devcfg::test_installs() {
             return;
         }
         let binary = WasmBindgen::new(VERSION);

packages/cli/src/wasm_opt.rs

@@ -2,15 +2,6 @@ use crate::config::WasmOptLevel;
 use crate::{Result, WasmOptConfig};
 use std::path::Path;
 
-#[memoize::memoize(SharedCache)]
-pub fn wasm_opt_available() -> bool {
-    if cfg!(feature = "optimizations") {
-        return true;
-    }
-
-    which::which("wasm-opt").is_ok()
-}
-
 /// Write these wasm bytes with a particular set of optimizations
 pub async fn write_wasm(bytes: &[u8], output_path: &Path, cfg: &WasmOptConfig) -> Result<()> {
     tokio::fs::write(output_path, bytes).await?;

packages/cli/src/workspace.rs

@@ -0,0 +1,384 @@
+use crate::CliSettings;
+use crate::Result;
+use crate::{config::DioxusConfig, AndroidTools};
+use anyhow::Context;
+use ignore::gitignore::Gitignore;
+use krates::KrateDetails;
+use krates::{Cmd, Krates, NodeId};
+use std::path::Path;
+use std::path::PathBuf;
+use std::sync::Arc;
+use target_lexicon::Triple;
+use tokio::process::Command;
+
+pub struct Workspace {
+    pub(crate) krates: Krates,
+    pub(crate) settings: CliSettings,
+    pub(crate) wasm_opt: Option<PathBuf>,
+    pub(crate) sysroot: PathBuf,
+    pub(crate) rustc_version: String,
+    pub(crate) ignore: Gitignore,
+    pub(crate) cargo_toml: cargo_toml::Manifest,
+    pub(crate) android_tools: Option<Arc<AndroidTools>>,
+}
+
+impl Workspace {
+    /// Load the workspace from the current directory. This is cached and will only be loaded once.
+    pub async fn current() -> Result<Arc<Workspace>> {
+        static WS: tokio::sync::Mutex<Option<Arc<Workspace>>> = tokio::sync::Mutex::const_new(None);
+
+        // Lock the workspace to prevent multiple threads from loading it at the same time
+        // If loading the workspace failed the first time, it won't be set and therefore permeate an error.
+        let mut lock = WS.lock().await;
+        if let Some(ws) = lock.as_ref() {
+            return Ok(ws.clone());
+        }
+
+        tracing::debug!("Loading workspace!");
+
+        let cmd = Cmd::new();
+        let mut builder = krates::Builder::new();
+        builder.workspace(true);
+        let krates = builder
+            .build(cmd, |_| {})
+            .context("Failed to run cargo metadata")?;
+
+        let settings = CliSettings::global_or_default();
+        let sysroot = Command::new("rustc")
+            .args(["--print", "sysroot"])
+            .output()
+            .await
+            .map(|out| String::from_utf8(out.stdout))?
+            .context("Failed to extract rustc sysroot output")?;
+
+        let rustc_version = Command::new("rustc")
+            .args(["--version"])
+            .output()
+            .await
+            .map(|out| String::from_utf8(out.stdout))?
+            .context("Failed to extract rustc version output")?;
+
+        let wasm_opt = which::which("wasm-opt").ok();
+
+        let ignore = Self::workspace_gitignore(krates.workspace_root().as_std_path());
+
+        let cargo_toml =
+            cargo_toml::Manifest::from_path(krates.workspace_root().join("Cargo.toml"))
+                .context("Failed to load Cargo.toml")?;
+
+        let android_tools = crate::build::get_android_tools();
+
+        let workspace = Arc::new(Self {
+            krates,
+            settings,
+            wasm_opt,
+            sysroot: sysroot.trim().into(),
+            rustc_version: rustc_version.trim().into(),
+            ignore,
+            cargo_toml,
+            android_tools,
+        });
+
+        lock.replace(workspace.clone());
+
+        Ok(workspace)
+    }
+
+    pub fn android_tools(&self) -> Result<Arc<AndroidTools>> {
+        Ok(self
+            .android_tools
+            .clone()
+            .context("Android not installed properly. Please set the `ANDROID_NDK_HOME` environment variable to the root of your NDK installation.")?)
+    }
+
+    pub fn is_release_profile(&self, profile: &str) -> bool {
+        // Check if the profile inherits from release by traversing the `inherits` chain
+        let mut current_profile_name = profile;
+
+        // Try to find the current profile in the custom profiles section
+        while let Some(profile_settings) = self.cargo_toml.profile.custom.get(current_profile_name)
+        {
+            if profile == "release" {
+                return true;
+            }
+
+            // Check what this profile inherits from
+            match &profile_settings.inherits {
+                // Otherwise, continue checking the profile it inherits from
+                Some(inherits_name) => current_profile_name = inherits_name,
+
+                // This profile doesn't explicitly inherit anything, so the chain ends here.
+                // Since it didn't lead to "release", return false.
+                None => break,
+            }
+        }
+
+        false
+    }
+
+    #[allow(unused)]
+    pub fn rust_lld(&self) -> PathBuf {
+        self.sysroot
+            .join("lib")
+            .join("rustlib")
+            .join(Triple::host().to_string())
+            .join("bin")
+            .join("rust-lld")
+    }
+
+    /// Return the path to the `cc` compiler
+    ///
+    /// This is used for the patching system to run the linker.
+    /// We could also just use lld given to us by rust itself.
+    pub fn cc(&self) -> PathBuf {
+        PathBuf::from("cc")
+    }
+
+    /// The windows linker
+    pub fn lld_link(&self) -> PathBuf {
+        self.gcc_ld_dir().join("lld-link")
+    }
+
+    pub fn wasm_ld(&self) -> PathBuf {
+        self.gcc_ld_dir().join("wasm-ld")
+    }
+
+    // wasm-ld: ./rustup/toolchains/nightly-x86_64-unknown-linux-gnu/bin/wasm-ld
+    // rust-lld: ./rustup/toolchains/nightly-x86_64-unknown-linux-gnu/bin/rust-lld
+    fn gcc_ld_dir(&self) -> PathBuf {
+        self.sysroot
+            .join("lib")
+            .join("rustlib")
+            .join(Triple::host().to_string())
+            .join("bin")
+            .join("gcc-ld")
+    }
+
+    pub fn has_wasm32_unknown_unknown(&self) -> bool {
+        self.sysroot
+            .join("lib/rustlib/wasm32-unknown-unknown")
+            .exists()
+    }
+
+    /// Find the "main" package in the workspace. There might not be one!
+    pub fn find_main_package(&self, package: Option<String>) -> Result<NodeId> {
+        if let Some(package) = package {
+            let mut workspace_members = self.krates.workspace_members();
+            let found = workspace_members.find_map(|node| {
+                if let krates::Node::Krate { id, krate, .. } = node {
+                    if krate.name == package {
+                        return Some(id);
+                    }
+                }
+                None
+            });
+
+            if found.is_none() {
+                tracing::error!("Could not find package {package} in the workspace. Did you forget to add it to the workspace?");
+                tracing::error!("Packages in the workspace:");
+                for package in self.krates.workspace_members() {
+                    if let krates::Node::Krate { krate, .. } = package {
+                        tracing::error!("{}", krate.name());
+                    }
+                }
+            }
+
+            let kid = found.ok_or_else(|| anyhow::anyhow!("Failed to find package {package}"))?;
+
+            return Ok(self.krates.nid_for_kid(kid).unwrap());
+        };
+
+        // Otherwise find the package that is the closest parent of the current directory
+        let current_dir = std::env::current_dir()?;
+        let current_dir = current_dir.as_path();
+
+        // Go through each member and find the path that is a parent of the current directory
+        let mut closest_parent = None;
+        for member in self.krates.workspace_members() {
+            if let krates::Node::Krate { id, krate, .. } = member {
+                let member_path = krate.manifest_path.parent().unwrap();
+                if let Ok(path) = current_dir.strip_prefix(member_path.as_std_path()) {
+                    let len = path.components().count();
+                    match closest_parent {
+                        Some((_, closest_parent_len)) => {
+                            if len < closest_parent_len {
+                                closest_parent = Some((id, len));
+                            }
+                        }
+                        None => {
+                            closest_parent = Some((id, len));
+                        }
+                    }
+                }
+            }
+        }
+
+        let kid = closest_parent
+        .map(|(id, _)| id)
+        .with_context(|| {
+            let bin_targets = self.krates.workspace_members().filter_map(|krate|match krate {
+                krates::Node::Krate { krate, .. } if krate.targets.iter().any(|t| t.kind.contains(&krates::cm::TargetKind::Bin))=> {
+                    Some(format!("- {}", krate.name))
+                }
+                _ => None
+            }).collect::<Vec<_>>();
+            format!("Failed to find binary package to build.\nYou need to either run dx from inside a binary crate or specify a binary package to build with the `--package` flag. Try building again with one of the binary packages in the workspace:\n{}", bin_targets.join("\n"))
+        })?;
+
+        let package = self.krates.nid_for_kid(kid).unwrap();
+        Ok(package)
+    }
+
+    pub fn load_dioxus_config(&self, package: NodeId) -> Result<Option<DioxusConfig>> {
+        // Walk up from the cargo.toml to the root of the workspace looking for Dioxus.toml
+        let mut current_dir = self.krates[package]
+            .manifest_path
+            .parent()
+            .unwrap()
+            .as_std_path()
+            .to_path_buf()
+            .canonicalize()?;
+
+        let workspace_path = self
+            .krates
+            .workspace_root()
+            .as_std_path()
+            .to_path_buf()
+            .canonicalize()?;
+
+        let mut dioxus_conf_file = None;
+        while current_dir.starts_with(&workspace_path) {
+            let config = ["Dioxus.toml", "dioxus.toml"]
+                .into_iter()
+                .map(|file| current_dir.join(file))
+                .find(|path| path.is_file());
+
+            // Try to find Dioxus.toml in the current directory
+            if let Some(new_config) = config {
+                dioxus_conf_file = Some(new_config.as_path().to_path_buf());
+                break;
+            }
+            // If we can't find it, go up a directory
+            current_dir = current_dir
+                .parent()
+                .context("Failed to find Dioxus.toml")?
+                .to_path_buf();
+        }
+
+        let Some(dioxus_conf_file) = dioxus_conf_file else {
+            return Ok(None);
+        };
+
+        toml::from_str::<DioxusConfig>(&std::fs::read_to_string(&dioxus_conf_file)?)
+            .map_err(|err| {
+                anyhow::anyhow!("Failed to parse Dioxus.toml at {dioxus_conf_file:?}: {err}").into()
+            })
+            .map(Some)
+    }
+
+    /// Create a new gitignore map for this target crate
+    ///
+    /// todo(jon): this is a bit expensive to build, so maybe we should cache it?
+    pub fn workspace_gitignore(workspace_dir: &Path) -> Gitignore {
+        let mut ignore_builder = ignore::gitignore::GitignoreBuilder::new(workspace_dir);
+        ignore_builder.add(workspace_dir.join(".gitignore"));
+
+        // todo!()
+        // let workspace_dir = self.workspace_dir();
+        // ignore_builder.add(workspace_dir.join(".gitignore"));
+
+        for path in Self::default_ignore_list() {
+            ignore_builder
+                .add_line(None, path)
+                .expect("failed to add path to file excluded");
+        }
+
+        ignore_builder.build().unwrap()
+    }
+
+    pub fn ignore_for_krate(&self, path: &Path) -> ignore::gitignore::Gitignore {
+        let mut ignore_builder = ignore::gitignore::GitignoreBuilder::new(path);
+        for path in Self::default_ignore_list() {
+            ignore_builder
+                .add_line(None, path)
+                .expect("failed to add path to file excluded");
+        }
+        ignore_builder.build().unwrap()
+    }
+
+    pub fn default_ignore_list() -> Vec<&'static str> {
+        vec![
+            ".git",
+            ".github",
+            ".vscode",
+            "target",
+            "node_modules",
+            "dist",
+            "*~",
+            ".*",
+            "*.lock",
+            "*.log",
+        ]
+    }
+
+    pub(crate) fn workspace_root(&self) -> PathBuf {
+        self.krates.workspace_root().as_std_path().to_path_buf()
+    }
+
+    /// Returns the root of the crate that the command is run from, without calling `cargo metadata`
+    ///
+    /// If the command is run from the workspace root, this will return the top-level Cargo.toml
+    pub(crate) fn crate_root_from_path() -> Result<PathBuf> {
+        /// How many parent folders are searched for a `Cargo.toml`
+        const MAX_ANCESTORS: u32 = 10;
+
+        /// Checks if the directory contains `Cargo.toml`
+        fn contains_manifest(path: &Path) -> bool {
+            std::fs::read_dir(path)
+                .map(|entries| {
+                    entries
+                        .filter_map(Result::ok)
+                        .any(|ent| &ent.file_name() == "Cargo.toml")
+                })
+                .unwrap_or(false)
+        }
+
+        // From the current directory we work our way up, looking for `Cargo.toml`
+        std::env::current_dir()
+            .ok()
+            .and_then(|mut wd| {
+                for _ in 0..MAX_ANCESTORS {
+                    if contains_manifest(&wd) {
+                        return Some(wd);
+                    }
+                    if !wd.pop() {
+                        break;
+                    }
+                }
+                None
+            })
+            .ok_or_else(|| {
+                crate::Error::Cargo("Failed to find directory containing Cargo.toml".to_string())
+            })
+    }
+
+    /// Returns the properly canonicalized path to the dx executable, used for linking and wrapping rustc
+    pub(crate) fn path_to_dx() -> Result<PathBuf> {
+        Ok(
+            dunce::canonicalize(std::env::current_exe().context("Failed to find dx")?)
+                .context("Failed to find dx")?,
+        )
+    }
+}
+
+impl std::fmt::Debug for Workspace {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Workspace")
+            .field("krates", &"..")
+            .field("settings", &self.settings)
+            .field("rustc_version", &self.rustc_version)
+            .field("sysroot", &self.sysroot)
+            .field("wasm_opt", &self.wasm_opt)
+            .finish()
+    }
+}

packages/core/Cargo.toml

@@ -24,6 +24,7 @@ tracing = { workspace = true }
 warnings = { workspace = true }
 futures-util = { workspace = true, default-features = false, features = ["alloc", "std"] }
 serde = { workspace = true, optional = true, features = ["derive"] }
+subsecond = { workspace = true }
 
 [dev-dependencies]
 dioxus = { workspace = true }

packages/core/README.md

@@ -65,7 +65,7 @@ use dioxus::prelude::*;
 
 // First, declare a root component
 fn app() -> Element {
-    rsx!{
+    rsx! {
         div { "hello world" }
     }
 }

packages/core/src/global_context.rs

@@ -479,3 +479,18 @@ pub fn use_hook_with_cleanup<T: Clone + 'static>(
     use_drop(move || cleanup(_value));
     value
 }
+
+/// Force every component to be dirty and require a re-render. Used by hot-reloading.
+///
+/// This might need to change to a different flag in the event hooks order changes within components.
+/// What we really need is a way to mark components as needing a complete rebuild if they were hit by changes.
+pub fn force_all_dirty() {
+    Runtime::with(|rt| {
+        rt.scope_states.borrow_mut().iter().for_each(|state| {
+            if let Some(scope) = state.as_ref() {
+                scope.needs_update();
+            }
+        });
+    })
+    .expect("Runtime to exist");
+}

packages/core/src/lib.rs

@@ -93,17 +93,18 @@ pub use crate::innerlude::{
 pub mod prelude {
     pub use crate::innerlude::{
         consume_context, consume_context_from_scope, current_owner, current_scope_id,
-        fc_to_builder, generation, has_context, needs_update, needs_update_any, parent_scope,
-        provide_context, provide_error_boundary, provide_root_context, queue_effect, remove_future,
-        schedule_update, schedule_update_any, spawn, spawn_forever, spawn_isomorphic, suspend,
-        suspense_context, throw_error, try_consume_context, use_after_render, use_before_render,
-        use_drop, use_hook, use_hook_with_cleanup, with_owner, AnyValue, Attribute, Callback,
-        Component, ComponentFunction, Context, Element, ErrorBoundary, ErrorContext, Event,
-        EventHandler, Fragment, HasAttributes, IntoAttributeValue, IntoDynNode,
-        OptionStringFromMarker, Properties, ReactiveContext, RenderError, Runtime, RuntimeGuard,
-        ScopeId, ScopeState, SuperFrom, SuperInto, SuspendedFuture, SuspenseBoundary,
-        SuspenseBoundaryProps, SuspenseContext, SuspenseExtension, Task, Template,
-        TemplateAttribute, TemplateNode, VNode, VNodeInner, VirtualDom,
+        fc_to_builder, force_all_dirty, generation, has_context, needs_update, needs_update_any,
+        parent_scope, provide_context, provide_error_boundary, provide_root_context, queue_effect,
+        remove_future, schedule_update, schedule_update_any, spawn, spawn_forever,
+        spawn_isomorphic, suspend, suspense_context, throw_error, try_consume_context,
+        use_after_render, use_before_render, use_drop, use_hook, use_hook_with_cleanup, with_owner,
+        AnyValue, Attribute, Callback, Component, ComponentFunction, Context, Element,
+        ErrorBoundary, ErrorContext, Event, EventHandler, Fragment, HasAttributes,
+        IntoAttributeValue, IntoDynNode, OptionStringFromMarker, Properties, ReactiveContext,
+        RenderError, Runtime, RuntimeGuard, ScopeId, ScopeState, SuperFrom, SuperInto,
+        SuspendedFuture, SuspenseBoundary, SuspenseBoundaryProps, SuspenseContext,
+        SuspenseExtension, Task, Template, TemplateAttribute, TemplateNode, VNode, VNodeInner,
+        VirtualDom,
     };
 }
 

packages/core/src/nodes.rs

@@ -609,10 +609,8 @@ pub struct VComponent {
     /// The name of this component
     pub name: &'static str,
 
-    /// The function pointer of the component, known at compile time
-    ///
-    /// It is possible that components get folded at compile time, so these shouldn't be really used as a key
-    pub(crate) render_fn: TypeId,
+    /// The raw pointer to the render function
+    pub(crate) render_fn: usize,
 
     /// The props for this component
     pub(crate) props: BoxedAnyProps,
@@ -622,8 +620,8 @@ impl Clone for VComponent {
     fn clone(&self) -> Self {
         Self {
             name: self.name,
-            render_fn: self.render_fn,
             props: self.props.duplicate(),
+            render_fn: self.render_fn,
         }
     }
 }
@@ -638,7 +636,7 @@ impl VComponent {
     where
         P: Properties + 'static,
     {
-        let render_fn = component.id();
+        let render_fn = component.fn_ptr();
         let props = Box::new(VProps::new(
             component,
             <P as Properties>::memoize,
@@ -647,9 +645,9 @@ impl VComponent {
         ));
 
         VComponent {
+            render_fn,
             name: fn_name,
             props,
-            render_fn,
         }
     }
 

packages/core/src/properties.rs

@@ -1,4 +1,4 @@
-use std::{any::TypeId, fmt::Arguments};
+use std::fmt::Arguments;
 
 use crate::innerlude::*;
 
@@ -167,27 +167,39 @@ pub fn verify_component_called_as_component<C: ComponentFunction<P, M>, P, M>(co
     )
 )]
 pub trait ComponentFunction<Props, Marker = ()>: Clone + 'static {
-    /// Get the type id of the component.
-    fn id(&self) -> TypeId {
-        TypeId::of::<Self>()
-    }
+    /// Get the raw address of the component render function.
+    fn fn_ptr(&self) -> usize;
 
     /// Convert the component to a function that takes props and returns an element.
     fn rebuild(&self, props: Props) -> Element;
 }
 
 /// Accept any callbacks that take props
-impl<F: Fn(P) -> Element + Clone + 'static, P> ComponentFunction<P> for F {
+impl<F, P> ComponentFunction<P> for F
+where
+    F: Fn(P) -> Element + Clone + 'static,
+{
     fn rebuild(&self, props: P) -> Element {
-        self(props)
+        subsecond::HotFn::current(self.clone()).call((props,))
+    }
+
+    fn fn_ptr(&self) -> usize {
+        subsecond::HotFn::current(self.clone()).ptr_address() as usize
     }
 }
 
 /// Accept any callbacks that take no props
 pub struct EmptyMarker;
-impl<F: Fn() -> Element + Clone + 'static> ComponentFunction<(), EmptyMarker> for F {
-    fn rebuild(&self, _: ()) -> Element {
-        self()
+impl<F> ComponentFunction<(), EmptyMarker> for F
+where
+    F: Fn() -> Element + Clone + 'static,
+{
+    fn rebuild(&self, props: ()) -> Element {
+        subsecond::HotFn::current(self.clone()).call(props)
+    }
+
+    fn fn_ptr(&self) -> usize {
+        subsecond::HotFn::current(self.clone()).ptr_address() as usize
     }
 }
 

packages/core/src/tasks.rs

@@ -380,6 +380,9 @@ impl TaskType {
 /// These messages control how the scheduler will process updates to the UI.
 #[derive(Debug)]
 pub(crate) enum SchedulerMsg {
+    /// All components have been marked as dirty, requiring a full render
+    AllDirty,
+
     /// Immediate updates from Components that mark them as dirty
     Immediate(ScopeId),
 

packages/core/src/virtual_dom.rs

@@ -16,7 +16,7 @@ use crate::{Task, VComponent};
 use futures_util::StreamExt;
 use slab::Slab;
 use std::collections::BTreeSet;
-use std::{any::Any, rc::Rc};
+use std::{any::Any, rc::Rc, sync::Arc};
 use tracing::instrument;
 
 /// A virtual node system that progresses user events and diffs UI trees.
@@ -294,7 +294,7 @@ impl VirtualDom {
         root: impl ComponentFunction<P, M>,
         root_props: P,
     ) -> Self {
-        let render_fn = root.id();
+        let render_fn = root.fn_ptr();
         let props = VProps::new(root, |_, _| true, root_props, "Root");
         Self::new_with_component(VComponent {
             name: "root",
@@ -331,6 +331,9 @@ impl VirtualDom {
         );
         dom.new_scope(Box::new(root), "app");
 
+        #[cfg(debug_assertions)]
+        dom.register_subsecond_handler();
+
         dom
     }
 
@@ -375,6 +378,19 @@ impl VirtualDom {
         self.base_scope().state().provide_any_context(context);
     }
 
+    /// Mark all scopes as dirty. Each scope will be re-rendered.
+    pub fn mark_all_dirty(&mut self) {
+        let mut orders = vec![];
+
+        for (_idx, scope) in self.scopes.iter() {
+            orders.push(ScopeOrder::new(scope.state().height(), scope.id()));
+        }
+
+        for order in orders {
+            self.queue_scope(order);
+        }
+    }
+
     /// Manually mark a scope as requiring a re-render
     ///
     /// Whenever the Runtime "works", it will re-render this scope
@@ -458,6 +474,7 @@ impl VirtualDom {
                 self.mark_task_dirty(Task::from_id(id));
             }
             SchedulerMsg::EffectQueued => {}
+            SchedulerMsg::AllDirty => self.mark_all_dirty(),
         };
     }
 
@@ -469,6 +486,7 @@ impl VirtualDom {
                 SchedulerMsg::Immediate(id) => self.mark_dirty(id),
                 SchedulerMsg::TaskNotified(task) => self.mark_task_dirty(Task::from_id(task)),
                 SchedulerMsg::EffectQueued => {}
+                SchedulerMsg::AllDirty => self.mark_all_dirty(),
             }
         }
     }
@@ -744,6 +762,14 @@ impl VirtualDom {
         let event = crate::Event::new(event, bubbling);
         self.runtime().handle_event(name, event, element);
     }
+
+    #[cfg(debug_assertions)]
+    fn register_subsecond_handler(&self) {
+        let sender = self.runtime().sender.clone();
+        subsecond::register_handler(Arc::new(move || {
+            _ = sender.unbounded_send(SchedulerMsg::AllDirty);
+        }));
+    }
 }
 
 impl Drop for VirtualDom {

packages/depinfo/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "depinfo"
+version.workspace = true
+edition = "2021"
+authors = ["Jonathan Kelley"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/DioxusLabs/dioxus/"
+homepage = "https://dioxuslabs.com"
+description = "Depinfo parser for Rust"
+keywords = ["rustc", "cargo", "dep-info" ]
+
+[dependencies]
+thiserror = { workspace = true }
+

packages/depinfo/README.md

@@ -0,0 +1,14 @@
+# Rustc Dep-Info Parser
+
+This crate parses the output of rustc's `.d` dep-info file. It is used by the hot-reloading engine and other libraries to provide higher quality dependency analysis for the user's project.
+
+## License
+
+This project is licensed under either the [MIT license] or the [Apache-2 License].
+
+[apache-2 license]: https://github.com/DioxusLabs/dioxus/blob/master/LICENSE-APACHE
+[mit license]: https://github.com/DioxusLabs/dioxus/blob/master/LICENSE-MIT
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Dioxus by you, shall be licensed as MIT or Apache-2, without any additional
+terms or conditions.

packages/depinfo/src/dx.d

@@ -0,0 +1 @@
+/dioxus/target/debug/dx: /dioxus/packages/autofmt/README.md /dioxus/packages/autofmt/src/buffer.rs /dioxus/packages/autofmt/src/collect_macros.rs /dioxus/packages/autofmt/src/indent.rs /dioxus/packages/autofmt/src/lib.rs /dioxus/packages/autofmt/src/prettier_please.rs /dioxus/packages/autofmt/src/writer.rs /dioxus/packages/check/README.md /dioxus/packages/check/src/check.rs /dioxus/packages/check/src/issues.rs /dioxus/packages/check/src/lib.rs /dioxus/packages/check/src/metadata.rs /dioxus/packages/cli/README.md /dioxus/packages/cli/assets/android/MainActivity.kt.hbs /dioxus/packages/cli/assets/android/gen/app/build.gradle.kts.hbs /dioxus/packages/cli/assets/android/gen/app/proguard-rules.pro /dioxus/packages/cli/assets/android/gen/app/src/main/AndroidManifest.xml.hbs /dioxus/packages/cli/assets/android/gen/app/src/main/res/drawable/ic_launcher_background.xml /dioxus/packages/cli/assets/android/gen/app/src/main/res/drawable-v24/ic_launcher_foreground.xml /dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml /dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-hdpi/ic_launcher.webp /dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-mdpi/ic_launcher.webp /dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-xhdpi/ic_launcher.webp /dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp /dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp /dioxus/packages/cli/assets/android/gen/app/src/main/res/values/colors.xml /dioxus/packages/cli/assets/android/gen/app/src/main/res/values/strings.xml.hbs /dioxus/packages/cli/assets/android/gen/app/src/main/res/values/styles.xml /dioxus/packages/cli/assets/android/gen/build.gradle.kts /dioxus/packages/cli/assets/android/gen/gradle/wrapper/gradle-wrapper.jar /dioxus/packages/cli/assets/android/gen/gradle/wrapper/gradle-wrapper.properties /dioxus/packages/cli/assets/android/gen/gradle.properties /dioxus/packages/cli/assets/android/gen/gradlew /dioxus/packages/cli/assets/android/gen/gradlew.bat /dioxus/packages/cli/assets/android/gen/settings.gradle /dioxus/packages/cli/assets/dioxus.toml /dioxus/packages/cli/assets/ios/ios.plist.hbs /dioxus/packages/cli/assets/macos/mac.plist.hbs /dioxus/packages/cli/assets/web/index.html /dioxus/packages/cli/assets/web/loading.html /dioxus/packages/cli/assets/web/toast.html /dioxus/packages/cli/build.rs /dioxus/packages/cli/src/build/builder.rs /dioxus/packages/cli/src/build/bundle.rs /dioxus/packages/cli/src/build/mod.rs /dioxus/packages/cli/src/build/prerender.rs /dioxus/packages/cli/src/build/progress.rs /dioxus/packages/cli/src/build/request.rs /dioxus/packages/cli/src/build/templates.rs /dioxus/packages/cli/src/build/verify.rs /dioxus/packages/cli/src/build/web.rs /dioxus/packages/cli/src/bundle_utils.rs /dioxus/packages/cli/src/cli/autoformat.rs /dioxus/packages/cli/src/cli/build.rs /dioxus/packages/cli/src/cli/bundle.rs /dioxus/packages/cli/src/cli/check.rs /dioxus/packages/cli/src/cli/clean.rs /dioxus/packages/cli/src/cli/config.rs /dioxus/packages/cli/src/cli/create.rs /dioxus/packages/cli/src/cli/init.rs /dioxus/packages/cli/src/cli/link.rs /dioxus/packages/cli/src/cli/mod.rs /dioxus/packages/cli/src/cli/run.rs /dioxus/packages/cli/src/cli/serve.rs /dioxus/packages/cli/src/cli/target.rs /dioxus/packages/cli/src/cli/translate.rs /dioxus/packages/cli/src/cli/verbosity.rs /dioxus/packages/cli/src/config/app.rs /dioxus/packages/cli/src/config/bundle.rs /dioxus/packages/cli/src/config/desktop.rs /dioxus/packages/cli/src/config/dioxus_config.rs /dioxus/packages/cli/src/config/serve.rs /dioxus/packages/cli/src/config/web.rs /dioxus/packages/cli/src/config.rs /dioxus/packages/cli/src/dioxus_crate.rs /dioxus/packages/cli/src/dx_build_info.rs /dioxus/packages/cli/src/error.rs /dioxus/packages/cli/src/fastfs.rs /dioxus/packages/cli/src/filemap.rs /dioxus/packages/cli/src/logging.rs /dioxus/packages/cli/src/main.rs /dioxus/packages/cli/src/metadata.rs /dioxus/packages/cli/src/platform.rs /dioxus/packages/cli/src/rustc.rs /dioxus/packages/cli/src/serve/ansi_buffer.rs /dioxus/packages/cli/src/serve/detect.rs /dioxus/packages/cli/src/serve/handle.rs /dioxus/packages/cli/src/serve/mod.rs /dioxus/packages/cli/src/serve/output.rs /dioxus/packages/cli/src/serve/proxy.rs /dioxus/packages/cli/src/serve/runner.rs /dioxus/packages/cli/src/serve/server.rs /dioxus/packages/cli/src/serve/update.rs /dioxus/packages/cli/src/serve/watcher.rs /dioxus/packages/cli/src/settings.rs /dioxus/packages/cli/src/wasm_bindgen.rs /dioxus/packages/cli-config/src/lib.rs /dioxus/packages/cli-opt/src/css.rs /dioxus/packages/cli-opt/src/file.rs /dioxus/packages/cli-opt/src/folder.rs /dioxus/packages/cli-opt/src/image/jpg.rs /dioxus/packages/cli-opt/src/image/mod.rs /dioxus/packages/cli-opt/src/image/png.rs /dioxus/packages/cli-opt/src/js.rs /dioxus/packages/cli-opt/src/json.rs /dioxus/packages/cli-opt/src/lib.rs /dioxus/packages/config-macro/README.md /dioxus/packages/config-macro/src/lib.rs /dioxus/packages/const-serialize/README.md /dioxus/packages/const-serialize/src/const_buffers.rs /dioxus/packages/const-serialize/src/const_vec.rs /dioxus/packages/const-serialize/src/lib.rs /dioxus/packages/const-serialize-macro/src/lib.rs /dioxus/packages/core/README.md /dioxus/packages/core/docs/common_spawn_errors.md /dioxus/packages/core/docs/reactivity.md /dioxus/packages/core/src/any_props.rs /dioxus/packages/core/src/arena.rs /dioxus/packages/core/src/diff/component.rs /dioxus/packages/core/src/diff/iterator.rs /dioxus/packages/core/src/diff/mod.rs /dioxus/packages/core/src/diff/node.rs /dioxus/packages/core/src/effect.rs /dioxus/packages/core/src/error_boundary.rs /dioxus/packages/core/src/events.rs /dioxus/packages/core/src/fragment.rs /dioxus/packages/core/src/generational_box.rs /dioxus/packages/core/src/global_context.rs /dioxus/packages/core/src/hotreload_utils.rs /dioxus/packages/core/src/launch.rs /dioxus/packages/core/src/lib.rs /dioxus/packages/core/src/mutations.rs /dioxus/packages/core/src/nodes.rs /dioxus/packages/core/src/properties.rs /dioxus/packages/core/src/reactive_context.rs /dioxus/packages/core/src/render_error.rs /dioxus/packages/core/src/root_wrapper.rs /dioxus/packages/core/src/runtime.rs /dioxus/packages/core/src/scheduler.rs /dioxus/packages/core/src/scope_arena.rs /dioxus/packages/core/src/scope_context.rs /dioxus/packages/core/src/scopes.rs /dioxus/packages/core/src/suspense/component.rs /dioxus/packages/core/src/suspense/mod.rs /dioxus/packages/core/src/tasks.rs /dioxus/packages/core/src/virtual_dom.rs /dioxus/packages/core-macro/README.md /dioxus/packages/core-macro/docs/component.md /dioxus/packages/core-macro/docs/props.md /dioxus/packages/core-macro/docs/rsx.md /dioxus/packages/core-macro/src/component.rs /dioxus/packages/core-macro/src/lib.rs /dioxus/packages/core-macro/src/props/mod.rs /dioxus/packages/core-macro/src/utils.rs /dioxus/packages/core-types/src/bubbles.rs /dioxus/packages/core-types/src/bundled.rs /dioxus/packages/core-types/src/formatter.rs /dioxus/packages/core-types/src/hr_context.rs /dioxus/packages/core-types/src/lib.rs /dioxus/packages/devtools/src/lib.rs /dioxus/packages/devtools-types/src/lib.rs /dioxus/packages/dioxus-lib/README.md /dioxus/packages/dioxus-lib/src/lib.rs /dioxus/packages/document/build.rs /dioxus/packages/document/docs/eval.md /dioxus/packages/document/docs/head.md /dioxus/packages/document/src/document.rs /dioxus/packages/document/src/elements/link.rs /dioxus/packages/document/src/elements/meta.rs /dioxus/packages/document/src/elements/mod.rs /dioxus/packages/document/src/elements/script.rs /dioxus/packages/document/src/elements/style.rs /dioxus/packages/document/src/elements/stylesheet.rs /dioxus/packages/document/src/elements/title.rs /dioxus/packages/document/src/error.rs /dioxus/packages/document/src/eval.rs /dioxus/packages/document/src/js/head.js /dioxus/packages/document/src/lib.rs /dioxus/packages/document/./src/ts/eval.ts /dioxus/packages/document/./src/ts/head.ts /dioxus/packages/dx-wire-format/src/lib.rs /dioxus/packages/fullstack/README.md /dioxus/packages/fullstack/src/document/mod.rs /dioxus/packages/fullstack/src/hooks/mod.rs /dioxus/packages/fullstack/src/hooks/server_cached.rs /dioxus/packages/fullstack/src/hooks/server_future.rs /dioxus/packages/fullstack/src/html_storage/mod.rs /dioxus/packages/fullstack/src/lib.rs /dioxus/packages/generational-box/README.md /dioxus/packages/generational-box/src/entry.rs /dioxus/packages/generational-box/src/error.rs /dioxus/packages/generational-box/src/lib.rs /dioxus/packages/generational-box/src/references.rs /dioxus/packages/generational-box/src/sync.rs /dioxus/packages/generational-box/src/unsync.rs /dioxus/packages/history/src/lib.rs /dioxus/packages/history/src/memory.rs /dioxus/packages/hooks/README.md /dioxus/packages/hooks/docs/derived_state.md /dioxus/packages/hooks/docs/moving_state_around.md /dioxus/packages/hooks/docs/rules_of_hooks.md /dioxus/packages/hooks/docs/side_effects.md /dioxus/packages/hooks/docs/use_resource.md /dioxus/packages/hooks/src/lib.rs /dioxus/packages/hooks/src/use_callback.rs /dioxus/packages/hooks/src/use_context.rs /dioxus/packages/hooks/src/use_coroutine.rs /dioxus/packages/hooks/src/use_effect.rs /dioxus/packages/hooks/src/use_future.rs /dioxus/packages/hooks/src/use_hook_did_run.rs /dioxus/packages/hooks/src/use_memo.rs /dioxus/packages/hooks/src/use_on_destroy.rs /dioxus/packages/hooks/src/use_reactive.rs /dioxus/packages/hooks/src/use_resource.rs /dioxus/packages/hooks/src/use_root_context.rs /dioxus/packages/hooks/src/use_set_compare.rs /dioxus/packages/hooks/src/use_signal.rs /dioxus/packages/html/README.md /dioxus/packages/html/docs/common_event_handler_errors.md /dioxus/packages/html/docs/event_handlers.md /dioxus/packages/html/src/attribute_groups.rs /dioxus/packages/html/src/elements.rs /dioxus/packages/html/src/events/animation.rs /dioxus/packages/html/src/events/clipboard.rs /dioxus/packages/html/src/events/composition.rs /dioxus/packages/html/src/events/drag.rs /dioxus/packages/html/src/events/focus.rs /dioxus/packages/html/src/events/form.rs /dioxus/packages/html/src/events/image.rs /dioxus/packages/html/src/events/keyboard.rs /dioxus/packages/html/src/events/media.rs /dioxus/packages/html/src/events/mod.rs /dioxus/packages/html/src/events/mounted.rs /dioxus/packages/html/src/events/mouse.rs /dioxus/packages/html/src/events/pointer.rs /dioxus/packages/html/src/events/resize.rs /dioxus/packages/html/src/events/scroll.rs /dioxus/packages/html/src/events/selection.rs /dioxus/packages/html/src/events/toggle.rs /dioxus/packages/html/src/events/touch.rs /dioxus/packages/html/src/events/transition.rs /dioxus/packages/html/src/events/visible.rs /dioxus/packages/html/src/events/wheel.rs /dioxus/packages/html/src/file_data.rs /dioxus/packages/html/src/geometry.rs /dioxus/packages/html/src/input_data.rs /dioxus/packages/html/src/lib.rs /dioxus/packages/html/src/point_interaction.rs /dioxus/packages/html/src/render_template.rs /dioxus/packages/html-internal-macro/src/lib.rs /dioxus/packages/lazy-js-bundle/src/lib.rs /dioxus/packages/manganis/manganis/README.md /dioxus/packages/manganis/manganis/src/hash.rs /dioxus/packages/manganis/manganis/src/lib.rs /dioxus/packages/manganis/manganis/src/macro_helpers.rs /dioxus/packages/manganis/manganis-core/src/asset.rs /dioxus/packages/manganis/manganis-core/src/css.rs /dioxus/packages/manganis/manganis-core/src/folder.rs /dioxus/packages/manganis/manganis-core/src/hash.rs /dioxus/packages/manganis/manganis-core/src/images.rs /dioxus/packages/manganis/manganis-core/src/js.rs /dioxus/packages/manganis/manganis-core/src/lib.rs /dioxus/packages/manganis/manganis-core/src/linker.rs /dioxus/packages/manganis/manganis-core/src/options.rs /dioxus/packages/manganis/manganis-macro/README.md /dioxus/packages/manganis/manganis-macro/src/asset.rs /dioxus/packages/manganis/manganis-macro/src/lib.rs /dioxus/packages/manganis/manganis-macro/src/linker.rs /dioxus/packages/rsx/src/assign_dyn_ids.rs /dioxus/packages/rsx/src/attribute.rs /dioxus/packages/rsx/src/component.rs /dioxus/packages/rsx/src/diagnostics.rs /dioxus/packages/rsx/src/element.rs /dioxus/packages/rsx/src/expr_node.rs /dioxus/packages/rsx/src/forloop.rs /dioxus/packages/rsx/src/ifchain.rs /dioxus/packages/rsx/src/ifmt.rs /dioxus/packages/rsx/src/lib.rs /dioxus/packages/rsx/src/literal.rs /dioxus/packages/rsx/src/location.rs /dioxus/packages/rsx/src/node.rs /dioxus/packages/rsx/src/partial_closure.rs /dioxus/packages/rsx/src/raw_expr.rs /dioxus/packages/rsx/src/rsx_block.rs /dioxus/packages/rsx/src/rsx_call.rs /dioxus/packages/rsx/src/template_body.rs /dioxus/packages/rsx/src/text_node.rs /dioxus/packages/rsx/src/util.rs /dioxus/packages/rsx-hotreload/src/collect.rs /dioxus/packages/rsx-hotreload/src/diff.rs /dioxus/packages/rsx-hotreload/src/extensions.rs /dioxus/packages/rsx-hotreload/src/last_build_state.rs /dioxus/packages/rsx-hotreload/src/lib.rs /dioxus/packages/rsx-rosetta/README.md /dioxus/packages/rsx-rosetta/src/lib.rs /dioxus/packages/server-macro/src/lib.rs /dioxus/packages/signals/README.md /dioxus/packages/signals/docs/hoist/error.rs /dioxus/packages/signals/docs/hoist/fixed_list.rs /dioxus/packages/signals/docs/memo.md /dioxus/packages/signals/docs/signals.md /dioxus/packages/signals/src/copy_value.rs /dioxus/packages/signals/src/global/memo.rs /dioxus/packages/signals/src/global/mod.rs /dioxus/packages/signals/src/global/signal.rs /dioxus/packages/signals/src/impls.rs /dioxus/packages/signals/src/lib.rs /dioxus/packages/signals/src/map.rs /dioxus/packages/signals/src/memo.rs /dioxus/packages/signals/src/props.rs /dioxus/packages/signals/src/read.rs /dioxus/packages/signals/src/read_only_signal.rs /dioxus/packages/signals/src/set_compare.rs /dioxus/packages/signals/src/signal.rs /dioxus/packages/signals/src/warnings.rs /dioxus/packages/signals/src/write.rs /dioxus/target/debug/build/dioxus-cli-90993e55e02b7cee/out/built.rs

packages/depinfo/src/lib.rs

@@ -0,0 +1,439 @@
+//! Parse the output of rustc's `.d` dep-info file.
+//!
+//! Used by the hot-reloading engine and other libraries to provide higher quality dependency analysis
+//! for the user's project.
+
+use std::path::PathBuf;
+
+#[non_exhaustive]
+#[derive(Debug, thiserror::Error)]
+pub enum DepInfoParseError {
+    /// The input was malformed - maybe this `.d` format is no longer supported?
+    #[error("Malformed input")]
+    MalformedInput,
+
+    /// An env var could not be escaped or parsed - this might be a bug in rustc.
+    #[error("Failed to parse env var name")]
+    InvalidEnvVarName,
+}
+
+#[non_exhaustive]
+#[derive(Default, Debug)]
+pub struct RustcDepInfo {
+    /// The list of files that the main target in the dep-info file depends on.
+    pub files: Vec<PathBuf>,
+
+    /// The list of environment variables we found that the rustc compilation
+    /// depends on.
+    ///
+    /// The first element of the pair is the name of the env var and the second
+    /// item is the value. `Some` means that the env var was set, and `None`
+    /// means that the env var wasn't actually set and the compilation depends
+    /// on it not being set.
+    pub env: Vec<(String, Option<String>)>,
+}
+
+impl std::str::FromStr for RustcDepInfo {
+    type Err = DepInfoParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::new(s)
+    }
+}
+
+impl RustcDepInfo {
+    /// Parse the `.d` dep-info file generated by rustc.
+    pub fn new(contents: &str) -> Result<RustcDepInfo, DepInfoParseError> {
+        let mut ret = RustcDepInfo::default();
+        let mut found_deps = false;
+
+        for line in contents.lines() {
+            if let Some(rest) = line.strip_prefix("# env-dep:") {
+                let mut parts = rest.splitn(2, '=');
+                let env_var = match parts.next() {
+                    Some(s) => s,
+                    None => continue,
+                };
+                let env_val = match parts.next() {
+                    Some(s) => Some(unescape_env(s)?),
+                    None => None,
+                };
+                ret.env.push((unescape_env(env_var)?, env_val));
+            } else if let Some(pos) = line.find(": ") {
+                if found_deps {
+                    continue;
+                }
+                found_deps = true;
+                let mut deps = line[pos + 2..].split_whitespace();
+
+                while let Some(s) = deps.next() {
+                    let mut file = s.to_string();
+                    while file.ends_with('\\') {
+                        file.pop();
+                        file.push(' ');
+                        file.push_str(deps.next().ok_or(DepInfoParseError::MalformedInput)?);
+                    }
+                    ret.files.push(file.into());
+                }
+            }
+        }
+        return Ok(ret);
+
+        // rustc tries to fit env var names and values all on a single line, which
+        // means it needs to escape `\r` and `\n`. The escape syntax used is "\n"
+        // which means that `\` also needs to be escaped.
+        fn unescape_env(s: &str) -> Result<String, DepInfoParseError> {
+            let mut ret = String::with_capacity(s.len());
+            let mut chars = s.chars();
+            while let Some(c) = chars.next() {
+                if c != '\\' {
+                    ret.push(c);
+                    continue;
+                }
+                match chars.next() {
+                    Some('\\') => ret.push('\\'),
+                    Some('n') => ret.push('\n'),
+                    Some('r') => ret.push('\r'),
+                    Some(_) => return Err(DepInfoParseError::InvalidEnvVarName),
+                    None => return Err(DepInfoParseError::InvalidEnvVarName),
+                }
+            }
+            Ok(ret)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn parses_from_path() {
+        let contents = include_str!("./dx.d");
+        let info: RustcDepInfo = contents.parse().unwrap();
+        let answer = vec![
+            "/dioxus/packages/autofmt/README.md",
+            "/dioxus/packages/autofmt/src/buffer.rs",
+            "/dioxus/packages/autofmt/src/collect_macros.rs",
+            "/dioxus/packages/autofmt/src/indent.rs",
+            "/dioxus/packages/autofmt/src/lib.rs",
+            "/dioxus/packages/autofmt/src/prettier_please.rs",
+            "/dioxus/packages/autofmt/src/writer.rs",
+            "/dioxus/packages/check/README.md",
+            "/dioxus/packages/check/src/check.rs",
+            "/dioxus/packages/check/src/issues.rs",
+            "/dioxus/packages/check/src/lib.rs",
+            "/dioxus/packages/check/src/metadata.rs",
+            "/dioxus/packages/cli/README.md",
+            "/dioxus/packages/cli/assets/android/MainActivity.kt.hbs",
+            "/dioxus/packages/cli/assets/android/gen/app/build.gradle.kts.hbs",
+            "/dioxus/packages/cli/assets/android/gen/app/proguard-rules.pro",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/AndroidManifest.xml.hbs",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/drawable/ic_launcher_background.xml",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/drawable-v24/ic_launcher_foreground.xml",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-hdpi/ic_launcher.webp",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-mdpi/ic_launcher.webp",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-xhdpi/ic_launcher.webp",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/values/colors.xml",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/values/strings.xml.hbs",
+            "/dioxus/packages/cli/assets/android/gen/app/src/main/res/values/styles.xml",
+            "/dioxus/packages/cli/assets/android/gen/build.gradle.kts",
+            "/dioxus/packages/cli/assets/android/gen/gradle/wrapper/gradle-wrapper.jar",
+            "/dioxus/packages/cli/assets/android/gen/gradle/wrapper/gradle-wrapper.properties",
+            "/dioxus/packages/cli/assets/android/gen/gradle.properties",
+            "/dioxus/packages/cli/assets/android/gen/gradlew",
+            "/dioxus/packages/cli/assets/android/gen/gradlew.bat",
+            "/dioxus/packages/cli/assets/android/gen/settings.gradle",
+            "/dioxus/packages/cli/assets/dioxus.toml",
+            "/dioxus/packages/cli/assets/ios/ios.plist.hbs",
+            "/dioxus/packages/cli/assets/macos/mac.plist.hbs",
+            "/dioxus/packages/cli/assets/web/index.html",
+            "/dioxus/packages/cli/assets/web/loading.html",
+            "/dioxus/packages/cli/assets/web/toast.html",
+            "/dioxus/packages/cli/build.rs",
+            "/dioxus/packages/cli/src/build/builder.rs",
+            "/dioxus/packages/cli/src/build/bundle.rs",
+            "/dioxus/packages/cli/src/build/mod.rs",
+            "/dioxus/packages/cli/src/build/prerender.rs",
+            "/dioxus/packages/cli/src/build/progress.rs",
+            "/dioxus/packages/cli/src/build/request.rs",
+            "/dioxus/packages/cli/src/build/templates.rs",
+            "/dioxus/packages/cli/src/build/verify.rs",
+            "/dioxus/packages/cli/src/build/web.rs",
+            "/dioxus/packages/cli/src/bundle_utils.rs",
+            "/dioxus/packages/cli/src/cli/autoformat.rs",
+            "/dioxus/packages/cli/src/cli/build.rs",
+            "/dioxus/packages/cli/src/cli/bundle.rs",
+            "/dioxus/packages/cli/src/cli/check.rs",
+            "/dioxus/packages/cli/src/cli/clean.rs",
+            "/dioxus/packages/cli/src/cli/config.rs",
+            "/dioxus/packages/cli/src/cli/create.rs",
+            "/dioxus/packages/cli/src/cli/init.rs",
+            "/dioxus/packages/cli/src/cli/link.rs",
+            "/dioxus/packages/cli/src/cli/mod.rs",
+            "/dioxus/packages/cli/src/cli/run.rs",
+            "/dioxus/packages/cli/src/cli/serve.rs",
+            "/dioxus/packages/cli/src/cli/target.rs",
+            "/dioxus/packages/cli/src/cli/translate.rs",
+            "/dioxus/packages/cli/src/cli/verbosity.rs",
+            "/dioxus/packages/cli/src/config/app.rs",
+            "/dioxus/packages/cli/src/config/bundle.rs",
+            "/dioxus/packages/cli/src/config/desktop.rs",
+            "/dioxus/packages/cli/src/config/dioxus_config.rs",
+            "/dioxus/packages/cli/src/config/serve.rs",
+            "/dioxus/packages/cli/src/config/web.rs",
+            "/dioxus/packages/cli/src/config.rs",
+            "/dioxus/packages/cli/src/dioxus_crate.rs",
+            "/dioxus/packages/cli/src/dx_build_info.rs",
+            "/dioxus/packages/cli/src/error.rs",
+            "/dioxus/packages/cli/src/fastfs.rs",
+            "/dioxus/packages/cli/src/filemap.rs",
+            "/dioxus/packages/cli/src/logging.rs",
+            "/dioxus/packages/cli/src/main.rs",
+            "/dioxus/packages/cli/src/metadata.rs",
+            "/dioxus/packages/cli/src/platform.rs",
+            "/dioxus/packages/cli/src/rustc.rs",
+            "/dioxus/packages/cli/src/serve/ansi_buffer.rs",
+            "/dioxus/packages/cli/src/serve/detect.rs",
+            "/dioxus/packages/cli/src/serve/handle.rs",
+            "/dioxus/packages/cli/src/serve/mod.rs",
+            "/dioxus/packages/cli/src/serve/output.rs",
+            "/dioxus/packages/cli/src/serve/proxy.rs",
+            "/dioxus/packages/cli/src/serve/runner.rs",
+            "/dioxus/packages/cli/src/serve/server.rs",
+            "/dioxus/packages/cli/src/serve/update.rs",
+            "/dioxus/packages/cli/src/serve/watcher.rs",
+            "/dioxus/packages/cli/src/settings.rs",
+            "/dioxus/packages/cli/src/wasm_bindgen.rs",
+            "/dioxus/packages/cli-config/src/lib.rs",
+            "/dioxus/packages/cli-opt/src/css.rs",
+            "/dioxus/packages/cli-opt/src/file.rs",
+            "/dioxus/packages/cli-opt/src/folder.rs",
+            "/dioxus/packages/cli-opt/src/image/jpg.rs",
+            "/dioxus/packages/cli-opt/src/image/mod.rs",
+            "/dioxus/packages/cli-opt/src/image/png.rs",
+            "/dioxus/packages/cli-opt/src/js.rs",
+            "/dioxus/packages/cli-opt/src/json.rs",
+            "/dioxus/packages/cli-opt/src/lib.rs",
+            "/dioxus/packages/config-macro/README.md",
+            "/dioxus/packages/config-macro/src/lib.rs",
+            "/dioxus/packages/const-serialize/README.md",
+            "/dioxus/packages/const-serialize/src/const_buffers.rs",
+            "/dioxus/packages/const-serialize/src/const_vec.rs",
+            "/dioxus/packages/const-serialize/src/lib.rs",
+            "/dioxus/packages/const-serialize-macro/src/lib.rs",
+            "/dioxus/packages/core/README.md",
+            "/dioxus/packages/core/docs/common_spawn_errors.md",
+            "/dioxus/packages/core/docs/reactivity.md",
+            "/dioxus/packages/core/src/any_props.rs",
+            "/dioxus/packages/core/src/arena.rs",
+            "/dioxus/packages/core/src/diff/component.rs",
+            "/dioxus/packages/core/src/diff/iterator.rs",
+            "/dioxus/packages/core/src/diff/mod.rs",
+            "/dioxus/packages/core/src/diff/node.rs",
+            "/dioxus/packages/core/src/effect.rs",
+            "/dioxus/packages/core/src/error_boundary.rs",
+            "/dioxus/packages/core/src/events.rs",
+            "/dioxus/packages/core/src/fragment.rs",
+            "/dioxus/packages/core/src/generational_box.rs",
+            "/dioxus/packages/core/src/global_context.rs",
+            "/dioxus/packages/core/src/hotreload_utils.rs",
+            "/dioxus/packages/core/src/launch.rs",
+            "/dioxus/packages/core/src/lib.rs",
+            "/dioxus/packages/core/src/mutations.rs",
+            "/dioxus/packages/core/src/nodes.rs",
+            "/dioxus/packages/core/src/properties.rs",
+            "/dioxus/packages/core/src/reactive_context.rs",
+            "/dioxus/packages/core/src/render_error.rs",
+            "/dioxus/packages/core/src/root_wrapper.rs",
+            "/dioxus/packages/core/src/runtime.rs",
+            "/dioxus/packages/core/src/scheduler.rs",
+            "/dioxus/packages/core/src/scope_arena.rs",
+            "/dioxus/packages/core/src/scope_context.rs",
+            "/dioxus/packages/core/src/scopes.rs",
+            "/dioxus/packages/core/src/suspense/component.rs",
+            "/dioxus/packages/core/src/suspense/mod.rs",
+            "/dioxus/packages/core/src/tasks.rs",
+            "/dioxus/packages/core/src/virtual_dom.rs",
+            "/dioxus/packages/core-macro/README.md",
+            "/dioxus/packages/core-macro/docs/component.md",
+            "/dioxus/packages/core-macro/docs/props.md",
+            "/dioxus/packages/core-macro/docs/rsx.md",
+            "/dioxus/packages/core-macro/src/component.rs",
+            "/dioxus/packages/core-macro/src/lib.rs",
+            "/dioxus/packages/core-macro/src/props/mod.rs",
+            "/dioxus/packages/core-macro/src/utils.rs",
+            "/dioxus/packages/core-types/src/bubbles.rs",
+            "/dioxus/packages/core-types/src/bundled.rs",
+            "/dioxus/packages/core-types/src/formatter.rs",
+            "/dioxus/packages/core-types/src/hr_context.rs",
+            "/dioxus/packages/core-types/src/lib.rs",
+            "/dioxus/packages/devtools/src/lib.rs",
+            "/dioxus/packages/devtools-types/src/lib.rs",
+            "/dioxus/packages/dioxus-lib/README.md",
+            "/dioxus/packages/dioxus-lib/src/lib.rs",
+            "/dioxus/packages/document/build.rs",
+            "/dioxus/packages/document/docs/eval.md",
+            "/dioxus/packages/document/docs/head.md",
+            "/dioxus/packages/document/src/document.rs",
+            "/dioxus/packages/document/src/elements/link.rs",
+            "/dioxus/packages/document/src/elements/meta.rs",
+            "/dioxus/packages/document/src/elements/mod.rs",
+            "/dioxus/packages/document/src/elements/script.rs",
+            "/dioxus/packages/document/src/elements/style.rs",
+            "/dioxus/packages/document/src/elements/stylesheet.rs",
+            "/dioxus/packages/document/src/elements/title.rs",
+            "/dioxus/packages/document/src/error.rs",
+            "/dioxus/packages/document/src/eval.rs",
+            "/dioxus/packages/document/src/js/head.js",
+            "/dioxus/packages/document/src/lib.rs",
+            "/dioxus/packages/document/./src/ts/eval.ts",
+            "/dioxus/packages/document/./src/ts/head.ts",
+            "/dioxus/packages/dx-wire-format/src/lib.rs",
+            "/dioxus/packages/fullstack/README.md",
+            "/dioxus/packages/fullstack/src/document/mod.rs",
+            "/dioxus/packages/fullstack/src/hooks/mod.rs",
+            "/dioxus/packages/fullstack/src/hooks/server_cached.rs",
+            "/dioxus/packages/fullstack/src/hooks/server_future.rs",
+            "/dioxus/packages/fullstack/src/html_storage/mod.rs",
+            "/dioxus/packages/fullstack/src/lib.rs",
+            "/dioxus/packages/generational-box/README.md",
+            "/dioxus/packages/generational-box/src/entry.rs",
+            "/dioxus/packages/generational-box/src/error.rs",
+            "/dioxus/packages/generational-box/src/lib.rs",
+            "/dioxus/packages/generational-box/src/references.rs",
+            "/dioxus/packages/generational-box/src/sync.rs",
+            "/dioxus/packages/generational-box/src/unsync.rs",
+            "/dioxus/packages/history/src/lib.rs",
+            "/dioxus/packages/history/src/memory.rs",
+            "/dioxus/packages/hooks/README.md",
+            "/dioxus/packages/hooks/docs/derived_state.md",
+            "/dioxus/packages/hooks/docs/moving_state_around.md",
+            "/dioxus/packages/hooks/docs/rules_of_hooks.md",
+            "/dioxus/packages/hooks/docs/side_effects.md",
+            "/dioxus/packages/hooks/docs/use_resource.md",
+            "/dioxus/packages/hooks/src/lib.rs",
+            "/dioxus/packages/hooks/src/use_callback.rs",
+            "/dioxus/packages/hooks/src/use_context.rs",
+            "/dioxus/packages/hooks/src/use_coroutine.rs",
+            "/dioxus/packages/hooks/src/use_effect.rs",
+            "/dioxus/packages/hooks/src/use_future.rs",
+            "/dioxus/packages/hooks/src/use_hook_did_run.rs",
+            "/dioxus/packages/hooks/src/use_memo.rs",
+            "/dioxus/packages/hooks/src/use_on_destroy.rs",
+            "/dioxus/packages/hooks/src/use_reactive.rs",
+            "/dioxus/packages/hooks/src/use_resource.rs",
+            "/dioxus/packages/hooks/src/use_root_context.rs",
+            "/dioxus/packages/hooks/src/use_set_compare.rs",
+            "/dioxus/packages/hooks/src/use_signal.rs",
+            "/dioxus/packages/html/README.md",
+            "/dioxus/packages/html/docs/common_event_handler_errors.md",
+            "/dioxus/packages/html/docs/event_handlers.md",
+            "/dioxus/packages/html/src/attribute_groups.rs",
+            "/dioxus/packages/html/src/elements.rs",
+            "/dioxus/packages/html/src/events/animation.rs",
+            "/dioxus/packages/html/src/events/clipboard.rs",
+            "/dioxus/packages/html/src/events/composition.rs",
+            "/dioxus/packages/html/src/events/drag.rs",
+            "/dioxus/packages/html/src/events/focus.rs",
+            "/dioxus/packages/html/src/events/form.rs",
+            "/dioxus/packages/html/src/events/image.rs",
+            "/dioxus/packages/html/src/events/keyboard.rs",
+            "/dioxus/packages/html/src/events/media.rs",
+            "/dioxus/packages/html/src/events/mod.rs",
+            "/dioxus/packages/html/src/events/mounted.rs",
+            "/dioxus/packages/html/src/events/mouse.rs",
+            "/dioxus/packages/html/src/events/pointer.rs",
+            "/dioxus/packages/html/src/events/resize.rs",
+            "/dioxus/packages/html/src/events/scroll.rs",
+            "/dioxus/packages/html/src/events/selection.rs",
+            "/dioxus/packages/html/src/events/toggle.rs",
+            "/dioxus/packages/html/src/events/touch.rs",
+            "/dioxus/packages/html/src/events/transition.rs",
+            "/dioxus/packages/html/src/events/visible.rs",
+            "/dioxus/packages/html/src/events/wheel.rs",
+            "/dioxus/packages/html/src/file_data.rs",
+            "/dioxus/packages/html/src/geometry.rs",
+            "/dioxus/packages/html/src/input_data.rs",
+            "/dioxus/packages/html/src/lib.rs",
+            "/dioxus/packages/html/src/point_interaction.rs",
+            "/dioxus/packages/html/src/render_template.rs",
+            "/dioxus/packages/html-internal-macro/src/lib.rs",
+            "/dioxus/packages/lazy-js-bundle/src/lib.rs",
+            "/dioxus/packages/manganis/manganis/README.md",
+            "/dioxus/packages/manganis/manganis/src/hash.rs",
+            "/dioxus/packages/manganis/manganis/src/lib.rs",
+            "/dioxus/packages/manganis/manganis/src/macro_helpers.rs",
+            "/dioxus/packages/manganis/manganis-core/src/asset.rs",
+            "/dioxus/packages/manganis/manganis-core/src/css.rs",
+            "/dioxus/packages/manganis/manganis-core/src/folder.rs",
+            "/dioxus/packages/manganis/manganis-core/src/hash.rs",
+            "/dioxus/packages/manganis/manganis-core/src/images.rs",
+            "/dioxus/packages/manganis/manganis-core/src/js.rs",
+            "/dioxus/packages/manganis/manganis-core/src/lib.rs",
+            "/dioxus/packages/manganis/manganis-core/src/linker.rs",
+            "/dioxus/packages/manganis/manganis-core/src/options.rs",
+            "/dioxus/packages/manganis/manganis-macro/README.md",
+            "/dioxus/packages/manganis/manganis-macro/src/asset.rs",
+            "/dioxus/packages/manganis/manganis-macro/src/lib.rs",
+            "/dioxus/packages/manganis/manganis-macro/src/linker.rs",
+            "/dioxus/packages/rsx/src/assign_dyn_ids.rs",
+            "/dioxus/packages/rsx/src/attribute.rs",
+            "/dioxus/packages/rsx/src/component.rs",
+            "/dioxus/packages/rsx/src/diagnostics.rs",
+            "/dioxus/packages/rsx/src/element.rs",
+            "/dioxus/packages/rsx/src/expr_node.rs",
+            "/dioxus/packages/rsx/src/forloop.rs",
+            "/dioxus/packages/rsx/src/ifchain.rs",
+            "/dioxus/packages/rsx/src/ifmt.rs",
+            "/dioxus/packages/rsx/src/lib.rs",
+            "/dioxus/packages/rsx/src/literal.rs",
+            "/dioxus/packages/rsx/src/location.rs",
+            "/dioxus/packages/rsx/src/node.rs",
+            "/dioxus/packages/rsx/src/partial_closure.rs",
+            "/dioxus/packages/rsx/src/raw_expr.rs",
+            "/dioxus/packages/rsx/src/rsx_block.rs",
+            "/dioxus/packages/rsx/src/rsx_call.rs",
+            "/dioxus/packages/rsx/src/template_body.rs",
+            "/dioxus/packages/rsx/src/text_node.rs",
+            "/dioxus/packages/rsx/src/util.rs",
+            "/dioxus/packages/rsx-hotreload/src/collect.rs",
+            "/dioxus/packages/rsx-hotreload/src/diff.rs",
+            "/dioxus/packages/rsx-hotreload/src/extensions.rs",
+            "/dioxus/packages/rsx-hotreload/src/last_build_state.rs",
+            "/dioxus/packages/rsx-hotreload/src/lib.rs",
+            "/dioxus/packages/rsx-rosetta/README.md",
+            "/dioxus/packages/rsx-rosetta/src/lib.rs",
+            "/dioxus/packages/server-macro/src/lib.rs",
+            "/dioxus/packages/signals/README.md",
+            "/dioxus/packages/signals/docs/hoist/error.rs",
+            "/dioxus/packages/signals/docs/hoist/fixed_list.rs",
+            "/dioxus/packages/signals/docs/memo.md",
+            "/dioxus/packages/signals/docs/signals.md",
+            "/dioxus/packages/signals/src/copy_value.rs",
+            "/dioxus/packages/signals/src/global/memo.rs",
+            "/dioxus/packages/signals/src/global/mod.rs",
+            "/dioxus/packages/signals/src/global/signal.rs",
+            "/dioxus/packages/signals/src/impls.rs",
+            "/dioxus/packages/signals/src/lib.rs",
+            "/dioxus/packages/signals/src/map.rs",
+            "/dioxus/packages/signals/src/memo.rs",
+            "/dioxus/packages/signals/src/props.rs",
+            "/dioxus/packages/signals/src/read.rs",
+            "/dioxus/packages/signals/src/read_only_signal.rs",
+            "/dioxus/packages/signals/src/set_compare.rs",
+            "/dioxus/packages/signals/src/signal.rs",
+            "/dioxus/packages/signals/src/warnings.rs",
+            "/dioxus/packages/signals/src/write.rs",
+            "/dioxus/target/debug/build/dioxus-cli-90993e55e02b7cee/out/built.rs",
+        ];
+        assert_eq!(
+            answer.iter().map(PathBuf::from).collect::<Vec<_>>(),
+            info.files
+        );
+    }
+}

packages/desktop/src/app.rs

@@ -327,7 +327,14 @@ impl App {
         match msg {
             DevserverMsg::HotReload(hr_msg) => {
                 for webview in self.webviews.values_mut() {
-                    dioxus_devtools::apply_changes(&webview.dom, &hr_msg);
+                    {
+                        // This is a place where wry says it's threadsafe but it's actually not.
+                        // If we're patching the app, we want to make sure it's not going to progress in the interim.
+                        let lock = crate::android_sync_lock::android_runtime_lock();
+                        dioxus_devtools::apply_changes(&webview.dom, &hr_msg);
+                        drop(lock);
+                    }
+
                     webview.poll_vdom();
                 }
 
@@ -346,6 +353,7 @@ impl App {
             DevserverMsg::Shutdown => {
                 self.control_flow = ControlFlow::Exit;
             }
+            _ => {}
         }
     }
 

packages/desktop/src/config.rs

@@ -70,12 +70,12 @@ impl LaunchConfig for Config {}
 
 pub(crate) type WryProtocol = (
     String,
-    Box<dyn Fn(&str, HttpRequest<Vec<u8>>) -> HttpResponse<Cow<'static, [u8]>> + 'static>,
+    Box<dyn Fn(HttpRequest<Vec<u8>>) -> HttpResponse<Cow<'static, [u8]>> + 'static>,
 );
 
 pub(crate) type AsyncWryProtocol = (
     String,
-    Box<dyn Fn(&str, HttpRequest<Vec<u8>>, RequestAsyncResponder) + 'static>,
+    Box<dyn Fn(HttpRequest<Vec<u8>>, RequestAsyncResponder) + 'static>,
 );
 
 impl Config {
@@ -188,7 +188,7 @@ impl Config {
     /// Set a custom protocol
     pub fn with_custom_protocol<F>(mut self, name: impl ToString, handler: F) -> Self
     where
-        F: Fn(&str, HttpRequest<Vec<u8>>) -> HttpResponse<Cow<'static, [u8]>> + 'static,
+        F: Fn(HttpRequest<Vec<u8>>) -> HttpResponse<Cow<'static, [u8]>> + 'static,
     {
         self.protocols.push((name.to_string(), Box::new(handler)));
         self
@@ -204,7 +204,7 @@ impl Config {
     /// #
     /// # fn main() {
     /// let cfg = Config::new()
-    ///     .with_asynchronous_custom_protocol("asset", |_webview_id, request, responder| {
+    ///     .with_asynchronous_custom_protocol("asset", |request, responder| {
     ///         tokio::spawn(async move {
     ///             responder.respond(
     ///                 HTTPResponse::builder()
@@ -222,7 +222,7 @@ impl Config {
     /// See [`wry`](wry::WebViewBuilder::with_asynchronous_custom_protocol) for more details on implementation
     pub fn with_asynchronous_custom_protocol<F>(mut self, name: impl ToString, handler: F) -> Self
     where
-        F: Fn(&str, HttpRequest<Vec<u8>>, RequestAsyncResponder) + 'static,
+        F: Fn(HttpRequest<Vec<u8>>, RequestAsyncResponder) + 'static,
     {
         self.asynchronous_protocols
             .push((name.to_string(), Box::new(handler)));

packages/desktop/src/webview.rs

@@ -235,7 +235,7 @@ impl WebviewInstance {
                 asset_handlers,
                 edits
             ];
-            move |_id: wry::WebViewId, request, responder: RequestAsyncResponder| {
+            move |request, responder: RequestAsyncResponder| {
                 protocol::desktop_handler(
                     request,
                     asset_handlers.clone(),
@@ -303,7 +303,33 @@ impl WebviewInstance {
             }
         };
 
-        let mut wv_builder = WebViewBuilder::with_web_context(&mut web_context)
+        #[cfg(any(
+            target_os = "windows",
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "android"
+        ))]
+        let mut webview = if cfg.as_child_window {
+            WebViewBuilder::new_as_child(&window)
+        } else {
+            WebViewBuilder::new(&window)
+        };
+
+        #[cfg(not(any(
+            target_os = "windows",
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "android"
+        )))]
+        let mut webview = {
+            use tao::platform::unix::WindowExtUnix;
+            use wry::WebViewBuilderExtUnix;
+            let vbox = window.default_vbox().unwrap();
+            WebViewBuilder::new_gtk(vbox)
+        };
+
+        webview = webview
+            .with_web_context(&mut web_context)
             .with_bounds(wry::Rect {
                 position: wry::dpi::Position::Logical(wry::dpi::LogicalPosition::new(0.0, 0.0)),
                 size: wry::dpi::Size::Physical(wry::dpi::PhysicalSize::new(
@@ -332,23 +358,23 @@ impl WebviewInstance {
         #[cfg(target_os = "windows")]
         {
             use wry::WebViewBuilderExtWindows;
-            wv_builder = wv_builder.with_browser_accelerator_keys(false);
+            webview = webview.with_browser_accelerator_keys(false);
         }
 
         if !cfg.disable_file_drop_handler {
-            wv_builder = wv_builder.with_drag_drop_handler(file_drop_handler);
+            webview = webview.with_drag_drop_handler(file_drop_handler);
         }
 
         if let Some(color) = cfg.background_color {
-            wv_builder = wv_builder.with_background_color(color);
+            webview = webview.with_background_color(color);
         }
 
         for (name, handler) in cfg.protocols.drain(..) {
-            wv_builder = wv_builder.with_custom_protocol(name, handler);
+            webview = webview.with_custom_protocol(name, handler);
         }
 
         for (name, handler) in cfg.asynchronous_protocols.drain(..) {
-            wv_builder = wv_builder.with_asynchronous_custom_protocol(name, handler);
+            webview = webview.with_asynchronous_custom_protocol(name, handler);
         }
 
         const INITIALIZATION_SCRIPT: &str = r#"
@@ -365,38 +391,12 @@ impl WebviewInstance {
 
         if cfg.disable_context_menu {
             // in release mode, we don't want to show the dev tool or reload menus
-            wv_builder = wv_builder.with_initialization_script(INITIALIZATION_SCRIPT)
+            webview = webview.with_initialization_script(INITIALIZATION_SCRIPT)
         } else {
             // in debug, we are okay with the reload menu showing and dev tool
-            wv_builder = wv_builder.with_devtools(true);
+            webview = webview.with_devtools(true);
         }
 
-        #[cfg(any(
-            target_os = "windows",
-            target_os = "macos",
-            target_os = "ios",
-            target_os = "android"
-        ))]
-        let webview = if cfg.as_child_window {
-            wv_builder.build_as_child(&window)
-        } else {
-            wv_builder.build(&window)
-        }
-        .unwrap();
-
-        #[cfg(not(any(
-            target_os = "windows",
-            target_os = "macos",
-            target_os = "ios",
-            target_os = "android"
-        )))]
-        let webview = {
-            use tao::platform::unix::WindowExtUnix;
-            use wry::WebViewBuilderExtUnix;
-            let vbox = window.default_vbox().unwrap();
-            wv_builder.build_gtk(vbox).unwrap()
-        };
-
         let menu = if cfg!(not(any(target_os = "android", target_os = "ios"))) {
             let menu_option = cfg.menu.into();
             if let Some(menu) = &menu_option {
@@ -407,6 +407,7 @@ impl WebviewInstance {
             None
         };
 
+        let webview = webview.build().unwrap();
         let desktop_context = Rc::from(DesktopService::new(
             webview,
             window,

packages/devtools-types/Cargo.toml

@@ -12,3 +12,4 @@ keywords = ["dom", "ui", "gui", "react", ]
 [dependencies]
 serde = { workspace = true, features = ["derive"] }
 dioxus-core = { workspace = true, features = ["serialize"] }
+subsecond-types = { workspace = true }

packages/devtools-types/src/lib.rs

@@ -1,14 +1,19 @@
 use dioxus_core::internal::HotReloadTemplateWithLocation;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use subsecond_types::JumpTable;
 
 /// A message the hot reloading server sends to the client
+#[non_exhaustive]
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub enum DevserverMsg {
     /// Attempt a hotreload
     /// This includes all the templates/literals/assets/binary patches that have changed in one shot
     HotReload(HotReloadMsg),
 
+    /// Starting a hotpatch
+    HotPatchStart,
+
     /// The devserver is starting a full rebuild.
     FullReloadStart,
 
@@ -25,6 +30,7 @@ pub enum DevserverMsg {
 /// A message the client sends from the frontend to the devserver
 ///
 /// This is used to communicate with the devserver
+#[non_exhaustive]
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub enum ClientMsg {
     Log {
@@ -37,11 +43,13 @@ pub enum ClientMsg {
 pub struct HotReloadMsg {
     pub templates: Vec<HotReloadTemplateWithLocation>,
     pub assets: Vec<PathBuf>,
-    pub unknown_files: Vec<PathBuf>,
+    pub ms_elapsed: u64,
+    pub jump_table: Option<JumpTable>,
+    pub for_build_id: Option<u64>,
 }
 
 impl HotReloadMsg {
     pub fn is_empty(&self) -> bool {
-        self.templates.is_empty() && self.assets.is_empty() && self.unknown_files.is_empty()
+        self.templates.is_empty() && self.assets.is_empty() && self.jump_table.is_none()
     }
 }

packages/devtools/Cargo.toml

@@ -13,8 +13,11 @@ keywords = ["dom", "ui", "gui", "react", "hot-reloading"]
 dioxus-signals = { workspace = true }
 dioxus-core = { workspace = true, features = ["serialize"] }
 dioxus-devtools-types = { workspace = true }
+dioxus-cli-config = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+subsecond = { workspace = true }
+thiserror = { workspace = true }
 
 # hot reloading serve
 tracing = { workspace = true }

packages/devtools/src/lib.rs

@@ -1,14 +1,24 @@
 use dioxus_core::{ScopeId, VirtualDom};
-pub use dioxus_devtools_types::*;
 use dioxus_signals::{GlobalKey, Writable};
 
+pub use dioxus_devtools_types::*;
+pub use subsecond;
+use subsecond::PatchError;
+
 /// Applies template and literal changes to the VirtualDom
 ///
 /// Assets need to be handled by the renderer.
 pub fn apply_changes(dom: &VirtualDom, msg: &HotReloadMsg) {
+    try_apply_changes(dom, msg).unwrap()
+}
+
+/// Applies template and literal changes to the VirtualDom, but doesn't panic if patching fails.
+///
+/// Assets need to be handled by the renderer.
+pub fn try_apply_changes(dom: &VirtualDom, msg: &HotReloadMsg) -> Result<(), PatchError> {
     dom.runtime().on_scope(ScopeId::ROOT, || {
+        // 1. Update signals...
         let ctx = dioxus_signals::get_global_context();
-
         for template in &msg.templates {
             let value = template.template.clone();
             let key = GlobalKey::File {
@@ -21,7 +31,17 @@ pub fn apply_changes(dom: &VirtualDom, msg: &HotReloadMsg) {
                 signal.set(Some(value));
             }
         }
-    });
+
+        // 2. Attempt to hotpatch
+        if let Some(jump_table) = msg.jump_table.as_ref().cloned() {
+            if msg.for_build_id == Some(dioxus_cli_config::build_id()) {
+                unsafe { subsecond::apply_patch(jump_table) }?;
+                dioxus_core::prelude::force_all_dirty();
+            }
+        }
+
+        Ok(())
+    })
 }
 
 /// Connect to the devserver and handle its messages with a callback.
@@ -30,7 +50,13 @@ pub fn apply_changes(dom: &VirtualDom, msg: &HotReloadMsg) {
 #[cfg(not(target_arch = "wasm32"))]
 pub fn connect(endpoint: String, mut callback: impl FnMut(DevserverMsg) + Send + 'static) {
     std::thread::spawn(move || {
-        let (mut websocket, _req) = match tungstenite::connect(endpoint.clone()) {
+        let uri = format!(
+            "{endpoint}?aslr_reference={}&build_id={}",
+            subsecond::__aslr_reference(),
+            dioxus_cli_config::build_id()
+        );
+
+        let (mut websocket, _req) = match tungstenite::connect(uri) {
             Ok((websocket, req)) => (websocket, req),
             Err(_) => return,
         };

packages/dioxus/Cargo.toml

@@ -26,17 +26,18 @@ dioxus-mobile = { workspace = true, optional = true }
 dioxus-desktop = { workspace = true, default-features = true, optional = true }
 dioxus-fullstack = { workspace = true, default-features = true, optional = true }
 dioxus-liveview = { workspace = true, optional = true }
+dioxus-server = { workspace = true, optional = true }
 dioxus-ssr = { workspace = true, optional = true }
 dioxus-native = { workspace = true, optional = true }
+dioxus_server_macro = { workspace = true, optional = true }
 manganis = { workspace = true, features = ["dioxus"], optional = true }
 dioxus-logger = { workspace = true, optional = true }
 warnings = { workspace = true, optional = true }
 wasm-split = { workspace = true, optional = true }
+subsecond = { workspace = true }
 
 serde = { workspace = true, optional = true }
 dioxus-cli-config = { workspace = true, optional = true }
-
-[target.'cfg(not(any(target_arch = "wasm32", target_os = "ios", target_os = "android")))'.dependencies]
 dioxus-devtools = { workspace = true, optional = true }
 
 [features]
@@ -89,8 +90,16 @@ web = [
 ]
 ssr = ["dep:dioxus-ssr", "dioxus-config-macro/ssr"]
 liveview = ["dep:dioxus-liveview", "dioxus-config-macro/liveview"]
-server = ["dioxus-fullstack?/axum", "dioxus-fullstack?/server", "ssr", "dioxus-liveview?/axum"]
 native = ["dep:dioxus-native"] # todo(jon): decompose the desktop crate such that "webview" is the default and native is opt-in
+server = [
+  "dep:dioxus-server",
+  "dep:dioxus_server_macro",
+  "dioxus_server_macro/server",
+  "dioxus_server_macro/axum",
+  "ssr",
+  "dioxus-liveview?/axum",
+  "dioxus-fullstack?/server",
+]
 
 # This feature just disables the no-renderer-enabled warning
 third-party-renderer = []

packages/dioxus/src/launch.rs

@@ -96,11 +96,7 @@ impl LaunchBuilder {
         )
     )]
     pub fn new() -> LaunchBuilder {
-        let platform = if cfg!(feature = "liveview") {
-            KnownPlatform::Liveview
-        } else if cfg!(feature = "server") {
-            KnownPlatform::Server
-        } else if cfg!(feature = "native") {
+        let platform = if cfg!(feature = "native") {
             KnownPlatform::Native
         } else if cfg!(feature = "desktop") {
             KnownPlatform::Desktop
@@ -108,6 +104,10 @@ impl LaunchBuilder {
             KnownPlatform::Mobile
         } else if cfg!(feature = "web") {
             KnownPlatform::Web
+        } else if cfg!(feature = "server") {
+            KnownPlatform::Server
+        } else if cfg!(feature = "liveview") {
+            KnownPlatform::Liveview
         } else {
             panic!("No platform feature enabled. Please enable one of the following features: liveview, desktop, mobile, web, tui, fullstack to use the launch API.")
         };
@@ -284,7 +284,6 @@ impl LaunchBuilder {
     }
 
     /// Launch your application.
-    ///
     #[allow(clippy::diverging_sub_expression)]
     pub fn launch(self, app: fn() -> Element) {
         let Self {
@@ -343,7 +342,7 @@ impl LaunchBuilder {
 
         #[cfg(feature = "server")]
         if matches!(platform, KnownPlatform::Server) {
-            return dioxus_fullstack::server::launch::launch(app, contexts, configs);
+            return dioxus_server::launch(app, contexts, configs);
         }
 
         #[cfg(feature = "web")]
@@ -364,8 +363,8 @@ impl LaunchBuilder {
 
                 #[cfg(feature = "document")]
                 {
-                    use dioxus_fullstack::document;
-                    let document = std::rc::Rc::new(document::web::FullstackWebDocument)
+                    use dioxus_fullstack::FullstackWebDocument;
+                    let document = std::rc::Rc::new(FullstackWebDocument)
                         as std::rc::Rc<dyn crate::prelude::document::Document>;
                     vdom.provide_root_context(document);
                 }

packages/dioxus/src/lib.rs

@@ -78,6 +78,8 @@ pub use dioxus_cli_config as cli_config;
 #[cfg_attr(docsrs, doc(cfg(feature = "wasm-split")))]
 pub use wasm_split;
 
+pub use subsecond;
+
 pub mod prelude {
     #[cfg(feature = "document")]
     #[cfg_attr(docsrs, doc(cfg(feature = "document")))]
@@ -118,10 +120,7 @@ pub mod prelude {
     #[cfg_attr(docsrs, doc(cfg(feature = "html")))]
     pub use dioxus_elements::{global_attributes, prelude::*, svg_attributes};
 
-    #[cfg(all(
-        not(any(target_arch = "wasm32", target_os = "ios", target_os = "android")),
-        feature = "devtools"
-    ))]
+    #[cfg(feature = "devtools")]
     #[cfg_attr(docsrs, doc(cfg(feature = "devtools")))]
     pub use dioxus_devtools;
 

packages/document/docs/head.md

@@ -38,7 +38,7 @@ fn RedirectToDioxusHomepageWithoutJS() -> Element {
 
 Since Dioxus does not guarantee head element ordering, one can use es6 imports as a more predictable way to handle dependencies.
 
-```rust
+```rust, ignore
 # use dioxus::prelude::*;
 static HIGHLIGHT: Asset = asset!("/assets/highlight/es/highlight.min.js");
 static RUST: Asset = asset!("/assets/highlight/es/languages/rust.min.js");

packages/dx-wire-format/src/lib.rs

@@ -22,13 +22,29 @@ pub use cargo_metadata;
 #[non_exhaustive]
 #[derive(Serialize, Deserialize, Clone)]
 pub enum StructuredOutput {
-    BuildFinished { path: PathBuf },
-    BuildUpdate { stage: BuildStage },
-    CargoOutput { message: CompilerMessage },
-    BundleOutput { bundles: Vec<PathBuf> },
-    HtmlTranslate { html: String },
+    BuildsFinished {
+        client: PathBuf,
+        server: Option<PathBuf>,
+    },
+    BuildFinished {
+        path: PathBuf,
+    },
+    BuildUpdate {
+        stage: BuildStage,
+    },
+    CargoOutput {
+        message: CompilerMessage,
+    },
+    BundleOutput {
+        bundles: Vec<PathBuf>,
+    },
+    HtmlTranslate {
+        html: String,
+    },
     Success,
-    Error { message: String },
+    Error {
+        message: String,
+    },
 }
 
 impl std::fmt::Debug for StructuredOutput {
@@ -46,11 +62,10 @@ pub enum BuildStage {
     Initializing,
     Starting {
         crate_count: usize,
-        is_server: bool,
+        patch: bool,
     },
     InstallingTooling,
     Compiling {
-        is_server: bool,
         current: usize,
         total: usize,
         krate: String,
@@ -58,7 +73,9 @@ pub enum BuildStage {
     RunningBindgen,
     SplittingBundle,
     OptimizingWasm,
-    PrerenderingRoutes,
+    Linking,
+    Hotpatching,
+    ExtractingAssets,
     CopyingAssets {
         current: usize,
         total: usize,

packages/fullstack-hooks/Cargo.toml

@@ -20,6 +20,8 @@ serde = { workspace = true }
 
 [dev-dependencies]
 dioxus-fullstack = { workspace = true }
+dioxus-lib = { workspace = true }
+dioxus = { workspace = true }
 
 [features]
 web = []

packages/fullstack-hooks/src/streaming.rs

@@ -89,7 +89,7 @@ pub fn commit_initial_chunk() {
 ///     // up in the initial chunk.
 ///     use_hook(|| {
 ///         if current_status() == StreamingStatus::InitialChunkCommitted {
-///            log::warn!("Since `MetaTitle` was rendered after the initial chunk was committed, the meta tag will not show up in the head without javascript enabled.");
+///            dioxus::logger::tracing::warn!("Since `MetaTitle` was rendered after the initial chunk was committed, the meta tag will not show up in the head without javascript enabled.");
 ///         }
 ///     });
 ///

packages/fullstack-protocol/src/lib.rs

@@ -399,3 +399,8 @@ impl std::fmt::Display for TakeDataError {
 }
 
 impl std::error::Error for TakeDataError {}
+
+/// Create a new entry in the serialize context for the head element hydration
+pub fn head_element_hydration_entry() -> SerializeContextEntry<bool> {
+    serialize_context().create_entry()
+}

packages/fullstack/Cargo.toml

@@ -12,7 +12,7 @@ resolver = "2"
 
 [dependencies]
 # server functions
-server_fn = { version = "0.8.0-rc1", features = ["browser"], default-features = false }
+server_fn = { workspace = true, default-features = false }
 dioxus_server_macro = { workspace = true }
 
 # axum
@@ -23,13 +23,11 @@ dioxus-lib = { workspace = true }
 generational-box = { workspace = true }
 
 # Dioxus + SSR
-dioxus-ssr = { workspace = true, optional = true }
+dioxus-server = { workspace = true, optional = true}
 dioxus-isrg = { workspace = true, optional = true }
 dioxus-router = { workspace = true, features = ["streaming"], optional = true }
 dioxus-fullstack-hooks = { workspace = true }
 dioxus-fullstack-protocol = { workspace = true }
-hyper = { workspace = true, optional = true }
-http = { workspace = true, optional = true }
 
 # Web Integration
 dioxus-web = { workspace = true, features = ["hydrate"], default-features = false, optional = true }
@@ -77,12 +75,6 @@ dioxus-devtools = { workspace = true, optional = true }
 aws-lc-rs = { version = "1.12.5", optional = true }
 dioxus-history = { workspace = true }
 
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-tokio = { workspace = true, features = ["rt", "sync"], optional = true }
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-tokio = { workspace = true, features = ["rt", "sync", "rt-multi-thread"], optional = true }
-
 [dev-dependencies]
 dioxus = { workspace = true, features = ["fullstack"] }
 
@@ -92,43 +84,24 @@ devtools = ["dioxus-web?/devtools", "dep:dioxus-devtools"]
 mounted = ["dioxus-web?/mounted"]
 file_engine = ["dioxus-web?/file_engine"]
 document = ["dioxus-web?/document"]
-web = ["dep:dioxus-web", "dep:web-sys", "dioxus-fullstack-hooks/web"]
-desktop = ["dep:dioxus-desktop", "server_fn/reqwest", "dioxus_server_macro/reqwest"]
-mobile = ["dep:dioxus-mobile", "server_fn/reqwest", "dioxus_server_macro/reqwest"]
+web = ["dep:dioxus-web", "dep:web-sys", "dioxus-fullstack-hooks/web", "server_fn/browser"]
+desktop = ["server_fn/reqwest", "dioxus_server_macro/reqwest"]
+mobile = ["server_fn/reqwest", "dioxus_server_macro/reqwest"]
 default-tls = ["server_fn/default-tls"]
 rustls = ["server_fn/rustls", "dep:rustls", "dep:hyper-rustls"]
-axum_core = [
-    "dep:axum",
-    "server_fn/axum-no-default",
-    "dioxus_server_macro/axum",
+server = [
+    "server-core" ,
     "default-tls",
-    "server",
-]
-axum = [
-    "dep:tower-http",
     "server_fn/axum",
-    "axum_core",
 ]
-server = [
+server-core = [
+    "server_fn/axum-no-default",
+    "dioxus_server_macro/axum",
+    "server_fn/reqwest",
     "server_fn/ssr",
-    "dioxus_server_macro/server",
+    "dioxus_server_macro/reqwest",
     "dioxus-fullstack-hooks/server",
-    "dep:tokio",
-    "dep:tokio-util",
-    "dep:tokio-stream",
-    "dep:dioxus-ssr",
-    "dep:dioxus-isrg",
-    "dep:dioxus-router",
-    "dep:tower",
-    "dep:hyper",
-    "dep:http",
-    "dep:tower-layer",
-    "dep:tracing-futures",
-    "dep:pin-project",
-    "dep:thiserror",
-    "dep:dioxus-cli-config",
-    "dep:async-trait",
-    "dep:parking_lot",
+    "dep:dioxus-server",
     "dioxus-interpreter-js",
 ]
 aws-lc-rs = ["dep:aws-lc-rs"]

packages/fullstack/README.md

@@ -72,7 +72,7 @@ First, make sure your `axum` dependency is optional and enabled by the server fe
 ```toml
 [dependencies]
 dioxus = { version = "*", features = ["fullstack"] }
-axum = { version = "0.7.0", optional = true }
+axum = { version = "0.8.0", optional = true }
 tokio = { version = "1.0", features = ["full"], optional = true }
 dioxus-cli-config = { version = "*", optional = true }
 

packages/fullstack/src/document/mod.rs

@@ -1,14 +0,0 @@
-//! This module contains the document providers for the fullstack platform.
-
-#[cfg(feature = "server")]
-pub mod server;
-use dioxus_fullstack_protocol::SerializeContextEntry;
-#[cfg(feature = "server")]
-pub use server::ServerDocument;
-#[cfg(all(feature = "web", feature = "document"))]
-pub mod web;
-
-#[allow(unused)]
-pub(crate) fn head_element_hydration_entry() -> SerializeContextEntry<bool> {
-    dioxus_fullstack_protocol::serialize_context().create_entry()
-}

packages/fullstack/src/lib.rs

@@ -6,63 +6,22 @@
 
 pub use once_cell;
 
-#[cfg(feature = "axum")]
-#[cfg_attr(docsrs, doc(cfg(feature = "axum")))]
-pub mod server;
+#[cfg(all(feature = "web", feature = "document"))]
+mod web;
 
-#[cfg(feature = "axum_core")]
-#[cfg_attr(docsrs, doc(cfg(feature = "axum_core")))]
-pub mod axum_core;
+#[cfg(all(feature = "web", feature = "document"))]
+pub use web::FullstackWebDocument;
 
-pub mod document;
 #[cfg(feature = "server")]
-mod render;
-#[cfg(feature = "server")]
-mod streaming;
-
-#[cfg(feature = "server")]
-mod serve_config;
-
-#[cfg(feature = "server")]
-pub use serve_config::*;
-
-#[cfg(feature = "server")]
-mod server_context;
+pub use dioxus_server::*;
 
 /// A prelude of commonly used items in dioxus-fullstack.
 pub mod prelude {
     pub use dioxus_fullstack_hooks::*;
 
-    #[cfg(feature = "axum")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "axum")))]
-    pub use crate::server::*;
-
-    #[cfg(feature = "axum_core")]
-    pub use crate::axum_core::*;
-
-    #[cfg(feature = "server")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "server")))]
-    pub use crate::render::{FullstackHTMLTemplate, SSRState};
-
-    #[cfg(feature = "server")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "server")))]
-    pub use crate::serve_config::{ServeConfig, ServeConfigBuilder};
-
-    #[cfg(feature = "axum")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "axum")))]
-    pub use crate::server_context::Axum;
-
-    #[cfg(feature = "server")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "server")))]
-    pub use crate::server_context::{
-        extract, server_context, with_server_context, DioxusServerContext, FromContext,
-        FromServerContext, ProvideServerContext,
-    };
-
-    #[cfg(feature = "server")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "server")))]
-    pub use dioxus_isrg::{IncrementalRenderer, IncrementalRendererConfig};
-
     pub use dioxus_server_macro::*;
     pub use server_fn::{self, ServerFn as _, ServerFnError};
+
+    #[cfg(feature = "server")]
+    pub use dioxus_server::prelude::*;
 }

packages/fullstack/src/server/launch.rs

@@ -1,110 +0,0 @@
-//! A launch function that creates an axum router for the LaunchBuilder
-
-use std::any::Any;
-
-use axum::{
-    body::Body,
-    extract::{Request, State},
-    response::IntoResponse,
-};
-use dioxus_cli_config::base_path;
-use dioxus_lib::prelude::*;
-
-use crate::server::{render_handler, RenderHandleState, SSRState};
-
-/// Launch a fullstack app with the given root component, contexts, and config.
-#[allow(unused)]
-pub fn launch(
-    root: fn() -> Element,
-    contexts: Vec<Box<dyn Fn() -> Box<dyn Any> + Send + Sync>>,
-    platform_config: Vec<Box<dyn Any>>,
-) -> ! {
-    use crate::{ServeConfig, ServeConfigBuilder};
-
-    #[cfg(not(target_arch = "wasm32"))]
-    tokio::runtime::Runtime::new()
-        .unwrap()
-        .block_on(async move {
-            let platform_config = platform_config
-                .into_iter()
-                .find_map(|cfg| {
-                    cfg.downcast::<ServeConfig>()
-                        .map(|cfg| Result::Ok(*cfg))
-                        .or_else(|cfg| {
-                            cfg.downcast::<ServeConfigBuilder>()
-                                .map(|builder| builder.build())
-                        })
-                        .ok()
-                })
-                .unwrap_or_else(ServeConfig::new);
-
-            // Extend the config's context providers with the context providers from the launch builder
-            let platform_config = platform_config.map(|mut cfg| {
-                let mut contexts = contexts;
-                let cfg_context_providers = cfg.context_providers.clone();
-                for i in 0..cfg_context_providers.len() {
-                    contexts.push(Box::new({
-                        let cfg_context_providers = cfg_context_providers.clone();
-                        move || (cfg_context_providers[i])()
-                    }));
-                }
-                cfg.context_providers = std::sync::Arc::new(contexts);
-                cfg
-            });
-
-            // Get the address the server should run on. If the CLI is running, the CLI proxies fullstack into the main address
-            // and we use the generated address the CLI gives us
-            let address = dioxus_cli_config::fullstack_address_or_localhost();
-
-            use crate::server::DioxusRouterExt;
-
-            struct TryIntoResult(Result<ServeConfig, crate::UnableToLoadIndex>);
-
-            impl TryInto<ServeConfig> for TryIntoResult {
-                type Error = crate::UnableToLoadIndex;
-
-                fn try_into(self) -> Result<ServeConfig, Self::Error> {
-                    self.0
-                }
-            }
-
-            let mut base_path = base_path();
-            let config = platform_config.as_ref().ok().cloned();
-            let dioxus_router =
-                axum::Router::new().serve_dioxus_application(TryIntoResult(platform_config), root);
-            let mut router;
-            match base_path.as_deref() {
-                Some(base_path) => {
-                    let base_path = base_path.trim_matches('/');
-                    // If there is a base path, nest the router under it and serve the root route manually
-                    // Nesting a route in axum only serves /base_path or /base_path/ not both
-                    router = axum::Router::new().nest(&format!("/{base_path}/"), dioxus_router);
-                    async fn root_render_handler(
-                        state: State<RenderHandleState>,
-                        mut request: Request<Body>,
-                    ) -> impl IntoResponse {
-                        // The root of the base path always looks like the root from dioxus fullstack
-                        *request.uri_mut() = "/".parse().unwrap();
-                        render_handler(state, request).await
-                    }
-                    if let Some(cfg) = config {
-                        let ssr_state = SSRState::new(&cfg);
-                        router = router.route(
-                            &format!("/{base_path}"),
-                            axum::routing::method_routing::get(root_render_handler).with_state(
-                                RenderHandleState::new(cfg, root).with_ssr_state(ssr_state),
-                            ),
-                        )
-                    }
-                }
-                None => router = dioxus_router,
-            }
-
-            let router = router.into_make_service();
-            let listener = tokio::net::TcpListener::bind(address).await.unwrap();
-
-            axum::serve(listener, router).await.unwrap();
-        });
-
-    unreachable!("Launching a fullstack app should never return")
-}

packages/fullstack/src/server/mod.rs

@@ -1,199 +0,0 @@
-//! Dioxus utilities for the [Axum](https://docs.rs/axum/latest/axum/index.html) server framework.
-//!
-//! # Example
-//! ```rust, no_run
-//! #![allow(non_snake_case)]
-//! use dioxus::prelude::*;
-//!
-//! fn main() {
-//!     #[cfg(feature = "web")]
-//!     // Hydrate the application on the client
-//!     dioxus::launch(app);
-//!     #[cfg(feature = "server")]
-//!     {
-//!         tokio::runtime::Runtime::new()
-//!             .unwrap()
-//!             .block_on(async move {
-//!                 // Get the address the server should run on. If the CLI is running, the CLI proxies fullstack into the main address
-//!                 // and we use the generated address the CLI gives us
-//!                 let address = dioxus::cli_config::fullstack_address_or_localhost();
-//!                 let listener = tokio::net::TcpListener::bind(address)
-//!                     .await
-//!                     .unwrap();
-//!                 axum::serve(
-//!                         listener,
-//!                         axum::Router::new()
-//!                             // Server side render the application, serve static assets, and register server functions
-//!                             .serve_dioxus_application(ServeConfigBuilder::default(), app)
-//!                             .into_make_service(),
-//!                     )
-//!                     .await
-//!                     .unwrap();
-//!             });
-//!      }
-//! }
-//!
-//! fn app() -> Element {
-//!     let mut text = use_signal(|| "...".to_string());
-//!
-//!     rsx! {
-//!         button {
-//!             onclick: move |_| async move {
-//!                 if let Ok(data) = get_server_data().await {
-//!                     text.set(data);
-//!                 }
-//!             },
-//!             "Run a server function"
-//!         }
-//!         "Server said: {text}"
-//!     }
-//! }
-//!
-//! #[server(GetServerData)]
-//! async fn get_server_data() -> Result<String, ServerFnError> {
-//!     Ok("Hello from the server!".to_string())
-//! }
-//! ```
-
-pub mod launch;
-
-use axum::routing::*;
-use dioxus_lib::prelude::Element;
-
-use crate::prelude::*;
-
-/// A extension trait with utilities for integrating Dioxus with your Axum router.
-pub trait DioxusRouterExt<S>: DioxusRouterFnExt<S> {
-    /// Serves the static WASM for your Dioxus application (except the generated index.html).
-    ///
-    /// # Example
-    /// ```rust, no_run
-    /// # #![allow(non_snake_case)]
-    /// # use dioxus_lib::prelude::*;
-    /// # use dioxus_fullstack::prelude::*;
-    /// #[tokio::main]
-    /// async fn main() {
-    ///     let addr = dioxus::cli_config::fullstack_address_or_localhost();
-    ///     let router = axum::Router::new()
-    ///         // Server side render the application, serve static assets, and register server functions
-    ///         .serve_static_assets()
-    ///         // Server render the application
-    ///         // ...
-    ///         .into_make_service();
-    ///     let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
-    ///     axum::serve(listener, router).await.unwrap();
-    /// }
-    /// ```
-    fn serve_static_assets(self) -> Self
-    where
-        Self: Sized;
-
-    /// Serves the Dioxus application. This will serve a complete server side rendered application.
-    /// This will serve static assets, server render the application, register server functions, and integrate with hot reloading.
-    ///
-    /// # Example
-    /// ```rust, no_run
-    /// # #![allow(non_snake_case)]
-    /// # use dioxus_lib::prelude::*;
-    /// # use dioxus_fullstack::prelude::*;
-    /// #[tokio::main]
-    /// async fn main() {
-    ///     let addr = dioxus::cli_config::fullstack_address_or_localhost();
-    ///     let router = axum::Router::new()
-    ///         // Server side render the application, serve static assets, and register server functions
-    ///         .serve_dioxus_application(ServeConfig::new().unwrap(), app)
-    ///         .into_make_service();
-    ///     let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
-    ///     axum::serve(listener, router).await.unwrap();
-    /// }
-    ///
-    /// fn app() -> Element {
-    ///     rsx! { "Hello World" }
-    /// }
-    /// ```
-    fn serve_dioxus_application<Cfg, Error>(self, cfg: Cfg, app: fn() -> Element) -> Self
-    where
-        Cfg: TryInto<ServeConfig, Error = Error>,
-        Error: std::error::Error,
-        Self: Sized;
-}
-
-impl<S> DioxusRouterExt<S> for Router<S>
-where
-    S: Send + Sync + Clone + 'static,
-{
-    fn serve_static_assets(mut self) -> Self {
-        use tower_http::services::{ServeDir, ServeFile};
-
-        let public_path = crate::public_path();
-
-        if !public_path.exists() {
-            return self;
-        }
-
-        // Serve all files in public folder except index.html
-        let dir = std::fs::read_dir(&public_path).unwrap_or_else(|e| {
-            panic!(
-                "Couldn't read public directory at {:?}: {}",
-                &public_path, e
-            )
-        });
-
-        for entry in dir.flatten() {
-            let path = entry.path();
-            if path.ends_with("index.html") {
-                continue;
-            }
-            let route = path
-                .strip_prefix(&public_path)
-                .unwrap()
-                .iter()
-                .map(|segment| {
-                    segment.to_str().unwrap_or_else(|| {
-                        panic!("Failed to convert path segment {:?} to string", segment)
-                    })
-                })
-                .collect::<Vec<_>>()
-                .join("/");
-            let route = format!("/{}", route);
-            if path.is_dir() {
-                self = self.nest_service(&route, ServeDir::new(path).precompressed_br());
-            } else {
-                self = self.nest_service(&route, ServeFile::new(path).precompressed_br());
-            }
-        }
-
-        self
-    }
-
-    fn serve_dioxus_application<Cfg, Error>(self, cfg: Cfg, app: fn() -> Element) -> Self
-    where
-        Cfg: TryInto<ServeConfig, Error = Error>,
-        Error: std::error::Error,
-    {
-        let cfg = cfg.try_into();
-        let context_providers = cfg
-            .as_ref()
-            .map(|cfg| cfg.context_providers.clone())
-            .unwrap_or_default();
-
-        // Add server functions and render index.html
-        let server = self
-            .serve_static_assets()
-            .register_server_functions_with_context(context_providers);
-
-        match cfg {
-            Ok(cfg) => {
-                let ssr_state = SSRState::new(&cfg);
-                server.fallback(
-                    get(render_handler)
-                        .with_state(RenderHandleState::new(cfg, app).with_ssr_state(ssr_state)),
-                )
-            }
-            Err(err) => {
-                tracing::trace!("Failed to create render handler. This is expected if you are only using fullstack for desktop/mobile server functions: {}", err);
-                server
-            }
-        }
-    }
-}

packages/fullstack/src/document/web.rs → packages/fullstack/src/web.rs

@@ -1,13 +1,10 @@
-#![allow(unused)]
 //! On the client, we use the [`WebDocument`] implementation to render the head for any elements that were not rendered on the server.
 
-use dioxus_lib::{document::*, prelude::queue_effect};
+use dioxus_lib::document::*;
 use dioxus_web::WebDocument;
 
-use super::head_element_hydration_entry;
-
 fn head_element_written_on_server() -> bool {
-    head_element_hydration_entry()
+    dioxus_fullstack_protocol::head_element_hydration_entry()
         .get()
         .ok()
         .unwrap_or_default()

packages/liveview/src/adapters/axum_adapter.rs

@@ -65,9 +65,9 @@ impl LiveviewRouter for Router {
         // Add an extra catch all segment to the route
         let mut route = route.trim_matches('/').to_string();
         if route.is_empty() {
-            route = "/*route".to_string();
+            route = "/{*route}".to_string();
         } else {
-            route = format!("/{route}/*route");
+            route = format!("/{route}/{{*route}}");
         }
 
         self.route(