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
2025-05-06 23:08:59 -07:00
1 parent 71d85e6dd5
commit d976ca184a
@@ -0,0 +1,526 @@
+//! Configuration for how to serve a Dioxus application
+#![allow(non_snake_case)]
+
+use dioxus_lib::prelude::dioxus_core::LaunchConfig;
+use std::any::Any;
+use std::fs::File;
+use std::io::Read;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[allow(unused)]
+pub(crate) type ContextProviders =
+    Arc<Vec<Box<dyn Fn() -> Box<dyn std::any::Any> + Send + Sync + 'static>>>;
+
+/// A ServeConfig is used to configure how to serve a Dioxus application. It contains information about how to serve static assets, and what content to render with [`dioxus-ssr`].
+#[derive(Clone, Default)]
+pub struct ServeConfigBuilder {
+    pub(crate) root_id: Option<&'static str>,
+    pub(crate) index_html: Option<String>,
+    pub(crate) index_path: Option<PathBuf>,
+    pub(crate) incremental: Option<dioxus_isrg::IncrementalRendererConfig>,
+    pub(crate) context_providers:
+        Vec<Arc<dyn Fn() -> Box<dyn std::any::Any> + Send + Sync + 'static>>,
+    pub(crate) streaming_mode: StreamingMode,
+}
+
+impl LaunchConfig for ServeConfigBuilder {}
+
+impl ServeConfigBuilder {
+    /// Create a new ServeConfigBuilder with incremental static generation disabled and the default index.html settings
+    pub fn new() -> Self {
+        Self {
+            root_id: None,
+            index_html: None,
+            index_path: None,
+            incremental: None,
+            context_providers: Default::default(),
+            streaming_mode: StreamingMode::default(),
+        }
+    }
+
+    /// Enable incremental static generation. Incremental static generation caches the
+    /// rendered html in memory and/or the file system. It can be used to improve performance of heavy routes.
+    ///
+    /// ```rust, no_run
+    /// # fn app() -> Element { todo!() }
+    /// use dioxus::prelude::*;
+    ///
+    /// // Finally, launch the app with the config
+    /// LaunchBuilder::new()
+    ///     // Only set the server config if the server feature is enabled
+    ///     .with_cfg(server_only!(ServeConfigBuilder::default().incremental(IncrementalRendererConfig::default())))
+    ///     .launch(app);
+    /// ```
+    pub fn incremental(mut self, cfg: dioxus_isrg::IncrementalRendererConfig) -> Self {
+        self.incremental = Some(cfg);
+        self
+    }
+
+    /// Set the contents of the index.html file to be served. (precedence over index_path)
+    pub fn index_html(mut self, index_html: String) -> Self {
+        self.index_html = Some(index_html);
+        self
+    }
+
+    /// Set the path of the index.html file to be served. (defaults to {assets_path}/index.html)
+    pub fn index_path(mut self, index_path: PathBuf) -> Self {
+        self.index_path = Some(index_path);
+        self
+    }
+
+    /// Set the id of the root element in the index.html file to place the prerendered content into. (defaults to main)
+    ///
+    /// # Example
+    ///
+    /// If your index.html file looks like this:
+    /// ```html
+    /// <!DOCTYPE html>
+    /// <html>
+    ///     <head>
+    ///         <title>My App</title>
+    ///     </head>
+    ///     <body>
+    ///         <div id="my-custom-root"></div>
+    ///     </body>
+    /// </html>
+    /// ```
+    ///
+    /// You can set the root id to `"my-custom-root"` to render the app into that element:
+    ///
+    /// ```rust, no_run
+    /// # fn app() -> Element { todo!() }
+    /// use dioxus::prelude::*;
+    ///
+    /// // Finally, launch the app with the config
+    /// LaunchBuilder::new()
+    ///     // Only set the server config if the server feature is enabled
+    ///     .with_cfg(server_only! {
+    ///         ServeConfigBuilder::default().root_id("app")
+    ///     })
+    ///     // You also need to set the root id in your web config
+    ///     .with_cfg(web! {
+    ///         dioxus::web::Config::default().rootname("app")
+    ///     })
+    ///     // And desktop config
+    ///     .with_cfg(desktop! {
+    ///         dioxus::desktop::Config::default().with_root_name("app")
+    ///     })
+    ///     .launch(app);
+    /// ```
+    pub fn root_id(mut self, root_id: &'static str) -> Self {
+        self.root_id = Some(root_id);
+        self
+    }
+
+    /// Provide context to the root and server functions. You can use this context while rendering with [`consume_context`](dioxus_lib::prelude::consume_context)
+    /// or in server functions with [`FromContext`](crate::prelude::FromContext).
+    ///
+    ///
+    /// The context providers passed into this method will be called when the context type is requested which may happen many times in the lifecycle of the application.
+    ///
+    ///
+    /// Context will be forwarded from the LaunchBuilder if it is provided.
+    ///
+    /// ```rust, no_run
+    /// #![allow(non_snake_case)]
+    /// use dioxus::prelude::*;
+    /// use std::sync::Arc;
+    /// use std::any::Any;
+    ///
+    /// 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 {
+    ///                 let address = dioxus_cli_config::fullstack_address_or_localhost();
+    ///                 let listener = tokio::net::TcpListener::bind(address)
+    ///                     .await
+    ///                     .unwrap();
+    ///                 let config = ServeConfigBuilder::default()
+    ///                     // You can provide context to your whole app on the server (including server functions) with the `context_provider` method on the launch builder
+    ///                     .context_providers(Arc::new(vec![Box::new(|| Box::new(1234u32) as Box<dyn Any>) as Box<dyn Fn() -> Box<dyn std::any::Any> + Send + Sync>]));
+    ///                 axum::serve(
+    ///                         listener,
+    ///                         axum::Router::new()
+    ///                             .serve_dioxus_application(config, app)
+    ///                             .into_make_service(),
+    ///                     )
+    ///                     .await
+    ///                     .unwrap();
+    ///             });
+    ///      }
+    /// }
+    ///
+    /// #[server]
+    /// async fn read_context() -> Result<u32, ServerFnError> {
+    ///     // You can extract values from the server context with the `extract` function
+    ///     let FromContext(value) = extract().await?;
+    ///     Ok(value)
+    /// }
+    ///
+    /// fn app() -> Element {
+    ///     let future = use_resource(read_context);
+    ///     rsx! {
+    ///         h1 { "{future:?}" }
+    ///     }
+    /// }
+    /// ```
+    pub fn context_providers(mut self, state: ContextProviders) -> Self {
+        // This API should probably accept Vec<Box<dyn Fn() -> Box<dyn Any> + Send + Sync + 'static>> instead of Arc so we can
+        // continue adding to the context list after calling this method. Changing the type is a breaking change so it cannot
+        // be done until 0.7 is released.
+        let context_providers = (0..state.len()).map(|i| {
+            let state = state.clone();
+            Arc::new(move || state[i]()) as Arc<dyn Fn() -> Box<dyn std::any::Any> + Send + Sync>
+        });
+        self.context_providers.extend(context_providers);
+        self
+    }
+
+    /// Provide context to the root and server functions. You can use this context
+    /// while rendering with [`consume_context`](dioxus_lib::prelude::consume_context) or in server functions with [`FromContext`](crate::prelude::FromContext).
+    ///
+    ///
+    /// The context providers passed into this method will be called when the context type is requested which may happen many times in the lifecycle of the application.
+    ///
+    ///
+    /// Context will be forwarded from the LaunchBuilder if it is provided.
+    ///
+    /// ```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 {
+    ///                 let address = dioxus_cli_config::fullstack_address_or_localhost();
+    ///                 let listener = tokio::net::TcpListener::bind(address)
+    ///                     .await
+    ///                     .unwrap();
+    ///                 let config = ServeConfigBuilder::default()
+    ///                     // You can provide context to your whole app on the server (including server functions) with the `context_provider` method on the launch builder
+    ///                     .context_provider(move || 1234u32);
+    ///                 axum::serve(
+    ///                         listener,
+    ///                         axum::Router::new()
+    ///                             .serve_dioxus_application(config, app)
+    ///                             .into_make_service(),
+    ///                     )
+    ///                     .await
+    ///                     .unwrap();
+    ///             });
+    ///      }
+    /// }
+    ///
+    /// #[server]
+    /// async fn read_context() -> Result<u32, ServerFnError> {
+    ///     // You can extract values from the server context with the `extract` function
+    ///     let FromContext(value) = extract().await?;
+    ///     Ok(value)
+    /// }
+    ///
+    /// fn app() -> Element {
+    ///     let future = use_resource(read_context);
+    ///     rsx! {
+    ///         h1 { "{future:?}" }
+    ///     }
+    /// }
+    /// ```
+    pub fn context_provider<C: 'static>(
+        mut self,
+        state: impl Fn() -> C + Send + Sync + 'static,
+    ) -> Self {
+        self.context_providers
+            .push(Arc::new(move || Box::new(state())));
+        self
+    }
+
+    /// Provide context to the root and server functions. You can use this context while rendering with [`consume_context`](dioxus_lib::prelude::consume_context)
+    /// or in server functions with [`FromContext`](crate::prelude::FromContext).
+    ///
+    /// Context will be forwarded from the LaunchBuilder if it is provided.
+    ///
+    /// ```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 {
+    ///                 let address = dioxus_cli_config::fullstack_address_or_localhost();
+    ///                 let listener = tokio::net::TcpListener::bind(address)
+    ///                     .await
+    ///                     .unwrap();
+    ///                 let config = ServeConfigBuilder::default()
+    ///                     // You can provide context to your whole app on the server (including server functions) with the `context_provider` method on the launch builder
+    ///                     .context(1234u32);
+    ///                 axum::serve(
+    ///                         listener,
+    ///                         axum::Router::new()
+    ///                             .serve_dioxus_application(config, app)
+    ///                             .into_make_service(),
+    ///                     )
+    ///                     .await
+    ///                     .unwrap();
+    ///             });
+    ///      }
+    /// }
+    ///
+    /// #[server]
+    /// async fn read_context() -> Result<u32, ServerFnError> {
+    ///     // You can extract values from the server context with the `extract` function
+    ///     let FromContext(value) = extract().await?;
+    ///     Ok(value)
+    /// }
+    ///
+    /// fn app() -> Element {
+    ///     let future = use_resource(read_context);
+    ///     rsx! {
+    ///         h1 { "{future:?}" }
+    ///     }
+    /// }
+    /// ```
+    pub fn context(mut self, state: impl Any + Clone + Send + Sync + 'static) -> Self {
+        self.context_providers
+            .push(Arc::new(move || Box::new(state.clone())));
+        self
+    }
+
+    /// Set the streaming mode for the server. By default, streaming is disabled.
+    ///
+    /// ```rust, no_run
+    /// # use dioxus::prelude::*;
+    /// # fn app() -> Element { todo!() }
+    /// dioxus::LaunchBuilder::new()
+    ///     .with_context(server_only! {
+    ///         dioxus::fullstack::ServeConfig::builder().streaming_mode(dioxus::fullstack::StreamingMode::OutOfOrder)
+    ///     })
+    ///     .launch(app);
+    /// ```
+    pub fn streaming_mode(mut self, mode: StreamingMode) -> Self {
+        self.streaming_mode = mode;
+        self
+    }
+
+    /// Enable out of order streaming. This will cause server futures to be resolved out of order and streamed to the client as they resolve.
+    ///
+    /// It is equivalent to calling `streaming_mode(StreamingMode::OutOfOrder)`
+    ///
+    /// ```rust, no_run
+    /// # use dioxus::prelude::*;
+    /// # fn app() -> Element { todo!() }
+    /// dioxus::LaunchBuilder::new()
+    ///     .with_context(server_only! {
+    ///         dioxus::fullstack::ServeConfig::builder().enable_out_of_order_streaming()
+    ///     })
+    ///     .launch(app);
+    /// ```
+    pub fn enable_out_of_order_streaming(mut self) -> Self {
+        self.streaming_mode = StreamingMode::OutOfOrder;
+        self
+    }
+
+    /// Build the ServeConfig. This may fail if the index.html file is not found.
+    ///
+    /// ## WASM compatibility
+    /// In the context of WASM the file system normally can't be read so this always requires
+    /// the `index_html` field to be set.
+    pub fn build(self) -> Result<ServeConfig, UnableToLoadIndex> {
+        let root_id = self.root_id.unwrap_or("main");
+
+        let index_html = match self.index_html {
+            Some(index) => index,
+            None => {
+                // The CLI always bundles static assets into the exe/public directory
+                let public_path = public_path();
+
+                let index_path = self
+                    .index_path
+                    .unwrap_or_else(|| public_path.join("index.html"));
+                load_index_path(index_path)?
+                // load_index_path(index_path).unwrap_or_else(|_| {
+                //     r#"
+                //     <!DOCTYPE html>
+                //     <html>
+                //         <head> </head>
+                //         <body>
+                //             <div id="main"></div>
+                //         </body>
+                //     </html>
+                //     "#
+                //     .to_string()
+                // })
+            }
+        };
+
+        let index = load_index_html(index_html, root_id);
+        let context_providers = Arc::new(
+            self.context_providers
+                .into_iter()
+                .map(|f| {
+                    Box::new(move || f()) as Box<dyn Fn() -> Box<dyn std::any::Any> + Send + Sync>
+                })
+                .collect(),
+        );
+
+        Ok(ServeConfig {
+            index,
+            incremental: self.incremental,
+            context_providers,
+            streaming_mode: self.streaming_mode,
+        })
+    }
+}
+
+impl TryInto<ServeConfig> for ServeConfigBuilder {
+    type Error = UnableToLoadIndex;
+
+    fn try_into(self) -> Result<ServeConfig, Self::Error> {
+        self.build()
+    }
+}
+
+/// Get the path to the public assets directory to serve static files from
+pub(crate) fn public_path() -> PathBuf {
+    if let Ok(path) = std::env::var("DIOXUS_PUBLIC_PATH") {
+        return PathBuf::from(path);
+    }
+
+    // The CLI always bundles static assets into the exe/public directory
+    std::env::current_exe()
+        .expect("Failed to get current executable path")
+        .parent()
+        .unwrap()
+        .join("public")
+}
+
+/// An error that can occur when loading the index.html file
+#[derive(Debug, Clone)]
+pub struct UnableToLoadIndex(PathBuf);
+
+impl std::fmt::Display for UnableToLoadIndex {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Failed to find index.html. Make sure the index_path is set correctly and the WASM application has been built. Tried to open file at path: {:?}", self.0)
+    }
+}
+
+impl std::error::Error for UnableToLoadIndex {}
+
+fn load_index_path(path: PathBuf) -> Result<String, UnableToLoadIndex> {
+    let mut file = File::open(&path).map_err(|_| UnableToLoadIndex(path))?;
+
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)
+        .expect("Failed to read index.html");
+    Ok(contents)
+}
+
+fn load_index_html(contents: String, root_id: &'static str) -> IndexHtml {
+    let (pre_main, post_main) = contents.split_once(&format!("id=\"{root_id}\"")).unwrap_or_else(|| panic!("Failed to find id=\"{root_id}\" in index.html. The id is used to inject the application into the page."));
+
+    let post_main = post_main.split_once('>').unwrap_or_else(|| {
+        panic!("Failed to find closing > after id=\"{root_id}\" in index.html.")
+    });
+
+    let (pre_main, post_main) = (
+        pre_main.to_string() + &format!("id=\"{root_id}\"") + post_main.0 + ">",
+        post_main.1.to_string(),
+    );
+
+    let (head, close_head) = pre_main.split_once("</head>").unwrap_or_else(|| {
+        panic!("Failed to find closing </head> tag after id=\"{root_id}\" in index.html.")
+    });
+    let (head, close_head) = (head.to_string(), "</head>".to_string() + close_head);
+
+    let (post_main, after_closing_body_tag) =
+        post_main.split_once("</body>").unwrap_or_else(|| {
+            panic!("Failed to find closing </body> tag after id=\"{root_id}\" in index.html.")
+        });
+
+    // Strip out the head if it exists
+    let mut head_before_title = String::new();
+    let mut head_after_title = head;
+    let mut title = String::new();
+    if let Some((new_head_before_title, new_title)) = head_after_title.split_once("<title>") {
+        let (new_title, new_head_after_title) = new_title
+            .split_once("</title>")
+            .expect("Failed to find closing </title> tag after <title> in index.html.");
+        title = format!("<title>{new_title}</title>");
+        head_before_title = new_head_before_title.to_string();
+        head_after_title = new_head_after_title.to_string();
+    }
+
+    IndexHtml {
+        head_before_title,
+        head_after_title,
+        title,
+        close_head,
+        post_main: post_main.to_string(),
+        after_closing_body_tag: "</body>".to_string() + after_closing_body_tag,
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct IndexHtml {
+    pub(crate) head_before_title: String,
+    pub(crate) head_after_title: String,
+    pub(crate) title: String,
+    pub(crate) close_head: String,
+    pub(crate) post_main: String,
+    pub(crate) after_closing_body_tag: String,
+}
+
+/// The streaming mode to use while rendering the page
+#[derive(Clone, Copy, Default, PartialEq)]
+pub enum StreamingMode {
+    /// Streaming is disabled; all server futures should be resolved before hydrating the page on the client
+    #[default]
+    Disabled,
+    /// Out of order streaming is enabled; server futures are resolved out of order and streamed to the client
+    /// as they resolve
+    OutOfOrder,
+}
+
+/// Used to configure how to serve a Dioxus application. It contains information about how to serve static assets, and what content to render with [`dioxus-ssr`].
+/// See [`ServeConfigBuilder`] to create a ServeConfig
+#[derive(Clone)]
+pub struct ServeConfig {
+    pub(crate) index: IndexHtml,
+    pub(crate) incremental: Option<dioxus_isrg::IncrementalRendererConfig>,
+    // This is used in the axum integration
+    #[allow(unused)]
+    pub(crate) context_providers: ContextProviders,
+    pub(crate) streaming_mode: StreamingMode,
+}
+
+impl LaunchConfig for ServeConfig {}
+
+impl ServeConfig {
+    /// Create a new ServeConfig
+    #[cfg(not(target_family = "wasm"))]
+    pub fn new() -> Result<Self, UnableToLoadIndex> {
+        ServeConfigBuilder::new().build()
+    }
+
+    /// Create a new builder for a ServeConfig
+    pub fn builder() -> ServeConfigBuilder {
+        ServeConfigBuilder::new()
+    }
+}