some tests, initial wiring to the cli

Cargo.lock

···
  "jacquard-identity",
  "jacquard-oauth",
  "jose-jwk",
- "miette",
+ "miette 7.6.0",
  "regex",
  "reqwest",
  "serde",
···
  "jacquard-common",
  "jacquard-derive",
  "jacquard-lexicon",
- "miette",
+ "miette 7.6.0",
  "rustversion",
  "serde",
  "serde_ipld_dagcbor",
···
  "jacquard-common",
  "jacquard-derive",
  "jacquard-identity",
- "miette",
+ "miette 7.6.0",
  "multibase",
  "serde",
  "serde_html_form",
···
  "ipld-core",
  "k256",
  "langtag",
- "miette",
+ "miette 7.6.0",
  "multibase",
  "multihash",
  "n0-future",
···
  "jacquard-api",
  "jacquard-common",
  "jacquard-lexicon",
- "miette",
+ "miette 7.6.0",
  "moka",
  "percent-encoding",
  "reqwest",
···
  "heck 0.5.0",
  "inventory",
  "jacquard-common",
- "miette",
+ "miette 7.6.0",
  "multihash",
  "prettyplease",
  "proc-macro2",
···
  "jacquard-identity",
  "jose-jwa",
  "jose-jwk",
- "miette",
+ "miette 7.6.0",
  "p256",
  "rand 0.8.5",
  "rouille",
···
  "ecdsa",
  "elliptic-curve",
  "sha2",
+]
+
+[[package]]
+name = "kdl"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e03e2e96c5926fe761088d66c8c2aee3a4352a2573f4eaca50043ad130af9117"
+dependencies = [
+ "miette 5.10.0",
+ "nom",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "miette"
+version = "5.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59bb584eaeeab6bd0226ccf3509a69d7936d148cf3d036ad350abe35e8c6856e"
+dependencies = [
+ "miette-derive 5.10.0",
+ "once_cell",
+ "thiserror 1.0.69",
+ "unicode-width 0.1.14",
+]
+
+[[package]]
+name = "miette"
 version = "7.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7"
···
  "backtrace",
  "backtrace-ext",
  "cfg-if",
- "miette-derive",
+ "miette-derive 7.6.0",
  "owo-colors",
  "supports-color",
  "supports-hyperlinks",
···
  "terminal_size",
  "textwrap",
  "unicode-width 0.1.14",
+]
+
+[[package]]
+name = "miette-derive"
+version = "5.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49e7bc1560b95a3c4a25d03de42fe76ca718ab92d1a22a55b9b4cf67b3ae635c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
 ]
 
 [[package]]
···
  "jacquard-axum",
  "jose",
  "jose-jwk",
- "miette",
+ "miette 7.6.0",
  "minijinja",
  "minijinja-contrib",
  "reqwest",
···
  "dirs",
  "jacquard",
  "jacquard-api",
- "miette",
+ "kdl",
+ "miette 7.6.0",
  "tokio",
  "weaver-common",
+ "weaver-renderer",
  "weaver-workspace-hack",
 ]
 
···
  "jose-jwk",
  "markdown-weaver",
  "markdown-weaver-escape",
- "miette",
+ "miette 7.6.0",
  "minijinja",
  "multibase",
  "n0-future",
···
  "insta",
  "markdown-weaver",
  "markdown-weaver-escape",
- "miette",
+ "miette 7.6.0",
  "n0-future",
  "pathdiff",
  "pin-project",
···
  "jacquard-oauth",
  "log",
  "memchr",
- "miette",
+ "miette 7.6.0",
  "mime_guess",
  "minijinja",
  "num-traits",

crates/weaver-cli/Cargo.toml

···
 license.workspace = true
 publish = false
 
+[[bin]]
+name = "weaver"
+path = "src/main.rs"
+
 [dependencies]
 clap = { version = "4.5", features = ["derive", "env", "cargo", "unicode"] }
 weaver-common = { path = "../weaver-common", features = ["native"] }
+weaver-renderer = { path = "../weaver-renderer" }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
 miette = { workspace = true, features = ["fancy"] }
 
···
 
 tokio = { version = "1.45.0", features = ["full"] }
 dirs = "6.0.0"
+kdl = "4.6"

crates/weaver-cli/src/main.rs

···
 use jacquard::client::{Agent, FileAuthStore};
