release: 0.6.0 - Add atproto-jetstream crate for event streaming

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

CLAUDE.md

···
 
 Avoid creating new errors with the `anyhow!(...)` macro.
 
-When a function call would return `anyhow::Error`, use the following pattern to log the error in addition to any code specific handling that must occur
+When a function call would return `anyhow::Error`, use the following pattern to log the error in addition to any code specific handling that must occur:
 
 ```
 If let Err(err) = result {

CLAUDE.prompts.md

···
 
 ## Review and ensure error correctness
 
-Review all of the errors in the `atproto-xrpcs` crate and ensure their names, messages, documentation, and usage are correct. Each error must have a globally unique identifier and error numbers must be ordered consistently. Think very very hard.
+Review all of the errors in the `atproto-jetstream` crate and ensure their names, messages, documentation, and usage are correct. Each error must have a globally unique identifier and error numbers must be ordered consistently. Think very very hard.
 
 Review all of the errors and identify any that are unused. Think very very hard.
 
···
 4. Update the `README.md` files in each of the project crates. Each `README.md` file should include a high level overview of what the crate provides and include a summary of each binary produced by the crate.
 
 5. Update the `README.md` file in the root of the project that describes the project as collection of components used to create ATProtocol applications. Note that parts of this was extracted from the open sourced https://tangled.sh/@smokesignal.events/smokesignal project. This project is open source under the MIT license.
+
+6. Ensure all crates can be packaged and published.
 
 Avoid introducing new dependencies. Think very very hard.

Cargo.lock

···
 
 [[package]]
 name = "atproto-client"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "atproto-identity",
  "atproto-oauth",
  "atproto-record",
+ "bytes",
  "reqwest",
  "reqwest-chain",
  "reqwest-middleware",
···
 
 [[package]]
 name = "atproto-identity"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "async-trait",
···
 ]
 
 [[package]]
+name = "atproto-jetstream"
+version = "0.6.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "atproto-identity",
+ "futures",
+ "http",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.12",
+ "tokio",
+ "tokio-util",
+ "tokio-websockets",
+ "tracing",
+ "tracing-subscriber",
+ "urlencoding",
+ "zstd",
+]
+
+[[package]]
 name = "atproto-oauth"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "async-trait",
···
 
 [[package]]
 name = "atproto-oauth-axum"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "async-trait",
···
 
 [[package]]
 name = "atproto-record"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "atproto-identity",
···
 
 [[package]]
 name = "atproto-xrpcs"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "async-trait",
···
 
 [[package]]
 name = "atproto-xrpcs-helloworld"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "async-trait",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
 dependencies = [
+ "jobserver",
+ "libc",
  "shlex",
 ]
 
···
 ]
 
 [[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
 name = "futures-channel"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
+ "futures-sink",
 ]
 
 [[package]]
···
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
 [[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
 name = "futures-io"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "futures-sink"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
+ "futures-channel",
  "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
  "futures-task",
+ "memchr",
  "pin-project-lite",
  "pin-utils",
  "slab",
···
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
+name = "jobserver"
+version = "0.1.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
+dependencies = [
+ "getrandom 0.3.3",
+ "libc",
+]
+
+[[package]]
 name = "js-sys"
 version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "openssl-probe",
  "openssl-sys",
  "schannel",
- "security-framework",
+ "security-framework 2.11.1",
  "security-framework-sys",
  "tempfile",
 ]
···
 ]
 
 [[package]]
+name = "rustls-native-certs"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.2.0",
+]
+
+[[package]]
 name = "rustls-pki-types"
 version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
  "bitflags",
- "core-foundation",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271720403f46ca04f7ba6f55d438f8bd878d6b8ca0a1046e8228c4145bcbb316"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.10.1",
  "core-foundation-sys",
  "libc",
  "security-framework-sys",
···
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
+name = "signal-hook-registry"
+version = "1.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
+dependencies = [
+ "libc",
+]
+
+[[package]]
 name = "signature"
 version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
+[[package]]
 name = "slab"
 version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
  "bitflags",
- "core-foundation",
+ "core-foundation 0.9.4",
  "system-configuration-sys",
 ]
 
···
  "bytes",
  "libc",
  "mio",
+ "parking_lot",
  "pin-project-lite",
+ "signal-hook-registry",
  "socket2",
  "tokio-macros",
  "windows-sys 0.52.0",
···
 ]
 
 [[package]]
+name = "tokio-websockets"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fcaf159b4e7a376b05b5bfd77bfd38f3324f5fce751b4213bfc7eaa47affb4e"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "httparse",
+ "rand 0.9.1",
+ "ring",
+ "rustls-native-certs",
+ "rustls-pki-types",
+ "simdutf8",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+]
+
+[[package]]
 name = "tower"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "quote",
  "syn",
 ]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.15+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237"
+dependencies = [
+ "cc",
+ "pkg-config",
+]

Cargo.toml

···
 members = [
     "crates/atproto-client",
     "crates/atproto-identity",
+    "crates/atproto-jetstream",
     "crates/atproto-oauth-axum",
     "crates/atproto-oauth",
     "crates/atproto-record",
···
 categories = ["command-line-utilities", "web-programming"]
 
 [workspace.dependencies]
-atproto-client = { version = "0.5.0", path = "crates/atproto-client" }
-atproto-identity = { version = "0.5.0", path = "crates/atproto-identity" }
-atproto-oauth = { version = "0.5.0", path = "crates/atproto-oauth" }
-atproto-record = { version = "0.5.0", path = "crates/atproto-record" }
-atproto-xrpcs = { version = "0.5.0", path = "crates/atproto-xrpcs" }
+atproto-client = { version = "0.6.0", path = "crates/atproto-client" }
+atproto-identity = { version = "0.6.0", path = "crates/atproto-identity" }
+atproto-oauth = { version = "0.6.0", path = "crates/atproto-oauth" }
+atproto-record = { version = "0.6.0", path = "crates/atproto-record" }
+atproto-xrpcs = { version = "0.6.0", path = "crates/atproto-xrpcs" }
+atproto-jetstream = { version = "0.6.0", path = "crates/atproto-jetstream" }
 
 anyhow = "1.0"
 async-trait = "0.1.88"
···
 chrono = {version = "0.4.41", default-features = false, features = ["std", "now"]}
 ecdsa = { version = "0.16.9", features = ["std"] }
 elliptic-curve = { version = "0.13.8", features = ["jwk", "serde"] }
+futures = "0.3"
 hickory-resolver = { version = "0.25" }
+http = "1.3.1"
 k256 = "0.13.4"
 lru = "0.12"
 multibase = "0.9.1"
···
 sha2 = "0.10.9"
 thiserror = "2.0"
 tokio = { version = "1.41", features = ["macros", "rt", "rt-multi-thread"] }
+tokio-websockets = { version = "0.11.4", features = ["client", "rustls-native-roots", "rand", "ring"] }
+tokio-util = "0.7"
 tracing = { version = "0.1", features = ["async-await"] }
 ulid = "1.2.1"
+urlencoding = "2.1"
+zstd = "0.13"
 
 [workspace.lints.rust]
 unsafe_code = "forbid"

Dockerfile

···
 LABEL org.opencontainers.image.description="AT Protocol identity management tools"
 LABEL org.opencontainers.image.authors="Nick Gerakines <[e-mail]>"
 LABEL org.opencontainers.image.source="https://tangled.sh/@smokesignal.events/atproto-identity-rs"
-LABEL org.opencontainers.image.version="0.5.0"
+LABEL org.opencontainers.image.version="0.6.0"
 LABEL org.opencontainers.image.licenses="MIT"
 
 # Document available binaries

README.md

···
 # AT Protocol Identity & Record Library
 
-A comprehensive Rust library for AT Protocol identity management, record signing, verification, and OAuth operations. This library provides full functionality for DID resolution, handle resolution, identity document management, cryptographic record operations, and OAuth 2.0 flows across multiple DID methods.
+A comprehensive collection of Rust crates for building AT Protocol applications. This workspace provides complete functionality for identity management, record operations, OAuth 2.0 flows, event streaming, XRPC services, and HTTP client operations across multiple DID methods.
 
-This project was extracted from the open-sourced [Smokesignal](https://tangled.sh/@smokesignal.events/smokesignal) project and is released under the MIT license.
+This project was extracted from the open-sourced [smokesignal.events](https://tangled.sh/@smokesignal.events/smokesignal) project and is released under the MIT license.
 
 ## Project Overview
 
···
 
 ## Crates
 
-This workspace contains seven specialized crates:
+This workspace contains eight specialized crates:
 
 ### [`atproto-identity`](crates/atproto-identity/) 
 **Core identity management and cryptographic operations**
···
 - **JWT Authentication**: Demonstrates integration with `atproto-xrpcs` authorization extractors
 - **Service Discovery**: Complete service document with verification methods and service endpoints
 
+### [`atproto-jetstream`](crates/atproto-jetstream/)
+**AT Protocol Jetstream event consumer library**
+
+- **Event Stream Consumer**: High-performance WebSocket-based event consumption from Jetstream instances
+- **Event Handler Registration**: Flexible event handler system supporting multiple concurrent handlers
+- **Compression Support**: Optional Zstandard compression with dictionary support for efficient data transfer
+- **Graceful Shutdown**: Cancellation token support for clean shutdown and resource cleanup
+- **Error Handling**: Comprehensive error types following project conventions with structured logging
+
 ## Command Line Tools
 
-The library includes 8 command-line utilities across the crates:
+The library includes 10 command-line utilities across the crates:
 
 ### Identity Operations (`atproto-identity`)
 - **`atproto-identity-resolve`** - Resolve AT Protocol handles and DIDs to identity documents
···
 - **`atproto-record-sign`** - Sign AT Protocol records with embedded signature metadata
 - **`atproto-record-verify`** - Verify AT Protocol record signatures with issuer authentication
 
+### HTTP Client Operations (`atproto-client`)
+- **`atproto-client-dpop`** - Test DPoP authentication flows with AT Protocol services
+
 ### OAuth Operations (`atproto-oauth-axum`)
 - **`atproto-oauth-tool`** - Complete OAuth client flow with local server and token acquisition
 
 ### XRPC Services (`atproto-xrpcs-helloworld`)
 - **`atproto-xrpcs-helloworld`** - Example AT Protocol XRPC service with DID web identity and authentication
 
+### Event Streaming (`atproto-jetstream`)
+- **`atproto-jetstream-consumer`** - Stream AT Protocol events from Jetstream instances with configurable handlers
+
 ## Quick Start
 
 Add the crates to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-atproto-identity = "0.5.0"
-atproto-record = "0.5.0" 
-atproto-oauth = "0.5.0"
-atproto-client = "0.5.0"
-atproto-oauth-axum = "0.5.0"
-atproto-xrpcs = "0.5.0"
-atproto-xrpcs-helloworld = "0.5.0"
+atproto-identity = "0.6.0"
+atproto-record = "0.6.0" 
+atproto-oauth = "0.6.0"
+atproto-client = "0.6.0"
+atproto-oauth-axum = "0.6.0"
+atproto-xrpcs = "0.6.0"
+atproto-jetstream = "0.6.0"
 ```
 
 ### Basic Identity Resolution
