working through the core types

Cargo.lock

···
 ]
 
 [[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
 name = "android_system_properties"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
 name = "form_urlencoded"
 version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
 
 [[package]]
 name = "hashbrown"
···
  "futures-lite",
  "getrandom 0.2.16",
  "getrandom 0.3.4",
+ "hashbrown 0.15.5",
  "http",
  "ipld-core",
  "k256",
  "langtag",
+ "maitake-sync",
  "miette",
  "multibase",
  "multihash",
···
  "serde_json",
  "signature",
  "smol_str",
+ "spin 0.10.0",
  "thiserror 2.0.17",
  "tokio",
  "tokio-tungstenite-wasm",
···
 checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 
 [[package]]
+name = "maitake-sync"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6816ab14147f80234c675b80ed6dc4f440d8a1cefc158e766067aedb84c0bcd5"
+dependencies = [
+ "cordyceps",
+ "loom",
+ "mycelium-bitfield",
+ "pin-project",
+ "portable-atomic",
+]
+
+[[package]]
 name = "markup5ever"
 version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "tempfile",
  "twoway",
 ]
+
+[[package]]
+name = "mycelium-bitfield"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24e0cc5e2c585acbd15c5ce911dff71e1f4d5313f43345873311c4f5efd741cc"
 
 [[package]]
 name = "n0-future"
···
  "flate2",
  "miniz_oxide 0.8.9",
 ]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
 
 [[package]]
 name = "postcard"

crates/jacquard-common/Cargo.toml

···
 license.workspace = true
 
 [features]
-default = ["service-auth", "reqwest-client", "crypto"]
+default = ["std", "service-auth", "reqwest-client", "crypto"]
+std = [
+    "dep:tokio",
+    "miette/fancy",
+    "serde_json/std",
+    "serde/std",
+]
 crypto = []
 crypto-ed25519 = ["crypto", "dep:ed25519-dalek"]
 crypto-k256 = ["crypto", "dep:k256", "k256/ecdsa"]
 crypto-p256 = ["crypto", "dep:p256", "p256/ecdsa"]
 service-auth = ["crypto-k256", "crypto-p256", "dep:signature"]
-reqwest-client = ["dep:reqwest"]
+reqwest-client = ["std", "dep:reqwest"]
 tracing = ["dep:tracing"]
 streaming = ["n0-future", "futures", "reqwest/stream"]
 websocket = ["streaming", "tokio-tungstenite-wasm", "dep:ciborium"]
···
 cid.workspace = true
 ipld-core.workspace = true
 langtag = { version = "0.4.0", features = ["serde"] }
-miette.workspace = true
+miette = { workspace = true } # also need to gate this to std only
 multibase = "0.9.1"
 multihash = "0.19.3"
 ouroboros = "0.18.5"
-rand = "0.9.2"
+rand = "0.9.2" # also need to check this for no-std
 serde.workspace = true
-serde_html_form.workspace = true
+serde_html_form.workspace = true # need to check these at workspace level
 serde_json.workspace = true
 smol_str.workspace = true
 thiserror.workspace = true
 url.workspace = true
 http.workspace = true
 serde_bytes = "0.11"
-
+spin = { version = "0.10", default-features = false, features = ["lazy"] }
+maitake-sync = { version = "0.1", default-features = false }
+hashbrown = "0.15"
 
 reqwest = { workspace = true, optional = true, features = ["json", "gzip", "charset"] }
 serde_ipld_dagcbor.workspace = true
 signature = { version = "2", optional = true }
 tracing = { workspace = true, optional = true }
-tokio = { workspace = true, default-features = false, features = ["sync"] }
+tokio = { workspace = true, default-features = false, features = ["sync"], optional = true }
 
 # Streaming support (optional)
 n0-future = { workspace = true, optional = true }

crates/jacquard-common/src/cowstr.rs

···
+use alloc::borrow::Cow;
+use alloc::boxed::Box;
+use alloc::string::String;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ops::Deref;
+
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
-use std::{
-    borrow::Cow,
-    fmt,
-    hash::{Hash, Hasher},
-    ops::Deref,
-};
 
 use crate::IntoStatic;
 