-use jacquard::oauth::client::OAuthClient;
+use jacquard::identity::JacquardResolver;
+use jacquard::oauth::client::{OAuthClient, OAuthSession};
 use jacquard::oauth::loopback::LoopbackConfig;
 use jacquard::prelude::XrpcClient;
 use jacquard::types::ident::AtIdentifier;
···
 use jacquard_api::app_bsky::actor::get_profile::GetProfile;
 use miette::{IntoDiagnostic, Result};
 use std::path::PathBuf;
+use weaver_renderer::static_site::StaticSiteWriter;
 
 use clap::{Parser, Subcommand};
 
 #[derive(Parser)]
-#[command(version, about, long_about = None)]
+#[command(version, about = "Weaver - Static site generator for AT Protocol notebooks", long_about = None)]
 #[command(propagate_version = true)]
 struct Cli {
+    /// Path to notebook directory
+    source: Option<PathBuf>,
+
+    /// Output directory for static site
+    dest: Option<PathBuf>,
+
+    /// Path to auth store file
+    #[arg(long)]
+    store: Option<PathBuf>,
+
     #[command(subcommand)]
-    command: Commands,
+    command: Option<Commands>,
 }
 
 #[derive(Subcommand)]
···
         #[arg(long)]
         store: Option<PathBuf>,
     },
-    /// Run a test command with stored auth
-    Run {
-        /// Path to auth store file
-        #[arg(long)]
-        store: Option<PathBuf>,
-    },
 }
 
 #[tokio::main]
