various little doc formatting fixes

Cargo.lock

···
  "http",
  "jacquard-api",
  "jacquard-common",
+ "jacquard-derive",
  "miette",
  "reqwest",
  "serde",

crates/jacquard-api/Cargo.toml

···
 description.workspace = true
 
 [features]
-default = ["app_bsky", "com_atproto", "tools_ozone", "chat_bsky"]
+default = [ "com_atproto"]
 app_bsky = []
 chat_bsky = []
 com_atproto = []

crates/jacquard-api/src/lib.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
+#[cfg(feature = "app_bsky")]
 pub mod app_bsky;
+
+#[cfg(feature = "chat_bsky")]
 pub mod chat_bsky;
+
+#[cfg(feature = "com_atproto")]
 pub mod com_atproto;
+
+#[cfg(feature = "tools_ozone")]
 pub mod tools_ozone;

crates/jacquard-common/src/cowstr.rs

···
 
 use crate::IntoStatic;
 
-/// Shamelessly copied from https://github.com/bearcove/merde
+/// Shamelessly copied from [](https://github.com/bearcove/merde)
 /// A copy-on-write immutable string type that uses [`SmolStr`] for
 /// the "owned" variant.
 ///

crates/jacquard-common/src/into_static.rs

···
 use std::hash::Hash;
 use std::sync::Arc;
 
-/// Shamelessly copied from https://github.com/bearcove/merde
+/// Shamelessly copied from [](https://github.com/bearcove/merde)
 /// Allow turning a value into an "owned" variant, which can then be
 /// returned, moved, etc.
 ///

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

···
 
 /// at:// URI type
 ///
-/// based on the regex here: https://github.com/bluesky-social/atproto/blob/main/packages/syntax/src/aturi_validation.ts
+/// based on the regex here: [](https://github.com/bluesky-social/atproto/blob/main/packages/syntax/src/aturi_validation.ts)
 ///
 /// Doesn't support the query segment, but then neither does the Typescript SDK.
 #[derive(PartialEq, Eq, Debug)]

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

···
     ///
     /// Panics if [`Self::NSID`] is not a valid NSID.
     ///
-    /// [`Nsid`]: string::Nsid
+    /// [`Nsid`]: crate::types::string::Nsid
     fn nsid() -> crate::types::nsid::Nsid<'static> {
         Nsid::new_static(Self::NSID).expect("should be valid NSID")
     }
···
     /// > [`RecordKey`].
     ///
     /// [Repo Data Structure v3]: https://atproto.com/specs/repository#repo-data-structure-v3
-    /// [`Nsid`]: string::Nsid
+    /// [`Nsid`]: crate::types::string::Nsid
     fn repo_path<'u, T: RecordKeyType>(
         rkey: &'u crate::types::recordkey::RecordKey<T>,
     ) -> UriPath<'u> {

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

···
     /// Infallible constructor for when you *know* the string is a valid DID.
     /// Will panic on invalid DIDs. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
