refactored app to work totally client-side wrt blob fetches and urls

Cargo.lock

···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "54e4348c16a3d2e2a45437eff67efc5462b60443de76f61b5d0ed9111c626d9d"
 dependencies = [
- "cc",
  "indexed_db_futures",
  "js-sys",
  "once_cell",
···
  "dioxus-primitives",
  "jacquard",
  "jacquard-axum",
+ "js-sys",
  "markdown-weaver",
  "mime-sniffer",
  "mini-moka",
···
  "serde_json",
  "sqlite-wasm-rs",
  "time",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
  "weaver-api",
  "weaver-common",
  "weaver-renderer",
+ "web-sys",
 ]
 
 [[package]]

crates/weaver-app/Cargo.toml

···
 
 [features]
 default = ["web"]
-# The feature that are only required for the web = ["dioxus/web"] build target should be optional and only enabled in the web = ["dioxus/web"] feature
-web = ["dioxus/web", "chrono/wasmbind"]
-# The feature that are only required for the desktop = ["dioxus/desktop"] build target should be optional and only enabled in the desktop = ["dioxus/desktop"] feature
+# Fullstack mode with SSR and server functions
+fullstack-server = ["dioxus/fullstack"]
+
+web = ["dioxus/web"]
 desktop = ["dioxus/desktop"]
-# The feature that are only required for the mobile = ["dioxus/mobile"] build target should be optional and only enabled in the mobile = ["dioxus/mobile"] feature
 mobile = ["dioxus/mobile"]
-# The feature that are only required for the server = ["dioxus/server"] build target should be optional and only enabled in the server = ["dioxus/server"] feature
-server = ["dioxus/server", "dep:jacquard-axum", "dep:axum"]
+server = [ "dioxus/server", "dep:jacquard-axum", "dep:axum"]
+
+
+
 
 [dependencies]
 dashmap = "6.1.0"
-dioxus = { version = "0.7.0", features = ["router", "fullstack"] }
+
+dioxus = { version = "0.7.0", features = ["router"] }
+#dioxus = { version = "0.7.0", features = ["router", "fullstack"] }
 weaver-common = { path = "../weaver-common" }
 jacquard = { workspace = true, features = ["streaming"] }
 jacquard-axum = { workspace = true, optional = true }
···
 
 
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
-sqlite-wasm-rs = { version = "0.4", features = ["relaxed-idb"] }
-
-
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
+sqlite-wasm-rs = { version = "0.4", default-features = false, features = ["precompiled", "relaxed-idb"] }
 time = { version = "0.3", features = ["wasm-bindgen"] }
 console_error_panic_hook = "0.1"
 mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d", features = ["js"] }
+chrono = { version = "0.4", features = ["wasmbind"] }
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3", features = ["ServiceWorkerContainer", "ServiceWorker", "ServiceWorkerRegistration", "RegistrationOptions", "Window", "Navigator", "MessageEvent", "console"] }
+js-sys = "0.3"

crates/weaver-app/Dioxus.toml

···
 style = []
 
 # Additional JavaScript files
-script = []
+script = ["assets/sw.js"]
 
 [web.resource.dev]
 

crates/weaver-app/assets/sw.js

