js renderer wrapper crate

Cargo.lock

···
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
+name = "tsify-next"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d0f2208feeb5f7a6edb15a2389c14cd42480ef6417318316bb866da5806a61d"
+dependencies = [
+ "gloo-utils",
+ "serde",
+ "serde_json",
+ "tsify-next-macros",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "tsify-next-macros"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f81253930d0d388a3ab8fa4ae56da9973ab171ef833d1be2e9080fc3ce502bd6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.111",
+]
+
+[[package]]
 name = "ttf-parser"
 version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "regex",
  "regex-lite",
  "reqwest",
+ "serde",
+ "serde_json",
  "smol_str",
  "syntect",
  "thiserror 2.0.17",
···
  "weaver-api",
  "weaver-common",
  "yaml-rust2",
+]
+
+[[package]]
+name = "weaver-renderer-js"
+version = "0.1.0"
+dependencies = [
+ "console_error_panic_hook",
+ "jacquard",
+ "js-sys",
+ "markdown-weaver",
+ "markdown-weaver-escape",
+ "serde",
+ "serde-wasm-bindgen 0.6.5",
+ "tsify-next",
+ "wasm-bindgen",
+ "weaver-api",
+ "weaver-common",
+ "weaver-renderer",
 ]
 
 [[package]]

crates/weaver-renderer-js/Cargo.toml

···
+[package]
+name = "weaver-renderer-js"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+description = "WASM bindings for weaver-renderer"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+weaver-renderer = { path = "../weaver-renderer" }
+weaver-common = { path = "../weaver-common" }
+weaver-api = { path = "../weaver-api" }
+jacquard = { workspace = true }
+markdown-weaver = { workspace = true }
+markdown-weaver-escape = { workspace = true }
+
+wasm-bindgen = "0.2"
+serde = { workspace = true }
+serde-wasm-bindgen = "0.6"
+tsify-next = "0.5"
+js-sys = "0.3"
+console_error_panic_hook = "0.1"
+
+[profile.release]
+lto = true
+opt-level = "z"

crates/weaver-renderer-js/src/lib.rs

