regex-lite usage on wasm

Cargo.lock

···
  "miette",
  "n0-future",
  "regex",
+ "regex-lite",
  "reqwest",
  "serde",
  "serde_html_form",
···
  "p256",
  "rand 0.9.2",
  "regex",
+ "regex-lite",
  "reqwest",
  "serde",
  "serde_html_form",
···
  "memchr",
  "regex-syntax",
 ]
+
+[[package]]
+name = "regex-lite"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
 
 [[package]]
 name = "regex-syntax"

Cargo.toml

···
 jose-jwk = "0.1"
 
 # Text processing
-regex = "1.11"
+regex = { version = "1.11", default-features = false }
 webpage = { version = "2.0", default-features = false }

crates/jacquard-common/Cargo.toml

···
 multihash = "0.19.3"
 ouroboros = "0.18.5"
 rand = "0.9.2"
-regex = "1.11.3"
 serde.workspace = true
 serde_html_form.workspace = true
 serde_json.workspace = true
···
 getrandom = { version = "0.3.4", features = ["wasm_js"] }
 chrono = { workspace = true, features = ["wasmbind"] }
 getrandom_02 = { package = "getrandom", version = "0.2", features = ["js"] }
+regex-lite = "0.1"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 reqwest = { workspace = true, optional = true, features = [ "http2", "system-proxy", "rustls-tls"] }
 tokio-util = { version = "0.7.16", features = ["io"] }
+regex = { version = "1.11.3", default-features = false, features = ["std", "perf-literal"] }
 
 
 

crates/jacquard-common/src/types/aturi.rs

···
 use crate::types::recordkey::{RecordKey, Rkey};
 use crate::types::string::AtStrError;
 use crate::{CowStr, IntoStatic};
+#[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
+#[cfg(target_arch = "wasm32")]
+use regex_lite::Regex;
 use serde::Serializer;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};

crates/jacquard-common/src/types/datetime.rs

···
 use std::{cmp, str::FromStr};
 
 use crate::{CowStr, IntoStatic};
+#[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
+#[cfg(target_arch = "wasm32")]
+use regex_lite::Regex;
 
 /// Regex for ISO 8601 datetime validation per AT Protocol spec
 pub static ISO8601_REGEX: LazyLock<Regex> = LazyLock::new(|| {

crates/jacquard-common/src/types/did.rs

···
 use crate::types::string::AtStrError;
 use crate::{CowStr, IntoStatic};
+#[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
+#[cfg(target_arch = "wasm32")]
+use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
 use std::fmt;

crates/jacquard-common/src/types/handle.rs

···
 use crate::types::string::AtStrError;
 use crate::types::{DISALLOWED_TLDS, ends_with};
 use crate::{CowStr, IntoStatic};
+#[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
+#[cfg(target_arch = "wasm32")]
+use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
 use std::fmt;

crates/jacquard-common/src/types/nsid.rs

···
 use crate::types::recordkey::RecordKeyType;
 use crate::types::string::AtStrError;
 use crate::{CowStr, IntoStatic};
+#[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
+#[cfg(target_arch = "wasm32")]
+use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
 use std::fmt;

crates/jacquard-common/src/types/recordkey.rs

···
 use crate::types::Literal;
 use crate::types::string::AtStrError;
 use crate::{CowStr, IntoStatic};
+#[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
+#[cfg(target_arch = "wasm32")]
+use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
 use std::fmt;

crates/jacquard-common/src/types/tid.rs

···
 use crate::CowStr;
 use crate::types::integer::LimitedU32;
 use crate::types::string::{AtStrError, StrParseKind};
+#[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
+#[cfg(target_arch = "wasm32")]
+use regex_lite::Regex;
 
 const S32_CHAR: &str = "234567abcdefghijklmnopqrstuvwxyz";
 

crates/jacquard-common/src/xrpc/dyn_req.rs

···
         }
     }
 }
