polish

Cargo.lock

···
 ]
 
 [[package]]
-name = "jacquard-talk"
-version = "0.1.0"
-dependencies = [
- "async-channel 2.5.0",
- "async-tungstenite",
- "bevy",
- "bevy-tokio-tasks",
- "bevy_brp_extras",
- "bevy_hanabi",
- "bevy_panorbit_camera",
- "bytes",
- "crossbeam-channel",
- "crossbeam-queue",
- "futures-timer",
- "futures-util",
- "http",
- "jacquard",
- "jacquard-common",
- "log",
- "pulldown-cmark",
- "rand 0.10.0",
- "rand_chacha 0.10.0",
- "reqwest",
- "rusqlite",
- "serde",
- "serde_json",
- "smol",
- "smol_str 0.3.6",
- "surf",
- "tokio",
-]
-
-[[package]]
 name = "jni"
 version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
 dependencies = [
  "libc",
+]
+
+[[package]]
+name = "magic"
+version = "0.1.0"
+dependencies = [
+ "async-channel 2.5.0",
+ "async-tungstenite",
+ "bevy",
+ "bevy-tokio-tasks",
+ "bevy_brp_extras",
+ "bevy_hanabi",
+ "bevy_panorbit_camera",
+ "bytes",
+ "crossbeam-channel",
+ "crossbeam-queue",
+ "futures-timer",
+ "futures-util",
+ "http",
+ "jacquard",
+ "jacquard-common",
+ "log",
+ "pulldown-cmark",
+ "rand 0.10.0",
+ "rand_chacha 0.10.0",
+ "reqwest",
+ "rusqlite",
+ "serde",
+ "serde_json",
+ "smol",
+ "smol_str 0.3.6",
+ "surf",
+ "tokio",
 ]
 
 [[package]]

Cargo.toml

···
 [package]
-name = "jacquard-talk"
+name = "magic"
 version = "0.1.0"
 edition = "2024"
 

Dioxus.toml

···
+[application]
+
+# Web `build` & `serve` dist path
+out_dir = "dist"
+
+# resource (static) file folder
+asset_dir = "public"
+
+[web.wasm_opt]
+# The level wasm-opt should target. z is the smallest. 4 is the fastest.
+level = "4"
+
+[web.app]
+
+# HTML title tag content
+title = "Dioxus | An elegant GUI library for Rust"
+
+[web.watcher]
+
+index_on_404 = true
+
+watch_path = ["src", "examples"]
+
+[bundle]
+# Bundle identifier
+identifier = "io.github.magic"
+
+# Bundle publisher
+publisher = "magic"
+
+# Bundle icon
+icon = ["icons/icon.png"]
+
+# Bundle resources
+resources = ["public/*"]
+
+# Bundle copyright
+copyright = ""
+
+# Bundle category
+category = "Utility"
+
+# Bundle short description
+short_description = "An amazing dioxus application."
+
+# Bundle long description
+long_description = """
+An amazing dioxus application.
+"""

assets/slides.md

···
-# Jacquard Talk
+# Jacquard Magic
+
+Making atproto actually easy with Rust
+
+---
+
+## Spite-driven development
+
+- Existing atproto libraries kinda sucked to work with
+- Couple of notable exceptions, but none in Rust
+- Put a project on hold because I got frustrated with atrium
+- Friends working on atproto stuff in Rust had similar frustrations
+
+---
+
+## Code Generation
+
+- Going from lexicon to app, generate API bindings
+- Then spend way more time (or LLM tokens) writing code around them to make them usable
+
+---
 
-Real-time 3D visualization of the AT Protocol firehose
+Not just an atproto problem, but hurts more here, especially for those not wanting to just play in Bluesky's sandbox.
 
 ---
 
-## What is the AT Protocol?
+# We don't have to live like this
 
-- A federated social networking protocol
-- **Jetstream** provides a real-time WebSocket firehose
-- Every post, like, follow, and identity event flows through it
+
+---
+
+## Why Rust?
+
+Only language where you can actually run it anywhere 
+
+and it's not a stupid idea to.
+
+---
+
+## Why Rust?
+
+- Rust has a reputation as a difficult and demanding language
+- That reputation is sort of deserved
+
+
+---
+
+## Why Rust?
+
+- The things Rust asks of you are things you often need to think about anyway
+- It just makes them explicit
+- We can make the sharp edges easier, if we care to
+
+--- 
+
+# We don't have to live like this!
 
 ---
 
 ## What you're seeing
 
-- Each **particle** is a real event from the network
-- Blue = posts, pink = likes, green = follows
-- Gold = non-Bluesky AT Protocol events
-- The helix maps **time** to **space**
+- Each dot is a Jetstream event
+- When you select one, we hit 
+  - Constellation for interactions
+  - Slingshot for records
+  - Bluesky appview for profiles
 
 ---
 
-## The Stack
+# But...
 
-- **Bevy** for 3D rendering and ECS
-- **Jacquard** for AT Protocol types
-- **bevy_hanabi** for GPU particle effects
-- **SQLite** for offline replay
-- All async runs on **smol**, not tokio
+
+---
+
+## HOW?
+
+- Standing upon the shoulders of giants here
+- Big party trick is the **subsecond** library
+- Bevy engine with hot patch support
+
 
 ---
 

src/db.rs

···
 //! SQLite persistence layer for Jetstream events.
-//!
-//! Two dedicated OS threads, each with its own connection to the same DB file:
-//! - **Writer thread**: handles batch inserts. Never blocks on reads.
-//! - **Reader thread**: handles queries. Never blocks on writes.
-//!
-//! SQLite WAL mode allows concurrent reads alongside a single writer.
-//! Splitting the threads eliminates read/write contention that caused
-//! periodic hitching when both operations shared a single thread.
 
 use bevy::prelude::*;
 use crossbeam_channel::{Receiver, Sender};
 use jacquard::types::string::{Did, Nsid};
 use rusqlite::{Connection, params};
 
-// ---------------------------------------------------------------------------
-// Request / response types
-// ---------------------------------------------------------------------------
-
-/// Write requests — handled by the dedicated writer thread.
 pub enum DbWriteRequest {
     WriteEvents(Vec<DbEvent>),
 }
 