···
 impl<'s> CowStr<'s> {
     #[inline]
     /// Borrow and decode a byte slice as utf8 into a CowStr
-    pub fn from_utf8(s: &'s [u8]) -> Result<Self, std::str::Utf8Error> {
-        Ok(Self::Borrowed(std::str::from_utf8(s)?))
+    pub fn from_utf8(s: &'s [u8]) -> Result<Self, core::str::Utf8Error> {
+        Ok(Self::Borrowed(core::str::from_utf8(s)?))
     }
 
     #[inline]
     /// Take bytes and decode them as utf8 into an owned CowStr. Might allocate.
-    pub fn from_utf8_owned(s: impl AsRef<[u8]>) -> Result<Self, std::str::Utf8Error> {
-        Ok(Self::Owned(SmolStr::new(std::str::from_utf8(&s.as_ref())?)))
+    pub fn from_utf8_owned(s: impl AsRef<[u8]>) -> Result<Self, core::str::Utf8Error> {
+        Ok(Self::Owned(SmolStr::new(core::str::from_utf8(s.as_ref())?)))
     }
 
     #[inline]
···
     /// This function is unsafe because it does not check that the bytes are valid UTF-8.
     #[inline]
     pub unsafe fn from_utf8_unchecked(s: &'s [u8]) -> Self {
-        unsafe { Self::Owned(SmolStr::new(std::str::from_utf8_unchecked(s))) }
+        unsafe { Self::Owned(SmolStr::new(core::str::from_utf8_unchecked(s))) }
     }
 
     /// Returns a reference to the underlying string slice.
···
 }
 
 impl PartialOrd for CowStr<'_> {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
         Some(match (self, other) {
             (CowStr::Borrowed(s1), CowStr::Borrowed(s2)) => s1.cmp(s2),
             (CowStr::Borrowed(s1), CowStr::Owned(s2)) => s1.cmp(&s2.as_ref()),
···
 }
 
 impl Ord for CowStr<'_> {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         match (self, other) {
             (CowStr::Borrowed(s1), CowStr::Borrowed(s2)) => s1.cmp(s2),
             (CowStr::Borrowed(s1), CowStr::Owned(s2)) => s1.cmp(&s2.as_ref()),

crates/jacquard-common/src/error.rs

···
 //! Error types for XRPC client operations
 
 use crate::xrpc::EncodeError;
+use alloc::boxed::Box;
+use alloc::string::ToString;
 use bytes::Bytes;
 use smol_str::SmolStr;
 
 /// Boxed error type for wrapping arbitrary errors
-pub type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;
+pub type BoxError = Box<dyn core::error::Error + Send + Sync + 'static>;
 
 /// Client error type for all XRPC client operations
 #[derive(Debug, thiserror::Error, miette::Diagnostic)]

crates/jacquard-common/src/http_client.rs

···
 //! Minimal HTTP client abstraction shared across crates.
 
-use std::fmt::Display;
-use std::future::Future;
-use std::sync::Arc;
+use alloc::string::ToString;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::fmt::Display;
+use core::future::Future;
 
 /// HTTP client trait for sending raw HTTP requests.
 #[cfg_attr(not(target_arch = "wasm32"), trait_variant::make(Send))]
 pub trait HttpClient {
     /// Error type returned by the HTTP client
-    type Error: std::error::Error + Display + Send + Sync + 'static;
+    type Error: core::error::Error + Display + Send + Sync + 'static;
 
     /// Send an HTTP request and return the response.
     fn send_http(
···
         request: http::Request<Vec<u8>>,
     ) -> core::result::Result<http::Response<Vec<u8>>, Self::Error> {
         // Convert http::Request to reqwest::Request
+
         let (parts, body) = request.into_parts();
 
         let mut req = self.request(parts.method, parts.uri.to_string()).body(body);

crates/jacquard-common/src/into_static.rs

···
-use std::borrow::Cow;
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
-use std::hash::BuildHasher;
-use std::hash::Hash;
-use std::sync::Arc;
+use alloc::borrow::Cow;
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
+use alloc::collections::VecDeque;
+use alloc::string::String;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::hash::BuildHasher;
+use core::hash::Hash;
+
+use hashbrown::HashMap;
+use hashbrown::HashSet;
 
 /// Allow turning a value into an "owned" variant, which can then be
 /// returned, moved, etc.

crates/jacquard-common/src/jetstream.rs

···
 use crate::types::string::{Datetime, Did, Handle, Rkey};
 use crate::xrpc::{MessageEncoding, SubscriptionResp, XrpcSubscription};
 use crate::{CowStr, Data, IntoStatic, RawData};
+use alloc::vec::Vec;
 use serde::{Deserialize, Serialize};
 
 /// Parameters for subscribing to Jetstream

crates/jacquard-common/src/lib.rs

···
 //! be happy to debug, and if it's using a method from one of the jacquard crates and seems like
 //! it *should* just work, that is a bug in jacquard, and you should [file an issue](https://tangled.org/@nonbinary.computer/jacquard/).
 
+#![no_std]
 #![warn(missing_docs)]
+
+#[macro_use]
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+/// Lazy initialization type for static values.
+///
+/// Uses `std::sync::LazyLock` when the `std` feature is enabled, or `spin::Lazy`
+/// for no_std environments. Exported so downstream crates can use it without
+/// their own conditional compilation.
+#[cfg(feature = "std")]
+pub type Lazy<T> = std::sync::LazyLock<T>;
+
+#[cfg(not(feature = "std"))]
+pub use spin::Lazy;
+
 pub use bytes;
 pub use chrono;
 pub use cowstr::CowStr;

crates/jacquard-common/src/opt_serde_bytes_helper.rs

···
 //! Custom serde helpers for bytes::Bytes using serde_bytes
 
+use alloc::string::String;
+use alloc::vec::Vec;
 use base64::{
     Engine,
     prelude::{BASE64_STANDARD, BASE64_STANDARD_NO_PAD, BASE64_URL_SAFE, BASE64_URL_SAFE_NO_PAD},

crates/jacquard-common/src/serde_bytes_helper.rs

···
 //! Custom serde helpers for bytes::Bytes using serde_bytes
 
+use alloc::string::String;
+use alloc::vec::Vec;
 use core::fmt;
 
 use base64::{

crates/jacquard-common/src/service_auth.rs

···
 use crate::CowStr;
 use crate::IntoStatic;
 use crate::types::string::{Did, Nsid};
+use alloc::string::String;
+use alloc::string::ToString;
+use alloc::vec::Vec;
 use base64::Engine;
 use base64::engine::general_purpose::URL_SAFE_NO_PAD;
 use ouroboros::self_referencing;

crates/jacquard-common/src/session.rs

···
 //! Generic session storage traits and utilities.
 
+use alloc::boxed::Box;
+use alloc::string::ToString;
+use alloc::sync::Arc;
+use core::error::Error as StdError;
+use core::fmt::Display;
+use core::future::Future;
+use core::hash::Hash;
+use hashbrown::HashMap;
+#[cfg(feature = "std")]
 use miette::Diagnostic;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 use serde_json::Value;
-use std::collections::HashMap;
-use std::error::Error as StdError;
-use std::fmt::Display;
-use std::future::Future;
-use std::hash::Hash;
+
+#[cfg(feature = "std")]
 use std::path::{Path, PathBuf};
-use std::sync::Arc;
+
+// Use tokio's RwLock with std, maitake-sync's async RwLock for no_std
+#[cfg(not(feature = "std"))]
+use maitake_sync::RwLock;
+#[cfg(feature = "std")]
 use tokio::sync::RwLock;
 
 /// Errors emitted by session stores.
-#[derive(Debug, thiserror::Error, Diagnostic)]
+#[derive(Debug, thiserror::Error)]
+#[cfg_attr(feature = "std", derive(Diagnostic))]
 pub enum SessionStoreError {
     /// Filesystem or I/O error
+    #[cfg(feature = "std")]
     #[error("I/O error: {0}")]
-    #[diagnostic(code(jacquard::session_store::io))]
+    #[cfg_attr(feature = "std", diagnostic(code(jacquard::session_store::io)))]
     Io(#[from] std::io::Error),
     /// Serialization error (e.g., JSON)
     #[error("serialization error: {0}")]
-    #[diagnostic(code(jacquard::session_store::serde))]
+    #[cfg_attr(feature = "std", diagnostic(code(jacquard::session_store::serde)))]
     Serde(#[from] serde_json::Error),
     /// Any other error from a backend implementation
     #[error(transparent)]
-    #[diagnostic(code(jacquard::session_store::other))]
+    #[cfg_attr(feature = "std", diagnostic(code(jacquard::session_store::other)))]
     Other(#[from] Box<dyn StdError + Send + Sync>),
 }
 
···
 /// let store = FileTokenStore::new("/tmp/jacquard-session.json");
 /// let client = AtClient::new(reqwest::Client::new(), base, store);
 /// ```
+#[cfg(feature = "std")]
 #[derive(Clone, Debug)]
 pub struct FileTokenStore {
     /// Path to the JSON file.
     pub path: PathBuf,
 }
 
+#[cfg(feature = "std")]
 impl FileTokenStore {
     /// Create a new file token store at the given path.
     pub fn new(path: impl AsRef<Path>) -> Self {
···
     }
 }
 
+#[cfg(feature = "std")]
 impl<K: Eq + Hash + Display + Send + Sync, T: Clone + Serialize + DeserializeOwned + Send + Sync>
     SessionStore<K, T> for FileTokenStore
 {

crates/jacquard-common/src/stream.rs

···
 //! # }
 //! ```
 
-use std::error::Error;
-use std::fmt;
-use std::pin::Pin;
+use alloc::boxed::Box;
+use alloc::string::String;
+use core::error::Error;
+use core::fmt;
+use core::pin::Pin;
 
 /// Boxed error type for streaming operations
 pub type BoxError = Box<dyn Error + Send + Sync + 'static>;

crates/jacquard-common/src/types.rs

···
 use serde::{Deserialize, Serialize};
 
+// Re-export Lazy from crate root for submodule use via `super::Lazy`
+pub use crate::Lazy;
+
 /// AT Protocol URI (at://) types and validation
 pub mod aturi;
 /// Blob references for binary data

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

···
 use crate::types::recordkey::{RecordKey, Rkey};
 use crate::types::string::AtStrError;
 use crate::{CowStr, IntoStatic};
+use alloc::string::String;
+use alloc::string::ToString;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ops::Deref;
+use core::str::FromStr;
 #[cfg(not(target_arch = "wasm32"))]
 use regex::Regex;
 #[cfg(target_arch = "wasm32")]
···
 use serde::Serializer;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::sync::LazyLock;
-use std::{ops::Deref, str::FromStr};
+
+use super::Lazy;
 
 /// AT Protocol URI (`at://`) for referencing records in repositories
 ///
···
 pub type UriPathBuf = RepoPath<'static>;
 
 /// Regex for AT URI validation per AT Protocol spec
-pub static ATURI_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+pub static ATURI_REGEX: Lazy<Regex> = Lazy::new(|| {
     // Fragment allows: / and \ and other special chars. In raw string, backslashes are literal.
     Regex::new(r##"^at://(?<authority>[a-zA-Z0-9._:%-]+)(/(?<collection>[a-zA-Z0-9-.]+)(/(?<rkey>[a-zA-Z0-9._~:@!$&%')(*+,;=-]+))?)?(#(?<fragment>/[a-zA-Z0-9._~:@!$&%')(*+,;=\-\[\]/\\]*))?$"##).unwrap()
 });

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

···
 use crate::{CowStr, IntoStatic, types::cid::CidLink};
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error};
 use smol_str::ToSmolStr;
-use std::convert::Infallible;
-use std::{fmt, hash::Hash, ops::Deref, str::FromStr};
+use alloc::string::{String, ToString};
+use core::convert::Infallible;
+use core::{fmt, hash::Hash, ops::Deref, str::FromStr};
 
 /// Blob reference for binary data in AT Protocol
 ///

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

···
 pub use cid::Cid as IpldCid;
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Visitor};
 use smol_str::ToSmolStr;
-use std::{convert::Infallible, fmt, ops::Deref, str::FromStr};
+use alloc::string::{String, ToString};
+use core::{convert::Infallible, fmt, ops::Deref, str::FromStr};
 
 /// CID codec for AT Protocol (raw)
 pub const ATP_CID_CODEC: u64 = 0x55;

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

···
+use alloc::string::String;
 use core::fmt;
 
 use serde::{Deserialize, Serialize};

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

···
 //! assert!(matches!(pk.codec, KeyCodec::Ed25519));
 //! assert_eq!(pk.bytes.as_ref(), &key);
 
+use alloc::borrow::Cow;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+
 use crate::IntoStatic;
-use std::borrow::Cow;
 
 /// Multicodec code for SHA2-256 hash
 pub const SHA2_256: u64 = 0x12;

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

···
+use alloc::string::{String, ToString};
+use core::cmp;
+use core::fmt;
+use core::str::FromStr;
+
 use chrono::DurationRound;
 use serde::Serializer;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
-use std::fmt;
-use std::sync::LazyLock;
-use std::{cmp, str::FromStr};
+
+use super::Lazy;
 
 use crate::{CowStr, IntoStatic};
 #[cfg(not(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(|| {
+pub static ISO8601_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?(Z|(\+[0-9]{2}|\-[0-9][1-9]):[0-9]{2})$").unwrap()
 });
 

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

···
 use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
-use std::fmt;
-use std::sync::LazyLock;
-use std::{ops::Deref, str::FromStr};
+use alloc::string::{String, ToString};
+use core::fmt;
+use core::ops::Deref;
+use core::str::FromStr;
+
+use super::Lazy;
 
 /// Decentralized Identifier (DID) for AT Protocol accounts
 ///
···
 /// enforce percent-encoding validity at validation time. While the spec states "percent sign
 /// must be followed by two hex characters," this is treated as a best practice rather than
 /// a hard validation requirement.
-pub static DID_REGEX: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$").unwrap());
+pub static DID_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$").unwrap());
 
 impl<'d> Did<'d> {
     /// Fallible constructor, validates, borrows from input

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

···
 use crate::types::string::{Did, Handle};
 use crate::types::value::Data;
 use crate::{CowStr, IntoStatic};
+use alloc::collections::BTreeMap;
+use alloc::vec::Vec;
 use bon::Builder;
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
-use std::collections::BTreeMap;
 use url::Url;
 
 /// DID Document representation with borrowed data where possible.
···
 
     /// Alternate identifiers for the subject, such as at://\<handle\>
     #[serde(borrow)]
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub also_known_as: Option<Vec<CowStr<'a>>>,
 
     /// Verification methods (keys) for this DID
     #[serde(borrow)]
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub verification_method: Option<Vec<VerificationMethod<'a>>>,
 
     /// Services associated with this DID (e.g., AtprotoPersonalDataServer)
     #[serde(borrow)]
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub service: Option<Vec<Service<'a>>>,
 
     /// Forward‑compatible capture of unmodeled fields
···
     pub r#type: CowStr<'a>,
     /// Optional controller DID
     #[serde(borrow)]
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub controller: Option<CowStr<'a>>,
     /// Multikey `publicKeyMultibase` (base58btc)
     #[serde(borrow)]
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub public_key_multibase: Option<CowStr<'a>>,
 
     /// Forward‑compatible capture of unmodeled fields
···
     pub r#type: CowStr<'a>,
     /// String or object; we preserve as Data
     #[serde(borrow)]
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub service_endpoint: Option<Data<'a>>,
 
     /// Forward‑compatible capture of unmodeled fields
···
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::string::String;
     use serde_json::json;
 
     fn encode_uvarint(mut x: u64) -> Vec<u8> {

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

···
 use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
-use std::fmt;
-use std::sync::LazyLock;
-use std::{ops::Deref, str::FromStr};
+use alloc::string::{String, ToString};
+use core::fmt;
+use core::ops::Deref;
+use core::str::FromStr;
+
+use super::Lazy;
 
 /// AT Protocol handle (human-readable account identifier)
 ///
···
 pub struct Handle<'h>(pub(crate) CowStr<'h>);
 
 /// Regex for handle validation per AT Protocol spec
-pub static HANDLE_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+pub static HANDLE_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r"^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$").unwrap()
 });
 impl<'h> Handle<'h> {

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

···
 use crate::types::handle::Handle;
 use crate::types::string::AtStrError;
 use crate::{IntoStatic, types::did::Did};
-use std::fmt;
-use std::str::FromStr;
+use alloc::string::String;
+use core::fmt;
+use core::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 

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

···
 //! Lexicon integer types with minimum or maximum acceptable values.
 //! Copied from [atrium](https://github.com/atrium-rs/atrium/blob/main/atrium-api/src/types/integer.rs), because this they got right
 
-use std::num::{NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64};
-use std::str::FromStr;
+use alloc::string::{String, ToString};
+use core::num::{NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64};
+use core::str::FromStr;
 
 use serde::{Deserialize, de::Error};
 

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

···
 use langtag::InvalidLangTag;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
-use std::fmt;
-use std::{ops::Deref, str::FromStr};
+use alloc::string::{String, ToString};
+use core::fmt;
+use core::ops::Deref;
+use core::str::FromStr;
 
 use crate::CowStr;
 

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

···
 use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
-use std::fmt;
-use std::sync::LazyLock;
-use std::{ops::Deref, str::FromStr};
+use alloc::string::{String, ToString};
+use core::fmt;
+use core::ops::Deref;
+use core::str::FromStr;
+
+use super::Lazy;
 
 /// Namespaced Identifier (NSID) for Lexicon schemas and XRPC endpoints
 ///
···
 pub struct Nsid<'n>(pub(crate) CowStr<'n>);
 
 /// Regex for NSID validation per AT Protocol spec
-pub static NSID_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+pub static NSID_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r"^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z][a-zA-Z0-9]{0,62})$").unwrap()
 });
 

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

···
 use regex_lite::Regex;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
-use std::fmt;
-use std::marker::PhantomData;
-use std::sync::LazyLock;
-use std::{ops::Deref, str::FromStr};
+use alloc::string::{String, ToString};
+use core::fmt;
+use core::marker::PhantomData;
+use core::ops::Deref;
+use core::str::FromStr;
+
+use super::Lazy;
 
 /// Trait for typed record key implementations
 ///
···
 }
 
 /// Regex for record key validation per AT Protocol spec
-pub static RKEY_REGEX: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9.\-_:~]{1,512}$").unwrap());
+pub static RKEY_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"^[a-zA-Z0-9.\-_:~]{1,512}$").unwrap());
 
 impl<'r> Rkey<'r> {
     /// Fallible constructor, validates, borrows from input

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

···
 use miette::SourceSpan;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use smol_str::{SmolStr, ToSmolStr};
-use std::{str::FromStr, sync::Arc};
+use alloc::string::{String, ToString};
+use alloc::sync::Arc;
+use core::str::FromStr;
 
 pub use crate::{
     CowStr,

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

···
+use alloc::borrow::ToOwned;
+use alloc::string::{String, ToString};
+use core::fmt;
+use core::ops::Deref;
+use core::str::FromStr;
+
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, SmolStrBuilder};
-use std::fmt;
-use std::sync::LazyLock;
-use std::{ops::Deref, str::FromStr};
+
+use super::Lazy;
 
 use crate::CowStr;
 use crate::types::integer::LimitedU32;
···
 }
 
 /// Regex for TID validation per AT Protocol spec