···
+//! WASM bindings for weaver-renderer.
+//!
+//! Exposes sync rendering functions to JS/TS apps via wasm-bindgen.
+
+use jacquard::types::string::AtUri;
+use jacquard::types::value::Data;
+use serde::Deserialize;
+use serde_wasm_bindgen::Deserializer;
+use wasm_bindgen::prelude::*;
+
+mod types;
+
+pub use types::*;
+
+/// Initialize panic hook for better error messages in console.
+#[wasm_bindgen(start)]
+pub fn init() {
+    console_error_panic_hook::set_once();
+}
+
+/// Render an AT Protocol record as HTML.
+///
+/// Takes a record URI and the record data (typically fetched from an appview).
+/// Returns the rendered HTML string.
+///
+/// # Arguments
+/// * `at_uri` - The AT Protocol URI (e.g., "at://did:plc:.../app.bsky.feed.post/...")
+/// * `record_json` - The record data as JSON
+/// * `fallback_author` - Optional author profile for records that don't include author info
+/// * `resolved_content` - Optional pre-rendered embed content
+#[wasm_bindgen]
+pub fn render_record(
+    at_uri: &str,
+    record_json: JsValue,
+    fallback_author: Option<JsValue>,
+    resolved_content: Option<JsResolvedContent>,
+) -> Result<String, JsError> {
+    let uri = AtUri::new(at_uri).map_err(|e| JsError::new(&format!("Invalid AT URI: {}", e)))?;
+
+    // Use Deserializer directly to avoid DeserializeOwned bounds (breaks Jacquard types).
+    let deserializer = Deserializer::from(record_json);
+    let data = Data::deserialize(deserializer)
+        .map_err(|e| JsError::new(&format!("Invalid record JSON: {}", e)))?;
+
+    let author: Option<weaver_api::sh_weaver::actor::ProfileDataView<'_>> = fallback_author
+        .map(|v| {
+            let deserializer = Deserializer::from(v);
+            weaver_api::sh_weaver::actor::ProfileDataView::deserialize(deserializer)
+        })
+        .transpose()
+        .map_err(|e| JsError::new(&format!("Invalid author JSON: {}", e)))?;
+
+    let resolved = resolved_content.map(|r| r.into_inner());
+
+    weaver_renderer::atproto::render_record(&uri, &data, author.as_ref(), resolved.as_ref())
+        .map_err(|e| JsError::new(&e.to_string()))
+}
+
+/// Render markdown to HTML.
+///
+/// # Arguments
+/// * `markdown` - The markdown source text
+/// * `resolved_content` - Optional pre-rendered embed content
+#[wasm_bindgen]
+pub fn render_markdown(
+    markdown: &str,
+    resolved_content: Option<JsResolvedContent>,
+) -> Result<String, JsError> {
+    use weaver_renderer::atproto::ClientWriter;
+
+    let resolved = resolved_content.map(|r| r.into_inner()).unwrap_or_default();
+
+    let parser = markdown_weaver::Parser::new_ext(markdown, weaver_renderer::default_md_options())
+        .into_offset_iter();
+    let events: Vec<_> = parser.collect();
+
+    let mut html_buf = String::new();
+    let writer = ClientWriter::new(events.into_iter(), &mut html_buf, markdown)
+        .with_embed_provider(&resolved);
+
+    writer.run().map_err(|_| JsError::new("Render error"))?;
+
+    Ok(html_buf)
+}
+
+/// Render LaTeX math to MathML.
+///
+/// # Arguments
+/// * `latex` - The LaTeX math expression
+/// * `display_mode` - true for display math (block), false for inline math
+#[wasm_bindgen]
+pub fn render_math(latex: &str, display_mode: bool) -> JsMathResult {
+    match weaver_renderer::math::render_math(latex, display_mode) {
+        weaver_renderer::math::MathResult::Success(html) => JsMathResult {
+            success: true,
+            html,
+            error: None,
+        },
+        weaver_renderer::math::MathResult::Error { html, message } => JsMathResult {
+            success: false,
+            html,
+            error: Some(message),
+        },
+    }
+}
+
+/// Render faceted text (rich text with mentions, links, etc.) to HTML.
+///
+/// Accepts facets from several AT Protocol lexicons (app.bsky, pub.leaflet, blog.pckt).
+///
+/// # Arguments
+/// * `text` - The plain text content
+/// * `facets_json` - Array of facets with `index` (byteStart/byteEnd) and `features` array
+#[wasm_bindgen]
+pub fn render_faceted_text(text: &str, facets_json: JsValue) -> Result<String, JsError> {
+    use weaver_renderer::facet::NormalizedFacet;
+
+    let deserializer = Deserializer::from(facets_json);
+    let facets = Vec::<NormalizedFacet<'_>>::deserialize(deserializer)
+        .map_err(|e| JsError::new(&format!("Invalid facets JSON: {}", e)))?;
+
+    weaver_renderer::facet::render_faceted_html(text, &facets)
+        .map_err(|e| JsError::new(&e.to_string()))
+}

crates/weaver-renderer-js/src/types.rs