-/// Read requests — handled by the dedicated reader thread.
 pub enum DbReadRequest {
     QueryTimeRange {
         start_us: i64,
···
     pub message_json: String,
 }
 
-/// Combined resource for backward compatibility with code that uses `DbChannel`.
 #[derive(Resource, Clone)]
 pub struct DbChannel {
     pub writer: Sender<DbWriteRequest>,
     pub reader: Sender<DbReadRequest>,
 }
 
-// ---------------------------------------------------------------------------
-// Schema
-// ---------------------------------------------------------------------------
-
 const CREATE_EVENTS_TABLE: &str = "
 CREATE TABLE IF NOT EXISTS events (
     id           INTEGER PRIMARY KEY,
···
     "CREATE INDEX IF NOT EXISTS idx_events_collection ON events(collection);";
 const CREATE_IDX_DID: &str = "CREATE INDEX IF NOT EXISTS idx_events_did ON events(did);";
 
-// ---------------------------------------------------------------------------
-// Startup
-// ---------------------------------------------------------------------------
-
 pub fn spawn_db_thread(mut commands: Commands) {
     let (write_tx, write_rx) = crossbeam_channel::bounded::<DbWriteRequest>(256);
     let (read_tx, read_rx) = crossbeam_channel::bounded::<DbReadRequest>(64);
 
-    // Writer thread — dedicated connection for inserts
     std::thread::spawn(move || {
         run_writer(write_rx);
     });
 
-    // Reader thread — dedicated connection for queries
     std::thread::spawn(move || {
         run_reader(read_rx);
     });
···
     info!("SQLite writer + reader threads started");
 }
 
-// ---------------------------------------------------------------------------
-// Writer thread
-// ---------------------------------------------------------------------------
-
 fn run_writer(rx: Receiver<DbWriteRequest>) {
     let conn = match open_and_init() {
         Some(c) => c,
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Reader thread
-// ---------------------------------------------------------------------------
-
 fn run_reader(rx: Receiver<DbReadRequest>) {
     let conn = match open_and_init() {
         Some(c) => c,
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
 fn open_and_init() -> Option<Connection> {
     let conn = match Connection::open("jetstream_events.db") {
         Ok(c) => c,
···
     conn.execute_batch(CREATE_IDX_DID)?;
     Ok(())
 }
-
-// ---------------------------------------------------------------------------
-// SQL operations
-// ---------------------------------------------------------------------------
 
 fn write_events(conn: &Connection, events: &[DbEvent]) -> rusqlite::Result<()> {
     if events.is_empty() {

src/event_card.rs

···
+use bevy::asset::Handle;
+use bevy::image::{ImageFormatSetting, ImageLoaderSettings};
 use bevy::prelude::*;
 
 use jacquard::Data;
 use jacquard::jetstream::JetstreamMessage;
 use jacquard::types::collection::Collection;
-use jacquard::types::string::Nsid;
+use jacquard::types::string::{AtUri, Nsid};
+
+use jacquard::client::AgentSessionExt;
 
 use crate::ingest::JetstreamEventMarker;
 use crate::interaction::SelectedEvent;
-
-// ---------------------------------------------------------------------------
-// Marker components — one per UI section so the update system can target them
-// ---------------------------------------------------------------------------
+use smol_str::ToSmolStr;
 
 /// Root node of the event detail card.
 #[derive(Component)]
···
     pub last_record_gen: u64,
     /// Tracks which slide was last rendered (for change detection).
     pub last_slide_index: Option<usize>,
+    /// Bumped when slide content changes (hot-reload), forces re-render.
+    pub slide_generation: u64,
+    pub last_slide_generation: u64,
 }
 
-// ---------------------------------------------------------------------------
-// Content tree: semantic representation of card content
-// ---------------------------------------------------------------------------
-
 /// Top-level content produced by dispatch_card_content.
 pub enum CardContent {
     Post {
···
 
 impl CardContent {
     /// Flatten the content tree into a primary display string.
-    /// Used for the main content text area.
-    /// Primary text for the content area. Empty for types that use the subject section.
     pub fn primary_text(&self) -> String {
         match self {
             CardContent::Post { text, .. } => text.clone(),
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// UI setup
-// ---------------------------------------------------------------------------
-
-/// Startup system: spawn the detail card UI hierarchy.
-///
-/// The card starts hidden (`Display::None`) and is shown by `update_detail_card`
-/// (Task 3) when an event is selected. The card is positioned absolute in the
-/// top-right of the screen.
+/// Spawn the detail card UI hierarchy. Starts hidden.
 ///
-/// Hierarchy:
-/// ```
-/// Card container (absolute, right:20, top:20, 400px wide, dark background)
-/// ├── Author row (horizontal flex, align_items: Center)
-/// │   ├── Avatar image (48x48, grey placeholder)
-/// │   └── Name column (vertical flex)
-/// │       ├── Display name (white, 16px)
-/// │       └── Handle (grey, 13px)
-/// ├── Content area (top padding 4px)
-/// │   └── Post text (white, 14px, wrapping)
-/// ├── Collection label (grey, 11px)
-/// └── Timestamp label (grey, 11px)
+/// ```text
+/// Card (absolute, right:16, top:16, 520px)
+/// ├── Author row (avatar + name column)
+/// ├── Content text
+/// ├── Embed section (images / quoted post / external link)
+/// ├── Subject section (liked post / followed user)
+/// ├── Stats row
+/// ├── Footer (collection label + timestamp)
 /// ```
 pub fn setup_detail_card(mut commands: Commands, font: Res<crate::UiFont>) {
     // Blueprint palette — cyan glow
···
                     ..default()
                 })
                 .with_children(|col| {
-                    col.spawn((
-                        DisplayNameText,
-                        Text::new("—"),
-                        make_font(13.0),
-                        bright,
-                    ));
-                    col.spawn((
-                        HandleText,
-                        Text::new("—"),
-                        make_font(11.0),
-                        dim,
-                    ));
+                    col.spawn((DisplayNameText, Text::new("—"), make_font(13.0), bright));
+                    col.spawn((HandleText, Text::new("—"), make_font(11.0), dim));
                 });
             });
 
···
                         BorderColor::all(border_color),
                     ))
                     .with_children(|qp| {
-                        qp.spawn((
-                            QuotedPostAuthor,
-                            Text::new(""),
-                            make_font(10.0),
-                            dim,
-                        ));
+                        qp.spawn((QuotedPostAuthor, Text::new(""), make_font(10.0), dim));
                         qp.spawn((
                             QuotedPostText,
                             Text::new(""),
···
                             },
                             ImageNode::default(),
                         ));
-                        ext.spawn((
-                            ExternalLinkTitle,
-                            Text::new(""),
-                            make_font(11.0),
-                            bright,
-                        ));
+                        ext.spawn((ExternalLinkTitle, Text::new(""), make_font(11.0), bright));
                         ext.spawn((
                             ExternalLinkDescription,
                             Text::new(""),
···
                 BorderColor::all(border_color),
             ))
             .with_children(|subj| {
-                subj.spawn((
-                    SubjectLabel,
-                    Text::new(""),
-                    make_font(10.0),
-                    dim,
-                ));
-                subj.spawn((
-                    SubjectAuthor,
-                    Text::new(""),
-                    make_font(10.0),
-                    dim,
-                ));
+                subj.spawn((SubjectLabel, Text::new(""), make_font(10.0), dim));
+                subj.spawn((SubjectAuthor, Text::new(""), make_font(10.0), dim));
                 subj.spawn((
                     SubjectContent,
                     Text::new(""),
···
                 },
             ))
             .with_children(|stats| {
-                stats.spawn((
-                    StatsText,
-                    Text::new(""),
-                    make_font(10.0),
-                    dim,
-                ));
+                stats.spawn((StatsText, Text::new(""), make_font(10.0), dim));
             });
 
             // --- Separator ---
···
                 ..default()
             })
             .with_children(|footer| {
-                footer.spawn((
-                    CollectionLabel,
-                    Text::new(""),
-                    make_font(10.0),
-                    dim,
-                ));
-                footer.spawn((
-                    TimestampLabel,
-                    Text::new(""),
-                    make_font(10.0),
-                    dim,
-                ));
+                footer.spawn((CollectionLabel, Text::new(""), make_font(10.0), dim));
+                footer.spawn((TimestampLabel, Text::new(""), make_font(10.0), dim));
             });
 
             // --- Slide content container (hidden by default) ---
···
     let last_slide = world.resource::<CardRenderState>().last_slide_index;
 
     if let Some(index) = slide_index {
-        if last_slide == Some(index) {
+        let slide_gen = world.resource::<CardRenderState>().slide_generation;
+        let last_slide_gen = world.resource::<CardRenderState>().last_slide_generation;
+        if last_slide == Some(index) && slide_gen == last_slide_gen {
             return;
         }
+        world
+            .resource_mut::<CardRenderState>()
+            .last_slide_generation = slide_gen;
         world.resource_mut::<CardRenderState>().last_slide_index = Some(index);
 
         let slide = {
···
                 // Label based on collection
                 let label = match &event.0 {
                     JetstreamMessage::Commit { commit, .. } => {
-                        let short = commit.collection.as_str().rsplit('.').next()
+                        let short = commit
+                            .collection
+                            .as_str()
+                            .rsplit('.')
+                            .next()
                             .unwrap_or(commit.collection.as_str());
                         // capitalize first letter
                         let mut label = short.to_string();
···
     world.resource_mut::<SelectedEvent>().previous_entity = Some(entity);
 }
 
-// ---------------------------------------------------------------------------
-// World helpers for the exclusive system
-// ---------------------------------------------------------------------------
-
 fn set_text<M: Component>(world: &mut World, value: &str) {
     let mut q = world.query_filtered::<&mut Text, With<M>>();
     for mut text in q.iter_mut(world) {
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Slide presentation helpers
-// ---------------------------------------------------------------------------
-
 fn set_card_presentation_mode(world: &mut World, presentation: bool) {
     let mut q = world.query_filtered::<&mut Node, With<DetailCard>>();
     for mut node in q.iter_mut(world) {
···
                     .id();
                 world.entity_mut(row).add_child(bullet);
 
-                let text_node =
-                    spawn_styled_spans(world, &font_handle, spans, 28.0, bright, dim);
+                let text_node = spawn_styled_spans(world, &font_handle, spans, 28.0, bright, dim);
                 world.entity_mut(row).add_child(text_node);
 
                 world.entity_mut(content_entity).add_child(row);
···
 
 fn spawn_styled_spans(
     world: &mut World,
-    font: &bevy::asset::Handle<bevy::text::Font>,
+    font: &Handle<bevy::text::Font>,
     spans: &[crate::slides::StyledSpan],
     font_size: f32,
     bright: Color,
···
         .id()
 }
 
-fn load_cdn_image(world: &World, did: &str, cid: &str) -> bevy::asset::Handle<Image> {
+fn load_cdn_image(world: &World, did: &str, cid: &str) -> Handle<Image> {
     let url = bsky_cdn_url(did, cid);
     let server = world.resource::<AssetServer>();
-    server.load_with_settings::<Image, bevy::image::ImageLoaderSettings>(
+    server.load_with_settings::<Image, ImageLoaderSettings>(
         url,
-        |settings: &mut bevy::image::ImageLoaderSettings| {
-            settings.format = bevy::image::ImageFormatSetting::Guess;
+        |settings: &mut ImageLoaderSettings| {
+            settings.format = ImageFormatSetting::Guess;
         },
     )
 }
···
     }
 }
 
-
-
-
-
 /// Build a bsky CDN URL for an image blob.
 pub fn bsky_cdn_url(did: &str, cid: &str) -> String {
     format!("https://cdn.bsky.app/img/feed_thumbnail/plain/{did}/{cid}@jpeg")
···
 pub struct CachedProfile {
     pub display_name: Option<String>,
     pub handle: String,
-    pub avatar_handle: Option<bevy::asset::Handle<Image>>,
+    pub avatar_handle: Option<Handle<Image>>,
 }
 
 /// Resource: cache of resolved profiles, keyed by DID.
···
 }
 
 impl ProfileCache {
-    pub fn bump(&mut self) { self.generation += 1; }
+    pub fn bump(&mut self) {
+        self.generation += 1;
+    }
 }
 
 /// Tracks debounce state for profile requests.
···
     pub last_did_change: f32,
 }
 
-// ---------------------------------------------------------------------------
-// Record cache: fetched records and engagement stats
-// ---------------------------------------------------------------------------
-
 /// A cached AT Protocol record fetched via slingshot.
 pub struct CachedRecord {
     pub data: Data,
···
 }
 
 impl RecordCache {
-    pub fn bump(&mut self) { self.generation += 1; }
+    pub fn bump(&mut self) {
+        self.generation += 1;
+    }
 }
-
-// ---------------------------------------------------------------------------
-// Constellation XRPC types
-// ---------------------------------------------------------------------------
 
 use jacquard::{BosStr, DefaultStr, IntoStatic, XrpcRequest};
 use serde::{Deserialize, Serialize};
···
                             Ok(response) => match response.into_output() {
                                 Ok(output) => {
                                     let profile = output.value;
-                                    let display_name: Option<String> = profile.display_name.as_ref().map(|s| {
-                                        let s: &str = s.as_ref();
-                                        s.to_owned()
-                                    });
+                                    let display_name: Option<String> =
+                                        profile.display_name.as_ref().map(|s| {
+                                            let s: &str = s.as_ref();
+                                            s.to_owned()
+                                        });
                                     let handle = profile.handle.as_str().to_owned();
                                     let avatar_url = profile.avatar.as_ref().map(|uri| {
                                         let mut url = uri.as_str().to_owned();
···
                                 Some((display_name, handle, avatar_url)) => {
                                     let avatar_handle = avatar_url.as_ref().and_then(|url| {
                                         world.get_resource::<AssetServer>().map(|server| {
-                                            use bevy::image::{ImageFormatSetting, ImageLoaderSettings};
+                                            use bevy::image::{
+                                                ImageFormatSetting, ImageLoaderSettings,
+                                            };
                                             server.load_with_settings::<Image, ImageLoaderSettings>(
                                                 url.clone(),
                                                 |settings: &mut ImageLoaderSettings| {
···
                                         })
                                     });
                                     let mut cache = world.resource_mut::<ProfileCache>();
-                                    cache.profiles.insert(did_main, CachedProfile {
-                                        display_name, handle, avatar_handle,
-                                    });
+                                    cache.profiles.insert(
+                                        did_main,
+                                        CachedProfile {
+                                            display_name,
+                                            handle,
+                                            avatar_handle,
+                                        },
+                                    );
                                     cache.bump();
                                 }
                                 None => {
-                                    cache.profiles.insert(did_main, CachedProfile {
-                                        display_name: None, handle: String::new(), avatar_handle: None,
-                                    });
+                                    cache.profiles.insert(
+                                        did_main,
+                                        CachedProfile {
+                                            display_name: None,
+                                            handle: String::new(),
+                                            avatar_handle: None,
+                                        },
+                                    );
                                 }
                             }
-                        }).await;
+                        })
+                        .await;
                     });
                 }
             }
···
         let uri_clone = uri.clone();
 
         runtime.spawn_background_task(move |mut ctx| async move {
-            use jacquard::client::AgentSessionExt;
-
-            use smol_str::ToSmolStr;
-
-            let parsed = match jacquard::types::string::AtUri::new(uri_clone.to_smolstr()) {
+            let parsed = match AtUri::new(uri_clone.to_smolstr()) {
                 Ok(u) => u,
                 Err(e) => {
                     warn!("invalid AT-URI {uri_clone}: {e:?}");
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
 #[cfg(test)]
 mod tests {
     use super::*;
···
     };
     use jacquard::types::string::{Datetime, Did, Nsid, Rkey};
 
-    // -----------------------------------------------------------------------
-    // Helpers
-    // -----------------------------------------------------------------------
 
     fn make_post_marker(text: &str) -> JetstreamEventMarker {
         let did = Did::new_static("did:plc:testuser123456789").expect("valid DID");
···
         })
     }
 
-    // -----------------------------------------------------------------------
-    // dispatch_card_content
-    // -----------------------------------------------------------------------
 
     #[test]
     fn dispatch_routes_post_to_text_content() {
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // build_post_content
-    // -----------------------------------------------------------------------
 
     #[test]
     fn post_extracts_text_field() {
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // build_unknown_content
-    // -----------------------------------------------------------------------
 
     #[test]
     fn unknown_shows_collection_nsid() {
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // embed parsing
-    // -----------------------------------------------------------------------
 
     #[test]
     fn parse_image_embed() {

src/helix.rs

···
 use bevy::prelude::*;
 
-/// A Frenet-Serret frame: tangent, normal, binormal at a point on the helix.
+/// Frenet-Serret frame at a point on the helix.
 #[derive(Debug, Clone, Copy)]
 pub struct Frame {
     pub position: Vec3,
-    /// Tangent vector along the curve. Reserved for #[hot] use (e.g. particle
-    /// orientation) — suppress dead_code while the feature is in progress.
     #[allow(dead_code)]
     pub tangent: Vec3,
     pub normal: Vec3,
     pub binormal: Vec3,
 }
 
-/// Describes one level of the nested helix hierarchy.
 #[derive(Debug, Clone)]
 pub struct HelixLevel {
-    /// How many times this level wraps around its parent per unit of t.
     pub turns_per_parent: f32,
-    /// How many sample points to evaluate per turn for rendering.
     pub samples_per_turn: u32,
-    /// Display label for this level. Reserved for #[hot] UI overlays — suppress
-    /// dead_code while the feature is in progress.
     #[allow(dead_code)]
     pub label: &'static str,
-    /// Color for gizmo rendering.
     pub color: Color,
-    /// Extra multiplier on this level's coil radius. Default 1.0.
     pub radius_scale: f32,
 }
 
-/// The full hierarchy of nested helix levels.
-/// Outermost level is index 0 (hours), innermost is last (sub-second).
+/// Outermost level is index 0, innermost is last.
 #[derive(Resource, Debug, Clone)]
 pub struct HelixHierarchy {
     pub levels: Vec<HelixLevel>,
-    /// Fraction of parent radius used for child coil radius.
     pub fill_factor: f32,
-    /// Base radius of the outermost helix.
     pub base_radius: f32,
-    /// Vertical spacing per turn of the outermost helix (units per 1.0 of t).
     pub pitch_per_turn: f32,
 }
 
-/// Current focal time and active zoom level for the helix view.
-///
-/// `focal_time` is in the same unbounded t-space as eval_coil — one unit of t
-/// equals one turn of the outermost helix. It advances continuously as new
-/// events arrive (when auto_follow is true).
+/// 1 unit of focal_time = 1 outermost helix turn = 1 minute.
 #[derive(Resource, Debug)]
 pub struct HelixState {
-    /// Focal time in unbounded t-space (1 unit = 1 outermost turn).
     pub focal_time: f32,
-    /// Currently active zoom level index into HelixHierarchy.levels.
     pub active_level: usize,
-    /// Smooth interpolation target for active_level (float for animation).
     pub target_level: f32,
-    /// Continuous interpolated level for smooth alpha blending in visualization.
     pub interpolated_level: f32,
-    /// Whether focal_time should auto-advance to track the latest data.
     pub auto_follow: bool,
-    /// Time tracking speed: 1.0 = real-time, 0.0 = frozen.
-    /// When < 1.0, auto_follow lerps toward latest_t instead of snapping.
     pub time_scale: f32,
 }
 
-/// Create default helix hierarchy with sensible parameters.
-///
-/// One unit of t = one turn of the outermost helix = one minute of real time
-/// (configured via TimeWindow::MICROS_PER_TURN).
 pub fn default_hierarchy() -> HelixHierarchy {
     HelixHierarchy {
         levels: vec![
···
     }
 }
 
-/// Evaluate the helix frame at parameter t through all levels up to `level`.
-///
-/// Uses iterative Gram-Schmidt orthogonalization (following the time-helix
-/// reference implementation) instead of a fixed up-vector cross product.
-/// This avoids frame discontinuities when the tangent is near-parallel to
-/// any fixed axis.
-///
-/// t is unbounded — one unit = one turn of the outermost helix.
+/// Evaluate helix frame at t through all levels up to `level`.
+/// Uses iterative Gram-Schmidt to avoid frame discontinuities.
 pub fn eval_coil(t: f32, level: usize, hierarchy: &HelixHierarchy) -> Frame {
     use std::f32::consts::TAU;
 
···
     let theta = t * TAU;
     let (s, c) = theta.sin_cos();
 
-    // Level 0: base helix position and tangent
     let mut px = r * c;
     let mut py = t * p;
     let mut pz = r * s;
 
-    // Tangent = derivative of position w.r.t. t
     let mut dtx = -r * TAU * s;
     let mut dty = p;
     let mut dtz = r * TAU * c;
 
-    // Initial normal: radial direction (inward toward helix axis)
     let mut nx = -c;
     let mut ny = 0.0_f32;
     let mut nz = -s;
 
-    // Binormal from tangent × normal
     let t_len = (dtx * dtx + dty * dty + dtz * dtz).sqrt();
     let (mut tx, mut ty, mut tz) = (dtx / t_len, dty / t_len, dtz / t_len);
     let mut bx = ty * nz - tz * ny;
     let mut by = tz * nx - tx * nz;
     let mut bz = tx * ny - ty * nx;
 
-    // Iterate through child levels
     for lvl in 1..=level {
         let level_info = &hierarchy.levels[lvl];
 
···
             .product();
         let child_r = hierarchy.base_radius * depth_scale;
 
-        // Cumulative total turns at this level — product of all turns_per_parent up to here.
         let total_turns: f32 = hierarchy.levels[..=lvl]
             .iter()
             .map(|l| l.turns_per_parent)
···
         let (sa, ca) = alpha.sin_cos();
         let w = total_turns * TAU;
 
-        // Offset from parent along normal/binormal plane
         let dx = nx * child_r * ca + bx * child_r * sa;
         let dy = ny * child_r * ca + by * child_r * sa;
         let dz = nz * child_r * ca + bz * child_r * sa;
···
         py += dy;
         pz += dz;
 
-        // Update tangent: add derivative of the child offset
-        // d(offset)/dt = child_r * w * (-sin(alpha) * normal + cos(alpha) * binormal)
         let ex = -nx * child_r * sa * w + bx * child_r * ca * w;
         let ey = -ny * child_r * sa * w + by * child_r * ca * w;
         let ez = -nz * child_r * sa * w + bz * child_r * ca * w;
···
         ty = dty / t_len;
         tz = dtz / t_len;
 
-        // Gram-Schmidt: orthogonalize offset direction against new tangent
-        // to get the new normal (rotation-minimizing frame)
         let dot = dx * tx + dy * ty + dz * tz;
         let mut nnx = dx - dot * tx;
         let mut nny = dy - dot * ty;
···
         ny = nny;
         nz = nnz;
 
-        // Recompute binormal from tangent × normal
         bx = ty * nz - tz * ny;
         by = tz * nx - tx * nz;
         bz = tx * ny - ty * nx;
···
     }
 }
 
-/// Compute the 3D position on the helix where the camera should focus.
-/// Always tracks level 0 (outermost helix) so the camera doesn't jump
-/// when the user zooms between levels.
 pub fn compute_focal_point(state: &HelixState, hierarchy: &HelixHierarchy) -> Vec3 {
     let frame = eval_coil(state.focal_time, 0, hierarchy);
     frame.position
 }
 
-/// Precomputed helix geometry buffer. Computed once at startup and extended
-/// lazily as time progresses. Each frame, `draw_helix` just slices the
-/// visible window from this buffer — zero eval_coil calls per frame.
 #[derive(Resource)]
 pub struct HelixGeometry {
-    /// Per-level precomputed vertex buffers.
-    /// Each entry: (t_start, t_step, positions).
     pub levels: Vec<HelixLevelGeometry>,
-    /// How far ahead (in t-space) we've precomputed.
     pub precomputed_to: f32,
 }
 
···
     pub positions: Vec<Vec3>,
 }
 
-/// Samples per unit of t for each level when precomputing.
-/// Innermost levels get more samples for smoother curves.
 fn samples_per_t(level_idx: usize, hierarchy: &HelixHierarchy) -> f32 {
     let total_turns: f32 = hierarchy.levels[..=level_idx]
         .iter()
         .map(|l| l.turns_per_parent)
         .product();
-    // Each turn gets samples_per_turn points. Innermost level uses 64 for smoothness.
     let spt = if level_idx == hierarchy.levels.len() - 1 {
         64.0
     } else {
···
     total_turns * spt
 }
 
-/// How much t-space to precompute ahead of current time. Generous buffer
-/// so we don't need to extend frequently.
-const PRECOMPUTE_AHEAD: f32 = 30.0; // 30 minutes
-const PRECOMPUTE_BEHIND: f32 = 10.0; // 5 minutes behind
+const PRECOMPUTE_AHEAD: f32 = 30.0;
+const PRECOMPUTE_BEHIND: f32 = 10.0;
 
-/// Build the initial helix geometry buffer.
 pub fn setup_helix_geometry(mut commands: Commands, hierarchy: Res<HelixHierarchy>) {
     let t_start = -PRECOMPUTE_BEHIND;
     let t_end = PRECOMPUTE_AHEAD;
···
     });
 }
 
-/// Extend the precomputed buffer if focal_time is approaching the end.
 pub fn extend_helix_geometry(
     state: Res<HelixState>,
     hierarchy: Res<HelixHierarchy>,
     mut geometry: ResMut<HelixGeometry>,
 ) {
-    // Extend when we're within 5 minutes of the precomputed boundary.
     if state.focal_time + 5.0 < geometry.precomputed_to {
         return;
     }
···
     geometry.precomputed_to = new_end;
 }
 
-/// Cached retained gizmo state.
 #[derive(Resource)]
 pub struct HelixGizmoCache {
     pub last_focal_time: f32,
···
     }
 }
 
-/// Draw helix using retained GizmoAsset from precomputed geometry slices.
-/// All levels are visible. Rebuilds asset only when the view changes.
 pub fn draw_helix(
     mut commands: Commands,
     hierarchy: Res<HelixHierarchy>,
···
         }
     }
 
-    // Reuse handle — never leak assets
     match &cache.asset_handle {
         Some(h) => {
             let _ = gizmo_assets.insert(h.id(), gizmo);
···
 mod tests {
     use super::*;
 
-    // -----------------------------------------------------------------------
-    // Helpers
-    // -----------------------------------------------------------------------
 
     /// Assert all components of a Vec3 are finite (non-NaN and non-Inf).
     fn assert_finite(v: Vec3, label: &str) {
···
         );
     }
 
-    // -----------------------------------------------------------------------
-    // I1a: default_hierarchy() structure
-    // -----------------------------------------------------------------------
 
     #[test]
     fn default_hierarchy_has_three_levels_with_positive_params() {
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // I1b: eval_coil level-0 produces finite positions over a wide t range
-    // -----------------------------------------------------------------------
 
     #[test]
     fn eval_coil_level0_finite_for_extreme_t_values() {
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // I1c: Frame vectors are approximately orthonormal at level 0
-    // -----------------------------------------------------------------------
 
     #[test]
     fn eval_coil_level0_frame_is_orthonormal() {
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // I1d: eval_coil level-1 positions are offset from level-0 by ~child_radius
-    // -----------------------------------------------------------------------
 
     #[test]
     fn eval_coil_level1_offset_from_level0_by_child_radius() {
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // I1e: eval_coil level-1 produces finite positions
-    // -----------------------------------------------------------------------
 
     #[test]
     fn eval_coil_level1_finite_for_various_t_values() {

src/ingest.rs

···
 use bevy::prelude::*;
-use crossbeam_channel::Receiver;
+use crossbeam_channel::{Receiver, bounded};
 use crossbeam_queue::ArrayQueue;
 use futures_util::StreamExt;
-use jacquard::jetstream::JetstreamMessage;
+use jacquard::DefaultStr;
+use jacquard::jetstream::{JetstreamMessage, JetstreamParams};
 use jacquard::types::string::{Did, Nsid};
 use jacquard::xrpc::{BasicSubscriptionClient, SubscriptionClient};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicI64};
+use std::time::Duration;
 
 use crate::db::{DbChannel, DbEvent, DbReadRequest, DbWriteRequest};
 use crate::helix::{self, HelixHierarchy, HelixState};
 use crate::net::AsyncTungsteniteClient;
 
-// ---------------------------------------------------------------------------
-// Jetstream → Bevy event pipeline
-// ---------------------------------------------------------------------------
+use jacquard::api::app_bsky::feed::like::LikeRecord;
+use jacquard::api::app_bsky::feed::post::PostRecord;
+use jacquard::api::app_bsky::graph::follow::FollowRecord;
+use jacquard::common::types::collection::Collection;
 
-/// Type alias for events flowing from Jetstream → Bevy.
 pub type IngestEvent = JetstreamMessage;
 
-/// Lock-free bounded queue for Jetstream → Bevy communication.
-///
-/// Uses crossbeam's `ArrayQueue` with `force_push()` — when full, the oldest
-/// event is displaced. Truly lock-free (no mutex), both push and pop take `&self`.
-/// The producer runs at firehose speed on IoTaskPool; the consumer pops per frame.
+/// Lock-free ring buffer: producer force_push, consumer pops per frame.
 #[derive(Resource)]
 pub struct JetstreamChannels {
     pub queue: Arc<ArrayQueue<IngestEvent>>,
 }
 
-/// Shared mesh + material handles for the small dot rendered at each event position.
-/// Spawned once at startup; every event entity clones these handles (cheap, instanced).
 #[derive(Resource)]
 pub struct EventDotAssets {
     pub mesh: Handle<Mesh>,
···
     pub default_bsky: Handle<StandardMaterial>,
 }
 
-/// Shared time state written by the consumer task, read by Bevy systems.
-/// Updated for EVERY event (not just sampled ones) so time tracking is accurate.
 #[derive(Resource)]
 pub struct SharedTimeState {
-    pub anchor_us: Arc<std::sync::atomic::AtomicI64>,
-    pub latest_us: Arc<std::sync::atomic::AtomicI64>,
-    pub initialized: Arc<std::sync::atomic::AtomicBool>,
+    pub anchor_us: Arc<AtomicI64>,
+    pub latest_us: Arc<AtomicI64>,
+    pub initialized: Arc<AtomicBool>,
 }
 
-// ---------------------------------------------------------------------------
-// Task 5: Event Marker Component and Time Window Resource
-// ---------------------------------------------------------------------------
-
-/// Component wrapping a Jetstream event. Preserves the full JetstreamMessage enum.
-/// Commit events carry Did, CommitOperation, Nsid, Rkey, Data, Cid.
-/// Identity events carry Did, Handle, seq, time.
-/// Account events carry Did, active, status, seq, time.
-/// All types are owned on bos-beta — no lifetime parameters.
 #[derive(Component, Debug, Clone)]
 pub struct JetstreamEventMarker(pub JetstreamMessage);
 
 impl JetstreamEventMarker {
-    /// Extract the DID from any event variant.
     pub fn did(&self) -> &Did {
         match &self.0 {
             JetstreamMessage::Commit { did, .. } => did,
···
         }
     }
 
-    /// Extract time_us from any event variant.
     pub fn time_us(&self) -> i64 {
         match &self.0 {
             JetstreamMessage::Commit { time_us, .. } => *time_us,
···
         }
     }
 
-    /// Extract collection NSID (only for Commit events).
     pub fn collection(&self) -> Option<&Nsid> {
         match &self.0 {
             JetstreamMessage::Commit { commit, .. } => Some(&commit.collection),
···
         }
     }
 
-    /// Extract the record Data (only for Commit events that carry a record).
     pub fn record(&self) -> Option<&jacquard::Data> {
         match &self.0 {
             JetstreamMessage::Commit { commit, .. } => commit.record.as_ref(),
···
     }
 }
 
-/// Marker: this event entity needs a particle effect spawned.
-///
-/// Attached to every newly spawned event entity by `drain_jetstream_events`.
-/// Consumed and removed by `spawn_event_particles` after the effect child
-/// is attached.
 #[derive(Component)]
 pub struct NeedsParticle;
 
-/// Whether this event came from the live Jetstream feed or historical SQLite load.
-///
-/// Determines which effect variant to use:
-/// - `Live` → bloom outward (particles radiate away from helix surface)
-/// - `Historical` → bloom inward (particles converge onto the helix surface)
+/// Live = bloom outward, Historical = bloom inward.
 #[derive(Component, Debug, Clone, Copy, PartialEq)]
 pub enum EventSource {
     Live,
     Historical,
 }
 
-/// Maps absolute timestamps (microseconds) to unbounded helix t-space.
-///
-/// One unit of t = one turn of the outermost helix = MICROS_PER_TURN microseconds.
-/// `anchor_us` is set on first event. `t = (time_us - anchor_us) / MICROS_PER_TURN`.
-/// t is unbounded and grows continuously as time passes.
+/// `t = (time_us - anchor_us) / MICROS_PER_TURN`. 1 t-unit = 1 minute.
 #[derive(Resource, Debug)]
 pub struct TimeWindow {
     pub anchor_us: i64,
···
 }
 
 impl TimeWindow {
-    /// Microseconds per one unit of t (one outermost helix turn).
-    /// 60 seconds = one turn = one minute of real time.
     pub const MICROS_PER_TURN: f64 = 60_000_000.0;
 
     pub fn time_to_t(&self, time_us: i64) -> f32 {
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Task 4 & 5: Historical event loading resources
-// ---------------------------------------------------------------------------
-
-/// Tracks which microsecond time ranges have already been loaded from SQLite.
-///
-/// Stored as sorted, non-overlapping `(start_us, end_us)` intervals. Before
-/// triggering a new history query, callers check whether the desired range is
-/// already covered.
+/// Sorted, non-overlapping `(start_us, end_us)` intervals already loaded from SQLite.
 #[derive(Resource, Debug, Default)]
 pub struct LoadedRanges {
-    /// Sorted list of `(start_us, end_us)` intervals that have been loaded.
     pub ranges: Vec<(i64, i64)>,
 }
 
 impl LoadedRanges {
-    /// Returns `true` if the given range is fully covered by loaded intervals.
     pub fn is_covered(&self, start_us: i64, end_us: i64) -> bool {
         self.ranges
             .iter()
             .any(|(lo, hi)| *lo <= start_us && *hi >= end_us)
     }
 
-    /// Add a new range, merging with any overlapping/adjacent intervals.
     pub fn insert(&mut self, start_us: i64, end_us: i64) {
         self.ranges.push((start_us, end_us));
         self.ranges.sort_unstable_by_key(|r| r.0);
 
-        // Merge overlapping / adjacent intervals.
         let mut merged: Vec<(i64, i64)> = Vec::with_capacity(self.ranges.len());
         for (lo, hi) in self.ranges.drain(..) {
             if let Some(last) = merged.last_mut() {
-                // Overlap or adjacent (within 1 µs) → extend.
                 if lo <= last.1 + 1 {
                     last.1 = last.1.max(hi);
                     continue;
···
     }
 }
 
-/// State for in-flight history queries triggered by panning.
-///
-/// Holds the response receiver for the most recently sent `QueryTimeRange`
-/// request so that `poll_history_responses` can drain it each frame. Also
-/// records the queried range so it can be marked as loaded on receipt.
 #[derive(Resource, Default)]
 pub struct HistoryQueryState {
-    /// Response channel for the current in-flight query, if any.
     pub pending: Option<Receiver<Vec<Vec<rusqlite::types::Value>>>>,
-    /// The `(start_us, end_us)` range of the pending query (used to update
-    /// `LoadedRanges` once the response arrives).
     pub pending_range: Option<(i64, i64)>,
 }
 
-/// Sampling rate for high-volume event types (posts, likes).
-/// Only 1-in-N events are forwarded to the Bevy ring buffer.
-/// Everything goes to SQLite regardless.
 const SAMPLE_RATE: u64 = 10;
-
-/// Ring buffer capacity. When full, oldest events are silently overwritten
-/// by the producer — no backpressure, no blocking, no cascading drops.
 const RING_BUFFER_CAPACITY: usize = 1024;
 
-/// Spawn the Jetstream consumer task on IoTaskPool.
-///
-/// The consumer:
-/// 1. Queries SQLite for the latest cached cursor
-/// 2. Connects to Jetstream and subscribes
-/// 3. For EVERY event: updates time tracking atomics + batches to SQLite
-/// 4. For SAMPLED events only: writes to the ring buffer for Bevy to consume
-/// 5. Reconnects on error with cursor
-///
-fn emissive_mat(materials: &mut Assets<StandardMaterial>, base: Color, emissive: LinearRgba) -> Handle<StandardMaterial> {
+fn emissive_mat(
+    materials: &mut Assets<StandardMaterial>,
+    base: Color,
+    emissive: LinearRgba,
+) -> Handle<StandardMaterial> {
     materials.add(StandardMaterial {
         base_color: base,
         emissive,
···
     })
 }
 
-/// Create the shared mesh + materials for event dot markers.
-/// Emissive materials give dots a self-illuminated glow against the black background.
 pub fn setup_event_dots(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
···
     let mesh = meshes.add(Sphere::new(0.002).mesh().ico(2).unwrap());
     commands.insert_resource(EventDotAssets {
         mesh,
-        post: emissive_mat(&mut materials,
+        post: emissive_mat(
+            &mut materials,
             Color::srgb(0.08, 0.15, 0.4),
-            LinearRgba::new(0.2, 0.4, 1.5, 1.0)),
-        like: emissive_mat(&mut materials,
+            LinearRgba::new(0.2, 0.4, 1.5, 1.0),
+        ),
+        like: emissive_mat(
+            &mut materials,
             Color::srgb(0.4, 0.08, 0.25),
-            LinearRgba::new(1.5, 0.2, 0.8, 1.0)),
-        follow: emissive_mat(&mut materials,
+            LinearRgba::new(1.5, 0.2, 0.8, 1.0),
+        ),
+        follow: emissive_mat(
+            &mut materials,
             Color::srgb(0.08, 0.4, 0.2),
-            LinearRgba::new(0.2, 1.5, 0.4, 1.0)),
-        shiny: emissive_mat(&mut materials,
+            LinearRgba::new(0.2, 1.5, 0.4, 1.0),
+        ),
+        shiny: emissive_mat(
+            &mut materials,
             Color::srgb(0.4, 0.35, 0.08),
-            LinearRgba::new(1.5, 1.2, 0.2, 1.0)),
-        default_bsky: emissive_mat(&mut materials,
+            LinearRgba::new(1.5, 1.2, 0.2, 1.0),
+        ),
+        default_bsky: emissive_mat(
+            &mut materials,
             Color::srgb(0.15, 0.15, 0.2),
-            LinearRgba::new(0.4, 0.4, 0.5, 1.0)),
+            LinearRgba::new(0.4, 0.4, 0.5, 1.0),
+        ),
     });
 }
 
-/// Time tracking uses atomics so the main thread always has accurate time
-/// state even when it can't keep up with the full event rate.
 pub fn spawn_jetstream_consumer(mut commands: Commands, db_channel: Res<DbChannel>) {
     use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
 
···
 
             // Query latest cursor from SQLite for reconnection.
             let initial_cursor = {
-                let (resp_tx, resp_rx) = crossbeam_channel::bounded::<Option<i64>>(1);
+                let (resp_tx, resp_rx) = bounded::<Option<i64>>(1);
                 if db_reader
                     .send(DbReadRequest::GetLatestCursor {
                         response_tx: resp_tx,
···
 
             let sub_client = BasicSubscriptionClient::new(client, base_uri);
 
-            let params = jacquard::jetstream::JetstreamParams::<jacquard::DefaultStr>::new()
+            let params = JetstreamParams::<DefaultStr>::new()
                 .wanted_collections(vec![])
                 .compress(false)
                 .build();
···
                                     };
                                     cursor = Some(time_us);
 
-                                    // Update shared time state atomically — always, for every event.
                                     if !init_handle.load(Ordering::Relaxed) {
                                         anchor_handle.store(time_us, Ordering::Relaxed);
                                         init_handle.store(true, Ordering::Release);
                                     }
                                     latest_handle.fetch_max(time_us, Ordering::Relaxed);
 
-                                    // SQLite: batch ALL events.
                                     if let Some(db_event) = jetstream_to_db_event(&msg) {
                                         db_batch.push(db_event);
                                     }
 
-                                    // Ring buffer: sample high-volume events.
                                     let is_high_volume = match &msg {
                                         JetstreamMessage::Commit { commit, .. } => {
-                                            use jacquard::api::app_bsky::feed::like::LikeRecord;
-                                            use jacquard::api::app_bsky::feed::post::PostRecord;
-                                            use jacquard::common::types::collection::Collection;
                                             let col: &str = commit.collection.as_ref();
                                             col == <PostRecord as Collection>::NSID
                                                 || col == <LikeRecord as Collection>::NSID
···
                                         queue_handle.force_push(msg);
                                     }
 
-                                    // Flush DB batch on size or time threshold.
                                     if db_batch.len() >= 100
-                                        || last_flush.elapsed()
-                                            >= std::time::Duration::from_millis(500)
+                                        || last_flush.elapsed() >= Duration::from_millis(500)
                                     {
                                         flush_db_batch(&db_writer, &mut db_batch);
                                         last_flush = std::time::Instant::now();
···
                     }
                 }
 
-                futures_timer::Delay::new(std::time::Duration::from_secs(2)).await;
+                futures_timer::Delay::new(Duration::from_secs(2)).await;
             }
         })
         .detach();
 }
 
-// ---------------------------------------------------------------------------
-// SQLite batch helpers
-// ---------------------------------------------------------------------------
-
-/// Flush the accumulated batch to the SQLite worker and clear the buffer.
-///
-/// If the channel is full or closed, events are dropped with a warning rather
-/// than blocking the async consumer task.
 fn flush_db_batch(db_writer: &crossbeam_channel::Sender<DbWriteRequest>, batch: &mut Vec<DbEvent>) {
     if batch.is_empty() {
         return;
···
     }
 }
 
-/// Convert a `JetstreamMessage` into a `DbEvent` for SQLite persistence.
-///
-/// The entire message is serialized as JSON into `message_json` for a lossless
-/// round-trip. Indexed columns (`kind`, `did`, `time_us`, `collection`) are
-/// extracted separately so SQLite can filter efficiently without parsing JSON.
 fn jetstream_to_db_event(msg: &JetstreamMessage) -> Option<DbEvent> {
     let message_json = match serde_json::to_string(msg) {
         Ok(json) => json,
···
     })
 }
 
-/// Drain pre-filtered events from the ring buffer and spawn ECS entities.
-///
-/// The producer task (IoTaskPool) already sampled high-volume events and
-/// updated SharedTimeState atomics. This system just pops whatever's
-/// available and spawns entities — no filtering, no time bookkeeping.
-/// If a frame hitches, the ring buffer overwrites old events silently.
 pub fn drain_jetstream_events(
     mut commands: Commands,
     channels: Res<JetstreamChannels>,
···
 
         let dot_mat = match &event {
             JetstreamMessage::Commit { commit, .. } => {
-                use jacquard::api::app_bsky::feed::like::LikeRecord;
-                use jacquard::api::app_bsky::feed::post::PostRecord;
-                use jacquard::api::app_bsky::graph::follow::FollowRecord;
-                use jacquard::common::types::collection::Collection;
                 let col: &str = commit.collection.as_ref();
                 if col == <PostRecord as Collection>::NSID {
                     dot_assets.post.clone()
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Task 4: Load historical events on startup
-// ---------------------------------------------------------------------------
-
 /// Startup system: query SQLite for recent events and spawn them as historical entities.
-///
-/// This runs after `spawn_db_thread` and `spawn_jetstream_consumer`. It uses a
-/// blocking `recv()` which is acceptable at startup (the DB worker responds
-/// quickly to the MAX query). Events are placed on the helix with
-/// `EventSource::Historical` so the particle system shows reverse-bloom effects.
-///
-/// The query window: up to 1 hour before the most recent persisted event.
 pub fn load_historical_events(
     mut commands: Commands,
     db_channel: Res<DbChannel>,
···
     mut time_window: ResMut<TimeWindow>,
     mut loaded_ranges: ResMut<LoadedRanges>,
 ) {
-    // Step 1: get the latest cursor so we know where in time we are.
     let latest_us = {
-        let (resp_tx, resp_rx) = crossbeam_channel::bounded::<Option<i64>>(1);
+        let (resp_tx, resp_rx) = bounded::<Option<i64>>(1);
         if db_channel
             .reader
             .send(DbReadRequest::GetLatestCursor {
···
         return;
     };
 
-    // Step 2: compute the query window: last 1 hour = 3600 seconds.
-    const HISTORY_WINDOW_US: i64 = 60_000_000; // 1 minute in microseconds
+    const HISTORY_WINDOW_US: i64 = 60_000_000;
     let start_us = end_us - HISTORY_WINDOW_US;
 
     info!(
···
         start_us, end_us
     );
 
-    // Step 3: query the time range.
-    let (resp_tx, resp_rx) = crossbeam_channel::bounded::<Vec<Vec<rusqlite::types::Value>>>(1);
+    let (resp_tx, resp_rx) = bounded::<Vec<Vec<rusqlite::types::Value>>>(1);
     if db_channel
         .reader
         .send(DbReadRequest::QueryTimeRange {
···
         rows.len()
     );
 
-    // Step 4: initialize TimeWindow from historical data if not yet set.
     if !time_window.is_initialized
         && let Some(first_row) = rows.first()
         && let Some(t) = row_time_us(first_row)
···
         );
     }
 
-    // Step 5: spawn entities for all historical rows.
     let count =
         spawn_historical_entities(&mut commands, &rows, &hierarchy, &state, &mut time_window);
 
···
         count
     );
 
-    // Step 6: record this range as loaded so pan detection doesn't re-request it.
     loaded_ranges.insert(start_us, end_us);
 }
 
-// ---------------------------------------------------------------------------
-// Task 5: Poll for pan-triggered history query responses
-// ---------------------------------------------------------------------------
-
-/// Update system: drain any pending history query responses and spawn entities.
-///
-/// Each frame, checks if a pan-triggered `QueryTimeRange` has returned results.
-/// Spawns all historical entities from the response and marks the range as loaded.
 pub fn poll_history_responses(
     mut commands: Commands,
     mut query_state: ResMut<HistoryQueryState>,
···
                 count
             );
 
-            // Mark the queried range as loaded so we don't re-request it.
             if let Some((start_us, end_us)) = query_state.pending_range.take() {
                 loaded_ranges.insert(start_us, end_us);
             }
 
-            // Clear the pending receiver — the query is complete.
             query_state.pending = None;
         }
-        Err(crossbeam_channel::TryRecvError::Empty) => {
-            // Still waiting; nothing to do this frame.
-        }
+        Err(crossbeam_channel::TryRecvError::Empty) => {}
+
         Err(crossbeam_channel::TryRecvError::Disconnected) => {
             warn!("poll_history_responses: SQLite worker closed response channel");
             query_state.pending = None;
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-/// Extract `time_us` from a DB row.
-///
-/// The `time_us` column is index 3 (0-indexed: id=0, kind=1, did=2, time_us=3).
 pub fn row_time_us(row: &[rusqlite::types::Value]) -> Option<i64> {
     match row.get(3)? {
         rusqlite::types::Value::Integer(v) => Some(*v),
···
     }
 }
 
-/// Extract a text value from a DB row at the given column index.
 fn row_text(row: &[rusqlite::types::Value], idx: usize) -> Option<&str> {
     match row.get(idx)? {
         rusqlite::types::Value::Text(s) => Some(s.as_str()),
···
     }
 }
 
-/// Convert a DB row into a `JetstreamMessage`.
-///
-/// Columns: id(0), kind(1), did(2), time_us(3), collection(4), message_json(5).
-///
-/// Deserializes the full `JetstreamMessage` from `message_json` — lossless
-/// round-trip with no fabricated placeholder values.
 fn row_to_message(row: &[rusqlite::types::Value]) -> Option<JetstreamMessage> {
     let json = row_text(row, 5)?;
     match serde_json::from_str::<JetstreamMessage>(json) {
···
     }
 }
 
-/// Spawn ECS entities for a batch of DB rows.
-///
-/// Returns the number of entities successfully spawned. Rows that cannot be
-/// converted (missing required fields, unknown kind, etc.) are skipped with
-/// a warning rather than aborting the batch.
-///
-/// Each entity receives:
-/// - `JetstreamEventMarker` with the reconstructed message
-/// - `Transform` at the helix position for the event's `time_us`
-/// - `Visibility::default()` (required for particle hierarchy)
-/// - NO `NeedsParticle` — historical events skip particles on load (perf)
-/// - `EventSource::Historical`
 fn spawn_historical_entities(
     commands: &mut Commands,
     rows: &[Vec<rusqlite::types::Value>],
···
             continue;
         };
 
-        // Lazily initialize the TimeWindow if this is the first event we process.
         if !time_window.is_initialized {
             time_window.anchor_us = time_us;
             time_window.is_initialized = true;
···
 
         let frame = helix::eval_coil(t, hierarchy.levels.len() - 1, hierarchy);
 
-        // Historical events skip NeedsParticle — no point blooming particles
-        // for events already in the past. Particles can be added later if the
-        // user pans back to inspect this region.
         commands.spawn((
             JetstreamEventMarker(msg),
             Transform::from_translation(frame.position),
···
     count
 }
 
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
 #[cfg(test)]
 mod tests {
     use super::*;
···
     use jacquard::types::string::{Cid, Datetime, Did, Nsid, Rkey};
     use std::str::FromStr;
 
-    // -----------------------------------------------------------------------
-    // LoadedRanges::is_covered
-    // -----------------------------------------------------------------------
 
     #[test]
     fn is_covered_empty_ranges_returns_false() {
···
     fn is_covered_subset_of_loaded_range() {
         let mut ranges = LoadedRanges::default();
         ranges.insert(0, 1000);
-        // Any sub-range that fits inside should be covered.
         assert!(ranges.is_covered(100, 200));
         assert!(ranges.is_covered(0, 1000));
         assert!(ranges.is_covered(500, 999));
···
     fn is_covered_partial_overlap_returns_false() {
         let mut ranges = LoadedRanges::default();
         ranges.insert(100, 200);
-        // Extends beyond the loaded range on either side.
         assert!(!ranges.is_covered(50, 200));
         assert!(!ranges.is_covered(100, 250));
         assert!(!ranges.is_covered(50, 250));
···
         assert!(!ranges.is_covered(0, 50));
     }
 
-    // -----------------------------------------------------------------------
-    // LoadedRanges::insert
-    // -----------------------------------------------------------------------
 
     #[test]
     fn insert_single_range() {
···
         assert_eq!(ranges.ranges, vec![(100, 600)]);
     }
 
-    // -----------------------------------------------------------------------
-    // Serialization roundtrip: JetstreamMessage
-    // -----------------------------------------------------------------------
 
     fn make_commit_message() -> JetstreamMessage {
         let did = Did::new_static("did:plc:testuser123456789").expect("valid DID");

src/interaction.rs

···
     }
 }
 
-/// Pan past loaded range → trigger SQLite query (5 min either side of focal_time).
+/// Pan past loaded range -> trigger SQLite query (5 min either side of focal_time).
 pub fn check_pan_triggers_history_load(
     state: Res<HelixState>,
     time_window: Res<TimeWindow>,
···
     query_state.pending = Some(resp_rx);
     query_state.pending_range = Some((query_start, query_end));
 }
-
-// ---------------------------------------------------------------------------
-// Event picking
-// ---------------------------------------------------------------------------
 
 #[derive(Resource, Default)]
 pub struct SelectedEvent {

src/main.rs

···
         .init_resource::<ingest::LoadedRanges>()
         .init_resource::<ingest::HistoryQueryState>()
         .init_resource::<particles::CleanupTimer>()
+        .init_asset::<slides::SlideDeckAsset>()
+        .init_asset_loader::<slides::SlideDeckLoader>()
         .init_resource::<slides::SlideDeck>()
         .init_resource::<slides::SlideMode>()
         .insert_resource(ClearColor(Color::BLACK))
···
                 interaction::check_pan_triggers_history_load.after(interaction::drag_pan_time),
                 interaction::toggle_pause,
                 interaction::toggle_slow_time,
+                slides::sync_slide_deck,
                 slides::slide_navigation,
                 interaction::auto_follow_latest,
                 interaction::interpolate_zoom_level,

src/net.rs

···
-use async_tungstenite::async_tls::client_async_tls;
-use async_tungstenite::tungstenite;
+use std::sync::Arc;
+
+use async_tungstenite::tungstenite::protocol::frame;
+use async_tungstenite::tungstenite::{self, Utf8Bytes};
+use async_tungstenite::{async_tls::client_async_tls, tungstenite::Message};
 use bytes::Bytes;
 use futures_util::{SinkExt, StreamExt};
 use jacquard::{
     CloseCode, CloseFrame, StreamError, WebSocketClient, WebSocketConnection, WsMessage, WsSink,
-    WsStream, WsText,
+    WsStream, WsText, client::BasicClient,
 };
 use smol::net::TcpStream;
-
-// ---------------------------------------------------------------------------
-// Task 2: WebSocketClient using async-tungstenite + async-tls (rustls)
-// ---------------------------------------------------------------------------
 
 #[derive(Debug, Clone, Default)]
 pub struct AsyncTungsteniteClient;
···
     }
 }
 
-fn convert_to_ws_message(msg: tungstenite::Message) -> Option<WsMessage> {
+fn convert_to_ws_message(msg: Message) -> Option<WsMessage> {
     match msg {
-        tungstenite::Message::Text(utf8_bytes) => {
+        Message::Text(utf8_bytes) => {
             // Both Utf8Bytes and WsText wrap Bytes with UTF-8 invariant — zero-copy
             let bytes: Bytes = utf8_bytes.into();
             // Safety: tungstenite already validated UTF-8
···
                 WsText::from_bytes_unchecked(bytes)
             }))
         }
-        tungstenite::Message::Binary(data) => Some(WsMessage::Binary(data)),
-        tungstenite::Message::Close(frame) => {
+        Message::Binary(data) => Some(WsMessage::Binary(data)),
+        Message::Close(frame) => {
             let close_frame = frame.map(|f| {
                 let code = convert_close_code(f.code);
                 let reason_bytes: Bytes = f.reason.into();
···
     }
 }
 
-fn convert_from_ws_message(msg: WsMessage) -> tungstenite::Message {
-    use tungstenite::protocol::frame::Utf8Bytes;
+fn convert_from_ws_message(msg: WsMessage) -> Message {
     match msg {
         WsMessage::Text(text) => {
             // WsText → Bytes → Utf8Bytes, both already UTF-8 validated
             let bytes = text.into_bytes();
             // Safety: WsText guarantees UTF-8
-            tungstenite::Message::Text(unsafe { Utf8Bytes::from_bytes_unchecked(bytes) })
+            Message::Text(unsafe { Utf8Bytes::from_bytes_unchecked(bytes) })
         }
-        WsMessage::Binary(bytes) => tungstenite::Message::Binary(bytes),
+        WsMessage::Binary(bytes) => Message::Binary(bytes),
         WsMessage::Close(frame) => {
             let close_frame = frame.map(|f| {
                 let code: u16 = f.code.into();
-                tungstenite::protocol::frame::CloseFrame {
+                frame::CloseFrame {
                     code: code.into(),
                     reason: Utf8Bytes::from(f.reason.to_string()),
                 }
             });
-            tungstenite::Message::Close(close_frame)
+            Message::Close(close_frame)
         }
     }
 }
 
-fn convert_close_code(code: tungstenite::protocol::frame::coding::CloseCode) -> CloseCode {
-    use tungstenite::protocol::frame::coding::CloseCode as TC;
+fn convert_close_code(code: frame::coding::CloseCode) -> CloseCode {
+    use frame::coding::CloseCode as TC;
     match code {
         TC::Normal => CloseCode::Normal,
         TC::Away => CloseCode::Away,
···
     }
 }
 
-// ---------------------------------------------------------------------------
-// Task 3: reqwest::Client as a shared Bevy resource
-//
-// With bevy-tokio-tasks, we have a real tokio runtime. reqwest::Client runs
-// natively on tokio — no DNS issues, no runtime conflicts. jacquard provides
-// `impl HttpClient for reqwest::Client` via the `reqwest-client` feature.
-// ---------------------------------------------------------------------------
-
 use bevy::prelude::*;
 
 /// Shared AT Protocol client for XRPC calls.
-/// Uses jacquard's BasicClient — unauthenticated, reqwest-backed.
-/// Wrapped in Arc for sharing with tokio background tasks.
 #[derive(Resource, Clone)]
-pub struct AtpClient(pub std::sync::Arc<jacquard::client::BasicClient>);
+pub struct AtpClient(pub Arc<BasicClient>);
 
 pub fn setup_atp_client(mut commands: Commands) {
-    commands.insert_resource(AtpClient(std::sync::Arc::new(
-        jacquard::client::BasicClient::unauthenticated(),
-    )));
+    commands.insert_resource(AtpClient(Arc::new(BasicClient::unauthenticated())));
 }

src/particles.rs

···
 use bevy::prelude::*;
 use bevy::image::{Image, TextureFormatPixelInfo};
 use bevy_hanabi::prelude::*;
-// Use the hanabi Gradient explicitly to avoid ambiguity with bevy's UI Gradient
 use bevy_hanabi::Gradient as HanabiGradient;
 use jacquard::common::types::collection::Collection;
 
 use crate::helix::HelixState;
 use crate::ingest::{EventSource, JetstreamEventMarker, NeedsParticle, TimeWindow};
 
-/// Which zoom variant to use when selecting a particle effect.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ZoomVariant {
-    /// Helix levels 0–1 (hours, minutes): shorter lifetime, smaller size.
     Outer,
-    /// Helix levels 2–3 (seconds, sub-second): longer lifetime, larger size.
     Inner,
 }
 
 impl ZoomVariant {
-    /// Classify the current helix active level into a zoom variant.
     pub fn from_level(level: usize) -> Self {
-        if level <= 1 {
-            ZoomVariant::Outer
-        } else {
-            ZoomVariant::Inner
-        }
+        if level <= 1 { ZoomVariant::Outer } else { ZoomVariant::Inner }
     }
 }
 
-/// Per-zoom-variant live/historical effect handle pair.
 #[derive(Clone)]
 pub struct ZoomEffects {
     pub live: Handle<EffectAsset>,
     pub hist: Handle<EffectAsset>,
 }
 
-/// Outer (dense, short-lived) and inner (spread, long-lived) zoom variants for fallback effects.
 #[derive(Clone)]
 pub struct ZoomPair {
     pub outer: ZoomEffects,
···
 }
 
 impl ZoomPair {
-    /// Select the appropriate ZoomEffects variant for the given zoom level.
     pub fn select(&self, zoom: ZoomVariant) -> &ZoomEffects {
         match zoom {
             ZoomVariant::Outer => &self.outer,
···
     }
 }
 
-/// Particle effects keyed by NSID or NSID prefix. Longest prefix match wins.
+/// NSID-keyed particle effects. Longest prefix match wins.
 #[derive(Resource)]
 pub struct ParticleEffects {
-    /// Registered effects: (nsid_or_prefix, outer_variant, inner_variant).
-    /// Sorted by key length descending for longest-prefix matching.
     pub effects: Vec<(&'static str, ZoomEffects, ZoomEffects)>,
-    /// Fallback for unmatched app.bsky.* collections (other Bluesky event types).
-    /// Contains both outer and inner zoom variants.
     pub bsky_default: ZoomPair,
-    /// Distinctive "shiny" effect for non-Bluesky AT Protocol events
-    /// (Identity/Account events, etc. with no collection NSID).
     pub shiny: ZoomPair,
 }
 
 impl ParticleEffects {
-    /// Look up the effect pair for the given NSID and zoom variant.
     pub fn lookup(&self, collection_str: Option<&str>, zoom: ZoomVariant) -> &ZoomEffects {
         collection_str
             .and_then(|collection| {
···
     }
 }
 
-/// Bloom effect parameters for a single speed/lifetime/size/burst combination.
 #[derive(Clone, Copy)]
 pub struct BloomParams {
-    /// Radial speed: positive = outward (live), negative = inward (historical).
     pub speed: f32,
-    /// Particle lifetime in seconds.
     pub lifetime: f32,
-    /// Initial particle size.
     pub size: f32,
-    /// Number of particles in the one-shot burst.
     pub burst_count: f32,
 }
 
-/// Generate a soft radial gradient circle texture for particles.
-/// White center fading to transparent edges — gaussian-ish falloff.
+/// Soft radial gradient circle texture (gaussian-ish falloff).
 pub fn generate_soft_circle(images: &mut Assets<Image>) -> Handle<Image> {
     const SIZE: u32 = 32;
     let mut data = vec![0u8; (SIZE * SIZE * 4) as usize];
···
             let dx = x as f32 + 0.5 - center;
             let dy = y as f32 + 0.5 - center;
             let dist = (dx * dx + dy * dy).sqrt() / center;
-            // Smooth gaussian-ish falloff
             let alpha = (1.0 - dist * dist).max(0.0).powf(2.0);
             let i = ((y * SIZE + x) * 4) as usize;
-            data[i] = 255;     // R
-            data[i + 1] = 255; // G
-            data[i + 2] = 255; // B
-            data[i + 3] = (alpha * 255.0) as u8; // A
+            data[i] = 255;
+            data[i + 1] = 255;
+            data[i + 2] = 255;
+            data[i + 3] = (alpha * 255.0) as u8;
         }
     }
     images.add(Image::new(
···
     ))
 }
 
-/// Create a particle effect: soft round glowing particles.
-///
-/// `speed` is radial velocity: positive = outward (live), negative = inward (historical).
-/// Near-zero speed = particles just appear and fade in place.
 pub fn create_bloom_effect(gradient: HanabiGradient<Vec4>, params: BloomParams) -> EffectAsset {
     let writer = ExprWriter::new();
 
-    // Spawn particles within a tiny sphere
     let init_pos = SetPositionSphereModifier {
         center: writer.lit(Vec3::ZERO).expr(),
         radius: writer.lit(0.005).expr(),
         dimension: ShapeDimension::Volume,
     };
 
-    // Very slow drift velocity
     let init_vel = SetVelocitySphereModifier {
         center: writer.lit(Vec3::ZERO).expr(),
         speed: writer.lit(params.speed).expr(),
···
 
     let spawner = SpawnerSettings::once(params.burst_count.into());
 
-    // Size gradient: full size → 0 as particle ages
     let mut size_gradient = HanabiGradient::new();
     size_gradient.add_key(0.0, Vec3::splat(params.size));
     size_gradient.add_key(0.8, Vec3::splat(params.size * 0.5));
     size_gradient.add_key(1.0, Vec3::ZERO);
 
-    // Texture slot must be registered on the module before building the effect
     let slot_zero = writer.lit(0u32).expr();
     let mut module = writer.finish();
     module.add_texture_slot("particle");
···
         })
 }
 
-/// Build a two-key gradient: full-color at t=0, transparent at t=1.
-/// Values can exceed 1.0 for HDR bloom effect.
 fn fade_gradient(r: f32, g: f32, b: f32) -> HanabiGradient<Vec4> {
     let mut gradient = HanabiGradient::new();
     gradient.add_key(0.0, Vec4::new(r, g, b, 1.0));
···
     gradient
 }
 
-/// Build live+historical `ZoomEffects` for a single color and zoom variant.
-///
-/// `outward_speed` must be positive; the historical effect uses its negation
-/// so particles converge inward (settling onto the helix surface).
 fn make_zoom_effects(
     effects: &mut Assets<EffectAsset>,
     gradient: HanabiGradient<Vec4>,
···
     size: f32,
     burst_count: f32,
 ) -> ZoomEffects {
-    let live_params = BloomParams {
-        speed: outward_speed,
-        lifetime,
-        size,
-        burst_count,
-    };
-    let hist_params = BloomParams {
-        speed: -outward_speed,
-        lifetime,
-        size,
-        burst_count,
-    };
+    let live_params = BloomParams { speed: outward_speed, lifetime, size, burst_count };
+    let hist_params = BloomParams { speed: -outward_speed, lifetime, size, burst_count };
     ZoomEffects {
         live: effects.add(create_bloom_effect(gradient.clone(), live_params)),
         hist: effects.add(create_bloom_effect(gradient, hist_params)),
     }
 }
 
-/// Build the default NSID-keyed particle effects and return the resource.
-///
-/// Effect color scheme:
-/// - Posts: bright blue (HDR boosted for bloom)
-/// - Likes: hot pink
-/// - Follows: green
-/// - bsky_default: dim white (other Bluesky collections)
-/// - shiny: gold with larger burst and longer lifetime (non-Bluesky events)
-///
-/// Zoom variants:
-/// - Outer (level 0–1: hours/minutes): shorter lifetime (0.3 s), smaller size
-///   (0.025), slightly higher burst count to create a dense glow cloud
-/// - Inner (level 2–3: seconds/sub-second): longer lifetime (0.8 s), larger
-///   size (0.06), standard burst for individual event visibility
 pub fn register_default_effects(effects: &mut Assets<EffectAsset>) -> ParticleEffects {
-    // Soft round particles: slow drift, visible halos
-    //                       speed, lifetime, size, burst_count
-    // Soft round particles: slow drift, visible halos
-    //                       speed, lifetime, size, burst_count
-    // ---- Posts: blue glow ----
     let post_outer = make_zoom_effects(effects, fade_gradient(0.4, 0.8, 3.0), 0.0, 0.8, 0.008, 3.0);
     let post_inner = make_zoom_effects(effects, fade_gradient(0.4, 0.8, 3.0), 0.0, 1.2, 0.02, 4.0);
 
-    // ---- Likes: pink glow ----
     let like_outer = make_zoom_effects(effects, fade_gradient(3.0, 0.4, 1.5), 0.0, 0.8, 0.006, 3.0);
     let like_inner = make_zoom_effects(effects, fade_gradient(3.0, 0.4, 1.5), 0.0, 1.2, 0.015, 4.0);
 
-    // ---- Follows: teal glow ----
-    let follow_outer =
-        make_zoom_effects(effects, fade_gradient(0.3, 3.0, 1.0), 0.0, 0.8, 0.008, 4.0);
-    let follow_inner =
-        make_zoom_effects(effects, fade_gradient(0.3, 3.0, 1.0), 0.0, 1.2, 0.02, 5.0);
+    let follow_outer = make_zoom_effects(effects, fade_gradient(0.3, 3.0, 1.0), 0.0, 0.8, 0.008, 4.0);
+    let follow_inner = make_zoom_effects(effects, fade_gradient(0.3, 3.0, 1.0), 0.0, 1.2, 0.02, 5.0);
 
-    // ---- bsky default: cool dim ----
     let bsky_default = ZoomPair {
         outer: make_zoom_effects(effects, fade_gradient(1.2, 1.2, 1.5), 0.0, 0.6, 0.005, 2.0),
         inner: make_zoom_effects(effects, fade_gradient(1.2, 1.2, 1.5), 0.0, 1.0, 0.012, 3.0),
     };
 
-    // ---- Shiny: amber (non-Bluesky AT Protocol events) ----
     let mut gold_gradient = HanabiGradient::new();
     gold_gradient.add_key(0.0, Vec4::new(2.0, 1.5, 0.2, 0.7));
     gold_gradient.add_key(0.5, Vec4::new(1.5, 1.0, 0.1, 0.4));
···
         inner: make_zoom_effects(effects, gold_gradient, 0.0, 1.5, 0.025, 5.0),
     };
 
-    // Build the keyed lookup vec using Collection::NSID for type safety.
-    // Static str keys avoid any Nsid<S> generic complexity.
     let mut keyed: Vec<(&'static str, ZoomEffects, ZoomEffects)> = vec![
-        (
-            jacquard::api::app_bsky::feed::post::PostRecord::NSID,
-            post_outer,
-            post_inner,
-        ),
-        (
-            jacquard::api::app_bsky::feed::like::LikeRecord::NSID,
-            like_outer,
-            like_inner,
-        ),
-        (
-            jacquard::api::app_bsky::graph::follow::FollowRecord::NSID,
-            follow_outer,
-            follow_inner,
-        ),
+        (jacquard::api::app_bsky::feed::post::PostRecord::NSID, post_outer, post_inner),
+        (jacquard::api::app_bsky::feed::like::LikeRecord::NSID, like_outer, like_inner),
+        (jacquard::api::app_bsky::graph::follow::FollowRecord::NSID, follow_outer, follow_inner),
     ];
-
-    // Sort by key string length descending so the first match in a scan is
-    // always the longest (most specific) prefix match.
     keyed.sort_by_key(|item| std::cmp::Reverse(item.0.len()));
 
-    ParticleEffects {
-        effects: keyed,
-        bsky_default,
-        shiny,
-    }
+    ParticleEffects { effects: keyed, bsky_default, shiny }
 }
 
-/// Soft circle texture handle for particle rendering.
 #[derive(Resource)]
 pub struct ParticleTexture(pub Handle<Image>);
 
-/// Startup system: build all default particle effects and register the resource.
 pub fn setup_particle_effects(
     mut commands: Commands,
     mut effects: ResMut<Assets<EffectAsset>>,
···
     }
 }
 
-/// Resource tracking the current active zoom variant for particle selection.
 #[derive(Resource, Debug)]
 pub struct ZoomLevelState {
     pub current: ZoomVariant,
···
 
 impl Default for ZoomLevelState {
     fn default() -> Self {
-        ZoomLevelState {
-            current: ZoomVariant::Outer,
-        }
+        ZoomLevelState { current: ZoomVariant::Outer }
     }
 }
 
···
     let current = ZoomVariant::from_level(state.active_level);
     if zoom_state.current != current {
         zoom_state.current = current;
-        info!(
-            "zoom variant → {:?} (helix level {})",
-            current, state.active_level
-        );
+        info!("zoom variant → {:?} (helix level {})", current, state.active_level);
     }
 }
 
-/// Frame counter for throttling `cleanup_expired_events`.
 #[derive(Resource, Default)]
 pub struct CleanupTimer {
     frame_count: u32,
 }
 
-/// Marker attached to event entities once their particle child has been spawned.
 #[derive(Component)]
 pub struct SpawnedAt(pub f32);
 
-/// How long (seconds) to keep an event entity alive after its particle burst
-/// has completed, to allow GPU particles to finish fading.
-///
-/// This is set to 2 s — comfortably above the longest particle lifetime in our
-/// effects (shiny inner = 1.5 s) to ensure all emitted particles have expired.
 const PARTICLE_GRACE_SECS: f32 = 2.0;
-
-/// Maximum particle lifetime across all effect variants (shiny inner = 1.5 s).
-/// Used as the guaranteed minimum age before we consider a spawner "done emitting
-/// and all particles expired."
 const MAX_PARTICLE_LIFETIME_SECS: f32 = 1.5;
 
 pub fn cleanup_expired_events(
···
     window: Res<TimeWindow>,
     mut timer: ResMut<CleanupTimer>,
 ) {
-    // In unbounded t-space, 1 unit = 1 minute. Keep 2 minutes of data.
     const CLEANUP_MARGIN: f32 = 2.0;
 
-    // Throttle: only run every 30 frames. At 60 fps this is ~0.5 s, which is
-    // well within the 3.5 s minimum age before any entity becomes eligible.
     timer.frame_count += 1;
     if !timer.frame_count.is_multiple_of(30) {
         return;
···
     for (entity, event_marker, spawned_at) in event_query.iter() {
         let t = window.time_to_t(event_marker.time_us());
         let distance_from_focal = (t - state.focal_time).abs();
-        let is_off_screen = distance_from_focal > CLEANUP_MARGIN;
 
-        if !is_off_screen {
+        if distance_from_focal <= CLEANUP_MARGIN {
             continue;
         }
 
-        // If it has particles, wait for them to expire before despawning.
-        // If no particles (historical events), despawn immediately when off-screen.
         let should_despawn = match spawned_at {
-            Some(sa) => {
-                let age = now - sa.0;
-                age >= MAX_PARTICLE_LIFETIME_SECS + PARTICLE_GRACE_SECS
-            }
+            Some(sa) => (now - sa.0) >= MAX_PARTICLE_LIFETIME_SECS + PARTICLE_GRACE_SECS,
             None => true,
         };
 
···
     use super::*;
     use bevy::asset::Handle;
 
-    // -----------------------------------------------------------------------
-    // Helper: build a minimal ParticleEffects for testing the lookup logic.
-    //
-    // Uses Handle::default() for all asset handles — valid for testing the pure
-    // NSID matching logic without requiring a Bevy World or asset server.
-    // -----------------------------------------------------------------------
-
     fn dummy_zoom_effects() -> ZoomEffects {
         ZoomEffects {
             live: Handle::default(),
···
         }
     }
 
-    /// Build a ParticleEffects with post/like/follow registered, using the same
-    /// NSID constants the production code uses.
     fn test_particle_effects() -> ParticleEffects {
         use jacquard::api::app_bsky::feed::like::LikeRecord;
         use jacquard::api::app_bsky::feed::post::PostRecord;
···
         let mut keyed: Vec<(&'static str, ZoomEffects, ZoomEffects)> = vec![
             (PostRecord::NSID, dummy_zoom_effects(), dummy_zoom_effects()),
             (LikeRecord::NSID, dummy_zoom_effects(), dummy_zoom_effects()),
-            (
-                FollowRecord::NSID,
-                dummy_zoom_effects(),
-                dummy_zoom_effects(),
-            ),
+            (FollowRecord::NSID, dummy_zoom_effects(), dummy_zoom_effects()),
         ];
         keyed.sort_by_key(|item| std::cmp::Reverse(item.0.len()));
 
···
         }
     }
 
-    // -----------------------------------------------------------------------
-    // I2: NSID prefix matching tests
-    // -----------------------------------------------------------------------
-
     #[test]
     fn lookup_post_nsid_matches_post_entry() {
         use jacquard::api::app_bsky::feed::post::PostRecord;
         let effects = test_particle_effects();
-        // The lookup should return the post-specific ZoomEffects (outer variant).
-        // We can't compare Handle<EffectAsset> by value, so we verify the call
-        // doesn't fall through to bsky_default or shiny by checking it returns
-        // a different pointer than the dummy_zoom_pair singletons.
-        //
-        // Since all handles are Handle::default(), we use a pointer identity
-        // check on the returned ZoomEffects via their address.
         let result = effects.lookup(Some(PostRecord::NSID), ZoomVariant::Outer);
-        // The result must be one of the registered per-NSID entries, not bsky_default or shiny.
         let result_ptr = result as *const ZoomEffects;
         let bsky_ptr = effects.bsky_default.select(ZoomVariant::Outer) as *const ZoomEffects;
         let shiny_ptr = effects.shiny.select(ZoomVariant::Outer) as *const ZoomEffects;
-        assert_ne!(
-            result_ptr, bsky_ptr,
-            "post NSID matched bsky_default instead of post entry"
-        );
-        assert_ne!(
-            result_ptr, shiny_ptr,
-            "post NSID matched shiny instead of post entry"
-        );
+        assert_ne!(result_ptr, bsky_ptr, "post NSID matched bsky_default instead of post entry");
+        assert_ne!(result_ptr, shiny_ptr, "post NSID matched shiny instead of post entry");
     }
 
     #[test]
     fn lookup_unknown_bsky_collection_falls_to_bsky_default() {
         let effects = test_particle_effects();
-        // An unregistered app.bsky.* NSID should fall through to bsky_default.
         let result = effects.lookup(Some("app.bsky.actor.something"), ZoomVariant::Outer);
         let result_ptr = result as *const ZoomEffects;
         let bsky_ptr = effects.bsky_default.select(ZoomVariant::Outer) as *const ZoomEffects;
-        assert_eq!(
-            result_ptr, bsky_ptr,
-            "unknown app.bsky.* NSID should fall to bsky_default"
-        );
+        assert_eq!(result_ptr, bsky_ptr, "unknown app.bsky.* should fall to bsky_default");
     }
 
     #[test]
     fn lookup_non_bsky_collection_falls_to_shiny() {
         let effects = test_particle_effects();
-        // A non-bsky NSID (e.g. a third-party collection) should fall to shiny.
         let result = effects.lookup(Some("com.example.some.collection"), ZoomVariant::Outer);
         let result_ptr = result as *const ZoomEffects;
         let shiny_ptr = effects.shiny.select(ZoomVariant::Outer) as *const ZoomEffects;
···
     #[test]
     fn lookup_none_collection_falls_to_shiny() {
         let effects = test_particle_effects();
-        // None (Identity/Account events — no collection NSID) should fall to shiny.
         let result = effects.lookup(None, ZoomVariant::Outer);
         let result_ptr = result as *const ZoomEffects;
         let shiny_ptr = effects.shiny.select(ZoomVariant::Outer) as *const ZoomEffects;
-        assert_eq!(
-            result_ptr, shiny_ptr,
-            "None collection (Identity/Account) should fall to shiny"
-        );
+        assert_eq!(result_ptr, shiny_ptr, "None collection should fall to shiny");
     }
 
     #[test]
     fn lookup_inner_zoom_variant_selects_inner_effects() {
         let effects = test_particle_effects();
-        // Verify ZoomVariant::Inner returns the inner slot, not the outer.
         let result_outer = effects.lookup(None, ZoomVariant::Outer) as *const ZoomEffects;
         let result_inner = effects.lookup(None, ZoomVariant::Inner) as *const ZoomEffects;
-        assert_ne!(
-            result_outer, result_inner,
-            "outer and inner zoom variants should return different ZoomEffects"
-        );
+        assert_ne!(result_outer, result_inner, "outer and inner should return different ZoomEffects");
     }
 }

src/slides.rs

···
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, LoadContext};
 use bevy::prelude::*;
 use pulldown_cmark::{Event, HeadingLevel, Options, Parser, Tag, TagEnd, TextMergeStream};
+
 
 #[derive(Debug, Clone)]
 pub struct StyledSpan {
···
     pub fragments: Vec<SlideFragment>,
 }
 
+/// Bevy asset: a parsed slide deck loaded from a markdown file.
+#[derive(Asset, TypePath, Debug, Clone)]
+pub struct SlideDeckAsset {
+    pub slides: Vec<Slide>,
+}
+
+/// Resource mirror of the loaded slide deck, updated on asset changes.
 #[derive(Resource, Default)]
 pub struct SlideDeck {
     pub slides: Vec<Slide>,
 }
 
+/// Handle to the loaded slide deck asset.
+#[derive(Resource)]
+pub struct SlideDeckHandle(pub Handle<SlideDeckAsset>);
+
 /// `None` = normal event card, `Some(index)` = showing slide.
 #[derive(Resource, Default)]
 pub struct SlideMode(pub Option<usize>);
+
+
+#[derive(Default, TypePath)]
+pub struct SlideDeckLoader;
+
+impl AssetLoader for SlideDeckLoader {
+    type Asset = SlideDeckAsset;
+    type Settings = ();
+    type Error = std::io::Error;
+
+    async fn load(
+        &self,
+        reader: &mut dyn Reader,
+        _settings: &(),
+        _load_context: &mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = Vec::new();
+        reader.read_to_end(&mut bytes).await?;
+        let markdown =
+            String::from_utf8(bytes).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
+        let slides = parse_slide_deck(&markdown);
+        Ok(SlideDeckAsset { slides })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["md"]
+    }
+}
+
 
 fn parse_slide(markdown: &str) -> Slide {
     let options = Options::empty();
···
     slides
 }
 
-pub fn load_slide_deck(mut commands: Commands) {
-    let path = std::path::Path::new("assets/slides.md");
-    match std::fs::read_to_string(path) {
-        Ok(markdown) => {
-            let slides = parse_slide_deck(&markdown);
-            info!("Loaded slide deck: {} slides", slides.len());
-            commands.insert_resource(SlideDeck { slides });
+
+/// Startup: kick off the asset load.
+pub fn load_slide_deck(mut commands: Commands, asset_server: Res<AssetServer>) {
+    let handle = asset_server.load::<SlideDeckAsset>("slides.md");
+    commands.insert_resource(SlideDeckHandle(handle));
+}
+
+/// Sync the `SlideDeck` resource when the asset is loaded or hot-reloaded.
+pub fn sync_slide_deck(
+    mut events: MessageReader<AssetEvent<SlideDeckAsset>>,
+    assets: Res<Assets<SlideDeckAsset>>,
+    handle: Option<Res<SlideDeckHandle>>,
+    mut deck: ResMut<SlideDeck>,
+    mut render_state: ResMut<crate::event_card::CardRenderState>,
+) {
+    let Some(handle) = handle else { return };
+
+    for event in events.read() {
+        let id = match event {
+            AssetEvent::Added { id } | AssetEvent::Modified { id } => id,
+            _ => continue,
+        };
+
+        if *id != handle.0.id() {
+            continue;
         }
-        Err(e) => {
-            warn!("Could not load slides.md: {e}");
-            commands.insert_resource(SlideDeck::default());
+
+        if let Some(asset) = assets.get(*id) {
+            let count = asset.slides.len();
+            deck.slides = asset.slides.clone();
+            render_state.slide_generation += 1;
+            info!("Slide deck reloaded: {count} slides");
         }
     }
 }

src/widgets.rs

···
-//! Simple widgets for example UI.
-//!
-//! Unlike other examples, which demonstrate an application, this demonstrates a plugin library.
-
-use bevy::prelude::*;
-
-/// An event that's sent whenever the user changes one of the settings by
-/// clicking a radio button.
-#[derive(Clone, Message, Deref, DerefMut)]
-pub struct WidgetClickEvent<T>(T);
-
-/// A marker component that we place on all widgets that send
-/// [`WidgetClickEvent`]s of the given type.
-#[derive(Clone, Component, Deref, DerefMut)]
-pub struct WidgetClickSender<T>(T)
-where
-    T: Clone + Send + Sync + 'static;
-
-/// A marker component that we place on all radio `Button`s.
-#[derive(Clone, Copy, Component)]
-pub struct RadioButton;
-
-/// A marker component that we place on all `Text` inside radio buttons.
-#[derive(Clone, Copy, Component)]
-pub struct RadioButtonText;
-
-/// The size of the border that surrounds buttons.
-pub const BUTTON_BORDER: UiRect = UiRect::all(Val::Px(1.0));
-
-/// The color of the border that surrounds buttons.
-pub const BUTTON_BORDER_COLOR: BorderColor = BorderColor {
-    left: Color::WHITE,
-    right: Color::WHITE,
-    top: Color::WHITE,
-    bottom: Color::WHITE,
-};
-
-/// The amount of rounding to apply to button corners.
-pub const BUTTON_BORDER_RADIUS_SIZE: Val = Val::Px(6.0);
-
-/// The amount of space between the edge of the button and its label.
-pub const BUTTON_PADDING: UiRect = UiRect::axes(Val::Px(12.0), Val::Px(6.0));
-
-/// Returns a [`Node`] appropriate for the outer main UI node.
-///
-/// This UI is in the bottom left corner and has flex column support
-pub fn main_ui_node() -> Node {
-    Node {
-        flex_direction: FlexDirection::Column,
-        position_type: PositionType::Absolute,
-        row_gap: px(6),
-        left: px(10),
-        bottom: px(10),
-        ..default()
-    }
-}
-
-/// Spawns a single radio button that allows configuration of a setting.
-///
-/// The type parameter specifies the value that will be packaged up and sent in
-/// a [`WidgetClickEvent`] when the radio button is clicked.
-pub fn option_button<T>(
-    option_value: T,
-    option_name: &str,
-    is_selected: bool,
-    is_first: bool,
-    is_last: bool,
-) -> impl Bundle
-where
-    T: Clone + Send + Sync + 'static,
-{
-    let (bg_color, fg_color) = if is_selected {
-        (Color::WHITE, Color::BLACK)
-    } else {
-        (Color::BLACK, Color::WHITE)
-    };
-
-    // Add the button node.
-    (
-        Button,
-        Node {
-            border: BUTTON_BORDER.with_left(if is_first { px(1) } else { px(0) }),
-            justify_content: JustifyContent::Center,
-            align_items: AlignItems::Center,
-            padding: BUTTON_PADDING,
-            border_radius: BorderRadius::ZERO
-                .with_left(if is_first {
-                    BUTTON_BORDER_RADIUS_SIZE
-                } else {
-                    px(0)
-                })
-                .with_right(if is_last {
-                    BUTTON_BORDER_RADIUS_SIZE
-                } else {
-                    px(0)
-                }),
-            ..default()
-        },
-        BUTTON_BORDER_COLOR,
-        BackgroundColor(bg_color),
-        RadioButton,
-        WidgetClickSender(option_value.clone()),
-        children![(
-            ui_text(option_name, fg_color),
-            RadioButtonText,
-            WidgetClickSender(option_value),
-        )],
-    )
-}
-
-/// Spawns the buttons that allow configuration of a setting.
-///
-/// The user may change the setting to any one of the labeled `options`. The
-/// value of the given type parameter will be packaged up and sent as a
-/// [`WidgetClickEvent`] when one of the radio buttons is clicked.
-pub fn option_buttons<T>(title: &str, options: &[(T, &str)]) -> impl Bundle
-where
-    T: Clone + Send + Sync + 'static,
-{
-    let buttons = options
-        .iter()
-        .cloned()
-        .enumerate()
-        .map(|(option_index, (option_value, option_name))| {
-            option_button(
-                option_value,
-                option_name,
-                option_index == 0,
-                option_index == 0,
-                option_index == options.len() - 1,
-            )
-        })
-        .collect::<Vec<_>>();
-    // Add the parent node for the row.
-    (
-        Node {
-            align_items: AlignItems::Center,
-            ..default()
-        },
-        Children::spawn((
-            Spawn((
-                ui_text(title, Color::BLACK),
-                Node {
-                    width: px(125),
-                    ..default()
-                },
-            )),
-            SpawnIter(buttons.into_iter()),
-        )),
-    )
-}
-
-/// Creates a text bundle for the UI.
-pub fn ui_text(label: &str, color: Color) -> impl Bundle + use<> {
-    (
-        Text::new(label),
-        TextFont {
-            font_size: 18.0,
-            ..default()
-        },
-        TextColor(color),
-    )
-}
-
-/// Checks for clicks on the radio buttons and sends `RadioButtonChangeEvent`s
-/// as necessary.
-pub fn handle_ui_interactions<T>(
-    mut interactions: Query<
-        (&Interaction, &WidgetClickSender<T>),
-        (With<Button>, With<RadioButton>),
-    >,
-    mut widget_click_events: MessageWriter<WidgetClickEvent<T>>,
-) where
-    T: Clone + Send + Sync + 'static,
-{
-    for (interaction, click_event) in interactions.iter_mut() {
-        if *interaction == Interaction::Pressed {
-            widget_click_events.write(WidgetClickEvent((**click_event).clone()));
-        }
-    }
-}
-
-/// Updates the style of the button part of a radio button to reflect its
-/// selected status.
-pub fn update_ui_radio_button(background_color: &mut BackgroundColor, selected: bool) {
-    background_color.0 = if selected { Color::WHITE } else { Color::BLACK };
-}
-
-/// Updates the color of the label of a radio button to reflect its selected
-/// status.
-pub fn update_ui_radio_button_text(entity: Entity, writer: &mut TextUiWriter, selected: bool) {
-    let text_color = if selected { Color::BLACK } else { Color::WHITE };
-
-    writer.for_each_color(entity, |mut color| {
-        color.0 = text_color;
-    });
-}