chore: 0.8.0 release prep

Signed-off-by: Nick Gerakines <[e-mail]>

README.md

···
 
 A comprehensive collection of Rust crates for building AT Protocol applications. This workspace provides identity management, record operations, OAuth 2.0 flows, HTTP client operations, XRPC services, and event streaming capabilities.
 
-Parts of this project were extracted from the open-source [smokesignal.events](https://tangled.sh/@smokesignal.events/smokesignal) project and are licensed under the MIT license.
+**Note**: This project contains components extracted from the open-source [smokesignal.events](https://tangled.sh/@smokesignal.events/smokesignal) project, an AT Protocol event and RSVP management application. This library is released under the MIT license.
 
 ## Components
 

crates/atproto-client/src/client.rs

···
         })?)
 }
 
-
 /// Performs an app password-authenticated HTTP POST request with JSON body and returns the response as bytes.
 ///
 /// This is useful when the server returns binary data such as images, CAR files,
···
             url: url.to_string(),
             error,
         })?)
-}
+}

crates/atproto-oauth-aip/src/lib.rs

···
-//! AT Protocol OAuth AIP implementation.
+//! # AT Protocol OAuth AIP (Identity Provider) Implementation
+//!
+//! This crate provides a comprehensive OAuth 2.0 workflow implementation for AT Protocol
+//! Identity Providers (AIPs). It handles the complete OAuth flow including Pushed 
+//! Authorization Requests (PAR), token exchange, and session management according to
+//! AT Protocol specifications.
+//!
+//! ## Key Features
+//!
+//! - **OAuth 2.0 Authorization Code Flow**: Complete implementation with PKCE support
+//! - **Pushed Authorization Requests (PAR)**: Enhanced security through server-side request storage
+//! - **Token Exchange**: Secure token issuance and refresh capabilities
+//! - **Session Management**: AT Protocol session establishment and validation
+//! - **Resource Validation**: OAuth protected resource and authorization server validation
+//!
+//! ## Usage
+//!
+//! The primary entry point is the workflow module which provides functions for each
+//! stage of the OAuth flow:
+//!
+//! ```rust,no_run
+//! use atproto_oauth_aip::workflow::{oauth_init, oauth_complete, session_exchange};
+//! use atproto_oauth_aip::resources::{oauth_protected_resource, oauth_authorization_server};
+//!
+//! // Initialize OAuth flow with PAR
+//! let auth_url = oauth_init(
+//!     &oauth_client,
+//!     &authorization_server,
+//!     "user_handle",
+//!     "https://redirect.example.com/callback"
+//! ).await?;
+//!
+//! // Complete OAuth flow with authorization code
+//! let token_response = oauth_complete(
+//!     &oauth_client,
+//!     &authorization_server,
+//!     &oauth_request,
+//!     "authorization_code"
+//! ).await?;
+//!
+//! // Exchange tokens for AT Protocol session
+//! let session = session_exchange(
+//!     &protected_resource,
+//!     &token_response.access_token,
+//!     &dpop_key
+//! ).await?;
+//! ```
+//!
+//! ## Error Handling
+//!
+//! All operations use structured error types with descriptive messages following
+//! the project's error convention format.
 #![warn(missing_docs)]
 
 /// Error types for OAuth workflow operations.

crates/atproto-oauth-aip/src/workflow.rs