···
 }
 ```
 
+### Jetstream Event Streaming
+
+```rust
+use atproto_jetstream::{Consumer, ConsumerTaskConfig, EventHandler, JetstreamEvent, CancellationToken};
+use async_trait::async_trait;
+use std::sync::Arc;
+
+// Custom event handler
+struct PostEventHandler;
+
+#[async_trait]
+impl EventHandler for PostEventHandler {
+    async fn handle_event(&self, event: JetstreamEvent) -> anyhow::Result<()> {
+        if event.kind == "commit" {
+            println!("Received post event: {:?}", event);
+        }
+        Ok(())
+    }
+
+    fn handler_id(&self) -> String {
+        "post-handler".to_string()
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let config = ConsumerTaskConfig {
+        user_agent: "my-app/1.0".to_string(),
+        compression: false,
+        zstd_dictionary_location: String::new(),
+        jetstream_hostname: "jetstream1.us-east.bsky.network".to_string(),
+        collections: vec!["app.bsky.feed.post".to_string()],
+    };
+
+    let consumer = Consumer::new(config);
+    let handler = Arc::new(PostEventHandler);
+    
+    consumer.register_handler(handler).await?;
+    
+    let cancellation_token = CancellationToken::new();
+    consumer.run_background(cancellation_token).await?;
+    
+    Ok(())
+}
+```
+
 ## CLI Usage Examples
 
 ```bash
···
 # Run example XRPC service with DID web identity
 EXTERNAL_BASE=localhost:8080 SERVICE_KEY=did:key:zQ3shNzMp4oaaQ1... \
   cargo run --bin atproto-xrpcs-helloworld
+
+# Stream events from Jetstream
+cargo run --bin atproto-jetstream-consumer \
+  --hostname jetstream1.us-east.bsky.network \
+  --collections app.bsky.feed.post \
+  --user-agent "my-consumer/1.0"
+
+# Stream with compression (requires dictionary file)
+cargo run --bin atproto-jetstream-consumer \
+  --hostname jetstream1.us-east.bsky.network \
+  --collections app.bsky.feed.post \
+  --compression \
+  --zstd-dictionary ./data/zstd_dictionary
 ```
 
 ## Features
···
 
 ## Acknowledgments
 
-This library was extracted from the [Smokesignal](https://tangled.sh/@smokesignal.events/smokesignal) project, an open-source event and RSVP management and discovery application. We thank the Smokesignal contributors for their foundational work on AT Protocol identity management and record operations.
+This library was extracted from the [smokesignal.events](https://tangled.sh/@smokesignal.events/smokesignal) project, an open-source event and RSVP management and discovery application built on AT Protocol. We thank the smokesignal.events contributors for their foundational work on AT Protocol identity management, record operations, and event streaming infrastructure.

crates/atproto-client/Cargo.toml

···
 [package]
 name = "atproto-client"
-version = "0.5.0"
+version = "0.6.0"
 description = "HTTP client for AT Protocol services with OAuth and identity integration"
 readme = "README.md"
 homepage = "https://tangled.sh/@smokesignal.events/atproto-identity-rs"
···
 tokio.workspace = true
 tracing.workspace = true
 urlencoding = "2.1.3"
+bytes = "1.10.1"
 
 [lints]
 workspace = true

crates/atproto-client/README.md

···
 
 ```toml
 [dependencies]
-atproto-client = "0.5.0"
+atproto-client = "0.6.0"
 ```
 
 ## Usage
···
 - `tracing` - Structured logging for debugging and monitoring
 - `thiserror` - Structured error type derivation
 
-## Library Only
+## Command Line Tools
 
-This crate is designed as a library and does not provide command line tools. All functionality is accessed programmatically through the Rust API. For command line operations, see the [`atproto-identity`](../atproto-identity) and [`atproto-record`](../atproto-record) crates which include CLI tools for identity resolution and record signing operations.
+The crate includes one command-line tool for DPoP authentication testing:
+
+### `atproto-client-dpop`
+
+A command-line tool for testing DPoP authentication flows with AT Protocol services. This tool demonstrates the complete DPoP authentication process including proof generation, HTTP request signing, and token usage.
+
+**Features:**
+- **DPoP Proof Generation**: Creates DPoP proofs for HTTP requests using private keys
+- **OAuth Integration**: Supports OAuth access tokens with DPoP binding
+- **HTTP Client Testing**: Tests DPoP authentication against real AT Protocol endpoints
+- **Request Signing**: Demonstrates proper DPoP header generation and validation
+- **Token Management**: Shows how to use DPoP-bound access tokens for API requests
+
+```bash
+# Test DPoP authentication with an AT Protocol endpoint
+cargo run --bin atproto-client-dpop \
+  --private-key did:key:zQ3shNzMp4oaaQ1gQRzCxMGXFrSW3NEM1M9T6KCY9eA7HhyEA \
+  --access-token your_access_token \
+  --issuer did:plc:issuer123 \
+  --url https://pds.example.com/xrpc/com.atproto.repo.listRecords \
+  --method GET
+
+# Example POST request with DPoP authentication
+cargo run --bin atproto-client-dpop \
+  --private-key did:key:zQ3shNzMp4oaaQ1gQRzCxMGXFrSW3NEM1M9T6KCY9eA7HhyEA \
+  --access-token your_access_token \
+  --issuer did:plc:issuer123 \
+  --url https://pds.example.com/xrpc/com.atproto.repo.createRecord \
+  --method POST \
+  --data '{"repo":"did:plc:user123","collection":"app.bsky.feed.post","record":{"$type":"app.bsky.feed.post","text":"Hello AT Protocol!"}}'
+```
+
+**Arguments:**
+- `--private-key` - DID key string for DPoP proof signing
+- `--access-token` - OAuth access token for authentication
+- `--issuer` - Issuer DID for proof validation
+- `--url` - Target URL for the authenticated request
+- `--method` - HTTP method (GET, POST, PUT, DELETE)
+- `--data` - Optional JSON data for POST/PUT requests
+
+This tool is useful for:
+- Testing DPoP implementation against AT Protocol services
+- Validating authentication flows during development
+- Debugging DPoP proof generation and validation
+- Learning how DPoP authentication works in practice
 
 ## Contributing
 

crates/atproto-client/src/client.rs

···
 //! with support for DPoP (Demonstration of Proof-of-Possession) authentication.
 
 use crate::errors::{ClientError, DPoPError};
-use anyhow::Result;
+use anyhow::{Context, Result};
 use atproto_identity::key::KeyData;
 use atproto_oauth::dpop::{DpopRetry, request_dpop};
+use bytes::Bytes;
 use reqwest::header::HeaderMap;
 use reqwest_chain::ChainMiddleware;
 use reqwest_middleware::ClientBuilder;
···
 /// Returns `ClientError::HttpRequestFailed` if the HTTP request fails,
 /// or `ClientError::JsonParseFailed` if JSON parsing fails.
 pub async fn get_json(http_client: &reqwest::Client, url: &str) -> Result<serde_json::Value> {
-    let http_response =
-        http_client
-            .get(url)
-            .send()
-            .await
-            .map_err(|error| ClientError::HttpRequestFailed {
-                url: url.to_string(),
-                error,
-            })?;
+    let empty = HeaderMap::default();
+    get_json_with_headers(http_client, url, &empty).await
+}
+
+/// Performs an unauthenticated HTTP GET request with additional headers and parses the response as JSON.
+///
+/// # Arguments
+///
+/// * `http_client` - The HTTP client to use for the request
+/// * `url` - The URL to request
+/// * `additional_headers` - Additional HTTP headers to include in the request
+///
+/// # Returns
+///
+/// The parsed JSON response as a `serde_json::Value`
+///
+/// # Errors
+///
+/// Returns `ClientError::HttpRequestFailed` if the HTTP request fails,
+/// or `ClientError::JsonParseFailed` if JSON parsing fails.
+pub async fn get_json_with_headers(
+    http_client: &reqwest::Client,
+    url: &str,
+    additional_headers: &HeaderMap,
+) -> Result<serde_json::Value> {
+    let http_response = http_client
+        .get(url)
+        .headers(additional_headers.clone())
+        .send()
+        .instrument(tracing::info_span!("get_json_with_headers", url = %url))
+        .await
+        .map_err(|error| ClientError::HttpRequestFailed {
+            url: url.to_string(),
+            error,
+        })?;
 
     let value = http_response
         .json::<serde_json::Value>()
···
         })?;
 
     Ok(value)
+}
+
+/// Performs an unauthenticated HTTP GET request and returns the response as bytes.
+///
+/// # Arguments
+///
+/// * `http_client` - The HTTP client to use for the request
+/// * `url` - The URL to request
+///
+/// # Returns
+///
+/// The response body as bytes
+///
+/// # Errors
+///
+/// Returns `ClientError::HttpRequestFailed` if the HTTP request fails,
+/// or an error if streaming the response bytes fails.
+pub async fn get_bytes(http_client: &reqwest::Client, url: &str) -> Result<Bytes> {
+    let empty = HeaderMap::default();
+    get_bytes_with_headers(http_client, url, &empty).await
+}
+
+/// Performs an unauthenticated HTTP GET request with additional headers and returns the response as bytes.
+///
+/// # Arguments
+///
+/// * `http_client` - The HTTP client to use for the request
+/// * `url` - The URL to request
+/// * `additional_headers` - Additional HTTP headers to include in the request
+///
+/// # Returns
+///
+/// The response body as bytes
+///
+/// # Errors
+///
+/// Returns `ClientError::HttpRequestFailed` if the HTTP request fails,
+/// or an error if streaming the response bytes fails.
+pub async fn get_bytes_with_headers(
+    http_client: &reqwest::Client,
+    url: &str,
+    additional_headers: &HeaderMap,
+) -> Result<Bytes> {
+    let http_response = http_client
+        .get(url)
+        .headers(additional_headers.clone())
+        .send()
+        .instrument(tracing::info_span!("get_bytes_with_headers", url = %url))
+        .await
+        .map_err(|error| ClientError::HttpRequestFailed {
+            url: url.to_string(),
+            error,
+        })?;
+    http_response
+        .bytes()
+        .await
+        .context("failed streaming bytes")
 }
 
 /// Performs a DPoP-authenticated HTTP GET request and parses the response as JSON.

crates/atproto-client/src/com_atproto_repo.rs

···
 use std::collections::HashMap;
 
 use anyhow::Result;
+use bytes::Bytes;
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 
 use crate::{
-    client::{DPoPAuth, get_dpop_json, get_json, post_dpop_json},
+    client::{DPoPAuth, get_bytes, get_dpop_json, get_json, post_dpop_json},
     errors::SimpleError,
     url::URLBuilder,
 };
···
     },
     /// Error response from the server
     Error(SimpleError),
+}
+
+/// Retrieves a blob from an AT Protocol repository by DID and CID.
+///
+/// # Arguments
+///
+/// * `http_client` - HTTP client for making requests
+/// * `base_url` - Base URL of the AT Protocol server
+/// * `did` - Repository identifier (DID) containing the blob
+/// * `cid` - Content identifier (CID) of the blob to retrieve
+///
+/// # Returns
+///
+/// The blob data as bytes
+pub async fn get_blob(
+    http_client: &reqwest::Client,
+    base_url: &str,
+    did: &str,
+    cid: &str,
+) -> Result<Bytes> {
+    let mut url_builder = URLBuilder::new(base_url);
+    url_builder.path("/xrpc/com.atproto.sync.getBlob");
+
+    url_builder.param("did", did);
+    url_builder.param("cid", cid);
+
+    let url = url_builder.build();
+
+    tracing::info!(?url, "get_blob");
+
+    get_bytes(http_client, &url).await
 }
 
 /// Retrieves a record from an AT Protocol repository.

crates/atproto-identity/Cargo.toml

···
 [package]
 name = "atproto-identity"
-version = "0.5.0"
+version = "0.6.0"
 description = "AT Protocol identity management - DID resolution, handle resolution, and cryptographic operations"
 readme = "README.md"
 homepage = "https://tangled.sh/@smokesignal.events/atproto-identity-rs"

crates/atproto-identity/README.md

···
 
 ```toml
 [dependencies]
-atproto-identity = "0.5.0"
+atproto-identity = "0.6.0"
 ```
 
 ## Usage

crates/atproto-identity/src/model.rs

···
 
 /// AT Protocol service configuration from a DID document.
 /// Represents services like Personal Data Servers (PDS).
-#[derive(Clone, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct Service {
     /// Unique identifier for the service.
···
 
 /// Cryptographic verification method from a DID document.
 /// Used to verify signatures and authenticate identity operations.
-#[derive(Clone, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 #[serde(tag = "type")]
 pub enum VerificationMethod {
     /// Multikey verification method with multibase-encoded public key.
···
 
 /// Complete DID document containing identity information.
 /// Contains services, verification methods, and aliases for a DID.
-#[derive(Clone, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct Document {
     /// The DID identifier (e.g., "did:plc:abc123").

crates/atproto-jetstream/Cargo.toml

···
+[package]
+name = "atproto-jetstream"
+version = "0.6.0"
+description = "AT Protocol Jetstream event consumer library with WebSocket streaming and compression support"
+readme = "README.md"
+homepage = "https://tangled.sh/@smokesignal.events/atproto-identity-rs"
+documentation = "https://docs.rs/atproto-jetstream"
+
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+authors.workspace = true
+license.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[dependencies]
+tokio = { workspace = true, features = ["full"] }
+tokio-util.workspace = true
+futures.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+zstd.workspace = true
+anyhow.workspace = true
+thiserror.workspace = true
+tracing.workspace = true
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+async-trait.workspace = true
+atproto-identity.workspace = true
+urlencoding.workspace = true
+tokio-websockets.workspace = true
+http.workspace = true
+
+[lints]
+workspace = true

crates/atproto-jetstream/README.md

···
+# atproto-jetstream
+
+A Rust library for consuming AT Protocol Jetstream events with high-performance WebSocket streaming, flexible event handling, and optional Zstandard compression support.
+
+## Overview
+
+`atproto-jetstream` provides a comprehensive async stream consumer for AT Protocol Jetstream events. This library enables real-time consumption of AT Protocol repository events, identity changes, and account updates through WebSocket connections with support for filtering, compression, and graceful shutdown patterns.
+
+This project was extracted from the open-sourced [Smokesignal](https://tangled.sh/@smokesignal.events/smokesignal) project and is designed to be a standalone, reusable library for AT Protocol event stream consumption.
+
+## Features
+
+- **High-Performance WebSocket Streaming**: Async WebSocket-based event consumption with automatic reconnection
+- **Flexible Event Handler System**: Register multiple custom event handlers with unique identifiers
+- **Zstandard Compression**: Optional compression support with custom dictionaries for bandwidth optimization
+- **Event Filtering**: Filter events by collections and DIDs for targeted consumption
+- **Graceful Shutdown**: Cancellation token support for clean shutdown and resource cleanup
+- **Message Size Management**: Configurable maximum message sizes and rate limiting
+- **Cursor Support**: Resume streaming from specific points using cursor positioning
+- **Structured Error Handling**: Comprehensive error types with detailed error codes following project conventions
+- **Built-in Event Broadcasting**: Event broadcasting to multiple consumers with `tokio::sync::broadcast`
+- **Tracing Integration**: Full structured logging support for debugging and monitoring
+
+## Usage
+
+### Basic Event Consumer
+
+```rust
+use atproto_jetstream::{Consumer, ConsumerTaskConfig, EventHandler, JetstreamEvent, CancellationToken};
+use async_trait::async_trait;
+use anyhow::Result;
+
+// Create a custom event handler
+struct MyEventHandler;
+
+#[async_trait]
+impl EventHandler for MyEventHandler {
+    async fn handle_event(&self, event: JetstreamEvent) -> Result<()> {
+        println!("Received event: {:?}", event);
+        Ok(())
+    }
+
+    fn handler_id(&self) -> String {
+        "my-handler".to_string()
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let config = ConsumerTaskConfig {
+        user_agent: "my-app/1.0".to_string(),
+        compression: false,
+        zstd_dictionary_location: String::new(),
+        jetstream_hostname: "jetstream1.us-east.bsky.network".to_string(),
+        collections: vec!["app.bsky.feed.post".to_string()],
+    };
+
+    let consumer = Consumer::new(config);
+    let handler = std::sync::Arc::new(MyEventHandler);
+    
+    consumer.register_handler(handler).await?;
+    
+    let cancellation_token = CancellationToken::new();
+    consumer.run_background(cancellation_token).await?;
+    
+    Ok(())
+}
+```
+
+### Using Multiple Event Handlers
+
+```rust
+use atproto_jetstream::{Consumer, LoggingHandler};
+use std::sync::Arc;
+
+// Register multiple handlers
+let consumer = Consumer::new(config);
+
+let logging_handler = Arc::new(LoggingHandler::new("logger".to_string()));
+let custom_handler = Arc::new(MyEventHandler);
+
+consumer.register_handler(logging_handler).await?;
+consumer.register_handler(custom_handler).await?;
+```
+
+### With Compression Support
+
+```rust
+let config = ConsumerTaskConfig {
+    user_agent: "my-app/1.0".to_string(),
+    compression: true,
+    zstd_dictionary_location: "./data/zstd_dictionary".to_string(),
+    jetstream_hostname: "jetstream1.us-east.bsky.network".to_string(),
+    collections: vec!["app.bsky.feed.post".to_string()],
+};
+
+// Download the Zstandard dictionary first:
+// mkdir -p data/
+// curl -o data/zstd_dictionary https://github.com/bluesky-social/jetstream/raw/refs/heads/main/pkg/models/zstd_dictionary
+```
+
+## Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+atproto-jetstream = "0.1.0"
+```
+
+## Command Line Tools
+
+The crate includes a command-line tool for consuming AT Protocol Jetstream events:
+
+### `atproto-jetstream-consumer`
+
+A comprehensive command-line tool for consuming AT Protocol Jetstream events with real-time streaming, filtering capabilities, and optional compression support. This tool provides an easy way to monitor AT Protocol event streams for development, testing, and production monitoring.
+
+**Features:**
+- **Real-Time Event Streaming**: Connects to AT Protocol Jetstream instances for live event consumption
+- **Event Filtering**: Filter events by specific collections and DIDs for targeted monitoring
+- **Compression Support**: Optional Zstandard compression with dictionary support for bandwidth optimization
+- **Flexible Output**: Structured JSON output for each event with customizable logging levels
+- **Connection Management**: Automatic reconnection handling and graceful shutdown on interruption
+- **Configurable Parameters**: Extensive configuration options for hostname, collections, message sizes, and more
+
+```bash
+# Basic event streaming from Jetstream
+cargo run --bin atproto-jetstream-consumer \
+    --hostname jetstream1.us-east.bsky.network \
+    --collections app.bsky.feed.post \
+    --user-agent "my-consumer/1.0"
+
+# Stream specific collections with filtering
+cargo run --bin atproto-jetstream-consumer \
+    --hostname jetstream1.us-east.bsky.network \
+    --collections "app.bsky.feed.post,app.bsky.actor.profile" \
+    --dids "did:plc:user123,did:plc:user456" \
+    --user-agent "filtered-consumer/1.0"
+
+# With Zstandard compression enabled
+cargo run --bin atproto-jetstream-consumer \
+    --hostname jetstream1.us-east.bsky.network \
+    --collections app.bsky.feed.post \
+    --compression \
+    --zstd-dictionary ./data/zstd_dictionary \
+    --user-agent "compressed-consumer/1.0"
+
+# Advanced configuration with message size limits and cursor
+cargo run --bin atproto-jetstream-consumer \
+    --hostname jetstream1.us-east.bsky.network \
+    --collections app.bsky.feed.post \
+    --max-message-size 1048576 \
+    --cursor 1234567890 \
+    --require-hello \
+    --user-agent "advanced-consumer/1.0"
+```
+
+**Command Line Arguments:**
+- `--hostname` - Jetstream hostname to connect to (e.g., jetstream1.us-east.bsky.network)
+- `--collections` - Comma-separated list of AT Protocol collections to subscribe to
+- `--dids` - Optional comma-separated list of DIDs to filter events for
+- `--user-agent` - User-Agent string for the WebSocket connection
+- `--compression` - Enable Zstandard compression (requires zstd-dictionary)
+- `--zstd-dictionary` - Path to Zstandard dictionary file for compression
+- `--max-message-size` - Maximum message size in bytes (default: 56000)
+- `--cursor` - Optional cursor position to start streaming from
+- `--require-hello` - Require hello message before receiving events (default: true)
+
+**Setting up Compression:**
+To use compression, you need to download the Zstandard dictionary:
+
+```bash
+# Create data directory and download dictionary
+mkdir -p data/
+curl -o data/zstd_dictionary \
+  https://github.com/bluesky-social/jetstream/raw/refs/heads/main/pkg/models/zstd_dictionary
+
+# Use with compression enabled
+cargo run --bin atproto-jetstream-consumer \
+    --hostname jetstream1.us-east.bsky.network \
+    --collections app.bsky.feed.post \
+    --compression \
+    --zstd-dictionary ./data/zstd_dictionary
+```
+
+**Output Format:**
+The tool outputs structured JSON for each received event:
+
+```json
+{
+  "kind": "commit",
+  "time_us": 1704067200000000,
+  "did": "did:plc:user123",
+  "commit": {
+    "rev": "3l2uygzaf5c2b",
+    "operation": "create",
+    "collection": "app.bsky.feed.post",
+    "rkey": "3l2uygzaf5c2c",
+    "cid": "bafyreif5n4jf6jfczjqzckzqxdxm5qnz4jf6jfczjqzckzqxdxm5qnz4",
+    "record": {
+      "$type": "app.bsky.feed.post",
+      "text": "Hello AT Protocol!",
+      "createdAt": "2024-01-01T00:00:00Z"
+    }
+  }
+}
+```
+
+This tool is ideal for:
+- **Development and Testing**: Monitor AT Protocol events during application development
+- **Production Monitoring**: Track repository changes and user activity in real-time
+- **Data Analysis**: Collect AT Protocol events for analysis and research
+- **Integration Testing**: Verify that your applications are generating expected events
+- **System Monitoring**: Monitor the health and activity of AT Protocol networks
+
+## Event Types
+
+The library handles `JetstreamEvent` structures with the following fields:
+
+- `kind`: Event type (e.g., "commit", "identity", "account")
+- `time_us`: Event timestamp in microseconds
+- `commit`: Optional commit data for repository events
+- `identity`: Optional identity change data
+- `account`: Optional account-related data
+
+## Modules
+
+- **[`consumer`]** - Core consumer implementation with WebSocket streaming and event handling
+- **[`lib`]** - Public library interface and re-exports
+
+## Error Handling
+
+The crate uses comprehensive structured error types with unique identifiers:
+
+```
+error-atproto-jetstream-<domain>-<number> <message>: <details>
+```
+
+All errors follow the project convention:
+
+- `ConsumerError::ConnectionFailed` - WebSocket connection establishment failures
+- `ConsumerError::DecompressionFailed` - Zstandard decompression operation failures  
+- `ConsumerError::DeserializationFailed` - JSON event parsing failures
+- `ConsumerError::HandlerRegistrationFailed` - Event handler registration conflicts
+- `ConsumerError::EventSenderNotInitialized` - Event broadcasting setup errors
+- `ConsumerError::MessageConversionFailed` - WebSocket message format errors
+- `ConsumerError::UpdateSerializationFailed` - Subscription update serialization errors
+- `ConsumerError::UpdateSendFailed` - Subscription update transmission errors
+- `ConsumerError::DecompressorCreationFailed` - Zstandard decompressor initialization errors
+
+```rust
+use atproto_jetstream::consumer::ConsumerError;
+
+// Example error handling
+match consumer_result {
+    Err(ConsumerError::ConnectionFailed(details)) => {
+        println!("Failed to connect to Jetstream: {}", details);
+    }
+    Err(ConsumerError::DecompressionFailed(error)) => {
+        println!("Decompression failed: {}", error);
+    }
+    Err(ConsumerError::HandlerRegistrationFailed(error)) => {
+        println!("Handler registration failed: {}", error);
+    }
+    Ok(()) => println!("Consumer operation successful"),
+}
+```
+
+## Dependencies
+
+This crate builds on:
+
+- `tokio` - Async runtime for WebSocket connections and event handling
+- `tokio-websockets` - WebSocket client implementation for Jetstream connections  
+- `tokio-util` - Additional utilities including cancellation token support
+- `futures` - Stream and sink traits for async WebSocket operations
+- `zstd` - Zstandard compression support with dictionary-based decompression
+- `serde_json` - JSON serialization and deserialization for AT Protocol events
+- `http` - HTTP types for WebSocket headers and URI parsing
+- `urlencoding` - URL encoding for query parameters in WebSocket connections
+- `async_trait` - Async trait support for event handler implementations
+- `anyhow` - Error handling utilities and result types
+- `tracing` - Structured logging for debugging and monitoring
+- `thiserror` - Structured error type derivation
+
+## AT Protocol Jetstream
+
+This library implements a client for [AT Protocol Jetstream](https://github.com/bluesky-social/jetstream), which provides:
+
+- **Real-Time Event Streaming**: Live consumption of AT Protocol repository events
+- **Efficient Compression**: Zstandard compression with custom dictionaries for bandwidth optimization
+- **Event Filtering**: Server-side filtering by collections and DIDs for targeted consumption
+- **High Performance**: WebSocket-based streaming designed for high-throughput event processing
+- **Reliability**: Built-in connection management and error recovery patterns
+
+## Contributing
+
+Contributions are welcome! Please ensure that:
+
+1. All tests pass: `cargo test`
+2. Code is properly formatted: `cargo fmt`
+3. No linting issues: `cargo clippy`
+4. New functionality includes appropriate tests and documentation
+5. Error handling follows the project's structured error format
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+## Acknowledgments
+
+This library was extracted from the [Smokesignal](https://tangled.sh/@smokesignal.events/smokesignal) project, an open-source event and RSVP management and discovery application.

crates/atproto-jetstream/src/bin/atproto-jetstream-consumer.rs

···
+//! AT Protocol Jetstream consumer tool for streaming events.
+//!
+//! This binary tool connects to a Jetstream instance and streams AT Protocol
+//! events from specified collections, with optional zstd compression support.
+
+use anyhow::Result;
+use atproto_identity::config::{CertificateBundles, default_env, optional_env, version};
+use atproto_jetstream::{CancellationToken, Consumer, ConsumerTaskConfig, LoggingHandler};
+use std::{env, sync::Arc};
+use tokio::signal;
+
+fn print_usage() {
+    println!("AT Protocol Jetstream Consumer Tool");
+    println!();
+    println!("Usage:");
+    println!("  atproto-jetstream-consumer <jetstream_hostname> <zstd_dictionary> [collection...]");
+    println!();
+    println!("Arguments:");
+    println!("  jetstream_hostname    Hostname of the Jetstream instance to connect to");
+    println!(
+        "  zstd_dictionary       Path to zstd dictionary file (use 'none' to disable compression)"
+    );
+    println!("  collection            Zero or more AT Protocol collections to subscribe to");
+    println!();
+    println!("Environment Variables:");
+    println!("  CERTIFICATE_BUNDLES   Optional path to additional CA certificates");
+    println!("  USER_AGENT           Custom user agent string");
+    println!();
+    println!("Examples:");
+    println!("  # Subscribe to feed posts with compression");
+    println!(
+        "  atproto-jetstream-consumer jetstream1.us-east.bsky.network /path/to/dict.zstd app.bsky.feed.post"
+    );
+    println!();
+    println!("  # Subscribe to multiple collections without compression");
+    println!(
+        "  atproto-jetstream-consumer jetstream1.us-east.bsky.network none app.bsky.feed.post app.bsky.feed.repost"
+    );
+    println!();
+    println!("  # Subscribe to all collections");
+    println!("  atproto-jetstream-consumer jetstream1.us-east.bsky.network none");
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize tracing
+    tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .init();
+
+    // Parse command line arguments
+    let args: Vec<String> = env::args().skip(1).collect();
+
+    if args.len() < 2 || args.iter().any(|arg| arg == "--help" || arg == "-h") {
+        print_usage();
+        return Ok(());
+    }
+
+    let jetstream_hostname = &args[0];
+    let zstd_dictionary_path = &args[1];
+    let collections: Vec<String> = args[2..].iter().map(|s| s.to_string()).collect();
+
+    tracing::info!(
+        hostname = %jetstream_hostname,
+        dictionary = %zstd_dictionary_path,
+        collections = ?collections,
+        "Starting Jetstream consumer"
+    );
+
+    // Handle environment variables
+    let _certificate_bundles: CertificateBundles =
+        optional_env("CERTIFICATE_BUNDLES").try_into()?;
+    let default_user_agent = format!(
+        "atproto-jetstream-rs ({}; +https://tangled.sh/@smokesignal.events/atproto-identity-rs)",
+        version()?
+    );
+    let user_agent = default_env("USER_AGENT", &default_user_agent);
+
+    tracing::info!(user_agent = %user_agent, "Configuration loaded");
+
+    // Load zstd dictionary if specified
+    let compression_enabled = zstd_dictionary_path != "none";
+
+    // Create consumer configuration
+    let config = ConsumerTaskConfig {
+        user_agent,
+        compression: compression_enabled,
+        zstd_dictionary_location: if compression_enabled {
+            zstd_dictionary_path.to_string()
+        } else {
+            String::new()
+        },
+        jetstream_hostname: jetstream_hostname.to_string(),
+        collections: if collections.is_empty() {
+            tracing::info!("No collections specified, subscribing to all");
+            vec![]
+        } else {
+            collections
+        },
+        dids: vec![],                 // Default to all DIDs
+        max_message_size_bytes: None, // Default to no limit
+        cursor: None,                 // Default to live-tail
+        require_hello: true,          // Default to true as requested
+    };
+
+    // Create consumer
+    let consumer = Consumer::new(config);
+
+    // Register logging handler
+    let logging_handler = Arc::new(LoggingHandler::new("jetstream-logger".to_string()));
+    consumer.register_handler(logging_handler).await?;
+
+    tracing::info!("Jetstream consumer registered and ready");
+
+    // Set up cancellation token for graceful shutdown
+    let cancellation_token = CancellationToken::new();
+    let cancellation_token_clone = cancellation_token.clone();
+
+    // Set up signal handling for graceful shutdown
+    let signal_handler = tokio::spawn(async move {
+        #[cfg(unix)]
+        {
+            let mut sigint = signal::unix::signal(signal::unix::SignalKind::interrupt())
+                .expect("Failed to create SIGINT handler");
+            let mut sigterm = signal::unix::signal(signal::unix::SignalKind::terminate())
+                .expect("Failed to create SIGTERM handler");
+
+            tokio::select! {
+                _ = sigint.recv() => {
+                    tracing::info!("Received SIGINT, initiating graceful shutdown");
+                }
+                _ = sigterm.recv() => {
+                    tracing::info!("Received SIGTERM, initiating graceful shutdown");
+                }
+            }
+        }
+
+        #[cfg(windows)]
+        {
+            signal::ctrl_c().await.expect("Failed to listen for Ctrl+C");
+            tracing::info!("Received Ctrl+C, initiating graceful shutdown");
+        }
+
+        cancellation_token_clone.cancel();
+    });
+
+    // Run consumer
+    let consumer_task = tokio::spawn(async move {
+        if let Err(err) = consumer.run_background(cancellation_token).await {
+            tracing::error!(error = ?err, "Consumer failed");
+            return Err(err);
+        }
+        Ok(())
+    });
+
+    tracing::info!("Consumer started, press Ctrl+C to stop");
+
+    // Wait for either the consumer to finish or signal handler
+    tokio::select! {
+        result = consumer_task => {
+            match result {
+                Ok(Ok(())) => tracing::info!("Consumer finished successfully"),
+                Ok(Err(err)) => {
+                    tracing::error!(error = ?err, "Consumer failed");
+                    return Err(err);
+                }
+                Err(err) => {
+                    tracing::error!(error = ?err, "Consumer task panicked");
+                    return Err(err.into());
+                }
+            }
+        }
+        _ = signal_handler => {
+            tracing::info!("Signal handler completed");
+        }
+    }
+
+    tracing::info!("Jetstream consumer shutting down");
+    Ok(())
+}

crates/atproto-jetstream/src/consumer.rs

···
+//! Async stream consumer for AT Protocol Jetstream events
+//!
+//! This module provides structures for consuming events from an async stream
+//! and dispatching them to registered event handlers.
+
+use anyhow::Result;
+use async_trait::async_trait;
+use futures::{SinkExt, StreamExt};
+use http::Uri;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use std::{collections::HashMap, str::FromStr};
+use tokio::sync::{RwLock, broadcast};
+use tokio::time::{Instant, sleep};
+use tokio_util::sync::CancellationToken;
+use tokio_websockets::{ClientBuilder, Message};
+use tracing::Instrument;
+
+const MAX_MESSAGE_SIZE: usize = 56000;
+
+/// Configuration for the Jetstream consumer task
+#[derive(Clone, Debug)]
+pub struct ConsumerTaskConfig {
+    /// User-Agent header value for WebSocket connections
+    pub user_agent: String,
+    /// Enable Zstandard compression for messages
+    pub compression: bool,
+    /// Path to Zstandard dictionary file (required if compression is enabled)
+    pub zstd_dictionary_location: String,
+    /// Hostname of the Jetstream instance to connect to
+    pub jetstream_hostname: String,
+    /// AT Protocol collections to subscribe to (empty for all)
+    pub collections: Vec<String>,
+    /// DIDs to filter events for (empty for all)
+    pub dids: Vec<String>,
+    /// Maximum message size in bytes (None for unlimited)
+    pub max_message_size_bytes: Option<u64>,
+    /// Optional cursor position to start streaming from
+    pub cursor: Option<i64>,
+    /// Whether to require a hello message before receiving events
+    pub require_hello: bool,
+}
+
+/// Event data structure for Jetstream events
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum JetstreamEvent {
+    /// Repository commit event (create/update operations)
+    Commit {
+        /// DID of the repository that was updated
+        did: String,
+        /// Event timestamp in microseconds since Unix epoch
+        time_us: u64,
+        /// Event type identifier
+        kind: String,
+
+        #[serde(rename = "commit")]
+        /// Commit operation details
+        commit: JetstreamEventCommit,
+    },
+
+    /// Repository delete event
+    Delete {
+        /// DID of the repository that was updated
+        did: String,
+        /// Event timestamp in microseconds since Unix epoch
+        time_us: u64,
+        /// Event type identifier
+        kind: String,
+
+        #[serde(rename = "commit")]
+        /// Delete operation details
+        commit: JetstreamEventDelete,
+    },
+
+    /// Identity document update event
+    Identity {
+        /// DID whose identity was updated
+        did: String,
+        /// Event timestamp in microseconds since Unix epoch
+        time_us: u64,
+        /// Event type identifier
+        kind: String,
+
+        #[serde(rename = "identity")]
+        /// Identity document data
+        identity: serde_json::Value,
+    },
+
+    /// Account-related event
+    Account {
+        /// DID of the account
+        did: String,
+        /// Event timestamp in microseconds since Unix epoch
+        time_us: u64,
+        /// Event type identifier
+        kind: String,
+
+        #[serde(rename = "account")]
+        /// Account data
+        identity: serde_json::Value,
+    },
+}
+
+/// Repository commit operation details
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JetstreamEventCommit {
+    /// Repository revision identifier
+    pub rev: String,
+    /// Operation type (create, update)
+    pub operation: String,
+    /// AT Protocol collection name
+    pub collection: String,
+    /// Record key within the collection
+    pub rkey: String,
+    /// Content identifier (CID) of the record
+    pub cid: String,
+    /// Record data as JSON
+    pub record: serde_json::Value,
+}
+
+/// Repository delete operation details
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JetstreamEventDelete {
+    /// Repository revision identifier
+    pub rev: String,
+    /// Operation type (delete)
+    pub operation: String,
+    /// AT Protocol collection name
+    pub collection: String,
+    /// Record key that was deleted
+    pub rkey: String,
+}
+
+/// Trait for handling Jetstream events
+#[async_trait]
+pub trait EventHandler: Send + Sync {
+    /// Handle a received event
+    async fn handle_event(&self, event: JetstreamEvent) -> Result<()>;
+
+    /// Get the handler's identifier
+    fn handler_id(&self) -> String;
+}
+
+/// Errors specific to the consumer module
+#[derive(thiserror::Error, Debug)]
+pub enum ConsumerError {
+    /// WebSocket connection establishment failed
+    #[error("error-atproto-jetstream-consumer-1 WebSocket connection failed: {0}")]
+    ConnectionFailed(String),
+    /// Message decompression operation failed
+    #[error("error-atproto-jetstream-consumer-2 Message decompression failed: {0}")]
+    DecompressionFailed(String),
+    /// JSON deserialization of event data failed
+    #[error("error-atproto-jetstream-consumer-3 Event deserialization failed: {0}")]
+    DeserializationFailed(String),
+    /// Event handler registration failed (e.g., duplicate handler ID)
+    #[error("error-atproto-jetstream-consumer-4 Handler registration failed: {0}")]
+    HandlerRegistrationFailed(String),
+    /// Event broadcast sender not initialized (consumer not running)
+    #[error("error-atproto-jetstream-consumer-5 Event sender not initialized: {0}")]
+    EventSenderNotInitialized(String),
+    /// WebSocket message format conversion failed
+    #[error("error-atproto-jetstream-consumer-6 Message conversion failed: {0}")]
+    MessageConversionFailed(String),
+    /// Serialization of subscription update message failed
+    #[error("error-atproto-jetstream-consumer-7 Update serialization failed: {0}")]
+    UpdateSerializationFailed(String),
+    /// Sending subscription update message failed
+    #[error("error-atproto-jetstream-consumer-8 Update send failed: {0}")]
+    UpdateSendFailed(String),
+    /// Zstandard decompressor initialization failed
+    #[error("error-atproto-jetstream-consumer-9 Decompressor creation failed: {0}")]
+    DecompressorCreationFailed(String),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", content = "payload")]
+pub(crate) enum SubscriberSourcedMessage {
+    #[serde(rename = "options_update")]
+    Update {
+        #[serde(rename = "wantedCollections")]
+        wanted_collections: Vec<String>,
+
+        #[serde(rename = "wantedDids", skip_serializing_if = "Vec::is_empty", default)]
+        wanted_dids: Vec<String>,
+
+        #[serde(rename = "maxMessageSizeBytes")]
+        max_message_size_bytes: u64,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cursor: Option<i64>,
+    },
+}
+
+/// Main consumer structure for handling async streams and event dispatching
+pub struct Consumer {
+    config: ConsumerTaskConfig,
+    handlers: Arc<RwLock<HashMap<String, Arc<dyn EventHandler>>>>,
+    event_sender: Arc<RwLock<Option<broadcast::Sender<JetstreamEvent>>>>,
+}
+
+impl Consumer {
+    /// Create a new consumer with the given configuration
+    pub fn new(config: ConsumerTaskConfig) -> Self {
+        Self {
+            config,
+            handlers: Arc::new(RwLock::new(HashMap::new())),
+            event_sender: Arc::new(RwLock::new(None)),
+        }
+    }
+
+    /// Register an event handler
+    pub async fn register_handler(&self, handler: Arc<dyn EventHandler>) -> Result<()> {
+        let handler_id = handler.handler_id();
+        let mut handlers = self.handlers.write().await;
+
+        if handlers.contains_key(&handler_id) {
+            return Err(ConsumerError::HandlerRegistrationFailed(format!(
+                "Handler with ID '{}' already registered",
+                handler_id
+            ))
+            .into());
+        }
+
+        handlers.insert(handler_id.clone(), handler);
+        tracing::info!(handler_id = %handler_id, "Event handler registered");
+        Ok(())
+    }
+
+    /// Unregister an event handler
+    pub async fn unregister_handler(&self, handler_id: &str) -> Result<()> {
+        let mut handlers = self.handlers.write().await;
+        handlers.remove(handler_id);
+        tracing::info!(handler_id = %handler_id, "Event handler unregistered");
+        Ok(())
+    }
+
+    /// Get a broadcast receiver for events
+    pub async fn get_event_receiver(&self) -> Result<broadcast::Receiver<JetstreamEvent>> {
+        let sender_guard = self.event_sender.read().await;
+        match sender_guard.as_ref() {
+            Some(sender) => Ok(sender.subscribe()),
+            None => Err(ConsumerError::EventSenderNotInitialized(
+                "consumer not running".to_string(),
+            )
+            .into()),
+        }
+    }
+
+    /// Run the consumer in the background
+    ///
+    /// # Example
+    /// ```rust,no_run
+    /// use atproto_jetstream::{Consumer, ConsumerTaskConfig, CancellationToken};
+    ///
+    /// # async fn example() -> anyhow::Result<()> {
+    /// let config = ConsumerTaskConfig {
+    ///     user_agent: "my-app/1.0".to_string(),
+    ///     compression: false,
+    ///     zstd_dictionary_location: String::new(),
+    ///     jetstream_hostname: "jetstream1.us-east.bsky.network".to_string(),
+    ///     collections: vec!["app.bsky.feed.post".to_string()],
+    ///     dids: vec![], // Subscribe to all DIDs
+    ///     max_message_size_bytes: None, // No limit
+    ///     cursor: None, // Live-tail from current time
+    ///     require_hello: true, // Wait for initial options update
+    /// };
+    ///
+    /// let consumer = Consumer::new(config);
+    /// let cancellation_token = CancellationToken::new();
+    ///
+    /// // To cancel the consumer later:
+    /// // cancellation_token.cancel();
+    ///
+    /// consumer.run_background(cancellation_token).await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn run_background(&self, cancellation_token: CancellationToken) -> Result<()> {
+        tracing::info!("Starting Jetstream consumer");
+
+        // Build WebSocket URL with query parameters
+        let mut query_params = vec![];
+
+        // Add compression parameter
+        query_params.push(format!("compress={}", self.config.compression));
+
+        // Add requireHello parameter
+        query_params.push(format!("requireHello={}", self.config.require_hello));
+
+        // Add wantedCollections if specified
+        if !self.config.collections.is_empty() {
+            let collections = self
+                .config
+                .collections
+                .iter()
+                .map(|c| urlencoding::encode(c))
+                .collect::<Vec<_>>()
+                .join(",");
+            query_params.push(format!("wantedCollections={}", collections));
+        }
+
+        // Add wantedDids if specified
+        if !self.config.dids.is_empty() {
+            let dids = self
+                .config
+                .dids
+                .iter()
+                .map(|d| urlencoding::encode(d))
+                .collect::<Vec<_>>()
+                .join(",");
+            query_params.push(format!("wantedDids={}", dids));
+        }
+
+        // Add maxMessageSizeBytes if specified
+        if let Some(max_size) = self.config.max_message_size_bytes {
+            query_params.push(format!("maxMessageSizeBytes={}", max_size));
+        }
+
+        // Add cursor if specified
+        if let Some(cursor) = self.config.cursor {
+            query_params.push(format!("cursor={}", cursor));
+        }
+
+        let query_string = query_params.join("&");
+        let ws_url = Uri::from_str(&format!(
+            "wss://{}/subscribe?{}",
+            self.config.jetstream_hostname, query_string
+        ))?;
+
+        tracing::info!(url = %ws_url, "Connecting to Jetstream");
+
+        let (mut client, _) = ClientBuilder::from_uri(ws_url)
+            .add_header(
+                http::header::USER_AGENT,
+                http::HeaderValue::from_str(&self.config.user_agent)?,
+            )?
+            .connect()
+            .await?;
+
+        let update = SubscriberSourcedMessage::Update {
+            wanted_collections: self.config.collections.clone(),
+            wanted_dids: self.config.dids.clone(),
+            max_message_size_bytes: self
+                .config
+                .max_message_size_bytes
+                .unwrap_or(MAX_MESSAGE_SIZE as u64),
+            cursor: self.config.cursor,
+        };
+        let serialized_update = serde_json::to_string(&update)
+            .map_err(|err| ConsumerError::UpdateSerializationFailed(err.to_string()))?;
+
+        client
+            .send(Message::text(serialized_update))
+            .await
+            .map_err(|err| ConsumerError::UpdateSendFailed(err.to_string()))?;
+
+        let mut decompressor = if self.config.compression {
+            // mkdir -p data/ && curl -o data/zstd_dictionary https://github.com/bluesky-social/jetstream/raw/refs/heads/main/pkg/models/zstd_dictionary
+            let data: Vec<u8> = std::fs::read(self.config.zstd_dictionary_location.clone())?;
+            zstd::bulk::Decompressor::with_dictionary(&data)
+                .map_err(|err| ConsumerError::DecompressorCreationFailed(err.to_string()))?
+        } else {
+            zstd::bulk::Decompressor::new()
+                .map_err(|err| ConsumerError::DecompressorCreationFailed(err.to_string()))?
+        };
+
+        let interval = std::time::Duration::from_secs(120);
+        let sleeper = sleep(interval);
+        tokio::pin!(sleeper);
+
+        loop {
+            tokio::select! {
+                () = cancellation_token.cancelled() => {
+                    break;
+                },
+                () = &mut sleeper => {
+                        // consumer_control_insert(&self.pool, &self.config.jetstream_hostname, time_usec).await?;
+
+                        sleeper.as_mut().reset(Instant::now() + interval);
+                },
+                item = client.next() => {
+                    if item.is_none() {
+                        tracing::warn!("jetstream connection closed");
+                        break;
+                    }
+                    let item = item.unwrap();
+
+                    if let Err(err) = item {
+                        tracing::error!(error = ?err, "error processing jetstream message");
+                        continue;
+                    }
+                    let item = item.unwrap();
+
+                    let event = if self.config.compression {
+                        if !item.is_binary() {
+                            tracing::debug!("compression enabled but message from jetstream is not binary");
+                            continue;
+                        }
+                        let payload = item.into_payload();
+
+                        let decoded = decompressor.decompress(&payload, MAX_MESSAGE_SIZE * 3);
+                        if let Err(err) = decoded {
+                            tracing::debug!(err = ?err, "cannot decompress message");
+                            continue;
+                        }
+                        let decoded = decoded.unwrap();
+                        serde_json::from_slice::<JetstreamEvent>(&decoded)
+                        .map_err(|err| ConsumerError::DeserializationFailed(err.to_string()))
+                    } else {
+                        if !item.is_text() {
+                            tracing::debug!("compression disabled but message from jetstream is binary");
+                            continue;
+                        }
+                        item.as_text()
+                            .ok_or_else(|| ConsumerError::MessageConversionFailed("cannot convert message to text".to_string()))
+                            .and_then(|value| {
+                                serde_json::from_str::<JetstreamEvent>(value)
+                                .map_err(|err| ConsumerError::DeserializationFailed(err.to_string()))
+                            })
+                    };
+                    if let Err(err) = event {
+                        tracing::error!(error = ?err, "error processing jetstream message");
+
+                        continue;
+                    }
+                    let event = event.unwrap();
+
+                    if let Err(err) = self.dispatch_to_handlers(event).await {
+                        tracing::error!(error = ?err, "Failed to process message");
+                    }
+
+                }
+            }
+        }
+
+        // Clean up
+        {
+            let mut sender_guard = self.event_sender.write().await;
+            *sender_guard = None;
+        }
+
+        tracing::info!("Consumer background task finished");
+        Ok(())
+    }
+
+    /// Dispatch event to all registered handlers
+    async fn dispatch_to_handlers(&self, event: JetstreamEvent) -> Result<()> {
+        let handlers = self.handlers.read().await;
+
+        for (handler_id, handler) in handlers.iter() {
+            let handler_span = tracing::debug_span!("handler_dispatch", handler_id = %handler_id);
+            async {
+                if let Err(err) = handler.handle_event(event.clone()).await {
+                    tracing::error!(
+                        error = ?err,
+                        handler_id = %handler_id,
+                        "Handler failed to process event"
+                    );
+                }
+            }
+            .instrument(handler_span)
+            .await;
+        }
+
+        Ok(())
+    }
+}
+
+/// Example event handler implementation
+pub struct LoggingHandler {
+    id: String,
+}
+
+impl LoggingHandler {
+    /// Create a new logging handler with the specified ID
+    pub fn new(id: String) -> Self {
+        Self { id }
+    }
+}
+
+#[async_trait]
+impl EventHandler for LoggingHandler {
+    async fn handle_event(&self, event: JetstreamEvent) -> Result<()> {
+        tracing::info!(
+            handler_id = %self.id,
+            event = ?event,
+            "Processing event"
+        );
+        Ok(())
+    }
+
+    fn handler_id(&self) -> String {
+        self.id.clone()
+    }
+}

crates/atproto-jetstream/src/lib.rs

···
+//! AT Protocol Jetstream event consumer library.
+//!
+//! Provides async stream consumption and event handling for AT Protocol Jetstream
+//! with support for WebSocket connections, event dispatching, and handler registration.
+//!
+//! ## Key Features
+//!
+//! - **Async Stream Consumer**: High-performance WebSocket-based event consumption
+//! - **Event Handler Registration**: Flexible event handler system with multiple handlers
+//! - **Compression Support**: Optional Zstandard compression with dictionary support
+//! - **Graceful Shutdown**: Cancellation token support for clean shutdown
+//! - **Error Handling**: Comprehensive error types following project conventions
+
+#![warn(missing_docs)]
+
+pub mod consumer;
+
+pub use consumer::{
+    Consumer, ConsumerError, ConsumerTaskConfig, EventHandler, JetstreamEvent,
+    JetstreamEventCommit, JetstreamEventDelete, LoggingHandler,
+};
+
+// Re-export CancellationToken for convenience
+pub use tokio_util::sync::CancellationToken;

crates/atproto-oauth-axum/Cargo.toml

···
 [package]
 name = "atproto-oauth-axum"
-version = "0.5.0"
+version = "0.6.0"
 description = "Axum web framework integration for AT Protocol OAuth workflows"
 readme = "README.md"
 homepage = "https://tangled.sh/@smokesignal.events/atproto-identity-rs"

crates/atproto-oauth-axum/README.md

···
 
 ```toml
 [dependencies]
-atproto-oauth-axum = "0.5.0"
+atproto-oauth-axum = "0.6.0"
 ```
 
 ## Usage

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

···
+//! # AT Protocol OAuth CLI Tool
+//!
+//! Command-line tool for managing AT Protocol OAuth authentication flows.
+//! Provides functionality to initiate OAuth login flows and refresh access tokens
+//! for AT Protocol services.
+//!
+//! ## Commands
+//!
+//! - `login <private_signing_key> <subject>`: Start OAuth login flow
+//! - `refresh <private_signing_key> <subject> <private_dpop_key> <refresh_token>`: Refresh OAuth tokens
+//!
+//! ## Features
+//!
+//! - Complete OAuth 2.0 authorization code flow with PKCE
+//! - DPoP (Demonstration of Proof-of-Possession) token support
+//! - AT Protocol identity resolution and DID document management
+//! - OAuth server endpoints for client metadata and callback handling
+//! - Support for both `did:plc` and `did:web` identity methods
+//!
+//! ## Environment Variables
+//!
+//! - `EXTERNAL_BASE`: External hostname for OAuth endpoints (required)
+//! - `PORT`: HTTP server port (default: 8080)
+//! - `PLC_HOSTNAME`: PLC directory hostname (default: plc.directory)
+//! - `USER_AGENT`: HTTP User-Agent header (auto-generated)
+//! - `DNS_NAMESERVERS`: Custom DNS nameservers (optional)
+//! - `CERTIFICATE_BUNDLES`: Additional CA certificates (optional)
+
 use anyhow::Result;
 use async_trait::async_trait;
 use atproto_identity::{

crates/atproto-oauth/Cargo.toml

···
 [package]
 name = "atproto-oauth"
-version = "0.5.0"
+version = "0.6.0"
 description = "OAuth workflow implementation for AT Protocol - PKCE, DPoP, and secure authentication flows"
 readme = "README.md"
 homepage = "https://tangled.sh/@smokesignal.events/atproto-identity-rs"

crates/atproto-oauth/README.md

···
 
 ```toml
 [dependencies]
-atproto-oauth = "0.5.0"
+atproto-oauth = "0.6.0"
 ```
 
 ## Usage

crates/atproto-record/Cargo.toml

···
 [package]
 name = "atproto-record"
-version = "0.5.0"
+version = "0.6.0"
 description = "AT Protocol record signature operations - cryptographic signing and verification for AT Protocol records"
 readme = "README.md"
 homepage = "https://tangled.sh/@smokesignal.events/atproto-identity-rs"

crates/atproto-xrpcs-helloworld/Cargo.toml

···
 [package]
 name = "atproto-xrpcs-helloworld"
-version = "0.5.0"
+version = "0.6.0"
+description = "Complete example implementation of an AT Protocol XRPC service with DID web functionality and JWT authentication"
 edition.workspace = true
 rust-version.workspace = true
 repository.workspace = true

crates/atproto-xrpcs-helloworld/src/main.rs

···
+//! # AT Protocol XRPC Hello World Service
+//!
+//! A demonstration XRPC service implementation showcasing the AT Protocol ecosystem.
+//! This service provides a simple "Hello, World!" endpoint that supports both authenticated
+//! and unauthenticated requests.
+//!
+//! ## Features
+//!
+//! - AT Protocol identity resolution and DID document management
+//! - XRPC service endpoint with optional authentication
+//! - DID:web identity publishing via `.well-known` endpoints
+//! - JWT-based request authentication using AT Protocol standards
+//!
+//! ## Environment Variables
+//!
+//! - `SERVICE_KEY`: Private key for service identity (required)
+//! - `EXTERNAL_BASE`: External hostname for service endpoints (required)
+//! - `PORT`: HTTP server port (default: 8080)
+//! - `PLC_HOSTNAME`: PLC directory hostname (default: plc.directory)
+//! - `USER_AGENT`: HTTP User-Agent header (auto-generated)
+//! - `DNS_NAMESERVERS`: Custom DNS nameservers (optional)
+//! - `CERTIFICATE_BUNDLES`: Additional CA certificates (optional)
+
 use anyhow::Result;
 use async_trait::async_trait;
 use atproto_identity::{

crates/atproto-xrpcs/Cargo.toml

···
 [package]
 name = "atproto-xrpcs"
-version = "0.5.0"
+version = "0.6.0"
+description = "Core building blocks for implementing AT Protocol XRPC services with JWT authorization"
 edition.workspace = true
 rust-version.workspace = true
 repository.workspace = true

crates/atproto-xrpcs/README.md

···
 
 ```toml
 [dependencies]
-atproto-xrpcs = "0.5.0"
+atproto-xrpcs = "0.6.0"
 ```
 
 ## Usage