···
     let cli = Cli::parse();
 
     match cli.command {
-        Commands::Auth { handle, store } => {
+        Some(Commands::Auth { handle, store }) => {
             let store_path = store.unwrap_or_else(default_auth_store_path);
             authenticate(handle, store_path).await?;
         }
-        Commands::Run { store } => {
-            let store_path = store.unwrap_or_else(default_auth_store_path);
-            run_test(store_path).await?;
+        None => {
+            // Render command (default)
+            let source = cli.source.ok_or_else(|| {
+                miette::miette!("Source directory required. Usage: weaver <source> <dest>")
+            })?;
+            let dest = cli.dest.ok_or_else(|| {
+                miette::miette!("Destination directory required. Usage: weaver <source> <dest>")
+            })?;
+            let store_path = cli.store.unwrap_or_else(default_auth_store_path);
+
+            render_notebook(source, dest, store_path).await?;
         }
     }
 
···
 }
 
 async fn authenticate(handle: String, store_path: PathBuf) -> Result<()> {
-    println!("Authenticating with {}...", handle);
+    println!("Authenticating as @{handle} ...");
 
     let oauth = OAuthClient::with_default_config(FileAuthStore::new(&store_path));
 
···
     let (did, session_id) = session.session_info().await;
 
     // Save DID and session_id for later use
-    let config_path = store_path.with_extension("toml");
-    let config_content = format!("did = \"{}\"\nsession_id = \"{}\"\n", did, session_id);
+    let config_path = store_path.with_extension("kdl");
+    let config_content = format!("did \"{}\"\nsession-id \"{}\"\n", did, session_id);
     std::fs::write(&config_path, config_content).into_diagnostic()?;
 
     println!("Successfully authenticated!");
     println!("Session saved to: {}", store_path.display());
-    println!("DID: {}", did);
 
     Ok(())
 }
 
-async fn run_test(store_path: PathBuf) -> Result<()> {
-    println!("Loading session from {}...", store_path.display());
+async fn try_load_session(
+    store_path: &PathBuf,
+) -> Option<OAuthSession<JacquardResolver, FileAuthStore>> {
+    use kdl::KdlDocument;
 
-    // Read DID and session_id from config
-    let config_path = store_path.with_extension("toml");
-    let config_content = std::fs::read_to_string(&config_path)
-        .into_diagnostic()
-        .map_err(|_| miette::miette!("No auth config found. Run 'weaver auth' first."))?;
+    // Check if auth store exists
+    if !store_path.exists() {
+        return None;
+    }
 
-    let did_line = config_content
-        .lines()
-        .find(|l| l.starts_with("did = "))
-        .ok_or_else(|| miette::miette!("Invalid config file"))?;
-    let session_id_line = config_content
-        .lines()
-        .find(|l| l.starts_with("session_id = "))
-        .ok_or_else(|| miette::miette!("Invalid config file"))?;
+    // Read KDL config
+    let config_path = store_path.with_extension("kdl");
+    let config_content = std::fs::read_to_string(&config_path).ok()?;
 
-    let did_str = did_line
-        .trim_start_matches("did = \"")
-        .trim_end_matches('"');
-    let session_id = session_id_line
-        .trim_start_matches("session_id = \"")
-        .trim_end_matches('"');
+    // Parse KDL
+    let doc: KdlDocument = config_content.parse().ok()?;
+
+    // Extract did and session-id
+    let did_node = doc.get("did")?;
+    let session_id_node = doc.get("session-id")?;
 
-    let did = jacquard::types::string::Did::new(did_str)
-        .map_err(|_| miette::miette!("Invalid DID in config"))?;
+    let did_str = did_node.entries().first()?.value().as_string()?;
+    let session_id = session_id_node.entries().first()?.value().as_string()?;
 
-    let oauth = OAuthClient::with_default_config(FileAuthStore::new(&store_path));
-    let session = oauth.restore(&did, session_id).await.into_diagnostic()?;
+    // Parse DID
+    let did = jacquard::types::string::Did::new(did_str).ok()?;
 
-    let agent = Agent::from(session);
+    // Restore OAuth session
+    let oauth = OAuthClient::with_default_config(FileAuthStore::new(store_path));
+    oauth.restore(&did, session_id).await.ok()
+}
 
-    println!("Fetching profile for {}...", did);
+async fn render_notebook(source: PathBuf, dest: PathBuf, store_path: PathBuf) -> Result<()> {
+    // Validate source exists
+    if !source.exists() {
+        return Err(miette::miette!(
+            "Source directory not found: {}",
+            source.display()
+        ));
+    }
 
-    let profile = agent
-        .send(GetProfile::new().actor(AtIdentifier::Did(did)).build())
-        .await
-        .into_diagnostic()?
-        .into_output()
-        .into_diagnostic()?;
+    // Try to load session
+    let session = try_load_session(&store_path).await;
 
-    println!("\nProfile:");
-    println!("  Handle: {}", profile.value.handle);
-    if let Some(display_name) = &profile.value.display_name {
-        println!("  Display Name: {}", display_name);
+    // Log auth status
+    if session.is_some() {
+        println!("✓ Found authentication");
+    } else {
+        println!("⚠ No authentication found");
+        println!("  Run 'weaver auth <handle>' to enable network features");
     }
-    if let Some(description) = &profile.value.description {
-        println!("  Description: {}", description);
+
+    // Create dest parent directories if needed
+    if let Some(parent) = dest.parent() {
+        if !parent.exists() {
+            std::fs::create_dir_all(parent).into_diagnostic()?;
+        }
     }
+
+    // Create renderer
+    let writer = StaticSiteWriter::new(source, dest.clone(), session);
+
+    // Render
+    println!("→ Rendering notebook...");
+    let start = std::time::Instant::now();
+    writer.run().await?;
+    let elapsed = start.elapsed();
+
+    // Report success
+    println!("✓ Rendered in {:.2}s", elapsed.as_secs_f64());
+    println!("✓ Output: {}", dest.display());
 
     Ok(())
 }

crates/weaver-renderer/src/base_html.rs

···
 
 /// Iterate over an `Iterator` of `Event`s, generate HTML for each `Event`, and
 /// push it to a `String`.
-///
-/// # Examples
-///
-/// ```
-/// use pulldown_cmark::{html, Parser};
-///
-/// let markdown_str = r#"
-/// hello
-/// =====
-///
-/// * alpha
-/// * beta
-/// "#;
-/// let parser = Parser::new(markdown_str);
-///
-/// let mut html_buf = String::new();
-/// html::push_html(&mut html_buf, parser);
-///
-/// assert_eq!(html_buf, r#"<h1>hello</h1>
-/// <ul>
-/// <li>alpha</li>
-/// <li>beta</li>
-/// </ul>
-/// "#);
-/// ```
 pub fn push_html<'a, I>(s: &mut String, iter: I)
 where
     I: Iterator<Item = Event<'a>>,
···
 /// will result in poor performance. Wrap these in a
 /// [`BufWriter`](https://doc.rust-lang.org/std/io/struct.BufWriter.html) to
 /// prevent unnecessary slowdowns.
-///
-/// # Examples
-///
-/// ```
-/// use pulldown_cmark::{html, Parser};
-/// use std::io::Cursor;
-///
-/// let markdown_str = r#"
-/// hello
-/// =====
-///
-/// * alpha
-/// * beta
-/// "#;
-/// let mut bytes = Vec::new();
-/// let parser = Parser::new(markdown_str);
-///
-/// html::write_html_io(Cursor::new(&mut bytes), parser);
-///
-/// assert_eq!(&String::from_utf8_lossy(&bytes)[..], r#"<h1>hello</h1>
-/// <ul>
-/// <li>alpha</li>
-/// <li>beta</li>
-/// </ul>
-/// "#);
-/// ```
+
 //#[cfg(feature = "std")]
 pub fn write_html_io<'a, I, W>(writer: W, iter: I) -> std::io::Result<()>
 where
···
 
 /// Iterate over an `Iterator` of `Event`s, generate HTML for each `Event`, and
 /// write it into Unicode-accepting buffer or stream.
-///
-/// # Examples
-///
-/// ```
-/// use pulldown_cmark::{html, Parser};
-///
-/// let markdown_str = r#"
-/// hello
-/// =====
-///
-/// * alpha
-/// * beta
-/// "#;
-/// let mut buf = String::new();
-/// let parser = Parser::new(markdown_str);
-///
-/// html::write_html_fmt(&mut buf, parser);
-///
-/// assert_eq!(buf, r#"<h1>hello</h1>
-/// <ul>
-/// <li>alpha</li>
-/// <li>beta</li>
-/// </ul>
-/// "#);
-/// ```
+
 pub fn write_html_fmt<'a, I, W>(writer: W, iter: I) -> core::fmt::Result
 where
     I: Iterator<Item = Event<'a>>,

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__blockquote_rendering.snap

···
+---
+source: crates/weaver-renderer/src/static_site.rs
+expression: output
+---
+<blockquote>
+<p>This is a quote</p>
+<p>With multiple lines</p>
+</blockquote>

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__code_block_rendering.snap

···
+---
+source: crates/weaver-renderer/src/static_site.rs
+expression: output
+---
+<pre><code class="language-rust">fn main() {
+    println!("Hello");
+}
+</code></pre>

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__heading_rendering.snap

···
+---
+source: crates/weaver-renderer/src/static_site.rs
+expression: output
+---
+<h1>Heading 1</h1>
+<h2>Heading 2</h2>
+<h3>Heading 3</h3>

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__list_rendering.snap

···
+---
+source: crates/weaver-renderer/src/static_site.rs
+expression: output
+---
+<ul>
+<li>Item 1</li>
+<li>Item 2
+<ul>
+<li>Nested</li>
+</ul>
+</li>
+</ul>
+<ol>
+<li>Ordered 1</li>
+<li>Ordered 2</li>
+</ol>

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__math_rendering.snap

···
+---
+source: crates/weaver-renderer/src/static_site.rs
+expression: output
+---
+<p>Inline <span class="math math-inline">x^2</span> and display:</p>
+<p><span class="math math-display">
+y = mx + b
+</span></p>

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__paragraph_rendering.snap

···
+---
+source: crates/weaver-renderer/src/static_site.rs
+expression: output
+---
+<p>This is a paragraph.</p>
+<p>This is another paragraph.</p>

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__table_rendering.snap

···
+---
+source: crates/weaver-renderer/src/static_site.rs
+expression: output
+---
+<table><thead><tr><th style="text-align: left">Left</th><th style="text-align: center">Center</th><th style="text-align: right">Right</th></tr></thead><tbody>
+<tr><td style="text-align: left">A</td><td style="text-align: center">B</td><td style="text-align: right">C</td></tr>
+</tbody></table>

crates/weaver-renderer/src/static_site.rs

···
     sync::Arc,
 };
 
-use crate::{ContextIterator, NotebookProcessor, base_html::TableState, walker::WalkOptions};
-use async_trait::async_trait;
+use crate::{
+    ContextIterator, NotebookProcessor,
+    base_html::TableState,
+    utils::flatten_dir_to_just_one_parent,
+    walker::{WalkOptions, vault_contents},
+};
 use bitflags::bitflags;
 use dashmap::DashMap;
 use markdown_weaver::{
···
     FmtWriter, StrWrite, escape_href, escape_html, escape_html_body_text,
 };
 use miette::IntoDiagnostic;
-use n0_future::StreamExt;
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 use n0_future::io::AsyncWriteExt;
+use n0_future::{IterExt, StreamExt};
 #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use tokio::io::AsyncWriteExt;
 use unicode_normalization::UnicodeNormalization;
···
 impl Default for StaticSiteOptions {
     fn default() -> Self {
         Self::FLATTEN_STRUCTURE
-            | Self::UPLOAD_BLOBS
+            //| Self::UPLOAD_BLOBS
             | Self::RESOLVE_AT_IDENTIFIERS
             | Self::RESOLVE_AT_URIS
             | Self::CREATE_INDEX
···
     reference_map: Arc<DashMap<CowStr<'a>, PathBuf>>,
     titles: Arc<DashMap<PathBuf, CowStr<'a>>>,
     position: usize,
-    client: reqwest::Client,
+    client: Option<reqwest::Client>,
     agent: Option<Arc<Agent<A>>>,
 }
 
+impl<'a, A: AgentSession> Clone for StaticSiteContext<'a, A> {
+    fn clone(&self) -> Self {
+        Self {
+            options: self.options.clone(),
+            md_options: self.md_options.clone(),
+            bsky_appview: self.bsky_appview.clone(),
+            root: self.root.clone(),
+            destination: self.destination.clone(),
+            start_at: self.start_at.clone(),
+            frontmatter: self.frontmatter.clone(),
+            dir_contents: self.dir_contents.clone(),
+            reference_map: self.reference_map.clone(),
+            titles: self.titles.clone(),
+            position: self.position.clone(),
+            client: self.client.clone(),
+            agent: self.agent.clone(),
+        }
+    }
+}
+
 impl<A: AgentSession> StaticSiteContext<'_, A> {
     pub fn clone_with_dir_contents(&self, dir_contents: &[PathBuf]) -> Self {
         Self {
···
             reference_map: self.reference_map.clone(),
             titles: self.titles.clone(),
             position,
-            client: reqwest::Client::default(),
+            client: Some(reqwest::Client::default()),
             agent: self.agent.clone(),
         }
     }
···
             reference_map: Arc::new(DashMap::new()),
             titles: Arc::new(DashMap::new()),
             position: 0,
-            client: reqwest::Client::default(),
+            client: Some(reqwest::Client::default()),
             agent: session.map(|session| Arc::new(Agent::new(session))),
         }
     }
···
                     } else {
                         600
                     };
-                    let html = if let Ok(resp) = self
-                        .client
-                        .get("https://embed.bsky.app/oembed")
-                        .query(&[
-                            ("url", dest_url.clone().into_string()),
-                            ("maxwidth", width.to_string()),
-                        ])
-                        .send()
-                        .await
-                    {
-                        resp.text().await.ok()
+                    let html = if let Some(client) = &self.client {
+                        if let Ok(resp) = client
+                            .get("https://embed.bsky.app/oembed")
+                            .query(&[
+                                ("url", dest_url.clone().into_string()),
+                                ("maxwidth", width.to_string()),
+                            ])
+                            .send()
+                            .await
+                        {
+                            resp.text().await.ok()
+                        } else {
+                            None
+                        }
                     } else {
                         None
                     };
···
                             PathBuf::from(&dest_url as &str)
                         };
                         crate::utils::inline_file(&file_path).await
-                    } else if let Some(agent) = &self.agent {
-                        if let Ok(resp) =
-                            self.client.get(dest_url.clone().into_string()).send().await
-                        {
+                    } else if let Some(client) = &self.client {
+                        if let Ok(resp) = client.get(dest_url.clone().into_string()).send().await {
                             resp.text().await.ok()
                         } else {
                             None
···
 }
 
 impl<A: AgentSession + IdentityResolver> StaticSiteContext<'_, A> {
+    /// TODO: rework this a bit, to not just do the same thing as whitewind
+    /// (also need to make a record to refer to them) that being said, doing
+    /// this with the static site renderer isn't *really* the standard workflow
     pub async fn upload_image<'s>(&self, image: Tag<'s>) -> Tag<'s> {
         if let Some(agent) = &self.agent {
             match &image {
···
                         let (parent, filename) = crate::utils::flatten_dir_to_just_one_parent(&dest_url);
                         let dest_url = if crate::utils::is_relative_link(&dest_url)
                             && self.options.contains(StaticSiteOptions::CREATE_CHAPTERS_BY_DIRECTORY) {
-                            CowStr::Boxed(format!("./{}/{}", parent, filename).into_boxed_str())
+                            if !parent.is_empty() {
+                                CowStr::Boxed(format!("./{}/{}", parent, filename).into_boxed_str())
+                            } else {
+                                CowStr::Boxed(format!("./{}", filename).into_boxed_str())
+                            }
                         } else {
                             CowStr::Boxed(format!("./entry/{}", filename).into_boxed_str())
                         };
···
 
 impl<'a, A> StaticSiteWriter<'a, A>
 where
-    A: AgentSession + IdentityResolver,
+    A: AgentSession + IdentityResolver + 'a,
 {
-    pub async fn run(self) -> Result<(), miette::Report> {
-        todo!()
-    }
+    pub async fn run(mut self) -> Result<(), miette::Report> {
+        if !self.context.root.exists() {
+            return Err(miette::miette!(
+                "The path specified ({}) does not exist",
+                self.context.root.display()
+            ));
+        }
+        let contents = vault_contents(&self.context.root, WalkOptions::new())?;
+
+        self.context.dir_contents = Some(contents.into());
+
+        if self.context.root.is_file() || self.context.start_at.is_file() {
+            let source_filename = self
+                .context
+                .start_at
+                .file_name()
+                .expect("wtf how!?")
+                .to_string_lossy();
+
+            let dest = if self.context.destination.is_dir() {
+                self.context.destination.join(String::from(source_filename))
+            } else {
+                let parent = self
+                    .context
+                    .destination
+                    .parent()
+                    .unwrap_or(&self.context.destination);
+                // Avoid recursively creating self.destination through the call to
+                // export_note when the parent directory doesn't exist.
+                if !parent.exists() {
+                    return Err(miette::miette!(
+                        "Destination parent path ({}) does not exist, SOMEHOW",
+                        parent.display()
+                    ));
+                }
+                self.context.destination.clone()
+            };
+            return write_page(self.context.clone(), &self.context.start_at, dest).await;
+        }
 
-    pub async fn export_page<'s, 'input>(
-        &'s self,
-        contents: &'input str,
-        context: StaticSiteContext<'s, A>,
-    ) -> Result<String, miette::Report> {
-        let callback = if let Some(dir_contents) = context.dir_contents.clone() {
-            Some(VaultBrokenLinkCallback {
-                vault_contents: dir_contents,
-            })
-        } else {
-            None
-        };
-        let parser = Parser::new_with_broken_link_callback(&contents, context.md_options, callback);
-        let iterator = ContextIterator::default(parser);
-        let mut output = String::new();
-        let writer = StaticPageWriter::new(
-            NotebookProcessor::new(context, iterator),
-            FmtWriter(&mut output),
-        );
-        writer.run().await.into_diagnostic()?;
-        Ok(output)
-    }
+        if !self.context.destination.exists() {
+            return Err(miette::miette!(
+                "The destination path specified ({}) does not exist",
+                self.context.destination.display()
+            ));
+        }
 
-    pub async fn write_page(&'a self, path: PathBuf) -> Result<(), miette::Report> {
-        let contents = tokio::fs::read_to_string(&path).await.into_diagnostic()?;
-        let mut output_file = crate::utils::create_file(&path).await?;
-        let context = self.context.clone_with_path(&path);
-        let output = self.export_page(&contents, context).await?;
-        output_file
-            .write_all(output.as_bytes())
-            .await
-            .into_diagnostic()?;
+        for file in self
+            .context
+            .dir_contents
+            .as_ref()
+            .unwrap()
+            .clone()
+            .into_iter()
+            .filter(|file| file.starts_with(&self.context.start_at))
+        {
+            let context = self.context.clone();
+            let relative_path = file
+                .strip_prefix(context.start_at.clone())
+                .expect("file should always be nested under root")
+                .to_path_buf();
+            if context
+                .options
+                .contains(StaticSiteOptions::FLATTEN_STRUCTURE)
+            {
+                let path_str = relative_path.to_string_lossy();
+                let (parent, file) = flatten_dir_to_just_one_parent(&path_str);
+                let output_path = context
+                    .destination
+                    .join(String::from(parent))
+                    .join(String::from(file));
+
+                write_page(context.clone(), relative_path, output_path).await?;
+            } else {
+                let output_path = context.destination.join(relative_path.clone());
+
+                write_page(context.clone(), relative_path, output_path).await?;
+            }
+        }
         Ok(())
     }
 }
 
+pub async fn export_page<'s, 'input, A>(
+    contents: &'input str,
+    context: StaticSiteContext<'s, A>,
+) -> Result<String, miette::Report>
+where
+    A: AgentSession + IdentityResolver,
+{
+    let callback = if let Some(dir_contents) = context.dir_contents.clone() {
+        Some(VaultBrokenLinkCallback {
+            vault_contents: dir_contents,
+        })
+    } else {
+        None
+    };
+    let parser = Parser::new_with_broken_link_callback(&contents, context.md_options, callback);
+    let iterator = ContextIterator::default(parser);
+    let mut output = String::new();
+    let writer = StaticPageWriter::new(
+        NotebookProcessor::new(context, iterator),
+        FmtWriter(&mut output),
+    );
+    writer.run().await.into_diagnostic()?;
+    Ok(output)
+}
+
+pub async fn write_page<'s, A>(
+    context: StaticSiteContext<'s, A>,
+    input_path: impl AsRef<Path>,
+    output_path: impl AsRef<Path>,
+) -> Result<(), miette::Report>
+where
+    A: AgentSession + IdentityResolver,
+{
+    let contents = tokio::fs::read_to_string(&input_path)
+        .await
+        .into_diagnostic()?;
+    let mut output_file = crate::utils::create_file(output_path.as_ref()).await?;
+    let context = context.clone_with_path(input_path);
+    let output = export_page(&contents, context).await?;
+    output_file
+        .write_all(output.as_bytes())
+        .await
+        .into_diagnostic()?;
+    Ok(())
+}
+
 pub struct StaticPageWriter<
     'a,
     'input,
···
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+    use weaver_common::jacquard::client::{
+        AtpSession, MemorySessionStore,
+        credential_session::{CredentialSession, SessionKey},
+    };
+
+    /// Type alias for the session used in tests
+    type TestSession = CredentialSession<
+        MemorySessionStore<SessionKey, AtpSession>,
+        weaver_common::jacquard::identity::JacquardResolver,
+    >;
+
+    /// Helper: Create test context without network capabilities
+    fn test_context() -> StaticSiteContext<'static, TestSession> {
+        let root = PathBuf::from("/tmp/test");
+        let destination = PathBuf::from("/tmp/output");
+        let mut ctx = StaticSiteContext::new(root, destination, None);
+        ctx.client = None; // Explicitly disable network
+        ctx
+    }
+
+    /// Helper: Render markdown to HTML using test context
+    async fn render_markdown(input: &str) -> String {
+        let context = test_context();
+        export_page(input, context).await.unwrap()
+    }
+
+    #[tokio::test]
+    async fn test_smoke() {
+        let output = render_markdown("Hello world").await;
+        assert!(output.contains("Hello world"));
+    }
+
+    #[tokio::test]
+    async fn test_paragraph_rendering() {
+        let input = "This is a paragraph.\n\nThis is another paragraph.";
+        let output = render_markdown(input).await;
+        insta::assert_snapshot!(output);
+    }
+
+    #[tokio::test]
+    async fn test_heading_rendering() {
+        let input = "# Heading 1\n\n## Heading 2\n\n### Heading 3";
+        let output = render_markdown(input).await;
+        insta::assert_snapshot!(output);
+    }
+
+    #[tokio::test]
+    async fn test_list_rendering() {
+        let input = "- Item 1\n- Item 2\n  - Nested\n\n1. Ordered 1\n2. Ordered 2";
+        let output = render_markdown(input).await;
+        insta::assert_snapshot!(output);
+    }
+
+    #[tokio::test]
+    async fn test_code_block_rendering() {
+        let input = "```rust\nfn main() {\n    println!(\"Hello\");\n}\n```";
+        let output = render_markdown(input).await;
+        insta::assert_snapshot!(output);
+    }
+
+    #[tokio::test]
+    async fn test_table_rendering() {
+        let input = "| Left | Center | Right |\n|:-----|:------:|------:|\n| A | B | C |";
+        let output = render_markdown(input).await;
+        insta::assert_snapshot!(output);
+    }
+
+    #[tokio::test]
+    async fn test_blockquote_rendering() {
+        let input = "> This is a quote\n>\n> With multiple lines";
+        let output = render_markdown(input).await;
+        insta::assert_snapshot!(output);
+    }
+
+    #[tokio::test]
+    async fn test_math_rendering() {
+        let input = "Inline $x^2$ and display:\n\n$$\ny = mx + b\n$$";
+        let output = render_markdown(input).await;
+        insta::assert_snapshot!(output);
+    }
+
+    #[tokio::test]
+    async fn test_wikilink_resolution() {
+        let vault_contents = vec![
+            PathBuf::from("notes/First Note.md"),
+            PathBuf::from("notes/Second Note.md"),
+        ];
+
+        let mut context = test_context();
+        context.dir_contents = Some(vault_contents.into());
+
+        let input = "[[First Note]] and [[Second Note]]";
+        let output = export_page(input, context).await.unwrap();
+        println!("{output}");
+        assert!(output.contains("./First%20Note"));
+        assert!(output.contains("./Second%20Note"));
+    }
+
+    #[tokio::test]
+    async fn test_broken_wikilink() {
+        let vault_contents = vec![PathBuf::from("notes/Exists.md")];
+
+        let mut context = test_context();
+        context.dir_contents = Some(vault_contents.into());
+
+        let input = "[[Does Not Exist]]";
+        let output = export_page(input, context).await.unwrap();
+
+        // Broken wikilinks become links (they just don't point anywhere valid)
+        // This is acceptable - static site will show 404 on click
+        assert!(output.contains("<a href="));
+        assert!(output.contains("Does Not Exist</a>") || output.contains("Does%20Not%20Exist"));
+    }
+
+    #[tokio::test]
+    async fn test_wikilink_with_section() {
+        let vault_contents = vec![PathBuf::from("Note.md")];
+
+        let mut context = test_context();
+        context.dir_contents = Some(vault_contents.into());
+
+        let input = "[[Note#Section]]";
+        let output = export_page(input, context).await.unwrap();
+        println!("{output}");
+        assert!(output.contains("Note#Section"));
+    }
+
+    #[tokio::test]
+    async fn test_link_flattening_enabled() {
+        let mut context = test_context();
+        context.options = StaticSiteOptions::FLATTEN_STRUCTURE;
+
+        let input = "[Link](path/to/nested/file.md)";
+        let output = export_page(input, context).await.unwrap();
+        println!("{output}");
+        // Should flatten to single parent directory
+        assert!(output.contains("./entry/file.md"));
+    }
+
+    #[tokio::test]
+    async fn test_link_flattening_disabled() {
+        let mut context = test_context();
+        context.options = StaticSiteOptions::empty();
+
+        let input = "[Link](path/to/nested/file.md)";
+        let output = export_page(input, context).await.unwrap();
+        println!("{output}");
+        // Should preserve original path
+        assert!(output.contains("path/to/nested/file.md"));
+    }
+
+    #[tokio::test]
+    async fn test_frontmatter_parsing() {
+        let input = "---\ntitle: Test Page\nauthor: Test Author\n---\n\nContent here";
+        let context = test_context();
+        let output = export_page(input, context.clone()).await.unwrap();
+
+        // Frontmatter should be parsed but not rendered
+        assert!(!output.contains("title: Test Page"));
+        assert!(output.contains("Content here"));
+
+        // Verify frontmatter was captured
+        let frontmatter = context.frontmatter();
+        let yaml = frontmatter.contents();
+        let yaml_guard = yaml.read().unwrap();
+        assert!(yaml_guard.len() > 0);
+    }
+
+    #[tokio::test]
+    async fn test_empty_frontmatter() {
+        let input = "---\n---\n\nContent";
+        let output = render_markdown(input).await;
+
+        assert!(output.contains("Content"));
+        assert!(!output.contains("---"));
+    }
+
+    #[tokio::test]
+    async fn test_empty_input() {
+        let output = render_markdown("").await;
+        assert_eq!(output, "");
+    }
+
+    #[tokio::test]
+    async fn test_html_and_special_characters() {
+        // Test that markdown correctly handles HTML and special chars per CommonMark spec
+        let input = "Text with <special> & some text. Valid tags: <em>emphasis</em> and <strong>bold</strong>";
+        let output = render_markdown(input).await;
+
+        // & must be escaped for valid HTML
+        assert!(output.contains("&amp;"));
+
+        // Inline HTML tags pass through (CommonMark behavior)
+        assert!(output.contains("<special>"));
+        assert!(output.contains("<em>emphasis</em>"));
+        assert!(output.contains("<strong>bold</strong>"));
+    }
+
+    #[tokio::test]
+    async fn test_unicode_content() {
+        let input = "Unicode: 你好 🎉 café";
+        let output = render_markdown(input).await;
+
+        assert!(output.contains("你好"));
+        assert!(output.contains("🎉"));
+        assert!(output.contains("café"));
+    }
+}

flake.nix

···
           alejandra
           diesel-cli
           postgresql
+          cargo-insta
           jq
         ];
       };