···
+//! Types exposed to JavaScript via wasm-bindgen.
+
+use jacquard::IntoStatic;
+use wasm_bindgen::prelude::*;
+use weaver_common::ResolvedContent;
+
+/// Result from rendering LaTeX math.
+#[wasm_bindgen]
+pub struct JsMathResult {
+    pub success: bool,
+    #[wasm_bindgen(getter_with_clone)]
+    pub html: String,
+    #[wasm_bindgen(getter_with_clone)]
+    pub error: Option<String>,
+}
+
+/// Pre-rendered embed content for synchronous rendering.
+///
+/// Build this by calling `create_resolved_content()` and adding embeds
+/// with `resolved_content_add_embed()`.
+#[wasm_bindgen]
+pub struct JsResolvedContent {
+    inner: ResolvedContent,
+}
+
+#[wasm_bindgen]
+impl JsResolvedContent {
+    /// Create an empty resolved content container.
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: ResolvedContent::new(),
+        }
+    }
+
+    /// Add pre-rendered embed HTML for an AT URI.
+    ///
+    /// # Arguments
+    /// * `at_uri` - The AT Protocol URI (e.g., "at://did:plc:.../app.bsky.feed.post/...")
+    /// * `html` - The pre-rendered HTML for this embed
+    #[wasm_bindgen(js_name = addEmbed)]
+    pub fn add_embed(&mut self, at_uri: &str, html: &str) -> Result<(), JsError> {
+        use jacquard::types::string::AtUri;
+        use jacquard::CowStr;
+
+        let uri = AtUri::new(at_uri)
+            .map_err(|e| JsError::new(&format!("Invalid AT URI: {}", e)))?
+            .into_static();
+
+        self.inner.add_embed(uri, CowStr::from(html.to_string()), None);
+        Ok(())
+    }
+}
+
+impl JsResolvedContent {
+    pub fn into_inner(self) -> ResolvedContent {
+        self.inner
+    }
+}
+
+impl Default for JsResolvedContent {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Create an empty resolved content container.
+///
+/// Use this to pre-render embeds before calling render functions.
+#[wasm_bindgen]
+pub fn create_resolved_content() -> JsResolvedContent {
+    JsResolvedContent::new()
+}

crates/weaver-renderer/Cargo.toml

···
 weaver-common = { path = "../weaver-common" }
 weaver-api = { path = "../weaver-api" }
 jacquard.workspace = true
+serde.workspace = true
 markdown-weaver = { workspace = true }
 http = "1.3.1"
 url = "2.5.4"
···
 
 [dev-dependencies]
 insta = { version = "1.40", features = ["yaml"] }
+serde_json = "1.0"

crates/weaver-renderer/src/facet/processor.rs

···
     let mut events: Vec<FacetEvent<'a>> = Vec::new();
 
     for (idx, facet) in facets.iter().enumerate() {
-        if facet.range.is_empty() {
+        if facet.index.is_empty() {
             continue;
         }
         for feature in &facet.features {
-            events.push(FacetEvent::start(facet.range.start, feature.clone(), idx));
-            events.push(FacetEvent::end(facet.range.end, feature.clone(), idx));
+            events.push(FacetEvent::start(facet.index.start(), feature.clone(), idx));
+            events.push(FacetEvent::end(facet.index.end(), feature.clone(), idx));
         }
     }
 
···
     fn test_simple_bold() {
         let text = "hello world";
         let facets = vec![NormalizedFacet {
-            range: ByteRange::new(0, 5),
+            index: ByteRange::new(0, 5),
             features: vec![FacetFeature::Bold],
         }];
 
···
         let text = "bold and italic just italic";
         let facets = vec![
             NormalizedFacet {
-                range: ByteRange::new(0, 15),
+                index: ByteRange::new(0, 15),
                 features: vec![FacetFeature::Bold],
             },
             NormalizedFacet {
-                range: ByteRange::new(5, 27),
+                index: ByteRange::new(5, 27),
                 features: vec![FacetFeature::Italic],
             },
         ];
···
     fn test_link_facet() {
         let text = "click here for more";
         let facets = vec![NormalizedFacet {
-            range: ByteRange::new(6, 10),
+            index: ByteRange::new(6, 10),
             features: vec![FacetFeature::Link {
                 uri: "https://example.com",
             }],

crates/weaver-renderer/src/facet/types.rs

···
+use serde::{Deserialize, Serialize};
 use std::ops::Range;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ByteRange {
-    pub start: usize,
-    pub end: usize,
+    pub byte_start: usize,
+    pub byte_end: usize,
 }
 
 impl ByteRange {
     pub fn new(start: i64, end: i64) -> Self {
         Self {
-            start: start.max(0) as usize,
-            end: end.max(0) as usize,
+            byte_start: start.max(0) as usize,
+            byte_end: end.max(0) as usize,
         }
     }
 
     pub fn to_range(self) -> Range<usize> {
-        self.start..self.end
+        self.byte_start..self.byte_end
     }
 
     pub fn is_empty(&self) -> bool {
-        self.start >= self.end
+        self.byte_start >= self.byte_end
+    }
+
+    pub fn start(&self) -> usize {
+        self.byte_start
+    }
+
+    pub fn end(&self) -> usize {
+        self.byte_end
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "$type")]
 pub enum FacetFeature<'a> {
+    #[serde(rename = "pub.leaflet.richtext.facet#bold")]
+    #[serde(alias = "blog.pckt.richtext.facet#bold")]
     Bold,
+    #[serde(rename = "pub.leaflet.richtext.facet#italic")]
+    #[serde(alias = "blog.pckt.richtext.facet#italic")]
     Italic,
+    #[serde(rename = "pub.leaflet.richtext.facet#code")]
+    #[serde(alias = "blog.pckt.richtext.facet#code")]
     Code,
+    #[serde(rename = "pub.leaflet.richtext.facet#underline")]
+    #[serde(alias = "blog.pckt.richtext.facet#underline")]
     Underline,
+    #[serde(rename = "pub.leaflet.richtext.facet#strikethrough")]
+    #[serde(alias = "blog.pckt.richtext.facet#strikethrough")]
     Strikethrough,
+    #[serde(rename = "pub.leaflet.richtext.facet#highlight")]
+    #[serde(alias = "blog.pckt.richtext.facet#highlight")]
     Highlight,
-    Link { uri: &'a str },
-    DidMention { did: &'a str },
-    AtMention { at_uri: &'a str },
-    Tag { tag: &'a str },
-    Id { id: Option<&'a str> },
+    #[serde(rename = "pub.leaflet.richtext.facet#link")]
+    #[serde(alias = "blog.pckt.richtext.facet#link")]
+    #[serde(alias = "app.bsky.richtext.facet#link")]
+    Link {
+        #[serde(borrow)]
+        uri: &'a str,
+    },
+    #[serde(rename = "pub.leaflet.richtext.facet#didMention")]
+    #[serde(alias = "blog.pckt.richtext.facet#didMention")]
+    #[serde(alias = "app.bsky.richtext.facet#mention")]
+    DidMention {
+        #[serde(borrow)]
+        did: &'a str,
+    },
+    #[serde(rename = "pub.leaflet.richtext.facet#atMention")]
+    #[serde(alias = "blog.pckt.richtext.facet#atMention")]
+    AtMention {
+        #[serde(borrow, rename = "atUri")]
+        at_uri: &'a str,
+    },
+    #[serde(rename = "app.bsky.richtext.facet#tag")]
+    Tag {
+        #[serde(borrow)]
+        tag: &'a str,
+    },
+    #[serde(rename = "pub.leaflet.richtext.facet#id")]
+    #[serde(alias = "blog.pckt.richtext.facet#id")]
+    Id {
+        #[serde(borrow)]
+        id: Option<&'a str>,
+    },
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct NormalizedFacet<'a> {
-    pub range: ByteRange,
+    pub index: ByteRange,
+    #[serde(borrow)]
     pub features: Vec<FacetFeature<'a>>,
 }
 
···
     fn from(facet: &'a weaver_api::app_bsky::richtext::facet::Facet<'a>) -> Self {
         use weaver_api::app_bsky::richtext::facet::FacetFeaturesItem;
 
-        let range = ByteRange::new(facet.index.byte_start, facet.index.byte_end);
+        let index = ByteRange::new(facet.index.byte_start, facet.index.byte_end);
 
         let features = facet
             .features
···
             })
             .collect();
 
-        Self { range, features }
+        Self { index, features }
     }
 }
 
···
     fn from(facet: &'a weaver_api::pub_leaflet::richtext::facet::Facet<'a>) -> Self {
         use weaver_api::pub_leaflet::richtext::facet::FacetFeaturesItem;
 
-        let range = ByteRange::new(facet.index.byte_start, facet.index.byte_end);
+        let index = ByteRange::new(facet.index.byte_start, facet.index.byte_end);
 
         let features = facet
             .features
···
             })
             .collect();
 
-        Self { range, features }
+        Self { index, features }
     }
 }
 
···
     fn from(facet: &'a weaver_api::blog_pckt::richtext::facet::Facet<'a>) -> Self {
         use weaver_api::blog_pckt::richtext::facet::FacetFeaturesItem;
 
-        let range = ByteRange::new(facet.index.byte_start, facet.index.byte_end);
+        let index = ByteRange::new(facet.index.byte_start, facet.index.byte_end);
 
         let features = facet
             .features
···
             })
             .collect();
 
-        Self { range, features }
+        Self { index, features }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_deserialize_leaflet_facet() {
+        let json = r#"{
+            "index": {"byteStart": 0, "byteEnd": 5},
+            "features": [
+                {"$type": "pub.leaflet.richtext.facet#bold"},
+                {"$type": "pub.leaflet.richtext.facet#italic"}
+            ]
+        }"#;
+
+        let facet: NormalizedFacet = serde_json::from_str(json).unwrap();
+        assert_eq!(facet.index.byte_start, 0);
+        assert_eq!(facet.index.byte_end, 5);
+        assert_eq!(facet.features.len(), 2);
+        assert!(matches!(facet.features[0], FacetFeature::Bold));
+        assert!(matches!(facet.features[1], FacetFeature::Italic));
+    }
+
+    #[test]
+    fn test_deserialize_bsky_facet() {
+        let json = r#"{
+            "index": {"byteStart": 0, "byteEnd": 10},
+            "features": [
+                {"$type": "app.bsky.richtext.facet#link", "uri": "https://example.com"},
+                {"$type": "app.bsky.richtext.facet#mention", "did": "did:plc:abc123"}
+            ]
+        }"#;
+
+        let facet: NormalizedFacet = serde_json::from_str(json).unwrap();
+        assert_eq!(facet.index.byte_start, 0);
+        assert_eq!(facet.index.byte_end, 10);
+        assert_eq!(facet.features.len(), 2);
+        assert!(matches!(facet.features[0], FacetFeature::Link { uri: "https://example.com" }));
+        assert!(matches!(facet.features[1], FacetFeature::DidMention { did: "did:plc:abc123" }));
+    }
+
+    #[test]
+    fn test_deserialize_pckt_facet() {
+        let json = r#"{
+            "index": {"byteStart": 5, "byteEnd": 15},
+            "features": [
+                {"$type": "blog.pckt.richtext.facet#code"},
+                {"$type": "blog.pckt.richtext.facet#strikethrough"}
+            ]
+        }"#;
+
+        let facet: NormalizedFacet = serde_json::from_str(json).unwrap();
+        assert_eq!(facet.index.byte_start, 5);
+        assert_eq!(facet.index.byte_end, 15);
+        assert_eq!(facet.features.len(), 2);
+        assert!(matches!(facet.features[0], FacetFeature::Code));
+        assert!(matches!(facet.features[1], FacetFeature::Strikethrough));
+    }
+
+    #[test]
+    fn test_deserialize_tag_facet() {
+        let json = r#"{
+            "index": {"byteStart": 0, "byteEnd": 8},
+            "features": [
+                {"$type": "app.bsky.richtext.facet#tag", "tag": "rust"}
+            ]
+        }"#;
+
+        let facet: NormalizedFacet = serde_json::from_str(json).unwrap();
+        assert!(matches!(facet.features[0], FacetFeature::Tag { tag: "rust" }));
     }
 }