···
+//! # OAuth 2.0 Workflow Implementation for AT Protocol Identity Providers
+//!
+//! This module provides a complete OAuth 2.0 authorization code flow implementation
+//! specifically designed for AT Protocol Identity Providers (AIPs). It handles the
+//! three main phases of OAuth authentication: initialization, completion, and session exchange.
+//!
+//! ## Workflow Overview
+//!
+//! The OAuth workflow consists of three main functions that handle different phases:
+//!
+//! 1. **Initialization (`oauth_init`)**: Creates a Pushed Authorization Request (PAR)
+//!    and returns the authorization URL for user consent
+//! 2. **Completion (`oauth_complete`)**: Exchanges the authorization code for access tokens
+//! 3. **Session Exchange (`session_exchange`)**: Converts OAuth tokens to AT Protocol sessions
+//!
+//! ## Security Features
+//!
+//! - **Pushed Authorization Requests (PAR)**: Enhanced security by storing authorization
+//!   parameters server-side rather than in redirect URLs
+//! - **PKCE (Proof Key for Code Exchange)**: Protection against authorization code
+//!   interception attacks
+//! - **DPoP (Demonstration of Proof-of-Possession)**: Cryptographic binding of tokens
+//!   to specific keys for enhanced security
+//!
+//! ## Usage Example
+//!
+//! ```rust,no_run
+//! use atproto_oauth_aip::workflow::{oauth_init, oauth_complete, session_exchange, OAuthClient};
+//! use atproto_oauth::resources::{AuthorizationServer, OAuthProtectedResource};
+//!
+//! // 1. Initialize OAuth flow
+//! let oauth_client = OAuthClient {
+//!     redirect_uri: "https://myapp.com/callback".to_string(),
+//!     client_id: "my_client_id".to_string(),
+//!     client_secret: "my_client_secret".to_string(),
+//! };
+//!
+//! let auth_url = oauth_init(
+//!     &oauth_client,
+//!     &authorization_server,
+//!     "user.bsky.social",
+//!     "https://myapp.com/callback"
+//! ).await?;
+//!
+//! // User visits auth_url and grants consent, returns with authorization code
+//!
+//! // 2. Complete OAuth flow
+//! let token_response = oauth_complete(
+//!     &oauth_client,
+//!     &authorization_server,
+//!     &oauth_request,
+//!     "received_auth_code"
+//! ).await?;
+//!
+//! // 3. Exchange for AT Protocol session
+//! let session = session_exchange(
+//!     &protected_resource,
+//!     &token_response.access_token,
+//!     &dpop_private_key
+//! ).await?;
+//! ```
+//!
+//! ## Error Handling
+//!
+//! All functions return `Result<T, OAuthWorkflowError>` with detailed error information
+//! for each phase of the OAuth flow including network failures, parsing errors,
+//! and protocol violations.
+
 use crate::errors::OAuthWorkflowError;
 use anyhow::Result;
 use atproto_oauth::{

crates/atproto-oauth-axum/src/bin/atproto-oauth-tool.rs

···
     println!("Refresh Token: {}", &token_response.refresh_token);
     println!("Scope: {}", token_response.scope);
     println!("Expires In: {} seconds", token_response.expires_in);
-    println!("Subject: {}", token_response.sub.as_deref().unwrap_or("N/A"));
+    println!(
+        "Subject: {}",
+        token_response.sub.as_deref().unwrap_or("N/A")
+    );
     println!("DPoP Key: {}", dpop_key);
 
     Ok(())

crates/atproto-oauth-axum/src/state.rs

···
 impl OAuthClientConfig {
     /// Returns the OAuth scope, using the default "atproto transition:generic" if not set.
     pub fn scope(&self) -> &str {
-        self.scope.as_deref().unwrap_or("atproto transition:generic")
+        self.scope
+            .as_deref()
+            .unwrap_or("atproto transition:generic")
     }
 }
 

crates/atproto-oauth/src/dpop.rs

···
         use atproto_identity::key::{KeyType, generate_key};
 
         let key_data = generate_key(KeyType::P256Private)?;
-        
+
         // Create a DPoP token with a nonce by manually building it
         let (_, header, mut claims) = auth_dpop(&key_data, "POST", "https://example.com/token")?;
-        
+
         // Add nonce to claims
         let test_nonce = "test_nonce_12345";
-        claims.private.insert("nonce".to_string(), test_nonce.into());
-        
+        claims
+            .private
+            .insert("nonce".to_string(), test_nonce.into());
+
         // Create the token with nonce
         let dpop_token = mint(&key_data, &header, &claims)?;
 
···
         use atproto_identity::key::{KeyType, generate_key};
 
         let key_data = generate_key(KeyType::P256Private)?;
-        
-        // Create a DPoP token with a specific nonce 
+
+        // Create a DPoP token with a specific nonce
         let (_, header, mut claims) = auth_dpop(&key_data, "POST", "https://example.com/token")?;
-        
+
         // Add a nonce that won't match the expected values
         let token_nonce = "token_nonce_that_wont_match";
-        claims.private.insert("nonce".to_string(), token_nonce.into());
-        
+        claims
+            .private
+            .insert("nonce".to_string(), token_nonce.into());
+
         // Create the token with nonce
         let dpop_token = mint(&key_data, &header, &claims)?;