···
+// Weaver Service Worker
+// Handles blob/image requests by intercepting fetch and serving from PDS
+
+const CACHE_NAME = "weaver-blobs-v1";
+
+// Map of notebook/path -> real URL
+// e.g., "notebook/image/foo.jpg" -> "https://pds.example.com/xrpc/com.atproto.sync.getBlob?..."
+const urlMappings = new Map();
+
+// Install and activate immediately
+self.addEventListener("install", (event) => {
+  console.log("[SW] Installing service worker");
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  console.log("[SW] Activating service worker");
+  event.waitUntil(clients.claim());
+});
+
+// Receive mappings from main thread
+self.addEventListener("message", (event) => {
+  if (event.data.type === "register_mappings") {
+    const notebook = event.data.notebook;
+    console.log("[SW] Registering blob mappings for notebook:", notebook);
+
+    // Store blob URL mappings
+    for (const [name, url] of Object.entries(event.data.blobs)) {
+      const key = `${notebook}/image/${name}`;
+      urlMappings.set(key, url);
+      console.log("[SW] Registered mapping:", key, "->", url);
+    }
+  }
+});
+
+// Intercept fetch requests
+self.addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+
+  // Extract key from path (e.g., "/notebook/image/foo.jpg" -> "notebook/image/foo.jpg")
+  const pathParts = url.pathname.split("/").filter((p) => p);
+
+  // Check if this looks like an image request (format: /:notebook/image/:name)
+  if (pathParts.length >= 3 && pathParts[pathParts.length - 2] === "image") {
+    // Reconstruct the key
+    const key = pathParts.join("/");
+
+    console.log("[SW] Intercepted image request:", key);
+
+    const mapping = urlMappings.get(key);
+    if (mapping) {
+      console.log("[SW] Found mapping for:", key, "->", mapping);
+      event.respondWith(handleBlobRequest(mapping, key));
+      return;
+    } else {
+      console.log("[SW] No mapping found for:", key);
+    }
+  }
+
+  // Let other requests pass through
+});
+
+async function handleBlobRequest(url, key) {
+  try {
+    // Check cache first
+    const cache = await caches.open(CACHE_NAME);
+    let response = await cache.match(key);
+
+    if (response) {
+      console.log("[SW] Cache hit for:", key);
+      return response;
+    }
+
+    // Fetch from PDS
+    console.log("[SW] Fetching from PDS:", url);
+    response = await fetch(url);
+
+    if (!response.ok) {
+      console.error("[SW] Fetch failed:", response.status, response.statusText);
+      return new Response("Blob not found", { status: 404 });
+    }
+
+    // Cache the response
+    await cache.put(key, response.clone());
+    console.log("[SW] Cached blob:", key);
+
+    return response;
+  } catch (error) {
+    console.error("[SW] Error handling blob request:", error);
+    return new Response("Error fetching blob", { status: 500 });
+  }
+}

crates/weaver-app/src/blobcache.rs