-    /// The From<String> and From<CowStr> impls use the same logic.
+    /// The `From<String>` and `From<CowStr>` impls use the same logic.
     pub fn raw(did: &'d str) -> Self {
         let did = did.strip_prefix("at://").unwrap_or(did);
         if did.len() > 2048 {

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

···
     /// Infallible constructor for when you *know* the string is a valid handle.
     /// Will panic on invalid handles. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
-    /// The From<String> and From<CowStr> impls use the same logic.
+    /// The `From<String>` and `From<CowStr>` impls use the same logic.
     ///
     /// Accepts (and strips) preceding '@' or 'at://' if present
     pub fn raw(handle: &'h str) -> Self {

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

···
     /// Infallible constructor for when you *know* the string is a valid identifier.
     /// Will panic on invalid identifiers. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
-    /// The From<String> and From<CowStr> impls use the same logic.
+    /// The `From<String>` and `From<CowStr>` impls use the same logic.
     pub fn raw(ident: &'i str) -> Self {
         if let Ok(did) = ident.parse() {
             AtIdentifier::Did(did)

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

···
     /// Infallible constructor for when you *know* the string is a valid IETF language tag.
     /// Will panic on invalid tag. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
-    /// The From<String> and From<CowStr> impls use the same logic.
+    /// The `From<String>` and `From<CowStr>` impls use the same logic.
     pub fn raw(lang: impl AsRef<str>) -> Self {
         let lang = lang.as_ref();
         let tag = langtag::LangTag::new(lang).expect("valid IETF language tag");

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

···
     /// Infallible constructor for when you *know* the string is a valid NSID.
     /// Will panic on invalid NSIDs. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
-    /// The From<String> and From<CowStr> impls use the same logic.
+    /// The `From<String>` and `From<CowStr>` impls use the same logic.
     pub fn raw(nsid: &'n str) -> Self {
         if nsid.len() > 317 {
             panic!("NSID too long")

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

···
 /// This is deliberately public (so that consumers can develop specialized record key types),
 /// but is marked as unsafe, because the implementer is expected to uphold the invariants
 /// required by this trait, namely compliance with the [spec](https://atproto.com/specs/record-key)
-/// as described by [`RKEY_REGEX`](RKEY_REGEX).
+/// as described by [`RKEY_REGEX`].
 ///
 /// This crate provides implementations for TID, NSID, literals, and generic strings
 pub unsafe trait RecordKeyType: Clone + Serialize {
···
 }
 
 /// ATProto Record Key (type `any`)
-/// Catch-all for any string meeting the overall Record Key requirements detailed https://atproto.com/specs/record-key
+/// Catch-all for any string meeting the overall Record Key requirements detailed [](https://atproto.com/specs/record-key)
 #[derive(Clone, PartialEq, Eq, Serialize, Hash)]
 #[serde(transparent)]
 #[repr(transparent)]
···
     /// Infallible constructor for when you *know* the string is a valid rkey.
     /// Will panic on invalid rkeys. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
-    /// The From<String> and From<CowStr> impls use the same logic.
+    /// The `From<String>` and `From<CowStr>` impls use the same logic.
     pub fn raw(rkey: &str) -> Self {
         if !rkey.eq_ignore_ascii_case(T::LITERAL) {
             panic!(

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

···
     /// Infallible constructor for when you *know* the string is a valid TID.
     /// Will panic on invalid TID. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
-    /// The From<String> and From<CowStr> impls use the same logic.
+    /// The `From<String>` and `From<CowStr>` impls use the same logic.
     pub fn raw(tid: impl AsRef<str>) -> Self {
         let tid = tid.as_ref();
         if tid.len() != 13 {

crates/jacquard-lexicon/src/codegen.rs

···
                 path
             };
 
+            let is_root = dir.components().count() == 0;
             let mods: Vec<_> = module_names
                 .iter()
                 .map(|name| {
                     let ident = syn::Ident::new(name, proc_macro2::Span::call_site());
-                    quote! { pub mod #ident; }
+                    if is_root {
+                        // Top-level modules get feature gates
+                        quote! {
+                            #[cfg(feature = #name)]
+                            pub mod #ident;
+                        }
+                    } else {
+                        quote! { pub mod #ident; }
+                    }
                 })
                 .collect();
 

crates/jacquard/Cargo.toml

···
 version.workspace = true
 edition.workspace = true
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = ["api_all"]
+derive = ["dep:jacquard-derive"]
+api = ["jacquard-api/com_atproto"]
+api_all = ["api", "jacquard-api/app_bsky", "jacquard-api/chat_bsky", "jacquard-api/tools_ozone"]
 
 [lib]
 name = "jacquard"
···
 http = "1.3.1"
 jacquard-api = { version = "0.1.0", path = "../jacquard-api" }
 jacquard-common = { path = "../jacquard-common" }
+jacquard-derive = { path = "../jacquard-derive", optional = true }
 miette = "7.6.0"
 reqwest = { version = "0.12.23", default-features = false, features = ["charset", "http2", "json", "system-proxy", "gzip", "rustls-tls"] }
 serde = { version = "1.0", features = ["derive"] }

crates/jacquard/src/lib.rs

···
 pub mod client;
 
 // Re-export common types
+#[cfg(feature = "api")]
+pub use jacquard_api as api;
 pub use jacquard_common::*;
+
+#[cfg(feature = "derive")]
+pub use jacquard_derive::*;