-static TID_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+static TID_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r"^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$").unwrap()
 });
 

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

···
 };
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use smol_str::ToSmolStr;
-use std::{fmt::Display, marker::PhantomData, ops::Deref, str::FromStr};
+use core::{fmt::Display, marker::PhantomData, ops::Deref, str::FromStr};
 use url::Url;
 
 /// Generic URI with type-specific parsing

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

···
     IntoStatic,
     types::{DataModelType, LexiconStringType, UriType, blob::Blob, string::*},
 };
+use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
 use bytes::Bytes;
+use core::convert::Infallible;
 use ipld_core::ipld::Ipld;
 use smol_str::{SmolStr, ToSmolStr};
-use std::{collections::BTreeMap, convert::Infallible};
 
 /// Conversion utilities for Data types
 pub mod convert;

crates/jacquard-common/src/types/value/convert.rs

···
     string::AtprotoStr,
     value::{Array, Data, Object, RawData, parsing},
 };
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
+use alloc::string::String;
+use alloc::string::ToString;
+use alloc::vec::Vec;
 use bytes::Bytes;
 use core::any::TypeId;
 use smol_str::SmolStr;
-use std::{borrow::ToOwned, boxed::Box, collections::BTreeMap, vec::Vec};
 
 /// Error used for converting from and into [`crate::types::value::Data`].
 #[derive(Clone, Debug, thiserror::Error, miette::Diagnostic)]