···
+use crate::cache_impl;
 use dioxus::{CapturedError, Result};
 use jacquard::{
     bytes::Bytes,
···
 #[derive(Clone)]
 pub struct BlobCache {
     client: Arc<BasicClient>,
-    cache: mini_moka::sync::Cache<Cid<'static>, Bytes>,
-    map: mini_moka::sync::Cache<SmolStr, Cid<'static>>,
+    cache: cache_impl::Cache<Cid<'static>, Bytes>,
+    map: cache_impl::Cache<SmolStr, Cid<'static>>,
 }
 
 impl BlobCache {
     pub fn new(client: Arc<BasicClient>) -> Self {
-        let cache = mini_moka::sync::Cache::builder()
-            .max_capacity(100)
-            .time_to_idle(Duration::from_secs(1200))
-            .build();
-        let map = mini_moka::sync::Cache::builder()
-            .max_capacity(500)
-            .time_to_idle(Duration::from_secs(1200))
-            .build();
+        let cache = cache_impl::new_cache(100, Duration::from_secs(1200));
+        let map = cache_impl::new_cache(500, Duration::from_secs(1200));
 
         Self { client, cache, map }
     }

crates/weaver-app/src/components/css.rs

···
 #[allow(unused_imports)]
 use crate::fetch;
 #[allow(unused_imports)]
-use dioxus::{
-    fullstack::{
-        get_server_url,
-        headers::ContentType,
-        http::header::CONTENT_TYPE,
-        response::{self, Response},
-    },
-    prelude::*,
-    CapturedError,
+use dioxus::{prelude::*, CapturedError};
+
+#[cfg(feature = "fullstack-server")]
+use dioxus::fullstack::{
+    get_server_url,
+    headers::ContentType,
+    http::header::CONTENT_TYPE,
+    response::{self, Response},
 };
 use jacquard::smol_str::SmolStr;
 #[allow(unused_imports)]
···
 #[cfg(feature = "server")]
 use axum::{extract::Extension, response::IntoResponse};
 
+#[cfg(feature = "fullstack-server")]
 #[component]
 pub fn NotebookCss(ident: SmolStr, notebook: SmolStr) -> Element {
     rsx! {
···
     }
 }
 
+#[cfg(not(feature = "fullstack-server"))]
+#[component]
+pub fn NotebookCss(ident: SmolStr, notebook: SmolStr) -> Element {
+    use jacquard::client::AgentSessionExt;
+    use jacquard::types::ident::AtIdentifier;
+    use jacquard::{from_data, CowStr};
+    use weaver_api::sh_weaver::notebook::book::Book;
+    use weaver_renderer::css::{generate_base_css, generate_syntax_css};
+    use weaver_renderer::theme::{default_resolved_theme, resolve_theme};
+
+    let fetcher = use_context::<fetch::CachedFetcher>();
+
+    let css_content = use_resource(move || {
+        let ident = ident.clone();
+        let notebook = notebook.clone();
+        let fetcher = fetcher.clone();
+
+        async move {
+            let ident = AtIdentifier::new_owned(ident).ok()?;
+            let resolved_theme =
+                if let Some(notebook) = fetcher.get_notebook(ident, notebook).await.ok()? {
+                    let book: Book = from_data(&notebook.0.record).ok()?;
+                    if let Some(theme_ref) = book.theme {
+                        if let Ok(theme_response) =
+                            fetcher.client.get_record::<Theme>(&theme_ref.uri).await
+                        {
+                            if let Ok(theme_output) = theme_response.into_output() {
+                                let theme: Theme = theme_output.into();
+                                resolve_theme(fetcher.client.as_ref(), &theme)
+                                    .await
+                                    .unwrap_or_else(|_| default_resolved_theme())
+                            } else {
+                                default_resolved_theme()
+                            }
+                        } else {
+                            default_resolved_theme()
+                        }
+                    } else {
+                        default_resolved_theme()
+                    }
+                } else {
+                    default_resolved_theme()
+                };
+
+            let mut css = generate_base_css(&resolved_theme);
+            css.push_str(
+                &generate_syntax_css(&resolved_theme)
+                    .await
+                    .unwrap_or_default(),
+            );
+
+            Some(css)
+        }
+    });
+
+    match css_content() {
+        Some(Some(css)) => rsx! { document::Style { {css} } },
+        _ => rsx! {},
+    }
+}
+
+#[cfg(feature = "fullstack-server")]
 #[get("/{ident}/{notebook}/css", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
 pub async fn css(ident: SmolStr, notebook: SmolStr) -> Result<Response> {
     use jacquard::client::AgentSessionExt;

crates/weaver-app/src/components/entry.rs

···
 use dioxus::prelude::*;
 
 const ENTRY_CSS: Asset = asset!("/assets/styling/entry.css");
+#[cfg(feature = "fullstack-server")]
+use dioxus::{fullstack::extract::Extension, CapturedError};
+use jacquard::prelude::*;
 #[allow(unused_imports)]
-use dioxus::{fullstack::extract::Extension, CapturedError};
-use jacquard::{
-    from_data, prelude::IdentityResolver, smol_str::ToSmolStr, types::string::Datetime,
-};
+use jacquard::smol_str::ToSmolStr;
+use jacquard::{from_data, types::string::Datetime};
 #[allow(unused_imports)]
 use jacquard::{
     smol_str::SmolStr,
···
     let entry = use_resource(use_reactive!(|(ident, book_title, title)| async move {
         let fetcher = use_context::<fetch::CachedFetcher>();
         let entry = fetcher
-            .get_entry(ident.clone(), book_title, title)
+            .get_entry(ident.clone(), book_title.clone(), title)
             .await
             .ok()
             .flatten();
-        if let Some(entry) = &entry {
-            let entry = &entry.1;
-            if let Some(embeds) = &entry.embeds {
+        if let Some(entry_data) = &entry {
+            let entry_record = &entry_data.1;
+            if let Some(embeds) = &entry_record.embeds {
                 if let Some(images) = &embeds.images {
-                    for image in &images.images {
-                        let cid = image.image.blob().cid();
-                        cache_blob(
-                            ident.to_smolstr(),
-                            cid.to_smolstr(),
-                            image.name.as_ref().map(|n| n.to_smolstr()),
+                    // Register blob mappings with service worker (client-side only)
+                    #[cfg(all(
+                        target_family = "wasm",
+                        target_os = "unknown",
+                        not(feature = "fullstack-server")
+                    ))]
+                    {
+                        let _ = crate::service_worker::register_entry_blobs(
+                            &ident,
+                            book_title.as_str(),
+                            images,
+                            &fetcher,
                         )
-                        .await
-                        .ok();
+                        .await;
+                    }
+                    #[cfg(feature = "fullstack-server")]
+                    {
+                        for image in &images.images {
+                            let cid = image.image.blob().cid();
+                            cache_blob(
+                                ident.to_smolstr(),
+                                cid.to_smolstr(),
+                                image.name.as_ref().map(|n| n.to_smolstr()),
+                            )
+                            .await
+                            .ok();
+                        }
                     }
                 }
             }
···
     }
 }
 
+#[cfg(feature = "fullstack-server")]
 #[put("/cache/{ident}/{cid}?name", cache: Extension<Arc<BlobCache>>)]
 pub async fn cache_blob(ident: SmolStr, cid: SmolStr, name: Option<SmolStr>) -> Result<()> {
     let ident = AtIdentifier::new_owned(ident)?;

crates/weaver-app/src/main.rs

···
 // need dioxus
 use components::{Entry, Repository, RepositoryIndex};
 #[allow(unused)]
-use dioxus::{
-    fullstack::{response::Extension, FullstackContext},
-    prelude::*,
-    CapturedError,
-};
+use dioxus::{prelude::*, CapturedError};
+
+#[cfg(feature = "fullstack-server")]
+use dioxus::fullstack::{response::Extension, FullstackContext};
 #[allow(unused)]
 use jacquard::{
     client::BasicClient,
···
 /// Define a components module that contains all shared components for our app.
 mod components;
 mod fetch;
+mod service_worker;
 /// Define a views module that contains the UI for all Layouts and Routes for our app.
 mod views;
 
···
 // The asset macro also minifies some assets like CSS and JS to make bundled smaller
 const MAIN_CSS: Asset = asset!("/assets/styling/main.css");
 
+#[cfg(not(feature = "fullstack-server"))]
+#[cfg(feature = "server")]
+async fn serve_sw() -> impl axum::response::IntoResponse {
+    use axum::response::IntoResponse;
+    let sw_js = include_str!("../assets/sw.js");
+    (
+        [(axum::http::header::CONTENT_TYPE, "application/javascript")],
+        sw_js,
+    )
+        .into_response()
+}
+
 fn main() {
     // Set up better panic messages for wasm
     #[cfg(target_arch = "wasm32")]
···
             extract::{Extension, Request},
             middleware,
             middleware::Next,
+            routing::get,
         };
         use std::convert::Infallible;
         use std::sync::Arc;
 
-        // Create shared state
-        let fetcher = Arc::new(CachedFetcher::new(Arc::new(BasicClient::unauthenticated())));
-        let blob_cache = Arc::new(BlobCache::new(Arc::new(BasicClient::unauthenticated())));
+        #[cfg(not(feature = "fullstack-server"))]
+        let router = {
+            axum::Router::new()
+                .route("/sw.js", get(serve_sw))
+                .merge(dioxus::server::router(App))
+        };
 
-        // Create a new router for our app using the `router` function
-        let router = dioxus::server::router(App).layer(middleware::from_fn({
-            let fetcher = fetcher.clone();
-            let blob_cache = blob_cache.clone();
-            move |mut req: Request, next: Next| {
+        #[cfg(feature = "fullstack-server")]
+        let router = {
+            let fetcher = Arc::new(CachedFetcher::new(Arc::new(BasicClient::unauthenticated())));
+            let blob_cache = Arc::new(BlobCache::new(Arc::new(BasicClient::unauthenticated())));
+            dioxus::server::router(App).layer(middleware::from_fn({
                 let fetcher = fetcher.clone();
                 let blob_cache = blob_cache.clone();
-                async move {
-                    // Attach extensions for dioxus server functions
-                    req.extensions_mut().insert(fetcher);
-                    req.extensions_mut().insert(blob_cache);
+                move |mut req: Request, next: Next| {
+                    let fetcher = fetcher.clone();
+                    let blob_cache = blob_cache.clone();
+                    async move {
+                        // Attach extensions for dioxus server functions
+                        req.extensions_mut().insert(fetcher);
+                        req.extensions_mut().insert(blob_cache);
 
-                    // And then return the response with `next.run()
-                    Ok::<_, Infallible>(next.run(req).await)
+                        // And then return the response with `next.run()
+                        Ok::<_, Infallible>(next.run(req).await)
+                    }
                 }
-            }
-        }));
+            }))
+        };
         // And then return the router
         Ok(router)
     });
···
 fn App() -> Element {
     // The `rsx!` macro lets us define HTML inside of rust. It expands to an Element with all of our HTML inside.
     use_context_provider(|| fetch::CachedFetcher::new(Arc::new(BasicClient::unauthenticated())));
+
+    // Register service worker on startup (only on web)
+    #[cfg(all(
+        target_family = "wasm",
+        target_os = "unknown",
+        not(feature = "fullstack-server")
+    ))]
+    use_effect(move || {
+        spawn(async move {
+            let _ = service_worker::register_service_worker().await;
+        });
+    });
+
     rsx! {
         document::Link { rel: "icon", href: FAVICON }
         document::Link { rel: "stylesheet", href: MAIN_CSS }
···
     rsx! {
         ErrorBoundary {
             handle_error: move |err: ErrorContext| {
-                let http_error = FullstackContext::commit_error_status(err.error().unwrap());
-                match http_error.status {
-                    StatusCode::NOT_FOUND => rsx! { div { "404 - Page not found" } },
-                    _ => rsx! { div { "An unknown error occurred" } },
+                #[cfg(feature = "fullstack-server")]
+                {
+                    let http_error = FullstackContext::commit_error_status(err.error().unwrap());
+                    match http_error.status {
+                        StatusCode::NOT_FOUND => rsx! { div { "404 - Page not found" } },
+                        _ => rsx! { div { "An unknown error occurred" } },
+                    }
+                }
+                #[cfg(not(feature = "fullstack-server"))]
+                {
+                    rsx! { div { "An error occurred" } }
                 }
             },
             Outlet::<Route> {}
···
     }
 }
 
+#[cfg(all(feature = "fullstack-server", feature = "server"))]
 #[get("/{notebook}/image/{name}", blob_cache: Extension<Arc<crate::blobcache::BlobCache>>)]
-pub async fn image_named(
-    notebook: SmolStr,
-    name: SmolStr,
-) -> Result<dioxus_fullstack::response::Response> {
-    use axum::response::IntoResponse;
+pub async fn image_named(notebook: SmolStr, name: SmolStr) -> Result<axum::response::Response> {
+    use axum::{http::header::CONTENT_TYPE, response::IntoResponse};
     use mime_sniffer::MimeTypeSniffer;
     if let Some(bytes) = blob_cache.get_named(&name) {
         let blob = bytes.clone();
-        let mime = blob.sniff_mime_type().unwrap_or("application/octet-stream");
-        Ok((
-            [(dioxus_fullstack::http::header::CONTENT_TYPE, mime)],
-            bytes,
-        )
-            .into_response())
+        let mime = blob.sniff_mime_type().unwrap_or("image/jpg");
+        Ok(([(CONTENT_TYPE, mime)], bytes).into_response())
     } else {
         Err(CapturedError::from_display("no image"))
     }
 }
 
+#[cfg(all(feature = "fullstack-server", feature = "server"))]
 #[get("/{notebook}/blob/{cid}", blob_cache: Extension<Arc<crate::blobcache::BlobCache>>)]
-pub async fn blob(notebook: SmolStr, cid: SmolStr) -> Result<dioxus_fullstack::response::Response> {
-    use axum::response::IntoResponse;
+pub async fn blob(notebook: SmolStr, cid: SmolStr) -> Result<axum::response::Response> {
+    use axum::{http::header::CONTENT_TYPE, response::IntoResponse};
     use mime_sniffer::MimeTypeSniffer;
     if let Some(bytes) = blob_cache.get_cid(&Cid::new_owned(cid.as_bytes())?) {
         let blob = bytes.clone();
         let mime = blob.sniff_mime_type().unwrap_or("application/octet-stream");
-        Ok((
-            [(dioxus_fullstack::http::header::CONTENT_TYPE, mime)],
-            bytes,
-        )
-            .into_response())
+        Ok(([(CONTENT_TYPE, mime)], bytes).into_response())
     } else {
         Err(CapturedError::from_display("no blob"))
     }

crates/weaver-app/src/service_worker.rs

···
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use wasm_bindgen::prelude::*;
+
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use wasm_bindgen_futures::JsFuture;
+
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use web_sys::{RegistrationOptions, ServiceWorkerContainer, Window};
+
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub async fn register_service_worker() -> Result<(), JsValue> {
+    let window = web_sys::window().ok_or_else(|| JsValue::from_str("no window"))?;
+    let navigator = window.navigator();
+    let sw_container = navigator.service_worker();
+
+    let promise = sw_container.register("/sw.js");
+    JsFuture::from(promise).await?;
+
+    Ok(())
+}
+
+/// Register blob mappings from entry images with the service worker
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub async fn register_entry_blobs(
+    ident: &jacquard::types::ident::AtIdentifier<'_>,
+    book_title: &str,
+    images: &weaver_api::sh_weaver::embed::images::Images<'_>,
+    fetcher: &crate::fetch::CachedFetcher,
+) -> Result<(), JsValue> {
+    use jacquard::prelude::IdentityResolver;
+    use std::collections::HashMap;
+
+    let mut blob_mappings = HashMap::new();
+
+    // Resolve DID and PDS URL
+    let (did, pds_url) = match ident {
+        jacquard::types::ident::AtIdentifier::Did(d) => {
+            let pds = fetcher.client.pds_for_did(d).await.ok();
+            (d.clone(), pds)
+        }
+        jacquard::types::ident::AtIdentifier::Handle(h) => {
+            if let Ok((did, pds)) = fetcher.client.pds_for_handle(h).await {
+                (did, Some(pds))
+            } else {
+                return Ok(());
+            }
+        }
+    };
+
+    if let Some(pds_url) = pds_url {
+        for image in &images.images {
+            let cid = image.image.blob().cid();
+
+            if let Some(name) = &image.name {
+                let blob_url = format!(
+                    "{}xrpc/com.atproto.sync.getBlob?did={}&cid={}",
+                    pds_url.as_str(),
+                    did.as_ref(),
+                    cid.as_ref()
+                );
+                blob_mappings.insert(name.as_ref().to_string(), blob_url);
+            }
+        }
+
+        // Send mappings to service worker
+        if !blob_mappings.is_empty() {
+            send_blob_mappings(book_title, blob_mappings)?;
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+fn send_blob_mappings(
+    notebook: &str,
+    mappings: std::collections::HashMap<String, String>,
+) -> Result<(), JsValue> {
+    let window = web_sys::window().ok_or_else(|| JsValue::from_str("no window"))?;
+    let navigator = window.navigator();
+    let sw_container = navigator.service_worker();
+
+    let controller = sw_container
+        .controller()
+        .ok_or_else(|| JsValue::from_str("no service worker controller"))?;
+
+    // Build message object
+    let msg = js_sys::Object::new();
+    js_sys::Reflect::set(&msg, &"type".into(), &"register_mappings".into())?;
+    js_sys::Reflect::set(&msg, &"notebook".into(), &notebook.into())?;
+
+    // Convert HashMap to JS Object
+    let blobs_obj = js_sys::Object::new();
+    for (name, url) in mappings {
+        js_sys::Reflect::set(&blobs_obj, &name.into(), &url.into())?;
+    }
+    js_sys::Reflect::set(&msg, &"blobs".into(), &blobs_obj)?;
+
+    controller.post_message(&msg)?;
+
+    Ok(())
+}
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+pub async fn register_service_worker() -> Result<(), String> {
+    Ok(())
+}
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+pub fn send_blob_mappings(
+    _notebook: &str,
+    _mappings: std::collections::HashMap<String, String>,
+) -> Result<(), String> {
+    Ok(())
+}