Restore docs CI checks and fix all doc lints (#4204)

.github/workflows/main.yml

@@ -139,12 +139,8 @@ jobs:
       - name: "doc --lib --all-features"
         run: |
           cargo doc --workspace --no-deps --all-features --document-private-items
-        # env:
-        #   RUSTFLAGS: --cfg docsrs
-        #   RUSTDOCFLAGS: --cfg docsrs
-        # todo: re-enable warnings, private items
-        # RUSTDOCFLAGS: --cfg docsrs -Dwarnings
-        #  --document-private-items
+        env:
+          RUSTDOCFLAGS: -Dwarnings --document-private-items
 
   check:
     if: github.event.pull_request.draft == false

Cargo.lock

@@ -4404,6 +4404,7 @@ dependencies = [
  "dioxus-fullstack-hooks",
  "dioxus-history",
  "dioxus-lib",
+ "dioxus-router",
  "dioxus-router-macro",
  "dioxus-ssr",
  "rustversion",

packages/cli/src/build/builder.rs

@@ -1140,7 +1140,7 @@ We checked the folder: {}
     /// - If the app fails to launch, errors are logged for debugging purposes.
     ///
     /// # Resources:
-    /// - https://developer.android.com/studio/run/emulator-commandline
+    /// - <https://developer.android.com/studio/run/emulator-commandline>
     async fn open_android_sim(
         &self,
         root: bool,

packages/cli/src/build/patch.rs

@@ -415,7 +415,7 @@ fn create_native_jump_table(
 /// 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
+/// <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;
@@ -1299,7 +1299,7 @@ pub fn prepare_wasm_base_module(bytes: &[u8]) -> Result<Vec<u8>> {
 ///
 /// 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
+/// <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")

packages/cli/src/build/request.rs

@@ -55,7 +55,7 @@
 //!
 //! 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).
+//! is a bit of a pain, but fortunately a solved process (<https://github.com/rust-mobile/xbuild>).
 //!
 //! ## Build Structure
 //!
@@ -107,7 +107,7 @@
 //!
 //! ### Linux:
 //!
-//! https://docs.appimage.org/reference/appdir.html#ref-appdir
+//! <https://docs.appimage.org/reference/appdir.html#ref-appdir>
 //! current_exe.join("Assets")
 //! ```
 //! app.appimage/
@@ -157,7 +157,7 @@
 //! 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
+//! <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.
@@ -309,8 +309,8 @@
 //! 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>
+//! - 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>

packages/cli/src/build/tools.rs

@@ -8,7 +8,7 @@ use tokio::process::Command;
 
 /// The tools for Android (ndk, sdk, etc)
 ///
-/// https://gist.github.com/Pulimet/5013acf2cd5b28e55036c82c91bd56d8?permalink_comment_id=3678614
+/// <https://gist.github.com/Pulimet/5013acf2cd5b28e55036c82c91bd56d8?permalink_comment_id=3678614>
 #[derive(Debug, Clone)]
 pub(crate) struct AndroidTools {
     pub(crate) sdk: Option<PathBuf>,

packages/cli/src/cli/build.rs

@@ -43,7 +43,7 @@ pub struct BuildArgs {
     ///
     /// Server and Client are special targets that integrate with `dx serve`, while `crate` is a generic.
     ///
-    /// ```
+    /// ```sh
     /// dx serve \
     ///     client --target aarch64-apple-darwin \
     ///     server --target wasm32-unknown-unknown \

packages/cli/src/cli/check.rs

@@ -1,7 +1,7 @@
 //! Run linting against the user's codebase.
 //!
 //! For reference, the rustfmt main.rs file
-//! https://github.com/rust-lang/rustfmt/blob/master/src/bin/main.rs
+//! <https://github.com/rust-lang/rustfmt/blob/master/src/bin/main.rs>
 
 use super::*;
 use crate::BuildRequest;

packages/cli/src/cli/create.rs

@@ -38,7 +38,7 @@ pub struct Create {
     #[clap(long)]
     subtemplate: Option<String>,
 
-    /// Pass <option>=<value> for the used template (e.g., `foo=bar`)
+    /// Pass `<option>=<value>` for the used template (e.g., `foo=bar`)
     #[clap(short, long)]
     option: Vec<String>,
 
@@ -119,7 +119,7 @@ pub(crate) fn resolve_template_and_branch(
 /// Prevent hidden cursor if Ctrl+C is pressed when interacting
 /// with cargo-generate's prompts.
 ///
-/// See https://github.com/DioxusLabs/dioxus/pull/2603.
+/// See <https://github.com/DioxusLabs/dioxus/pull/2603>.
 pub(crate) fn restore_cursor_on_sigint() {
     ctrlc::set_handler(move || {
         if let Err(err) = console::Term::stdout().show_cursor() {

packages/cli/src/cli/init.rs

@@ -35,7 +35,7 @@ pub struct Init {
     #[clap(long)]
     subtemplate: Option<String>,
 
-    /// Pass <option>=<value> for the used template (e.g., `foo=bar`)
+    /// Pass `<option>=<value>` for the used template (e.g., `foo=bar`)
     #[clap(short, long)]
     option: Vec<String>,
 

packages/cli/src/cli/link.rs

@@ -38,7 +38,7 @@ pub struct LinkAction {
 /// 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
+/// <https://doc.rust-lang.org/beta/nightly-rustc/rustc_target/spec/enum.LinkerFlavor.html>
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
 pub enum LinkerFlavor {
     Gnu,

packages/cli/src/cli/serve.rs

@@ -8,25 +8,20 @@ use std::{backtrace::Backtrace, panic::AssertUnwindSafe};
 ///
 /// `dx serve` takes cargo args by default, except with a required `--platform` arg:
 ///
-/// ```
+/// ```sh
 /// dx serve --example blah --target blah --platform android
 /// ```
 ///
 /// A simple serve:
-/// ```
+/// ```sh
 /// 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.
 ///
-/// ```
+/// ```sh
 /// dx serve \
 ///     client --package frontend \
 ///     server --package backend

packages/cli/src/config/bundle.rs

@@ -80,7 +80,7 @@ pub(crate) struct WixSettings {
     pub(crate) fips_compliant: bool,
     /// MSI installer version in the format `major.minor.patch.build` (build is optional).
     ///
-    /// Because a valid version is required for MSI installer, it will be derived from [`PackageSettings::version`] if this field is not set.
+    /// Because a valid version is required for MSI installer, it will be derived from [`tauri_bundler::PackageSettings::version`] if this field is not set.
     ///
     /// The first field is the major version and has a maximum value of 255. The second field is the minor version and has a maximum value of 255.
     /// The third and fourth fields have a maximum value of 65,535.

packages/cli/src/rustcwrapper.rs

@@ -30,7 +30,7 @@ pub struct RustcArgs {
 
 /// Run rustc directly, but output the result to a file.
 ///
-/// https://doc.rust-lang.org/cargo/reference/config.html#buildrustc
+/// <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

packages/cli/src/serve/ansi_buffer.rs

@@ -3,7 +3,7 @@ use std::fmt::{self, Display, Formatter};
 
 /// A buffer that can be rendered to and then dumped as raw ansi codes
 ///
-/// This is taken from a PR on the ratatui repo (https://github.com/ratatui/ratatui/pull/1065) and
+/// This is taken from a PR on the ratatui repo (<https://github.com/ratatui/ratatui/pull/1065>) and
 /// modified to be more appropriate for our use case.
 pub struct AnsiStringLine {
     buf: Buffer,

packages/cli/src/serve/runner.rs

@@ -773,7 +773,7 @@ impl AppServer {
     /// 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
+    /// <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());
 
@@ -1109,9 +1109,9 @@ fn handle_notify_error(err: notify::Error) {
 
 /// 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.
+/// 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
+/// 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";

packages/const-serialize/README.md

@@ -53,5 +53,5 @@ The rust [nomicon](https://doc.rust-lang.org/nomicon/data.html) defines the memo
 ## Limitations
 
 - Only constant sized types are supported. This means that you can't serialize a type like `Vec<T>`. These types are difficult to create in const contexts in general
-- Only types with a well defined memory layout are supported (see https://github.com/rust-lang/rfcs/pull/3727 and https://onevariable.com/blog/pods-from-scratch). `repr(Rust)` enums don't have a well defined layout, so they are not supported. `repr(C, u8)` enums can be used instead
+- Only types with a well defined memory layout are supported (see <https://github.com/rust-lang/rfcs/pull/3727> and <https://onevariable.com/blog/pods-from-scratch>). `repr(Rust)` enums don't have a well defined layout, so they are not supported. `repr(C, u8)` enums can be used instead
 - Const rust does not support mutable references or points, so this crate leans heavily on function data structures for data processing.

packages/const-serialize/src/const_vec.rs

@@ -328,7 +328,7 @@ impl<T, const MAX_SIZE: usize> ConstVec<T, MAX_SIZE> {
 }
 
 impl<const MAX_SIZE: usize> ConstVec<u8, MAX_SIZE> {
-    /// Convert the [`ConstVec`] into a [`ConstReadBuffer`](crate::ConstReadBuffer)
+    /// Convert the [`ConstVec`] into a [`ConstReadBuffer`]
     ///
     /// # Example
     /// ```rust

packages/const-serialize/src/lib.rs

@@ -857,7 +857,7 @@ const fn deserialize_const_ptr<'a, const N: usize>(
     }
 }
 
-/// Deserialize a type into the output buffer. Accepts (Type, ConstVec<u8>) as input and returns Option<(ConstReadBuffer, Instance of type)>
+/// Deserialize a type into the output buffer. Accepts `(type, ConstVec<u8>)` as input and returns `Option<(ConstReadBuffer, Instance of type)>`
 ///
 /// # Example
 /// ```rust

packages/core/src/diff/component.rs

@@ -62,7 +62,7 @@ impl VirtualDom {
         })
     }
 
-    /// Create a new [`ScopeState`] for a component that has been created with [`VirtualDom::create_scope`]
+    /// Create a new [`Scope`](crate::scope_context::Scope) for a component.
     ///
     /// Returns the number of nodes created on the stack
     #[tracing::instrument(skip(self, to), level = "trace", name = "VirtualDom::create_scope")]
@@ -178,7 +178,7 @@ impl VNode {
         dom.remove_component_node(to, true, scope, Some(m));
     }
 
-    /// Create a new component (if it doesn't already exist) node and then mount the [`ScopeState`] for a component
+    /// Create a new component (if it doesn't already exist) node and then mount the [`crate::ScopeState`] for a component
     ///
     /// Returns the number of nodes created on the stack
     pub(super) fn create_component_node(

packages/core/src/global_context.rs

@@ -232,7 +232,7 @@ pub fn remove_future(id: Task) {
 ///
 /// <div class="warning">
 ///
-/// `use_hook` is not reactive. It just returns the value on every render. If you need state that will track changes, use [`use_signal`](dioxus::prelude::use_signal) instead.
+/// `use_hook` is not reactive. It just returns the value on every render. If you need state that will track changes, use [`use_signal`](https://docs.rs/dioxus-hooks/latest/dioxus_hooks/fn.use_signal.html) instead.
 ///
 /// ❌ Don't use `use_hook` with `Rc<RefCell<T>>` for state. It will not update the UI and other hooks when the state changes.
 /// ```rust
@@ -356,7 +356,7 @@ pub fn schedule_update_any() -> Arc<dyn Fn(ScopeId) + Send + Sync> {
 
 /// Creates a callback that will be run before the component is removed.
 /// This can be used to clean up side effects from the component
-/// (created with [`use_effect`](dioxus::prelude::use_effect)).
+/// (created with [`use_effect`](https://docs.rs/dioxus-hooks/latest/dioxus_hooks/fn.use_effect.html)).
 ///
 /// Note:
 /// Effects do not run on the server, but use_drop **DOES**. It runs any time the component is dropped including during SSR rendering on the server. If your clean up logic targets web, the logic has to be gated by a feature, see the below example for details.

packages/core/src/nodes.rs

@@ -341,11 +341,8 @@ type StaticTemplateAttributeArray = &'static [TemplateAttribute];
 /// A static layout of a UI tree that describes a set of dynamic and static nodes.
 ///
 /// This is the core innovation in Dioxus. Most UIs are made of static nodes, yet participate in diffing like any
-/// dynamic node. This struct can be created at compile time. It promises that its name is unique, allow Dioxus to use
+/// dynamic node. This struct can be created at compile time. It promises that its pointer is unique, allow Dioxus to use
 /// its static description of the UI to skip immediately to the dynamic nodes during diffing.
-///
-/// For this to work properly, the [`Template::name`] *must* be unique across your entire project. This can be done via variety of
-/// ways, with the suggested approach being the unique code location (file, line, col, etc).
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Eq, PartialOrd, Ord)]
 pub struct Template {

packages/core/src/scope_context.rs

@@ -147,7 +147,7 @@ impl Scope {
 
     /// Create a subscription that schedules a future render for the reference component
     ///
-    /// ## Notice: you should prefer using [`Self::schedule_update_any`] and [`Self::scope_id`]
+    /// ## Notice: you should prefer using [`Self::schedule_update_any`] and [`Self::id`]
     pub fn schedule_update(&self) -> Arc<dyn Fn() + Send + Sync + 'static> {
         let (chan, id) = (self.sender(), self.id);
         Arc::new(move || drop(chan.unbounded_send(SchedulerMsg::Immediate(id))))
@@ -155,7 +155,7 @@ impl Scope {
 
     /// Schedule an update for any component given its [`ScopeId`].
     ///
-    /// A component's [`ScopeId`] can be obtained from `use_hook` or the [`current_scope_id`] method.
+    /// A component's [`ScopeId`] can be obtained from `use_hook` or the [`current_scope_id`](crate::prelude::current_scope_id) method.
     ///
     /// This method should be used when you want to schedule an update for a component
     pub fn schedule_update_any(&self) -> Arc<dyn Fn(ScopeId) + Send + Sync> {
@@ -233,7 +233,7 @@ impl Scope {
         }
     }
 
-    /// Inject a Box<dyn Any> into the context of this scope
+    /// Inject a `Box<dyn Any>` into the context of this scope
     pub(crate) fn provide_any_context(&self, mut value: Box<dyn Any>) {
         let mut contexts = self.shared_contexts.borrow_mut();
 
@@ -369,7 +369,7 @@ impl Scope {
     ///
     /// <div class="warning">
     ///
-    /// `use_hook` is not reactive. It just returns the value on every render. If you need state that will track changes, use [`use_signal`](dioxus::prelude::use_signal) instead.
+    /// `use_hook` is not reactive. It just returns the value on every render. If you need state that will track changes, use [`use_signal`](https://docs.rs/dioxus-hooks/latest/dioxus_hooks/fn.use_signal.html) instead.
     ///
     /// ❌ Don't use `use_hook` with `Rc<RefCell<T>>` for state. It will not update the UI and other hooks when the state changes.
     /// ```rust
@@ -605,7 +605,7 @@ impl ScopeId {
             .on_scope(self, f)
     }
 
-    /// Throw a [`CapturedError`] into a scope. The error will bubble up to the nearest [`ErrorBoundary`] or the root of the app.
+    /// Throw a [`CapturedError`] into a scope. The error will bubble up to the nearest [`ErrorBoundary`](crate::prelude::ErrorBoundary) or the root of the app.
     ///
     /// # Examples
     /// ```rust, no_run

packages/core/src/scopes.rs

@@ -33,7 +33,7 @@ impl std::fmt::Debug for ScopeId {
 }
 
 impl ScopeId {
-    /// The ScopeId of the main scope passed into [`VirtualDom::new`].
+    /// The ScopeId of the main scope passed into [`crate::prelude::VirtualDom::new`].
     ///
     /// This scope will last for the entire duration of your app, making it convenient for long-lived state
     /// that is created dynamically somewhere down the component tree.
@@ -51,7 +51,7 @@ impl ScopeId {
     pub const APP: ScopeId = ScopeId(3);
 
     /// The ScopeId of the topmost scope in the tree.
-    /// This will be higher up in the tree than [`ScopeId::APP`] because dioxus inserts a default [`SuspenseBoundary`] and [`ErrorBoundary`] at the root of the tree.
+    /// This will be higher up in the tree than [`ScopeId::APP`] because dioxus inserts a default [`crate::prelude::SuspenseBoundary`] and [`crate::prelude::ErrorBoundary`] at the root of the tree.
     // ScopeId(0) is the root scope wrapper
     pub const ROOT: ScopeId = ScopeId(0);
 

packages/core/src/virtual_dom.rs

@@ -303,7 +303,7 @@ impl VirtualDom {
         dom
     }
 
-    /// Create a new VirtualDom from something that implements [`AnyProps`]
+    /// Create a new VirtualDom from a VComponent
     #[instrument(skip(root), level = "trace", name = "VirtualDom::new")]
     pub(crate) fn new_with_component(root: VComponent) -> Self {
         let (tx, rx) = futures_channel::mpsc::unbounded();

packages/desktop/src/desktop_context.rs

@@ -42,7 +42,7 @@ pub type WeakDesktopContext = Weak<DesktopService>;
 
 /// An imperative interface to the current window.
 ///
-/// To get a handle to the current window, use the [`use_window`] hook.
+/// To get a handle to the current window, use the [`window`] function.
 ///
 ///
 /// # Example
@@ -195,7 +195,7 @@ impl DesktopService {
     /// Create a wry event handler that listens for wry events.
     /// This event handler is scoped to the currently active window and will only receive events that are either global or related to the current window.
     ///
-    /// The id this function returns can be used to remove the event handler with [`DesktopContext::remove_wry_event_handler`]
+    /// The id this function returns can be used to remove the event handler with [`Self::remove_wry_event_handler`]
     pub fn create_wry_event_handler(
         &self,
         handler: impl FnMut(&Event<UserWindowEvent>, &EventLoopWindowTarget<UserWindowEvent>) + 'static,
@@ -203,7 +203,7 @@ impl DesktopService {
         self.shared.event_handlers.add(self.window.id(), handler)
     }
 
-    /// Remove a wry event handler created with [`DesktopContext::create_wry_event_handler`]
+    /// Remove a wry event handler created with [`Self::create_wry_event_handler`]
     pub fn remove_wry_event_handler(&self, id: WryEventHandler) {
         self.shared.event_handlers.remove(id)
     }
@@ -237,7 +237,7 @@ impl DesktopService {
     ///
     /// When the component is dropped, the handler is removed.
     ///
-    /// See [`use_asset_handle`](crate::use_asset_handle) for a convenient hook.
+    /// See [`crate::use_asset_handler`] for a convenient hook.
     pub fn register_asset_handler(
         &self,
         name: String,

packages/desktop/src/menubar.rs

@@ -18,7 +18,7 @@ pub fn init_menu_bar(menu: &DioxusMenu, window: &Window) {
 /// to further customize the menu bar and pass it to a [`WindowBuilder`](tao::window::WindowBuilder).
 /// > Note: The default menu bar enables macOS shortcuts like cut/copy/paste.
 /// > The menu bar differs per platform because of constraints introduced
-/// > by [`MenuItem`](tao::menu::MenuItem).
+/// > by [`MenuItem`](muda::MenuItem).
 #[allow(unused)]
 pub fn default_menu_bar() -> DioxusMenu {
     #[cfg(not(any(target_os = "ios", target_os = "android")))]

packages/document/docs/eval.md

@@ -91,7 +91,7 @@ fn app() -> Element {
 
 ## Interacting with the DOM with Eval
 
-You can also use the `eval` function to execute JavaScript code that reads or modifies the DOM. If you want to interact with the mounted DOM, you need to use `eval` inside the [`dioxus_hooks::use_effect`] hook which runs after the component has been mounted.
+You can also use the `eval` function to execute JavaScript code that reads or modifies the DOM. If you want to interact with the mounted DOM, you need to use `eval` inside the [`use_effect`](https://docs.rs/dioxus-hooks/latest/dioxus_hooks/fn.use_effect.html) hook which runs after the component has been mounted.
 
 ```rust
 use dioxus::prelude::*;

packages/document/docs/head.md

@@ -2,11 +2,11 @@
 
 Dioxus includes a series of components that render into the head of the page:
 
-- [Title](crate::Title)
-- [Meta](crate::Meta)
-- [document::Link](crate::document::Link)
-- [Script](crate::Script)
-- [Style](crate::Style)
+- [Title]
+- [Meta]
+- [document::Link](crate::Link)
+- [Script]
+- [Style]
 
 Each of these components can be used to add extra information to the head of the page. For example, you can use the `Title` component to set the title of the page, or the `Meta` component to add extra metadata to the page.
 

packages/document/src/elements/link.rs

@@ -83,7 +83,7 @@ impl LinkProps {
     }
 }
 
-/// Render a [`link`](crate::elements::link) tag into the head of the page.
+/// Render a [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/link) tag into the head of the page.
 ///
 /// > The [Link](https://docs.rs/dioxus-router/latest/dioxus_router/components/fn.Link.html) component in dioxus router and this component are completely different.
 /// > This component links resources in the head of the page, while the router component creates clickable links in the body of the page.

packages/document/src/elements/meta.rs

@@ -39,7 +39,7 @@ impl MetaProps {
     }
 }
 
-/// Render a [`meta`](crate::elements::meta) tag into the head of the page.
+/// Render a [`<meta>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/meta) tag into the head of the page.
 ///
 /// # Example
 ///

packages/document/src/elements/script.rs

@@ -61,7 +61,7 @@ impl ScriptProps {
     }
 }
 
-/// Render a [`script`](crate::elements::script) tag into the head of the page.
+/// Render a [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script) tag into the head of the page.
 ///
 ///
 /// If present, the children of the script component must be a single static or formatted string. If there are more children or the children contain components, conditionals, loops, or fragments, the script will not be added.

packages/document/src/elements/style.rs

@@ -41,7 +41,7 @@ impl StyleProps {
     }
 }
 
-/// Render a [`style`](crate::elements::style) or [`link`](crate::elements::link) tag into the head of the page.
+/// Render a [`<style>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/style) or [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/link) tag into the head of the page.
 ///
 /// If present, the children of the style component must be a single static or formatted string. If there are more children or the children contain components, conditionals, loops, or fragments, the style will not be added.
 ///

packages/document/src/elements/stylesheet.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-/// Render a [`link`](crate::elements::link) tag into the head of the page with the stylesheet rel.
+/// Render a [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/link) tag into the head of the page with the stylesheet rel.
 /// This is equivalent to the [`Link`](crate::Link) component with a slightly more ergonomic API.
 ///
 ///

packages/document/src/elements/title.rs

@@ -8,7 +8,7 @@ pub struct TitleProps {
     children: Element,
 }
 
-/// Render the title of the page. On web renderers, this will set the [title](crate::elements::title) in the head. On desktop, it will set the window title.
+/// Render the title of the page. On web renderers, this will set the [`<title>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/title) in the head. On desktop, it will set the window title.
 ///
 /// Unlike most head components, the Title can be modified after the first render. Only the latest update to the title will be reflected if multiple title components are rendered.
 ///

packages/fullstack-protocol/src/lib.rs

@@ -127,7 +127,7 @@ impl<T> Clone for SerializeContextEntry<T> {
 }
 
 impl<T> SerializeContextEntry<T> {
-    /// Insert data into an entry that was created with [`SerializeContext::create_entry`]
+    /// Insert data into an entry that was created with [`HydrationContext::create_entry`]
     pub fn insert(self, value: &T, location: &'static std::panic::Location<'static>)
     where
         T: Serialize,

packages/fullstack/docs/request_origin.md

@@ -1,6 +1,6 @@
 This method interacts with information from the current request. The request may come from:
 
-1. The initial SSR render if this method called from a [`Component`](dioxus_lib::prelude::component) or a [`server`](crate::prelude::server) function that is called during the initial render
+1. The initial SSR render if this method called from a [`Component`](dioxus_lib::prelude::component) or a [`server`](dioxus_server) function that is called during the initial render
 
 ```rust
 # use dioxus::prelude::*;
@@ -18,7 +18,7 @@ fn PrintHtmlRequestInfo() -> Element {
 }
 ```
 
-2. A request to a [`server`](crate::prelude::server) function called directly from the client (either on desktop/mobile or on the web frontend after the initial render)
+2. A request to a [`server`](dioxus_server) function called directly from the client (either on desktop/mobile or on the web frontend after the initial render)
 
 ```rust
 # use dioxus::prelude::*;

packages/history/src/lib.rs

@@ -49,8 +49,8 @@ pub trait History {
 
     /// Get the current path prefix of the URL.
     ///
-    /// Not all [`HistoryProvider`]s need a prefix feature. It is meant for environments where a
-    /// dioxus-router-core-routed application is not running on `/`. The [`HistoryProvider`] is responsible
+    /// Not all [`History`]s need a prefix feature. It is meant for environments where a
+    /// dioxus-router-core-routed application is not running on `/`. The [`History`] is responsible
     /// for removing the prefix from the dioxus-router-core-internal path, and also for adding it back in
     /// during navigation. This functions value is only used for creating `href`s (e.g. for SSR or
     /// display (but not navigation) in a web app).
@@ -60,7 +60,7 @@ pub trait History {
 
     /// Check whether there is a previous page to navigate back to.
     ///
-    /// If a [`HistoryProvider`] cannot know this, it should return [`true`].
+    /// If a [`History`] cannot know this, it should return [`true`].
     ///
     /// ```rust
     /// # use dioxus::prelude::*;
@@ -87,7 +87,7 @@ pub trait History {
 
     /// Go back to a previous page.
     ///
-    /// If a [`HistoryProvider`] cannot go to a previous page, it should do nothing. This method
+    /// If a [`History`] cannot go to a previous page, it should do nothing. This method
     /// might be called, even if `can_go_back` returns [`false`].
     ///
     /// ```rust
@@ -119,7 +119,7 @@ pub trait History {
 
     /// Check whether there is a future page to navigate forward to.
     ///
-    /// If a [`HistoryProvider`] cannot know this, it should return [`true`].
+    /// If a [`History`] cannot know this, it should return [`true`].
     ///
     /// ```rust
     /// # use dioxus::prelude::*;
@@ -150,7 +150,7 @@ pub trait History {
 
     /// Go forward to a future page.
     ///
-    /// If a [`HistoryProvider`] cannot go to a previous page, it should do nothing. This method
+    /// If a [`History`] cannot go to a previous page, it should do nothing. This method
     /// might be called, even if `can_go_forward` returns [`false`].
     ///
     /// ```rust
@@ -238,7 +238,7 @@ pub trait History {
     /// Navigate to an external URL.
     ///
     /// This should navigate to an external URL, which isn't controlled by the router. If a
-    /// [`HistoryProvider`] cannot do that, it should return [`false`], otherwise [`true`].
+    /// [`History`] cannot do that, it should return [`false`], otherwise [`true`].
     ///
     /// Returning [`false`] will cause the router to handle the external navigation failure.
     #[allow(unused_variables)]
@@ -246,9 +246,9 @@ pub trait History {
         false
     }
 
-    /// Provide the [`HistoryProvider`] with an update callback.
+    /// Provide the [`History`] with an update callback.
     ///
-    /// Some [`HistoryProvider`]s may receive URL updates from outside the router. When such
+    /// Some [`History`]s may receive URL updates from outside the router. When such
     /// updates are received, they should call `callback`, which will cause the router to update.
     #[allow(unused_variables)]
     fn updater(&self, callback: Arc<dyn Fn() + Send + Sync>) {}

packages/html/src/elements.rs

@@ -758,9 +758,9 @@ builder_constructors! {
     /// element.
     ///
     /// # About
-    /// - The HTML <h1> element is found within the <body> tag.
+    /// - The HTML `<h1>` element is found within the `<body>` tag.
     /// - Headings can range from `<h1>` to `<h6>`.
-    /// - The most important heading is `<h1>`` and the least important heading is `<h6>`.
+    /// - The most important heading is `<h1>` and the least important heading is `<h6>`.
     /// - The `<h1>` heading is the first heading in the document.
     /// - The `<h1>` heading is usually a large bolded font.
     h3 None {};
@@ -820,7 +820,7 @@ builder_constructors! {
     /// - The `<div>` tag is easily styled by using the class or id attribute.
     /// - Any sort of content can be put inside the `<div>` tag!
     ///
-    /// Note: By default, browsers always place a line break before and after the <div> element.
+    /// Note: By default, browsers always place a line break before and after the `<div>` element.
     ///
     /// ## References:
     /// - <https://developer.mozilla.org/en-US/docs/Web/HTML/Element/div>
@@ -1236,8 +1236,8 @@ builder_constructors! {
     /// [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
     /// element.
     ///
-    /// The [`script`] HTML element is used to embed executable code or data; this is typically used to embed or refer to
-    /// JavaScript code. The [`script`] element can also be used with other languages, such as WebGL's GLSL shader
+    /// The script HTML element is used to embed executable code or data; this is typically used to embed or refer to
+    /// JavaScript code. The script element can also be used with other languages, such as WebGL's GLSL shader
     /// programming language and JSON.
     script None {
         /// Normal script elements pass minimal information to the window.onerror for scripts which do not pass the

packages/html/src/events/mounted.rs

@@ -218,7 +218,7 @@ impl_event! [
     #[doc(alias = "useRef")]
     /// The onmounted event is fired when the element is first added to the DOM. This event gives you a [`MountedData`] object and lets you interact with the raw DOM element.
     ///
-    /// This event is fired once per element. If you need to access the element multiple times, you can store the [`MountedData`] object in a [`use_signal`] hook and use it as needed.
+    /// This event is fired once per element. If you need to access the element multiple times, you can store the [`MountedData`] object in a [`use_signal`](https://docs.rs/dioxus-hooks/latest/dioxus_hooks/fn.use_signal.html) hook and use it as needed.
     ///
     /// # Examples
     ///

packages/interpreter/README.md

@@ -31,11 +31,11 @@ We use TypeScript to write the bindings and a very simple build.rs along with bu
 
 Not every snippet of JS will be used, so we split out the snippets from the core interpreter.
 
-In theory, we *could* use Rust in the browser to do everything these bindings are doing. In reality, we want to stick with JS to skip the need for a WASM build step when running the LiveView and WebView renderers. We also want to use JS to prevent diverging behavior of things like canceling events, uploading files, and collecting form inputs. These details are tough to ensure 1:1 compatibility when implementing them in two languages.
+In theory, we _could_ use Rust in the browser to do everything these bindings are doing. In reality, we want to stick with JS to skip the need for a WASM build step when running the LiveView and WebView renderers. We also want to use JS to prevent diverging behavior of things like canceling events, uploading files, and collecting form inputs. These details are tough to ensure 1:1 compatibility when implementing them in two languages.
 
 If you want to contribute to the bindings, you'll need to have the typescript compiler installed on your machine as well as bun:
 
-https://bun.sh/docs/installation
+<https://bun.sh/docs/installation>
 
 ## Contributing
 

packages/liveview/src/history.rs

@@ -6,7 +6,7 @@ use std::rc::Rc;
 use std::sync::{Mutex, RwLock};
 use std::{collections::BTreeMap, sync::Arc};
 
-/// A [`HistoryProvider`] that evaluates history through JS.
+/// A [`History`] that evaluates history through JS.
 pub(crate) struct LiveviewHistory {
     action_tx: tokio::sync::mpsc::UnboundedSender<Action>,
     timeline: Arc<Mutex<Timeline>>,

packages/manganis/manganis-core/src/folder.rs

@@ -2,7 +2,7 @@ use const_serialize::SerializeConst;
 
 use crate::AssetOptions;
 
-/// The builder for [`FolderAsset`]
+/// The builder for a folder asset.
 #[derive(
     Debug,
     PartialEq,

packages/mobile/src/lib.rs

@@ -53,9 +53,9 @@ pub fn launch_cfg(
 ///
 /// If you look closely, you'll notice that we impl Send for this struct. This would normally be
 /// unsound. However, we know that the thread that created these objects ("main()" - see JNI_OnLoad)
-/// is finished once `start_app` is called. This is similar to how an Rc<T> is technically safe
-/// to move between threads if you can prove that no other thread is using the Rc<T> at the same time.
-/// Crates like https://crates.io/crates/sendable exist that build on this idea but with runtimk,
+/// is finished once `start_app` is called. This is similar to how an `Rc<T>` is technically safe
+/// to move between threads if you can prove that no other thread is using the `Rc<T>` at the same time.
+/// Crates like <https://crates.io/crates/sendable> exist that build on this idea but with runtime
 /// validation that the current thread is the one that created the object.
 ///
 /// Since `main()` completes, the only reader of this data will be `start_app`, so it's okay to

packages/native/src/lib.rs

@@ -4,9 +4,9 @@
 //!
 //! ## Feature flags
 //!  - `default`: Enables the features listed below.
-//!  - `accessibility`: Enables [`accesskit`] accessibility support.
+//!  - `accessibility`: Enables [`accesskit`](https://docs.rs/accesskit/latest/accesskit/) accessibility support.
 //!  - `hot-reload`: Enables hot-reloading of Dioxus RSX.
-//!  - `menu`: Enables the [`muda`] menubar.
+//!  - `menu`: Enables the [`muda`](https://docs.rs/muda/latest/muda/) menubar.
 //!  - `tracing`: Enables tracing support.
 
 mod assets;

packages/router/Cargo.toml

@@ -34,6 +34,7 @@ ciborium = { workspace = true }
 base64 = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 tokio = { workspace = true, features = ["full"] }
+dioxus-router = { workspace = true }
 
 [package.metadata.docs.rs]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]

packages/router/src/components/child_router.rs

@@ -36,7 +36,7 @@ impl<R> Clone for ChildRouteMapping<R> {
     }
 }
 
-/// Props for the [`ChildHistoryProvider`] component.
+/// Props for the [`ChildRouter`] component.
 #[derive(Props, Clone)]
 pub struct ChildRouterProps<R: Routable> {
     /// The child route to render

packages/router/src/components/history_buttons.rs

@@ -13,12 +13,12 @@ pub struct HistoryButtonProps {
 
 /// A button to go back through the navigation history. Similar to a browsers back button.
 ///
-/// Only works as descendant of a [`Link`] component, otherwise it will be inactive.
+/// Only works as descendant of a [`super::Link`] component, otherwise it will be inactive.
 ///
 /// The button will disable itself if it is known that no prior history is available.
 ///
 /// # Panic
-/// - When the [`GoBackButton`] is not nested within a [`Link`] component
+/// - When the [`GoBackButton`] is not nested within a [`super::Link`] component
 ///   hook, but only in debug builds.
 ///
 /// # Example
@@ -86,12 +86,12 @@ pub fn GoBackButton(props: HistoryButtonProps) -> Element {
 
 /// A button to go forward through the navigation history. Similar to a browsers forward button.
 ///
-/// Only works as descendant of a [`Link`] component, otherwise it will be inactive.
+/// Only works as descendant of a [`super::Link`] component, otherwise it will be inactive.
 ///
 /// The button will disable itself if it is known that no later history is available.
 ///
 /// # Panic
-/// - When the [`GoForwardButton`] is not nested within a [`Link`] component
+/// - When the [`GoForwardButton`] is not nested within a [`super::Link`] component
 ///   hook, but only in debug builds.
 ///
 /// # Example

packages/router/src/components/link.rs

@@ -31,7 +31,7 @@ pub struct LinkProps {
     pub onclick: Option<EventHandler<MouseEvent>>,
 
     /// The onmounted event handler.
-    /// Fired when the <a> element is mounted.
+    /// Fired when the `<a>` element is mounted.
     pub onmounted: Option<EventHandler<MountedEvent>>,
 
     #[props(default)]
@@ -72,7 +72,7 @@ impl Debug for LinkProps {
 
 /// A link to navigate to another route.
 ///
-/// Only works as descendant of a [`Router`] component, otherwise it will be inactive.
+/// Only works as descendant of a [`super::Router`] component, otherwise it will be inactive.
 ///
 /// Unlike a regular HTML anchor, a [`Link`] allows the router to handle the navigation and doesn't
 /// cause the browser to load a new page.
@@ -82,10 +82,10 @@ impl Debug for LinkProps {
 ///
 /// # External targets
 /// When the [`Link`]s target is an [`NavigationTarget::External`] target, that is used as the `href` directly. This
-/// means that a [`Link`] can always navigate to an [`NavigationTarget::External`] target, even if the [`HistoryProvider`] does not support it.
+/// means that a [`Link`] can always navigate to an [`NavigationTarget::External`] target, even if the [`dioxus_history::History`] does not support it.
 ///
 /// # Panic
-/// - When the [`Link`] is not nested within a [`Router`], but
+/// - When the [`Link`] is not nested within a [`super::Router`], but
 ///   only in debug builds.
 ///
 /// # Example

packages/rsx/src/template_body.rs

@@ -31,23 +31,23 @@
 //! This means you can't query the ID of any node "in a vacuum" - these are assigned once - but at
 //! least they're stable enough for the purposes of hotreloading
 //!
-//! ```rust, ignore
+//! ```text
 //! rsx! {
 //!     div {
 //!         class: "hello",
-//!         id: "node-{node_id}",    <--- {node_id} has the formatted segment id 0 in the literal pool
-//!         ..props,                 <--- spreads are not reloadable
+//!         id: "node-{node_id}",         <--- {node_id} has the formatted segment id 0 in the literal pool
+//!         ..props,                      <--- spreads are not reloadable
 //!
-//!         "Hello, world!           <--- not tracked but reloadable in the template since it's just a string
+//!         "Hello, world!"               <--- not tracked but reloadable in the template since it's just a string
 //!
-//!         for item in 0..10 {      <--- both 0 and 10 are technically reloadable, but we don't hot reload them today...
+//!         for item in 0..10 {           <--- both 0 and 10 are technically reloadable, but we don't hot reload them today...
 //!             div { "cool-{item}" }     <--- {item} has the formatted segment id 1 in the literal pool
 //!         }
 //!
 //!         Link {
-//!             to: "/home", <-- hotreloadable since its a component prop literal (with component literal id 0)
-//!             class: "link {is_ready}", <-- {is_ready} has the formatted segment id 2 in the literal pool and the property has the component literal id 1
-//!             "Home" <-- hotreloadable since its a component child (via template)
+//!             to: "/home",              <--- hotreloadable since its a component prop literal (with component literal id 0)
+//!             class: "link {is_ready}", <--- {is_ready} has the formatted segment id 2 in the literal pool and the property has the component literal id 1
+//!             "Home"                    <--- hotreloadable since its a component child (via template)
 //!         }
 //!     }
 //! }

packages/server/docs/request_origin.md

@@ -1,6 +1,6 @@
 This method interacts with information from the current request. The request may come from:
 
-1. The initial SSR render if this method called from a [`Component`](dioxus_lib::prelude::component) or a [`server`](crate::prelude::server) function that is called during the initial render
+1. The initial SSR render if this method called from a [`Component`](dioxus_lib::prelude::component) or a [`server`](crate) function that is called during the initial render
 
 ```rust
 # use dioxus::prelude::*;
@@ -18,7 +18,7 @@ fn PrintHtmlRequestInfo() -> Element {
 }
 ```
 
-2. A request to a [`server`](crate::prelude::server) function called directly from the client (either on desktop/mobile or on the web frontend after the initial render)
+2. A request to a [`server`](crate) function called directly from the client (either on desktop/mobile or on the web frontend after the initial render)
 
 ```rust
 # use dioxus::prelude::*;

packages/signals/docs/memo.md

@@ -51,7 +51,7 @@ fn app() -> Element {
 }
 ```
 
-For a full list of all the helpers available, check out the [`Readable`], [`ReadableVecExt`], and [`ReadableOptionExt`] traits.
+For a full list of all the helpers available, check out the [`Readable`], [`ReadableVecExt`](crate::ReadableVecExt), and [`ReadableOptionExt`](crate::ReadableOptionExt) traits.
 
 # Memos with Async
 

packages/signals/src/read.rs

@@ -263,7 +263,7 @@ pub trait Readable {
     }
 }
 
-/// An extension trait for Readable<Vec<T>> that provides some convenience methods.
+/// An extension trait for `Readable<Vec<T>>` that provides some convenience methods.
 pub trait ReadableVecExt<T: 'static>: Readable<Target = Vec<T>> {
     /// Returns the length of the inner vector.
     #[track_caller]
@@ -331,7 +331,7 @@ where
 {
 }
 
-/// An extension trait for Readable<Option<T>> that provides some convenience methods.
+/// An extension trait for `Readable<Option<T>>` that provides some convenience methods.
 pub trait ReadableOptionExt<T: 'static>: Readable<Target = Option<T>> {
     /// Unwraps the inner value and clones it.
     #[track_caller]
@@ -356,7 +356,7 @@ where
 {
 }
 
-/// An extension trait for Readable<Option<T>> that provides some convenience methods.
+/// An extension trait for `Readable<Option<T>>` that provides some convenience methods.
 pub trait ReadableResultExt<T: 'static, E: 'static>: Readable<Target = Result<T, E>> {
     /// Unwraps the inner value and clones it.
     #[track_caller]

packages/signals/src/set_compare.rs

@@ -18,7 +18,7 @@ pub struct SetCompare<R: 'static, S: Storage<SignalData<bool>> = UnsyncStorage>
 impl<R: Eq + Hash> SetCompare<R> {
     /// Creates a new [`SetCompare`] which efficiently tracks when a value changes to check if it is equal to a set of values.
     ///
-    /// Generally, you shouldn't need to use this hook. Instead you can use [`crate::use_memo`]. If you have many values that you need to compare to a single value, this hook will change updates from O(n) to O(1) where n is the number of values you are comparing to.
+    /// Generally, you shouldn't need to use this hook. Instead you can use [`crate::Memo`]. If you have many values that you need to compare to a single value, this hook will change updates from O(n) to O(1) where n is the number of values you are comparing to.
     #[track_caller]
     pub fn new(f: impl FnMut() -> R + 'static) -> SetCompare<R> {
         Self::new_maybe_sync(f)
@@ -28,7 +28,7 @@ impl<R: Eq + Hash> SetCompare<R> {
 impl<R: Eq + Hash, S: Storage<SignalData<bool>>> SetCompare<R, S> {
     /// Creates a new [`SetCompare`] that may be `Sync + Send` which efficiently tracks when a value changes to check if it is equal to a set of values.
     ///
-    /// Generally, you shouldn't need to use this hook. Instead you can use [`crate::use_memo`]. If you have many values that you need to compare to a single value, this hook will change updates from O(n) to O(1) where n is the number of values you are comparing to.
+    /// Generally, you shouldn't need to use this hook. Instead you can use [`crate::Memo`]. If you have many values that you need to compare to a single value, this hook will change updates from O(n) to O(1) where n is the number of values you are comparing to.
     #[track_caller]
     pub fn new_maybe_sync(mut f: impl FnMut() -> R + 'static) -> SetCompare<R> {
         let subscribers: CopyValue<FxHashMap<R, Signal<bool>>> =

packages/wasm-split/wasm-split-cli/src/lib.rs

@@ -1361,12 +1361,12 @@ pub struct SplitPoint {
 ///
 /// These will be in the form of:
 ///
-/// __wasm_split_00<module>00_<import|export>_<hash>_<function>
+/// `__wasm_split_00<module>00_<import|export>_<hash>_<function>`
 ///
 /// For a function named `SomeRoute2` in the module `add_body_element`, the pairings would be:
 ///
-/// __wasm_split_00add_body_element00_import_abef5ee3ebe66ff17677c56ee392b4c2_SomeRoute2
-/// __wasm_split_00add_body_element00_export_abef5ee3ebe66ff17677c56ee392b4c2_SomeRoute2
+/// `__wasm_split_00add_body_element00_import_abef5ee3ebe66ff17677c56ee392b4c2_SomeRoute2`
+/// `__wasm_split_00add_body_element00_export_abef5ee3ebe66ff17677c56ee392b4c2_SomeRoute2`
 ///
 fn accumulate_split_points(module: &Module) -> Vec<SplitPoint> {
     let mut index = 0;

packages/web/src/history/mod.rs

@@ -20,14 +20,14 @@ fn update_scroll(window: &Window, history: &History) {
     }
 }
 
-/// A [`HistoryProvider`] that integrates with a browser via the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API).
+/// A [`dioxus_history::History`] provider that integrates with a browser via the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API).
 ///
 /// # Prefix
-/// This [`HistoryProvider`] supports a prefix, which can be used for web apps that aren't located
+/// This [`dioxus_history::History`] supports a prefix, which can be used for web apps that aren't located
 /// at the root of their domain.
 ///
 /// Application developers are responsible for ensuring that right after the prefix comes a `/`. If
-/// that is not the case, this [`HistoryProvider`] will replace the first character after the prefix
+/// that is not the case, this [`dioxus_history::History`] will replace the first character after the prefix
 /// with one.
 ///
 /// Application developers are responsible for not rendering the router if the prefix is not present

packages/web/src/hydration/hydrate.rs

@@ -61,7 +61,7 @@ impl SuspenseHydrationIdsNode {
 ///
 /// This struct keeps track of the order the suspense boundaries are discovered in on the client so we can map the id in the dom to the scope we need to rehydrate.
 ///
-/// Diagram: https://excalidraw.com/#json=4NxmW90g0207Y62lESxfF,vP_Yn6j7k23utq2HZIsuiw
+/// Diagram: <https://excalidraw.com/#json=4NxmW90g0207Y62lESxfF,vP_Yn6j7k23utq2HZIsuiw>
 #[derive(Default, Debug)]
 pub(crate) struct SuspenseHydrationIds {
     /// A dense mapping from traversal order to the scope id of the suspense boundary