crates/jacquard-common/src/types/value/parsing.rs

···
 use bytes::Bytes;
 use ipld_core::ipld::Ipld;
 use smol_str::{SmolStr, ToSmolStr};
-use std::{collections::BTreeMap, str::FromStr};
+use alloc::collections::BTreeMap;
+use alloc::string::String;
+use core::str::FromStr;
 use url::Url;
 
 /// Insert a string into an at:// `Data<'_>` map, inferring its type.

crates/jacquard-common/src/types/value/serde_impl.rs

···
 use crate::types::cid::IpldCid;
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
+use alloc::string::String;
+use alloc::string::ToString;
+use alloc::vec::Vec;
 use base64::{Engine, prelude::BASE64_STANDARD};
 use bytes::Bytes;
 use core::fmt;
+use core::str::FromStr;
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::VariantAccess};
 use smol_str::{SmolStr, ToSmolStr};
-use std::{collections::BTreeMap, str::FromStr};
 
 use crate::{
     IntoStatic,

crates/jacquard-common/src/types/value/tests.rs

···
 use super::*;
-use std::str::FromStr;
+use core::str::FromStr;
 
 /// Canonicalize JSON by sorting object keys recursively
 fn canonicalize_json(value: &serde_json::Value) -> serde_json::Value {
···
     // Test complex types
     let mut map = BTreeMap::new();
     map.insert(SmolStr::new_static("num"), Data::Integer(42));
-    map.insert(SmolStr::new_static("text"), Data::String(AtprotoStr::String("test".into())));
+    map.insert(
+        SmolStr::new_static("text"),
+        Data::String(AtprotoStr::String("test".into())),
+    );
     let obj_data = Data::Object(Object(map));
     let cbor_result = obj_data.to_dag_cbor();
     assert!(cbor_result.is_ok());
     assert!(!cbor_result.unwrap().is_empty());
 
     // Test array
-    let arr_data = Data::Array(Array(vec![Data::Integer(1), Data::Integer(2), Data::Integer(3)]));
+    let arr_data = Data::Array(Array(vec![
+        Data::Integer(1),
+        Data::Integer(2),
+        Data::Integer(3),
+    ]));
     let arr_cbor = arr_data.to_dag_cbor();
     assert!(arr_cbor.is_ok());
     assert!(!arr_cbor.unwrap().is_empty());
···
 fn test_object_methods() {
     let mut map = BTreeMap::new();
     map.insert(SmolStr::new_static("num"), Data::Integer(42));
-    map.insert(SmolStr::new_static("text"), Data::String(AtprotoStr::String("hello".into())));
+    map.insert(
+        SmolStr::new_static("text"),
+        Data::String(AtprotoStr::String("hello".into())),
+    );
     let obj = Object(map);
 
     // Test get
···
 fn test_get_at_path_simple() {
     // Build nested structure: {"embed": {"alt": "test"}}
     let mut inner = BTreeMap::new();
-    inner.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("test".into())));
+    inner.insert(
+        SmolStr::new_static("alt"),
+        Data::String(AtprotoStr::String("test".into())),
+    );
 
     let mut outer = BTreeMap::new();
     outer.insert(SmolStr::new_static("embed"), Data::Object(Object(inner)));
···
 fn test_get_at_path_arrays() {
     // Build: {"items": [{"name": "first"}, {"name": "second"}]}
     let mut item1 = BTreeMap::new();
-    item1.insert(SmolStr::new_static("name"), Data::String(AtprotoStr::String("first".into())));
+    item1.insert(
+        SmolStr::new_static("name"),
+        Data::String(AtprotoStr::String("first".into())),
+    );
 
     let mut item2 = BTreeMap::new();
-    item2.insert(SmolStr::new_static("name"), Data::String(AtprotoStr::String("second".into())));
+    item2.insert(
+        SmolStr::new_static("name"),
+        Data::String(AtprotoStr::String("second".into())),
+    );
 
     let items = Data::Array(Array(vec![
         Data::Object(Object(item1)),
···
 fn test_get_at_path_complex() {
     // Build: {"post": {"embed": {"images": [{"alt": "img1"}, {"alt": "img2"}]}}}
     let mut img1 = BTreeMap::new();
-    img1.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("img1".into())));
+    img1.insert(
+        SmolStr::new_static("alt"),
+        Data::String(AtprotoStr::String("img1".into())),
+    );
 
     let mut img2 = BTreeMap::new();
-    img2.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("img2".into())));
+    img2.insert(
+        SmolStr::new_static("alt"),
+        Data::String(AtprotoStr::String("img2".into())),
+    );
 
     let images = Data::Array(Array(vec![
         Data::Object(Object(img1)),
···
     embed_map.insert(SmolStr::new_static("images"), images);
 
     let mut post_map = BTreeMap::new();
-    post_map.insert(SmolStr::new_static("embed"), Data::Object(Object(embed_map)));
+    post_map.insert(
+        SmolStr::new_static("embed"),
+        Data::Object(Object(embed_map)),
+    );
 
     let mut root = BTreeMap::new();
     root.insert(SmolStr::new_static("post"), Data::Object(Object(post_map)));
···
 #[test]
 fn test_query_exact_path() {
     let mut inner = BTreeMap::new();
-    inner.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice.bsky.social".into())));
+    inner.insert(
+        SmolStr::new_static("handle"),
+        Data::String(AtprotoStr::String("alice.bsky.social".into())),
+    );
 
     let mut outer = BTreeMap::new();
     outer.insert(SmolStr::new_static("author"), Data::Object(Object(inner)));
···
 fn test_query_wildcard_array() {
     // Build: {"actors": [{"handle": "alice"}, {"handle": "bob"}, {"name": "carol"}]}
     let mut actor1 = BTreeMap::new();
-    actor1.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice".into())));
+    actor1.insert(
+        SmolStr::new_static("handle"),
+        Data::String(AtprotoStr::String("alice".into())),
+    );
 
     let mut actor2 = BTreeMap::new();
-    actor2.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("bob".into())));
+    actor2.insert(
+        SmolStr::new_static("handle"),
+        Data::String(AtprotoStr::String("bob".into())),
+    );
 
     let mut actor3 = BTreeMap::new();
-    actor3.insert(SmolStr::new_static("name"), Data::String(AtprotoStr::String("carol".into())));
+    actor3.insert(
+        SmolStr::new_static("name"),
+        Data::String(AtprotoStr::String("carol".into())),
+    );
 
     let actors = Data::Array(Array(vec![
         Data::Object(Object(actor1)),
···
 fn test_query_wildcard_object() {
     // Build: {"embed": {"images": {...}, "video": {...}}}
     let mut images = BTreeMap::new();
-    images.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("img".into())));
+    images.insert(
+        SmolStr::new_static("alt"),
+        Data::String(AtprotoStr::String("img".into())),
+    );
 
     let mut video = BTreeMap::new();
-    video.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("vid".into())));
+    video.insert(
+        SmolStr::new_static("alt"),
+        Data::String(AtprotoStr::String("vid".into())),
+    );
 
     let mut embed = BTreeMap::new();
     embed.insert(SmolStr::new_static("images"), Data::Object(Object(images)));
···
 fn test_query_scoped_recursion() {
     // Build: {"post": {"author": {"profile": {"handle": "alice"}}}}
     let mut handle_map = BTreeMap::new();
-    handle_map.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice".into())));
+    handle_map.insert(
+        SmolStr::new_static("handle"),
+        Data::String(AtprotoStr::String("alice".into())),
+    );
 
     let mut profile_map = BTreeMap::new();
-    profile_map.insert(SmolStr::new_static("profile"), Data::Object(Object(handle_map)));
+    profile_map.insert(
+        SmolStr::new_static("profile"),
+        Data::Object(Object(handle_map)),
+    );
 
     let mut author_map = BTreeMap::new();
-    author_map.insert(SmolStr::new_static("author"), Data::Object(Object(profile_map)));
+    author_map.insert(
+        SmolStr::new_static("author"),
+        Data::Object(Object(profile_map)),
+    );
 
     let mut post_map = BTreeMap::new();
-    post_map.insert(SmolStr::new_static("post"), Data::Object(Object(author_map)));
+    post_map.insert(
+        SmolStr::new_static("post"),
+        Data::Object(Object(author_map)),
+    );
 
     let data = Data::Object(Object(post_map));
 
···
 fn test_query_global_recursion() {
     // Build structure with multiple 'cid' fields at different depths
     let mut inner1 = BTreeMap::new();
-    inner1.insert(SmolStr::new_static("cid"), Data::String(AtprotoStr::String("cid1".into())));
+    inner1.insert(
+        SmolStr::new_static("cid"),
+        Data::String(AtprotoStr::String("cid1".into())),
+    );
 
     let mut inner2 = BTreeMap::new();
-    inner2.insert(SmolStr::new_static("cid"), Data::String(AtprotoStr::String("cid2".into())));
+    inner2.insert(
+        SmolStr::new_static("cid"),
+        Data::String(AtprotoStr::String("cid2".into())),
+    );
 
     let mut middle = BTreeMap::new();
     middle.insert(SmolStr::new_static("post"), Data::Object(Object(inner1)));
···
 
     let mut root = BTreeMap::new();
     root.insert(SmolStr::new_static("thread"), Data::Object(Object(middle)));
-    root.insert(SmolStr::new_static("cid"), Data::String(AtprotoStr::String("cid3".into())));
+    root.insert(
+        SmolStr::new_static("cid"),
+        Data::String(AtprotoStr::String("cid3".into())),
+    );
 
     let data = Data::Object(Object(root));
 
···
 fn test_query_combined_wildcard_field() {
     // Build: {"actors": [{"handle": "alice"}, {"handle": "bob"}]}
     let mut actor1 = BTreeMap::new();
-    actor1.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice".into())));
+    actor1.insert(
+        SmolStr::new_static("handle"),
+        Data::String(AtprotoStr::String("alice".into())),
+    );
 
     let mut actor2 = BTreeMap::new();
-    actor2.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("bob".into())));
+    actor2.insert(
+        SmolStr::new_static("handle"),
+        Data::String(AtprotoStr::String("bob".into())),
+    );
 
     let actors = Data::Array(Array(vec![
         Data::Object(Object(actor1)),
···
         SmolStr::new_static("$type"),
         Data::String(AtprotoStr::String(CowStr::new_static("app.bsky.feed.post"))),
     );
-    map.insert(SmolStr::new_static("text"), Data::String(AtprotoStr::String(CowStr::new_static("hello"))));
+    map.insert(
+        SmolStr::new_static("text"),
+        Data::String(AtprotoStr::String(CowStr::new_static("hello"))),
+    );
     let obj = Object(map);
 
     assert_eq!(obj.type_discriminator(), Some("app.bsky.feed.post"));

crates/jacquard-common/src/websocket.rs

···
 
 use crate::CowStr;
 use crate::stream::StreamError;
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::string::ToString;
+use alloc::vec::Vec;
 use bytes::Bytes;
+use core::borrow::Borrow;
+use core::fmt::{self, Display};
+use core::future::Future;
+use core::ops::Deref;
+use core::pin::Pin;
 use n0_future::Stream;
-use std::borrow::Borrow;
-use std::fmt::{self, Display};
-use std::future::Future;
-use std::ops::Deref;
-use std::pin::Pin;
 use url::Url;
 
 /// UTF-8 validated bytes for WebSocket text messages
···
 
     /// Get as string slice
     pub fn as_str(&self) -> &str {
-        unsafe { std::str::from_utf8_unchecked(&self.0) }
+        unsafe { core::str::from_utf8_unchecked(&self.0) }
     }
 
     /// Create from bytes without validation (caller must ensure UTF-8)

crates/jacquard-common/src/xrpc.rs

···
 #[cfg(feature = "streaming")]
 pub mod streaming;
 
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::string::String;
+#[cfg(feature = "streaming")]
+use alloc::string::ToString;
+use alloc::vec::Vec;
 use ipld_core::ipld::Ipld;
 #[cfg(feature = "streaming")]
 pub use streaming::{
···
 use crate::{CowStr, error::XrpcResult};
 use crate::{IntoStatic, types::value::RawData};
 use bytes::Bytes;
+use core::error::Error;
+use core::fmt::{self, Debug};
+use core::marker::PhantomData;
 use http::{
     HeaderName, HeaderValue, Request, StatusCode,
     header::{AUTHORIZATION, CONTENT_TYPE},
 };
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
-use std::fmt::{self, Debug};
-use std::{error::Error, marker::PhantomData};
 #[cfg(feature = "websocket")]
 pub use subscription::{
     BasicSubscriptionClient, MessageEncoding, SubscriptionCall, SubscriptionClient,

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

···
 //! Streaming support for XRPC requests and responses
 
 use crate::{IntoStatic, StreamError, stream::ByteStream, xrpc::XrpcRequest};
+use alloc::boxed::Box;
 use bytes::Bytes;
+use core::{marker::PhantomData, pin::Pin};
 use http::StatusCode;
 use n0_future::{StreamExt, TryStreamExt};
 use serde::{Deserialize, Serialize};
 #[cfg(not(target_arch = "wasm32"))]
 use std::path::Path;
-use std::{marker::PhantomData, pin::Pin};
 
 /// Boxed stream type with proper Send bounds for native, no Send for WASM
 #[cfg(not(target_arch = "wasm32"))]
···
 where
     <P as XrpcProcedureStream>::Frame<'static>: Serialize,
 {
-    let stream = s
-        .map(|f| P::encode_frame(f).map(|b| XrpcStreamFrame::new_typed::<P::Frame<'_>>(b)));
+    let stream =
+        s.map(|f| P::encode_frame(f).map(|b| XrpcStreamFrame::new_typed::<P::Frame<'_>>(b)));
 
     XrpcProcedureSend(Box::pin(stream))
 }
···
     pub fn from_bytestream(StreamingResponse { parts, body }: StreamingResponse) -> Self {
         Self {
             parts,
-            body: Box::pin(body
-                .into_inner()
-                .map_ok(|b| XrpcStreamFrame::new(b))),
+            body: Box::pin(body.into_inner().map_ok(|b| XrpcStreamFrame::new(b))),
         }
     }
 
···
     pub fn from_parts(parts: http::response::Parts, body: ByteStream) -> Self {
         Self {
             parts,
-            body: Box::pin(body
-                .into_inner()
-                .map_ok(|b| XrpcStreamFrame::new(b))),
+            body: Box::pin(body.into_inner().map_ok(|b| XrpcStreamFrame::new(b))),
         }
     }
 
···
     pub fn from_stream(StreamingResponse { parts, body }: StreamingResponse) -> Self {
         Self {
             parts,
-            body: Box::pin(body
-                .into_inner()
-                .map_ok(|b| XrpcStreamFrame::new_typed::<F::Frame<'_>>(b))),
+            body: Box::pin(
+                body.into_inner()
+                    .map_ok(|b| XrpcStreamFrame::new_typed::<F::Frame<'_>>(b)),
+            ),
         }
     }
 
···
     pub fn from_typed_parts(parts: http::response::Parts, body: ByteStream) -> Self {
         Self {
             parts,
-            body: Box::pin(body
-                .into_inner()
-                .map_ok(|b| XrpcStreamFrame::new_typed::<F::Frame<'_>>(b))),
+            body: Box::pin(
+                body.into_inner()
+                    .map_ok(|b| XrpcStreamFrame::new_typed::<F::Frame<'_>>(b)),
+            ),
         }
     }
 }

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

···
 //! This module defines traits and types for typed WebSocket subscriptions,
 //! mirroring the request/response pattern used for HTTP XRPC endpoints.
 
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use core::error::Error;
+use core::future::Future;
+use core::marker::PhantomData;
 #[cfg(not(target_arch = "wasm32"))]
 use n0_future::stream::Boxed;
 #[cfg(target_arch = "wasm32")]
 use n0_future::stream::BoxedLocal as Boxed;
 use serde::{Deserialize, Serialize};
-use std::error::Error;
-use std::future::Future;
-use std::marker::PhantomData;
 use url::Url;
 
 use crate::cowstr::ToCowStr;

crates/jacquard-derive/tests/lexicon.rs

···
 use jacquard_derive::lexicon;
 use serde::{Deserialize, Serialize};
+extern crate alloc;
 
 #[lexicon]
 #[derive(Serialize, Deserialize, Debug, PartialEq)]

crates/jacquard-derive/tests/lexicon_schema_derive.rs

···
 use jacquard_derive::{LexiconSchema, open_union};
 use jacquard_lexicon::schema::LexiconSchema as LexiconSchemaTrait;
 use serde::{Deserialize, Serialize};
+extern crate alloc;
 
 #[test]
 fn test_simple_struct() {

crates/jacquard-derive/tests/open_union.rs

···
 use jacquard_derive::open_union;
 use serde::{Deserialize, Serialize};
+extern crate alloc;
 
 #[open_union]
 #[derive(Serialize, Deserialize, Debug, PartialEq)]

crates/jacquard-lexicon/tests/roundtrip_post.rs

···
 //
 // This test verifies that the derive macro generates lexicon documents that match
 // the original JSON schemas.
-
+extern crate alloc;
 use jacquard_common::CowStr;
 use jacquard_common::types::string::{Datetime, Language};
 use jacquard_lexicon::lexicon::LexiconDoc;

crates/jacquard-lexicon/tests/union_test.rs

···
 // Minimal test for union attribute
-
+extern crate alloc;
 use jacquard_common::CowStr;
 use serde::{Deserialize, Serialize};