+
+pub struct DynResponse {
+    buffer: Bytes,
+    status: StatusCode,
+}
+
+impl DynResponse {
+    pub fn new(buffer: Bytes, status: StatusCode) -> Self {
+        Self { buffer, status }
+    }
+
+    /// Parse the response into an owned output
+    pub fn into_output<R>(self) -> Result<RespOutput<'static, R>, XrpcError<RespErr<'static, R>>>
+    where
+        R: XrpcResp,
+        for<'a> RespOutput<'a, R>: IntoStatic<Output = RespOutput<'static, R>>,
+        for<'a> RespErr<'a, R>: IntoStatic<Output = RespErr<'static, R>>,
+    {
+        fn parse_error<'b, R: XrpcResp>(buffer: &'b [u8]) -> Result<R::Err<'b>, serde_json::Error> {
+            serde_json::from_slice(buffer)
+        }
+
+        // 200: parse as output
+        if self.status.is_success() {
+            match R::decode_output(&self.buffer) {
+                Ok(output) => Ok(output.into_static()),
+                Err(e) => Err(XrpcError::Decode(e)),
+            }
+        // 400: try typed XRPC error, fallback to generic error
+        } else if self.status.as_u16() == 400 {
+            let error = match parse_error::<R>(&self.buffer) {
+                Ok(error) => XrpcError::Xrpc(error),
+                Err(_) => {
+                    // Fallback to generic error (InvalidRequest, ExpiredToken, etc.)
+                    match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {
+                        Ok(mut generic) => {
+                            generic.nsid = R::NSID;
+                            generic.method = ""; // method info only available on request
+                            generic.http_status = self.status;
+                            // Map auth-related errors to AuthError
+                            match generic.error.as_ref() {
+                                "ExpiredToken" => XrpcError::Auth(AuthError::TokenExpired),
+                                "InvalidToken" => XrpcError::Auth(AuthError::InvalidToken),
+                                _ => XrpcError::Generic(generic),
+                            }
+                        }
+                        Err(e) => XrpcError::Decode(DecodeError::Json(e)),
+                    }
+                }
+            };
+            Err(error.into_static())
+        // 401: always auth error
+        } else {
+            let error: XrpcError<<R as XrpcResp>::Err<'_>> =
+                match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {
+                    Ok(mut generic) => {
+                        let status = self.status;
+                        generic.nsid = R::NSID;
+                        generic.method = ""; // method info only available on request
+                        generic.http_status = status;
+                        match generic.error.as_ref() {
+                            "ExpiredToken" => XrpcError::Auth(AuthError::TokenExpired),
+                            "InvalidToken" => XrpcError::Auth(AuthError::InvalidToken),
+                            _ => XrpcError::Auth(AuthError::NotAuthenticated),
+                        }
+                    }
+                    Err(e) => XrpcError::Decode(DecodeError::Json(e)),
+                };
+
+            Err(error.into_static())
+        }
+    }
+}

crates/jacquard/Cargo.toml

···
 tokio = { workspace = true, default-features = false, features = ["sync"] }
 url.workspace = true
 smol_str.workspace = true
-regex.workspace = true
 webpage.workspace = true
 jose-jwk = { workspace = true, features = ["p256"] }
 tracing = { workspace = true, optional = true }
···
     "rustls-tls",
 ] }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "fs"] }
+regex = { workspace = true, default-features = false, features = ["std", "perf-literal", "unicode"] }
 
 [target.'cfg(target_family = "wasm")'.dependencies]
 getrandom = { version = "0.2", features = ["js"] }
+regex-lite = "0.1"
 
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
 gloo-storage = "0.3"

crates/jacquard/src/richtext.rs

···
 use jacquard_identity::resolver::IdentityError;
 #[cfg(feature = "api_bluesky")]
 use jacquard_identity::resolver::IdentityResolver;
-use regex::Regex;
+#[cfg(not(target_family = "wasm"))]
+use regex::{Regex, Captures};
+#[cfg(target_family = "wasm")]
+use regex_lite::{Regex, Captures};
 use std::marker::PhantomData;
 use std::ops::Range;
 use std::sync::LazyLock;
···
 /// runs of newlines and invisible chars to at most two newlines.
 fn sanitize_text(text: &str) -> String {
     SANITIZE_NEWLINES_REGEX
-        .replace_all(text, |caps: &regex::Captures| {
+        .replace_all(text, |caps: &Captures| {
             let matched = caps.get(0).unwrap().as_str();
 
             // Count newline sequences, treating \r\n as one unit