should be working hopefully

bot/src/main.rs

···
     let mut hbs = Handlebars::new();
     let _ = hbs.register_embed_templates::<Templates>();
 
-    // let cfg = BrowserConfig::builder()
-    //     .headless_mode(HeadlessMode::New)
-    //     .no_sandbox()
-    //     .build()
-    //     .map_err(|e| anyhow::anyhow!(e))
-    //     .expect("build browser config");
+    // Initialize a long-running Chromium browser
+    let cfg = BrowserConfig::builder()
+        .headless_mode(HeadlessMode::New)
+        .no_sandbox()
+        .build()
+        .map_err(|e| anyhow::anyhow!(e))
+        .expect("build browser config");
 
-    // let handle = tokio::spawn(async move { while let Some(_) = browser_handler.next().await {} });
+    let (browser, mut browser_handler) = Browser::launch(cfg).await.expect("launch browser");
+    // Drive the browser handler for the lifetime of the program
+    tokio::spawn(async move { while let Some(_evt) = browser_handler.next().await {} });
+    let browser = Arc::new(browser);
 
     // Ingestor for the star collection
     let mut ingestors: HashMap<String, Box<dyn LexiconIngestor + Send + Sync>> = HashMap::new();
···
             pool: pool.clone(),
             bot: Arc::new(bot_api),
             sling_shot: sling_shot.clone(),
-            //Come back to this
-            // browser: Arc::new(browser),
+            browser: browser.clone(),
             hbs: Arc::new(hbs),
             timeframe_hours,
             star_threshold,
···
     pool: SqlitePool,
     bot: Arc<BotApi>,
     sling_shot: Arc<Slingshot>,
-    // browser: Arc<Browser>,
+    browser: Arc<Browser>,
     hbs: Arc<Handlebars<'static>>,
     timeframe_hours: i64,
     star_threshold: i64,
···
 
                                     let html = &self.hbs.render("repo_header.hbs", &ctx)?;
 
-                                    // let bytes = render_with_chromiumoxide(&html, 336, 114).await?;
+                                    let bytes = render_with_chromiumoxide(
+                                        self.browser.as_ref(),
+                                        &html,
+                                        336,
+                                        114,
+                                    )
+                                    .await?;
 
-                                    // let blob_upload = &self
-                                    //     .bot
-                                    //     .agent
-                                    //     .api
-                                    //     .com
-                                    //     .atproto
-                                    //     .repo
-                                    //     .upload_blob(bytes)
-                                    //     .await?;
+                                    let blob_upload = &self
+                                        .bot
+                                        .agent
+                                        .api
+                                        .com
+                                        .atproto
+                                        .repo
+                                        .upload_blob(bytes)
+                                        .await?;
 
                                     // let rt = RichText::new_with_detect_facets(format!(
                                     //     "{handle_and_repo}{description}\n⭐️ {stars} {tangled_sh_url}"
···
                                     let post_text =
                                         format!("{handle_and_repo}{description}\n⭐️ {stars}");
 
-                                    // let image = atrium_api::app::bsky::embed::images::ImageData {
-                                    //     alt: format!(
-                                    //         "An image showing the same text inside of the post. {post_text}"
-                                    //     ),
-                                    //     aspect_ratio: Some(
-                                    //         atrium_api::app::bsky::embed::defs::AspectRatioData {
-                                    //             height: NonZeroU64::try_from(114_u64)?,
-                                    //             width: NonZeroU64::try_from(336_u64)?,
-                                    //         }
-                                    //         .into(),
-                                    //     ),
-                                    //     //Good lord how many clones is that
-                                    //     image: blob_upload.clone().blob.clone(),
-                                    // };
-                                    // let embed = Some(atrium_api::types::Union::Refs(
-                                    //     RecordEmbedRefs::AppBskyEmbedImagesMain(Box::new(
-                                    //         atrium_api::app::bsky::embed::images::MainData {
-                                    //             images: vec![image.into()],
-                                    //         }
-                                    //         .into(),
-                                    //     )),
-                                    // ));
+                                    let image = atrium_api::app::bsky::embed::images::ImageData {
+                                        alt: format!(
+                                            "An image showing the same text inside of the post. {post_text}"
+                                        ),
+                                        aspect_ratio: Some(
+                                            atrium_api::app::bsky::embed::defs::AspectRatioData {
+                                                height: NonZeroU64::try_from(114_u64)?,
+                                                width: NonZeroU64::try_from(336_u64)?,
+                                            }
+                                            .into(),
+                                        ),
+                                        //Good lord how many clones is that
+                                        image: blob_upload.clone().blob.clone(),
+                                    };
+                                    let embed = Some(atrium_api::types::Union::Refs(
+                                        RecordEmbedRefs::AppBskyEmbedImagesMain(Box::new(
+                                            atrium_api::app::bsky::embed::images::MainData {
+                                                images: vec![image.into()],
+                                            }
+                                            .into(),
+                                        )),
+                                    ));
 
                                     let post = atrium_api::app::bsky::feed::post::RecordData {
                                         created_at: atrium_api::types::string::Datetime::now(),
-                                        embed: None,
+                                        embed,
                                         entities: None,
                                         facets: Some(vec![
                                             atrium_api::app::bsky::richtext::facet::MainData {
···
 }
 
 async fn render_with_chromiumoxide(
+    browser: &Browser,
     html: &str,
     width: u32,
     height: u32,
 ) -> Result<Vec<u8>, anyhow::Error> {
-    // Configure and launch the browser
-
-    let cfg = BrowserConfig::builder()
-        .headless_mode(HeadlessMode::New)
-        .no_sandbox()
-        .build()
-        .map_err(|e| anyhow::anyhow!(e))
-        .expect("build browser config");
-
-    let (mut browser, mut browser_handler) = Browser::launch(cfg).await.expect("launch browser");
-
-    let handle = tokio::task::spawn(async move {
-        loop {
-            match browser_handler.next().await {
-                Some(h) => match h {
-                    Ok(_) => continue,
-                    Err(_) => break,
-                },
-                None => break,
-            }
-        }
-    });
-
+    // Use the long-running browser to render a page and capture a screenshot
     let page = browser.new_page("about:blank").await?;
 
     // Load the provided HTML as a data URL to avoid external fetches
     let data_url = format!("data:text/html;charset=utf-8,{}", urlencoding::encode(html));
     page.goto(data_url).await?;
 
-    // Wait for network idle-ish
+    // Wait for navigation to settle
     page.wait_for_navigation().await.ok();
 
     // Screenshot: clip to desired viewport size regardless of page layout
···
         .build();
     let png_bytes = page.screenshot(params).await?;
 
-    // Close
+    // Close just the page; keep the browser alive
     page.close().await.ok();
-    browser.close().await.ok();
-    // stop handler task
-    handle.await?;
+
     Ok(png_bytes)
 }