async fn _preload(&self, path: &str, is_route_preload: bool) -> Result<(), ClientError> {
        use crate::router::{match_route, FullRouteVerdict};

        // It is reasonable to assume that this function will not be called before the
        // instantiation of a translator
        let locale = self.get_translator().get_locale();
        let full_path = PathMaybeWithLocale::new(&PathWithoutLocale(path.to_string()), &locale);

        let path_segments = full_path
            .split('/')
            .filter(|s| !s.is_empty())
            .collect::<Vec<&str>>(); // This parsing is identical to the Sycamore router's
                                     // Get a route verdict on this so we know where we're going (this doesn't modify
                                     // the router state)
        let verdict = match_route(
            &path_segments,
            &self.render_cfg,
            &self.entities,
            &self.locales,
        );
        // Make sure we've got a valid verdict (otherwise the user should be told there
        // was an error)
        let route_info = match verdict.into_full(&self.entities) {
            FullRouteVerdict::Found(info) => info,
            FullRouteVerdict::NotFound { .. } => {
                return Err(ClientPreloadError::PreloadNotFound {
                    path: path.to_string(),
                }
                .into())
            }
            FullRouteVerdict::LocaleDetection(_) => {
                return Err(ClientPreloadError::PreloadLocaleDetection {
                    path: path.to_string(),
                }
                .into())
            }
        };

        // We just needed to acquire the arguments to this function
        self.state_store
            .preload(
                // We want an unlocalized path, which will be amalgamated with the locale for the
                // key
                &route_info.path,
                &route_info.locale,
                &route_info.entity.get_path(),
                route_info.was_incremental_match,
                is_route_preload,
                // While we might be preloading a widget, this just controls asset types, and,
                // since this function is intended for end user abstractions, this should always
                // use `AssetType::Preload`
                false,
            )
            .await
    }
Preloads the given URL from the server and caches it, preventing
future network requests to fetch that page. Localization will be
handled automatically.

To preload a widget, you must prefix its path with `__capsule/`.
packages/perseus/src/reactor/state.rs