Merge branch 'refs/heads/dev'

docs/extensions.md

···
 | `AtpClient::hasDomainExtension($domain, $name)` | Check if a request client extension is registered |
 | `AtpClient::flushExtensions()` | Clear all extensions (useful for testing) |
 
-The same methods are available on `AtpPublicClient` for unauthenticated extensions.
-
 ### Extension Types
 
 | Type | Access Pattern | Use Case |
···
 ```bash
 # Create a domain client extension
 php artisan make:atp-client AnalyticsClient
-
-# Create a public domain client extension
-php artisan make:atp-client DiscoverClient --public
 
 # Create a request client extension for an existing domain
 php artisan make:atp-request MetricsClient --domain=bsky
-
-# Create a public request client extension
-php artisan make:atp-request TrendingClient --domain=bsky --public
 ```
 
 The generated files are placed in configurable directories. You can customize these paths in `config/client.php`:
···
 ```php
 'generators' => [
     'client_path' => 'app/Services/Clients',
-    'client_public_path' => 'app/Services/Clients/Public',
     'request_path' => 'app/Services/Clients/Requests',
-    'request_public_path' => 'app/Services/Clients/Public/Requests',
 ],
 ```
 
···
 $authorMetrics = $client->bsky->metrics->getAuthorMetrics('someone.bsky.social');
 ```
 
-## Public Client Extensions
+## Public vs Authenticated Mode
 
-The `AtpPublicClient` supports the same extension system for unauthenticated API access:
+The `AtpClient` class works in both public and authenticated modes. Both `Atp::public()` and `Atp::as()` return the same `AtpClient` class:
 
 ```php
-use SocialDept\AtpClient\Client\Public\AtpPublicClient;
+// Public mode - no authentication
+$publicClient = Atp::public('https://public.api.bsky.app');
+$publicClient->bsky->actor->getProfile('someone.bsky.social');
 
-// Domain client extension
-AtpPublicClient::extend('discover', fn($atp) => new DiscoverClient($atp));
-
-// Request client extension on existing domain
-AtpPublicClient::extendDomain('bsky', 'trending', fn($bsky) => new TrendingClient($bsky));
+// Authenticated mode - with session
+$authClient = Atp::as('did:plc:xxx');
+$authClient->bsky->actor->getProfile('someone.bsky.social');
 ```
 
-For public request clients, extend `PublicRequest` instead of `Request`:
-
-```php
-<?php
-
-namespace App\Atp;
-
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-
-class TrendingPublicClient extends PublicRequest
-{
-    public function getPopularFeeds(int $limit = 10): array
-    {
-        return $this->atp->bsky->feed->getPopularFeedGenerators($limit)->feeds;
-    }
-}
-```
+Extensions registered on `AtpClient` work in both modes. The underlying HTTP layer automatically handles authentication based on whether a session is present.
 
 ## Registering Multiple Extensions
 
···
     AtpClient::extendDomain('bsky', 'metrics', fn($bsky) => new BskyMetricsClient($bsky));
     AtpClient::extendDomain('bsky', 'lists', fn($bsky) => new BskyListsClient($bsky));
     AtpClient::extendDomain('atproto', 'backup', fn($atproto) => new RepoBackupClient($atproto));
-
-    // Public client extensions
-    AtpPublicClient::extend('discover', fn($atp) => new DiscoverClient($atp));
 }
 ```
 
···
     }
 }
 ```
+
+### Documenting Scope Requirements
+
+Use the `#[ScopedEndpoint]` and `#[PublicEndpoint]` attributes to document the authentication requirements of your extension methods:
+
+```php
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
+use SocialDept\AtpClient\Client\Requests\Request;
+use SocialDept\AtpClient\Enums\Scope;
+
+class BskyMetricsClient extends Request
+{
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getTimeline')]
+    public function getTimelineMetrics(): array
+    {
+        $timeline = $this->atp->bsky->feed->getTimeline();
+        // Process and return metrics...
+    }
+
+    #[PublicEndpoint]
+    public function getPublicPostMetrics(string $uri): array
+    {
+        $thread = $this->atp->bsky->feed->getPostThread($uri);
+        // Process and return metrics...
+    }
+}
+```
+
+> **Note:** These attributes currently serve as documentation only. Runtime scope enforcement will be implemented in a future release. Using them correctly now ensures forward compatibility.
+
+Methods with `#[ScopedEndpoint]` indicate they require authentication, while methods with `#[PublicEndpoint]` work without authentication. See [scopes.md](scopes.md) for full documentation on scope handling.
 
 ## Available Domains
 

docs/scopes.md

···
+# OAuth Scopes
+
+The AT Protocol uses OAuth scopes to control what actions an application can perform on behalf of a user. AtpClient provides attributes for documenting scope requirements on endpoints.
+
+> **Note:** The `#[ScopedEndpoint]` and `#[PublicEndpoint]` attributes currently serve as documentation only. Runtime scope validation and enforcement will be implemented in a future release. Using these attributes correctly now ensures forward compatibility.
+
+## Quick Reference
+
+### Scope Enum
+
+```php
+use SocialDept\AtpClient\Enums\Scope;
+
+// Transition scopes (current AT Protocol scopes)
+Scope::Atproto              // 'atproto' - Full access
+Scope::TransitionGeneric    // 'transition:generic' - General API access
+Scope::TransitionEmail      // 'transition:email' - Email access
+Scope::TransitionChat       // 'transition:chat.bsky' - Chat access
+
+// Granular scope builders (future AT Protocol scopes)
+Scope::repo('app.bsky.feed.post', ['create', 'delete'])  // Record operations
+Scope::rpc('app.bsky.feed.getTimeline')                  // RPC endpoint access
+Scope::blob('image/*')                                    // Blob upload access
+Scope::account('email')                                   // Account attribute access
+Scope::identity('handle')                                 // Identity attribute access
+```
+
+### ScopedEndpoint Attribute
+
+```php
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
+use SocialDept\AtpClient\Enums\Scope;
+
+#[ScopedEndpoint(Scope::TransitionGeneric)]
+public function getTimeline(): GetTimelineResponse
+{
+    // Method implementation
+}
+```
+
+## Understanding AT Protocol Scopes
+
+### Current Transition Scopes
+
+The AT Protocol is currently in a transition period where broad "transition scopes" are used:
+
+| Scope | Description |
+|-------|-------------|
+| `atproto` | Full access to the AT Protocol |
+| `transition:generic` | General API access for most operations |
+| `transition:email` | Access to email-related operations |
+| `transition:chat.bsky` | Access to Bluesky chat features |
+
+### Future Granular Scopes
+
+The AT Protocol is moving toward granular scopes that provide fine-grained access control:
+
+```php
+// Record operations
+'repo:app.bsky.feed.post'                      // All operations on posts
+'repo:app.bsky.feed.post?action=create'        // Only create posts
+'repo:app.bsky.feed.like?action=create&action=delete'  // Create or delete likes
+'repo:*'                                       // All collections, all actions
+
+// RPC endpoint access
+'rpc:app.bsky.feed.getTimeline'               // Access to timeline endpoint
+'rpc:app.bsky.feed.*'                         // All feed endpoints
+
+// Blob operations
+'blob:image/*'                                 // Upload images
+'blob:*/*'                                     // Upload any blob type
+
+// Account and identity
+'account:email'                                // Access email
+'identity:handle'                              // Manage handle
+```
+
+## The ScopedEndpoint Attribute
+
+The `#[ScopedEndpoint]` attribute documents scope requirements on methods that require authentication.
+
+### Basic Usage
+
+```php
+<?php
+
+namespace App\Atp;
+
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
+use SocialDept\AtpClient\Client\Requests\Request;
+use SocialDept\AtpClient\Enums\Scope;
+
+class CustomClient extends Request
+{
+    #[ScopedEndpoint(Scope::TransitionGeneric)]
+    public function getTimeline(): array
+    {
+        return $this->atp->client->get('app.bsky.feed.getTimeline')->json();
+    }
+}
+```
+
+### With Granular Scope
+
+Document the future granular scope that will replace the transition scope:
+
+```php
+#[ScopedEndpoint(
+    Scope::TransitionGeneric,
+    granular: 'rpc:app.bsky.feed.getTimeline'
+)]
+public function getTimeline(): GetTimelineResponse
+{
+    // ...
+}
+```
+
+### With Description
+
+Add a human-readable description for documentation:
+
+```php
+#[ScopedEndpoint(
+    Scope::TransitionGeneric,
+    granular: 'rpc:app.bsky.feed.getTimeline',
+    description: 'Access to the user\'s home timeline'
+)]
+public function getTimeline(): GetTimelineResponse
+{
+    // ...
+}
+```
+
+### Multiple Scopes (AND Logic)
+
+When a method requires multiple scopes, all must be present:
+
+```php
+#[ScopedEndpoint([Scope::TransitionGeneric, Scope::TransitionEmail])]
+public function getEmailPreferences(): array
+{
+    // Requires BOTH scopes
+}
+```
+
+### Multiple Attributes (OR Logic)
+
+Use multiple attributes for alternative scope requirements:
+
+```php
+#[ScopedEndpoint(Scope::Atproto)]
+#[ScopedEndpoint(Scope::TransitionGeneric)]
+public function getProfile(string $actor): ProfileViewDetailed
+{
+    // Either scope satisfies the requirement
+}
+```
+
+## Scope Enforcement (Planned)
+
+> **Coming Soon:** Runtime scope enforcement is not yet implemented. The following documentation describes planned functionality for a future release.
+
+### Configuration
+
+Configure scope enforcement in `config/client.php` or via environment variables:
+
+```php
+'scope_enforcement' => ScopeEnforcementLevel::Permissive,
+```
+
+| Level | Behavior |
+|-------|----------|
+| `Strict` | Throws `MissingScopeException` if required scopes are missing |
+| `Permissive` | Logs a warning but attempts the request anyway |
+
+Set via environment variable:
+
+```env
+ATP_SCOPE_ENFORCEMENT=strict
+```
+
+### Programmatic Scope Checking
+
+Check scopes programmatically using the `ScopeChecker`:
+
+```php
+use SocialDept\AtpClient\Auth\ScopeChecker;
+use SocialDept\AtpClient\Facades\Atp;
+
+$checker = app(ScopeChecker::class);
+$session = Atp::as($did)->client->session();
+
+// Check if session has a scope
+if ($checker->hasScope($session, Scope::TransitionGeneric)) {
+    // Session has the scope
+}
+
+// Check multiple scopes
+if ($checker->check($session, [Scope::TransitionGeneric, Scope::TransitionEmail])) {
+    // Session has ALL required scopes
+}
+
+// Check and fail if missing (respects enforcement level)
+$checker->checkOrFail($session, [Scope::TransitionGeneric]);
+
+// Check repo scope for specific action
+if ($checker->checkRepoScope($session, 'app.bsky.feed.post', 'create')) {
+    // Can create posts
+}
+```
+
+### Granular Pattern Matching
+
+The scope checker supports wildcard patterns:
+
+```php
+// Check if session can access any feed endpoint
+$checker->matchesGranular($session, 'rpc:app.bsky.feed.*');
+
+// Check if session can upload images
+$checker->matchesGranular($session, 'blob:image/*');
+
+// Check if session has any repo access
+$checker->matchesGranular($session, 'repo:*');
+```
+
+## Route Middleware (Planned)
+
+> **Coming Soon:** Route middleware is not yet implemented. The following documentation describes planned functionality for a future release.
+
+Protect Laravel routes based on ATP session scopes:
+
+```php
+use Illuminate\Support\Facades\Route;
+
+// Single scope
+Route::get('/timeline', TimelineController::class)
+    ->middleware('atp.scope:transition:generic');
+
+// Multiple scopes (AND logic)
+Route::get('/email-settings', EmailSettingsController::class)
+    ->middleware('atp.scope:transition:generic,transition:email');
+```
+
+### Middleware Configuration
+
+Configure middleware behavior in `config/client.php`:
+
+```php
+'scope_authorization' => [
+    // What to do when scope check fails
+    'failure_action' => ScopeAuthorizationFailure::Abort,  // abort, redirect, or exception
+
+    // Where to redirect (when failure_action is 'redirect')
+    'redirect_to' => '/login',
+],
+```
+
+| Failure Action | Behavior |
+|----------------|----------|
+| `Abort` | Returns 403 Forbidden response |
+| `Redirect` | Redirects to configured URL |
+| `Exception` | Throws `ScopeAuthorizationException` |
+
+Set via environment variables:
+
+```env
+ATP_SCOPE_FAILURE_ACTION=redirect
+ATP_SCOPE_REDIRECT=/auth/login
+```
+
+### User Model Integration
+
+For the middleware to work, your User model must implement `HasAtpSession`:
+
+```php
+<?php
+
+namespace App\Models;
+
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use SocialDept\AtpClient\Contracts\HasAtpSession;
+
+class User extends Authenticatable implements HasAtpSession
+{
+    public function getAtpDid(): ?string
+    {
+        return $this->atp_did;
+    }
+}
+```
+
+## Public Mode and Scopes
+
+Methods marked with `#[PublicEndpoint]` can be called without authentication using `Atp::public()`:
+
+```php
+// Public mode - no authentication required
+$client = Atp::public('https://public.api.bsky.app');
+$client->bsky->actor->getProfile('someone.bsky.social');  // Works without auth
+
+// Authenticated mode - for endpoints requiring scopes
+$client = Atp::as($did);
+$client->bsky->feed->getTimeline();  // Requires transition:generic scope
+```
+
+Methods with `#[PublicEndpoint]` work in both modes, while methods with `#[ScopedEndpoint]` require authentication.
+
+## Exception Handling (Planned)
+
+> **Coming Soon:** These exceptions will be thrown when scope enforcement is implemented in a future release.
+
+### MissingScopeException
+
+Will be thrown when required scopes are missing and enforcement is strict:
+
+```php
+use SocialDept\AtpClient\Exceptions\MissingScopeException;
+
+try {
+    $timeline = $client->bsky->feed->getTimeline();
+} catch (MissingScopeException $e) {
+    $missing = $e->getMissingScopes();   // Scopes that are missing
+    $granted = $e->getGrantedScopes();   // Scopes the session has
+
+    // Handle missing scope
+}
+```
+
+### ScopeAuthorizationException
+
+Will be thrown by middleware when route access is denied:
+
+```php
+use SocialDept\AtpClient\Exceptions\ScopeAuthorizationException;
+
+try {
+    // Route protected by atp.scope middleware
+} catch (ScopeAuthorizationException $e) {
+    $required = $e->getRequiredScopes();
+    $granted = $e->getGrantedScopes();
+    $message = $e->getMessage();
+}
+```
+
+## Best Practices
+
+### 1. Document All Scope Requirements
+
+Always add `#[ScopedEndpoint]` to methods that require authentication:
+
+```php
+#[ScopedEndpoint(
+    Scope::TransitionGeneric,
+    granular: 'rpc:app.bsky.feed.getTimeline',
+    description: 'Fetches the authenticated user\'s home timeline'
+)]
+public function getTimeline(): GetTimelineResponse
+```
+
+### 2. Use the Scope Enum
+
+Prefer the `Scope` enum over string literals for type safety:
+
+```php
+// Good
+#[ScopedEndpoint(Scope::TransitionGeneric)]
+
+// Avoid
+#[ScopedEndpoint('transition:generic')]
+```
+
+### 3. Request Minimal Scopes
+
+When implementing OAuth, request only the scopes your application needs:
+
+```php
+$authUrl = Atp::oauth()->getAuthorizationUrl([
+    'scope' => 'atproto transition:generic',
+]);
+```
+
+### 4. Handle Missing Scopes Gracefully
+
+Check for scope availability before attempting operations:
+
+```php
+$checker = app(ScopeChecker::class);
+$session = $client->client->session();
+
+if ($checker->hasScope($session, Scope::TransitionChat)) {
+    $conversations = $client->chat->getConversations();
+} else {
+    // Inform user they need to re-authorize with chat scope
+}
+```
+
+### 5. Use Permissive Mode in Development
+
+Start with permissive enforcement during development, then switch to strict for production:
+
+```env
+# .env.local
+ATP_SCOPE_ENFORCEMENT=permissive
+
+# .env.production
+ATP_SCOPE_ENFORCEMENT=strict
+```

src/AtpClient.php

···
 class AtpClient
 {
     use HasExtensions;
+
     /**
      * Raw API communication/networking class
      */
···
     public OzoneClient $ozone;
 
     public function __construct(
-        SessionManager $sessions,
-        string $did,
+        ?SessionManager $sessions = null,
+        ?string $did = null,
+        ?string $serviceUrl = null,
     ) {
-        // Load the network client
-        $this->client = new Client($this, $sessions, $did);
+        // Load the network client (supports both public and authenticated modes)
+        $this->client = new Client($this, $sessions, $did, $serviceUrl);
 
         // Load all function collections
         $this->bsky = new BskyClient($this);
         $this->atproto = new AtprotoClient($this);
         $this->chat = new ChatClient($this);
         $this->ozone = new OzoneClient($this);
+    }
+
+    /**
+     * Check if client is in public mode (no authentication).
+     */
+    public function isPublicMode(): bool
+    {
+        return $this->client->isPublicMode();
     }
 }

src/AtpClientServiceProvider.php

···
 use SocialDept\AtpClient\Http\DPoPClient;
 use SocialDept\AtpClient\Session\SessionManager;
 use SocialDept\AtpClient\Storage\EncryptedFileKeyStore;
-use SocialDept\AtpClient\Client\Public\AtpPublicClient;
 
 class AtpClientServiceProvider extends ServiceProvider
 {
···
                     $this->app->instance(CredentialProvider::class, $provider);
                 }
 
-                public function public(?string $service = null): AtpPublicClient
+                public function public(?string $service = null): AtpClient
                 {
-                    return new AtpPublicClient(
-                        $service ?? config('atp-client.public.service_url', 'https://public.api.bsky.app')
+                    return new AtpClient(
+                        sessions: null,
+                        did: null,
+                        serviceUrl: $service ?? config('atp-client.public.service_url', 'https://public.api.bsky.app')
                     );
                 }
             };

src/Attributes/PublicEndpoint.php

···
+<?php
+
+namespace SocialDept\AtpClient\Attributes;
+
+use Attribute;
+
+/**
+ * Documents that a method is a public endpoint that does not require authentication.
+ *
+ * This attribute currently serves as documentation to indicate which AT Protocol
+ * endpoints can be called without an authenticated session. It helps developers
+ * understand which endpoints work with `Atp::public()` against public API endpoints
+ * like `https://public.api.bsky.app`.
+ *
+ * While this attribute does not currently perform runtime enforcement, scope
+ * validation will be implemented in a future release. Correctly attributing
+ * endpoints now ensures forward compatibility when enforcement is enabled.
+ *
+ * Public endpoints typically include operations like:
+ * - Reading public profiles and posts
+ * - Searching actors and content
+ * - Resolving handles to DIDs
+ * - Accessing repository data (sync endpoints)
+ * - Describing servers and feed generators
+ *
+ * @example Basic usage
+ * ```php
+ * #[PublicEndpoint]
+ * public function getProfile(string $actor): ProfileViewDetailed
+ * ```
+ *
+ * @see \SocialDept\AtpClient\Attributes\ScopedEndpoint For endpoints that require authentication
+ */
+#[Attribute(Attribute::TARGET_METHOD)]
+class PublicEndpoint
+{
+    /**
+     * @param  string  $description  Human-readable description of the endpoint
+     */
+    public function __construct(
+        public readonly string $description = '',
+    ) {}
+}

src/Attributes/RequiresScope.php

···
-<?php
-
-namespace SocialDept\AtpClient\Attributes;
-
-use Attribute;
-use SocialDept\AtpClient\Enums\Scope;
-
-#[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
-class RequiresScope
-{
-    public array $scopes;
-
-    /**
-     * @param  string|Scope|array<string|Scope>  $scopes  Required scope(s) for this method
-     * @param  string|null  $granular  Future granular scope equivalent
-     * @param  string  $description  Human-readable description of scope requirement
-     */
-    public function __construct(
-        string|Scope|array $scopes,
-        public readonly ?string $granular = null,
-        public readonly string $description = '',
-    ) {
-        $this->scopes = $this->normalizeScopes($scopes);
-    }
-
-    protected function normalizeScopes(string|Scope|array $scopes): array
-    {
-        if (! is_array($scopes)) {
-            $scopes = [$scopes];
-        }
-
-        return array_map(
-            fn ($scope) => $scope instanceof Scope ? $scope->value : $scope,
-            $scopes
-        );
-    }
-}

src/Attributes/ScopedEndpoint.php

···
+<?php
+
+namespace SocialDept\AtpClient\Attributes;
+
+use Attribute;
+use SocialDept\AtpClient\Enums\Scope;
+
+/**
+ * Documents that a method requires authentication with specific OAuth scopes.
+ *
+ * This attribute currently serves as documentation to indicate which AT Protocol
+ * endpoints require authentication and what scopes they need. It helps developers
+ * understand scope requirements when building applications.
+ *
+ * While this attribute does not currently perform runtime enforcement, scope
+ * validation will be implemented in a future release. Correctly attributing
+ * endpoints now ensures forward compatibility when enforcement is enabled.
+ *
+ * The AT Protocol currently uses "transition scopes" (like `transition:generic`) while
+ * moving toward more granular scopes. The `granular` parameter allows documenting the
+ * future granular scope that will replace the transition scope.
+ *
+ * @example Basic usage with a transition scope
+ * ```php
+ * #[ScopedEndpoint(Scope::TransitionGeneric)]
+ * public function getTimeline(): GetTimelineResponse
+ * ```
+ *
+ * @example With future granular scope documented
+ * ```php
+ * #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getTimeline')]
+ * public function getTimeline(): GetTimelineResponse
+ * ```
+ *
+ * @see \SocialDept\AtpClient\Attributes\PublicEndpoint For endpoints that don't require authentication
+ * @see \SocialDept\AtpClient\Enums\Scope For available scope values
+ */
+#[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
+class ScopedEndpoint
+{
+    public array $scopes;
+
+    /**
+     * @param  string|Scope|array<string|Scope>  $scopes  Required scope(s) for this method
+     * @param  string|null  $granular  Future granular scope equivalent
+     * @param  string  $description  Human-readable description of scope requirement
+     */
+    public function __construct(
+        string|Scope|array $scopes,
+        public readonly ?string $granular = null,
+        public readonly string $description = '',
+    ) {
+        $this->scopes = $this->normalizeScopes($scopes);
+    }
+
+    protected function normalizeScopes(string|Scope|array $scopes): array
+    {
+        if (! is_array($scopes)) {
+            $scopes = [$scopes];
+        }
+
+        return array_map(
+            fn ($scope) => $scope instanceof Scope ? $scope->value : $scope,
+            $scopes
+        );
+    }
+}

src/Client/BskyClient.php

···
 class BskyClient
 {
     use HasDomainExtensions;
+
     /**
      * The parent AtpClient instance
      */
···
     public Bsky\ActorRequestClient $actor;
 
     /**
+     * Graph operations (app.bsky.graph.*)
+     */
+    public Bsky\GraphRequestClient $graph;
+
+    /**
+     * Labeler operations (app.bsky.labeler.*)
+     */
+    public Bsky\LabelerRequestClient $labeler;
+
+    /**
      * Post record client
      */
     public PostRecordClient $post;
···
         $this->atp = $parent;
         $this->feed = new Bsky\FeedRequestClient($this);
         $this->actor = new Bsky\ActorRequestClient($this);
+        $this->graph = new Bsky\GraphRequestClient($this);
+        $this->labeler = new Bsky\LabelerRequestClient($this);
         $this->post = new PostRecordClient($this);
         $this->profile = new ProfileRecordClient($this);
         $this->like = new LikeRecordClient($this);

src/Client/Client.php

···
 
 namespace SocialDept\AtpClient\Client;
 
+use BackedEnum;
+use Illuminate\Support\Facades\Http;
 use SocialDept\AtpClient\AtpClient;
+use SocialDept\AtpClient\Exceptions\AtpResponseException;
 use SocialDept\AtpClient\Http\DPoPClient;
 use SocialDept\AtpClient\Http\HasHttp;
+use SocialDept\AtpClient\Http\Response;
 use SocialDept\AtpClient\Session\Session;
 use SocialDept\AtpClient\Session\SessionManager;
 
 class Client
 {
-    use HasHttp;
+    use HasHttp {
+        call as authenticatedCall;
+        postBlob as authenticatedPostBlob;
+    }
 
     /**
      * The parent AtpClient instance we belong to
      */
     protected AtpClient $atp;
 
+    /**
+     * Service URL for public mode
+     */
+    protected ?string $serviceUrl;
+
     public function __construct(
         AtpClient $parent,
-        SessionManager $sessions,
-        string $did,
+        ?SessionManager $sessions = null,
+        ?string $did = null,
+        ?string $serviceUrl = null,
     ) {
         $this->atp = $parent;
         $this->sessions = $sessions;
         $this->did = $did;
-        $this->dpopClient = app(DPoPClient::class);
+        $this->serviceUrl = $serviceUrl;
+
+        if (! $this->isPublicMode()) {
+            $this->dpopClient = app(DPoPClient::class);
+        }
+    }
+
+    /**
+     * Check if client is in public mode (no authentication).
+     */
+    public function isPublicMode(): bool
+    {
+        return $this->sessions === null || $this->did === null;
     }
 
     /**
···
     public function session(): Session
     {
         return $this->sessions->session($this->did);
+    }
+
+    /**
+     * Get the service URL.
+     */
+    public function serviceUrl(): string
+    {
+        return $this->serviceUrl;
+    }
+
+    /**
+     * Make XRPC call - routes to public or authenticated based on mode.
+     */
+    protected function call(
+        string|BackedEnum $endpoint,
+        string $method,
+        ?array $params = null,
+        ?array $body = null
+    ): Response {
+        if ($this->isPublicMode()) {
+            return $this->publicCall($endpoint, $method, $params, $body);
+        }
+
+        return $this->authenticatedCall($endpoint, $method, $params, $body);
+    }
+
+    /**
+     * Make public XRPC call (no authentication).
+     */
+    protected function publicCall(
+        string|BackedEnum $endpoint,
+        string $method,
+        ?array $params = null,
+        ?array $body = null
+    ): Response {
+        $endpoint = $endpoint instanceof BackedEnum ? $endpoint->value : $endpoint;
+        $url = rtrim($this->serviceUrl, '/') . '/xrpc/' . $endpoint;
+        $params = array_filter($params ?? [], fn ($v) => ! is_null($v));
+
+        $response = match ($method) {
+            'GET' => Http::get($url, $params),
+            'POST' => Http::post($url, $body ?? $params),
+            'DELETE' => Http::delete($url, $params),
+            default => throw new \InvalidArgumentException("Unsupported method: {$method}"),
+        };
+
+        if ($response->failed() || isset($response->json()['error'])) {
+            throw AtpResponseException::fromResponse($response, $endpoint);
+        }
+
+        return new Response($response);
+    }
+
+    /**
+     * Make POST request with raw binary body (for blob uploads).
+     * Only works in authenticated mode.
+     */
+    public function postBlob(string|BackedEnum $endpoint, string $data, string $mimeType): Response
+    {
+        if ($this->isPublicMode()) {
+            throw new \RuntimeException('Blob uploads require authentication.');
+        }
+
+        return $this->authenticatedPostBlob($endpoint, $data, $mimeType);
     }
 }

src/Client/Public/AtpPublicClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public;
-
-use SocialDept\AtpClient\Concerns\HasExtensions;
-
-class AtpPublicClient
-{
-    use HasExtensions;
-    public PublicClient $client;
-    public BskyPublicClient $bsky;
-    public AtprotoPublicClient $atproto;
-
-    public function __construct(string $serviceUrl = null)
-    {
-        $serviceUrl = $serviceUrl ?? config('client.public.service_url');
-
-        $this->client = new PublicClient($serviceUrl);
-        $this->bsky = new BskyPublicClient($this);
-        $this->atproto = new AtprotoPublicClient($this);
-    }
-}

src/Client/Public/AtprotoPublicClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public;
-
-use SocialDept\AtpClient\Client\Public\Requests\Atproto\IdentityPublicRequestClient;
-use SocialDept\AtpClient\Client\Public\Requests\Atproto\RepoPublicRequestClient;
-use SocialDept\AtpClient\Concerns\HasDomainExtensions;
-
-class AtprotoPublicClient
-{
-    use HasDomainExtensions;
-
-    protected AtpPublicClient $atp;
-    public IdentityPublicRequestClient $identity;
-    public RepoPublicRequestClient $repo;
-
-    public function __construct(AtpPublicClient $parent)
-    {
-        $this->atp = $parent;
-        $this->identity = new IdentityPublicRequestClient($this);
-        $this->repo = new RepoPublicRequestClient($this);
-    }
-
-    protected function getDomainName(): string
-    {
-        return 'atproto';
-    }
-
-    protected function getRootClientClass(): string
-    {
-        return AtpPublicClient::class;
-    }
-
-    public function root(): AtpPublicClient
-    {
-        return $this->atp;
-    }
-}

src/Client/Public/BskyPublicClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public;
-
-use SocialDept\AtpClient\Client\Public\Requests\Bsky\ActorPublicRequestClient;
-use SocialDept\AtpClient\Client\Public\Requests\Bsky\FeedPublicRequestClient;
-use SocialDept\AtpClient\Client\Public\Requests\Bsky\GraphPublicRequestClient;
-use SocialDept\AtpClient\Client\Public\Requests\Bsky\LabelerPublicRequestClient;
-use SocialDept\AtpClient\Concerns\HasDomainExtensions;
-
-class BskyPublicClient
-{
-    use HasDomainExtensions;
-
-    protected AtpPublicClient $atp;
-    public ActorPublicRequestClient $actor;
-    public FeedPublicRequestClient $feed;
-    public GraphPublicRequestClient $graph;
-    public LabelerPublicRequestClient $labeler;
-
-    public function __construct(AtpPublicClient $parent)
-    {
-        $this->atp = $parent;
-        $this->actor = new ActorPublicRequestClient($this);
-        $this->feed = new FeedPublicRequestClient($this);
-        $this->graph = new GraphPublicRequestClient($this);
-        $this->labeler = new LabelerPublicRequestClient($this);
-    }
-
-    protected function getDomainName(): string
-    {
-        return 'bsky';
-    }
-
-    protected function getRootClientClass(): string
-    {
-        return AtpPublicClient::class;
-    }
-
-    public function root(): AtpPublicClient
-    {
-        return $this->atp;
-    }
-}

src/Client/Public/PublicClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public;
-
-use BackedEnum;
-use Illuminate\Support\Facades\Http;
-use SocialDept\AtpClient\Exceptions\AtpResponseException;
-use SocialDept\AtpClient\Http\Response;
-
-class PublicClient
-{
-    public function __construct(
-        protected string $serviceUrl
-    ) {}
-
-    public function get(string|BackedEnum $endpoint, array $params = []): Response
-    {
-        $endpoint = $endpoint instanceof BackedEnum ? $endpoint->value : $endpoint;
-        $url = rtrim($this->serviceUrl, '/') . '/xrpc/' . $endpoint;
-        $params = array_filter($params, fn ($v) => !is_null($v));
-
-        $response = Http::get($url, $params);
-
-        if ($response->failed() || isset($response->json()['error'])) {
-            throw AtpResponseException::fromResponse($response, $endpoint);
-        }
-
-        return new Response($response);
-    }
-
-    public function serviceUrl(): string
-    {
-        return $this->serviceUrl;
-    }
-}

src/Client/Public/Requests/Atproto/IdentityPublicRequestClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public\Requests\Atproto;
-
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-use SocialDept\AtpClient\Enums\Nsid\AtprotoIdentity;
-
-class IdentityPublicRequestClient extends PublicRequest
-{
-    public function resolveHandle(string $handle): string
-    {
-        $response = $this->atp->client->get(
-            endpoint: AtprotoIdentity::ResolveHandle,
-            params: compact('handle')
-        );
-
-        return $response->json()['did'];
-    }
-}

src/Client/Public/Requests/Atproto/RepoPublicRequestClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public\Requests\Atproto;
-
-use BackedEnum;
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-use SocialDept\AtpClient\Data\Responses\Atproto\Repo\DescribeRepoResponse;
-use SocialDept\AtpClient\Data\Responses\Atproto\Repo\GetRecordResponse;
-use SocialDept\AtpClient\Data\Responses\Atproto\Repo\ListRecordsResponse;
-use SocialDept\AtpClient\Enums\Nsid\AtprotoRepo;
-
-class RepoPublicRequestClient extends PublicRequest
-{
-    /**
-     * Get a record
-     *
-     * @see https://docs.bsky.app/docs/api/com-atproto-repo-get-record
-     */
-    public function getRecord(
-        string $repo,
-        string|BackedEnum $collection,
-        string $rkey,
-        ?string $cid = null
-    ): GetRecordResponse {
-        $collection = $collection instanceof BackedEnum ? $collection->value : $collection;
-        $response = $this->atp->client->get(
-            endpoint: AtprotoRepo::GetRecord,
-            params: compact('repo', 'collection', 'rkey', 'cid')
-        );
-
-        return GetRecordResponse::fromArray($response->json());
-    }
-
-    /**
-     * List records in a collection
-     *
-     * @see https://docs.bsky.app/docs/api/com-atproto-repo-list-records
-     */
-    public function listRecords(
-        string $repo,
-        string|BackedEnum $collection,
-        int $limit = 50,
-        ?string $cursor = null,
-        bool $reverse = false
-    ): ListRecordsResponse {
-        $collection = $collection instanceof BackedEnum ? $collection->value : $collection;
-        $response = $this->atp->client->get(
-            endpoint: AtprotoRepo::ListRecords,
-            params: compact('repo', 'collection', 'limit', 'cursor', 'reverse')
-        );
-
-        return ListRecordsResponse::fromArray($response->json());
-    }
-
-    /**
-     * Describe the repository
-     *
-     * @see https://docs.bsky.app/docs/api/com-atproto-repo-describe-repo
-     */
-    public function describeRepo(string $repo): DescribeRepoResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: AtprotoRepo::DescribeRepo,
-            params: compact('repo')
-        );
-
-        return DescribeRepoResponse::fromArray($response->json());
-    }
-}

src/Client/Public/Requests/Bsky/ActorPublicRequestClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public\Requests\Bsky;
-
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-use SocialDept\AtpClient\Enums\Nsid\BskyActor;
-use SocialDept\AtpClient\Data\Responses\Bsky\Actor\GetProfilesResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Actor\GetSuggestionsResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Actor\SearchActorsResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Actor\SearchActorsTypeaheadResponse;
-use SocialDept\AtpSchema\Generated\App\Bsky\Actor\Defs\ProfileViewDetailed;
-
-class ActorPublicRequestClient extends PublicRequest
-{
-    public function getProfile(string $actor): ProfileViewDetailed
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyActor::GetProfile,
-            params: compact('actor')
-        );
-
-        return ProfileViewDetailed::fromArray($response->json());
-    }
-
-    public function getProfiles(array $actors): GetProfilesResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyActor::GetProfiles,
-            params: compact('actors')
-        );
-
-        return GetProfilesResponse::fromArray($response->json());
-    }
-
-    public function getSuggestions(int $limit = 50, ?string $cursor = null): GetSuggestionsResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyActor::GetSuggestions,
-            params: compact('limit', 'cursor')
-        );
-
-        return GetSuggestionsResponse::fromArray($response->json());
-    }
-
-    public function searchActors(string $q, int $limit = 25, ?string $cursor = null): SearchActorsResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyActor::SearchActors,
-            params: compact('q', 'limit', 'cursor')
-        );
-
-        return SearchActorsResponse::fromArray($response->json());
-    }
-
-    public function searchActorsTypeahead(string $q, int $limit = 10): SearchActorsTypeaheadResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyActor::SearchActorsTypeahead,
-            params: compact('q', 'limit')
-        );
-
-        return SearchActorsTypeaheadResponse::fromArray($response->json());
-    }
-}

src/Client/Public/Requests/Bsky/FeedPublicRequestClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public\Requests\Bsky;
-
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-use SocialDept\AtpClient\Enums\Nsid\BskyFeed;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\DescribeFeedGeneratorResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetActorFeedsResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetActorLikesResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetAuthorFeedResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetFeedGeneratorResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetFeedGeneratorsResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetFeedResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetLikesResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetPostsResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetPostThreadResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetQuotesResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetRepostedByResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetSuggestedFeedsResponse;
-use SocialDept\AtpClient\Data\Responses\Bsky\Feed\SearchPostsResponse;
-
-class FeedPublicRequestClient extends PublicRequest
-{
-    public function describeFeedGenerator(): DescribeFeedGeneratorResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::DescribeFeedGenerator
-        );
-
-        return DescribeFeedGeneratorResponse::fromArray($response->json());
-    }
-
-    public function getAuthorFeed(string $actor, int $limit = 50, ?string $cursor = null, ?string $filter = null): GetAuthorFeedResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetAuthorFeed,
-            params: compact('actor', 'limit', 'cursor', 'filter')
-        );
-
-        return GetAuthorFeedResponse::fromArray($response->json());
-    }
-
-    public function getActorFeeds(string $actor, int $limit = 50, ?string $cursor = null): GetActorFeedsResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetActorFeeds,
-            params: compact('actor', 'limit', 'cursor')
-        );
-
-        return GetActorFeedsResponse::fromArray($response->json());
-    }
-
-    public function getActorLikes(string $actor, int $limit = 50, ?string $cursor = null): GetActorLikesResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetActorLikes,
-            params: compact('actor', 'limit', 'cursor')
-        );
-
-        return GetActorLikesResponse::fromArray($response->json());
-    }
-
-    public function getFeed(string $feed, int $limit = 50, ?string $cursor = null): GetFeedResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetFeed,
-            params: compact('feed', 'limit', 'cursor')
-        );
-
-        return GetFeedResponse::fromArray($response->json());
-    }
-
-    public function getFeedGenerator(string $feed): GetFeedGeneratorResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetFeedGenerator,
-            params: compact('feed')
-        );
-
-        return GetFeedGeneratorResponse::fromArray($response->json());
-    }
-
-    public function getFeedGenerators(array $feeds): GetFeedGeneratorsResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetFeedGenerators,
-            params: compact('feeds')
-        );
-
-        return GetFeedGeneratorsResponse::fromArray($response->json());
-    }
-
-    public function getLikes(string $uri, int $limit = 50, ?string $cursor = null, ?string $cid = null): GetLikesResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetLikes,
-            params: compact('uri', 'limit', 'cursor', 'cid')
-        );
-
-        return GetLikesResponse::fromArray($response->json());
-    }
-
-    public function getPostThread(string $uri, int $depth = 6, int $parentHeight = 80): GetPostThreadResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetPostThread,
-            params: compact('uri', 'depth', 'parentHeight')
-        );
-
-        return GetPostThreadResponse::fromArray($response->json());
-    }
-
-    public function getPosts(array $uris): GetPostsResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetPosts,
-            params: compact('uris')
-        );
-
-        return GetPostsResponse::fromArray($response->json());
-    }
-
-    public function getQuotes(string $uri, int $limit = 50, ?string $cursor = null, ?string $cid = null): GetQuotesResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetQuotes,
-            params: compact('uri', 'limit', 'cursor', 'cid')
-        );
-
-        return GetQuotesResponse::fromArray($response->json());
-    }
-
-    public function getRepostedBy(string $uri, int $limit = 50, ?string $cursor = null, ?string $cid = null): GetRepostedByResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetRepostedBy,
-            params: compact('uri', 'limit', 'cursor', 'cid')
-        );
-
-        return GetRepostedByResponse::fromArray($response->json());
-    }
-
-    public function getSuggestedFeeds(int $limit = 50, ?string $cursor = null): GetSuggestedFeedsResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::GetSuggestedFeeds,
-            params: compact('limit', 'cursor')
-        );
-
-        return GetSuggestedFeedsResponse::fromArray($response->json());
-    }
-
-    public function searchPosts(string $q, int $limit = 25, ?string $cursor = null, ?string $sort = null): SearchPostsResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyFeed::SearchPosts,
-            params: compact('q', 'limit', 'cursor', 'sort')
-        );
-
-        return SearchPostsResponse::fromArray($response->json());
-    }
-}

src/Client/Public/Requests/Bsky/GraphPublicRequestClient.php src/Client/Requests/Bsky/GraphRequestClient.php

···
 <?php
 
-namespace SocialDept\AtpClient\Client\Public\Requests\Bsky;
+namespace SocialDept\AtpClient\Client\Requests\Bsky;
 
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-use SocialDept\AtpClient\Enums\Nsid\BskyGraph;
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
+use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Bsky\Graph\GetFollowersResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Graph\GetFollowsResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Graph\GetKnownFollowersResponse;
···
 use SocialDept\AtpClient\Data\Responses\Bsky\Graph\GetRelationshipsResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Graph\GetStarterPacksResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Graph\GetSuggestedFollowsByActorResponse;
+use SocialDept\AtpClient\Enums\Nsid\BskyGraph;
 use SocialDept\AtpSchema\Generated\App\Bsky\Graph\Defs\StarterPackView;
 
-class GraphPublicRequestClient extends PublicRequest
+class GraphRequestClient extends Request
 {
+    /**
+     * Get followers of an actor
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-followers
+     */
+    #[PublicEndpoint]
     public function getFollowers(string $actor, int $limit = 50, ?string $cursor = null): GetFollowersResponse
     {
         $response = $this->atp->client->get(
···
         return GetFollowersResponse::fromArray($response->json());
     }
 
+    /**
+     * Get accounts that an actor follows
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-follows
+     */
+    #[PublicEndpoint]
     public function getFollows(string $actor, int $limit = 50, ?string $cursor = null): GetFollowsResponse
     {
         $response = $this->atp->client->get(
···
         return GetFollowsResponse::fromArray($response->json());
     }
 
+    /**
+     * Get followers of an actor that you also follow
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-known-followers
+     */
+    #[PublicEndpoint]
     public function getKnownFollowers(string $actor, int $limit = 50, ?string $cursor = null): GetKnownFollowersResponse
     {
         $response = $this->atp->client->get(
···
         return GetKnownFollowersResponse::fromArray($response->json());
     }
 
+    /**
+     * Get a list by URI
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-list
+     */
+    #[PublicEndpoint]
     public function getList(string $list, int $limit = 50, ?string $cursor = null): GetListResponse
     {
         $response = $this->atp->client->get(
···
         return GetListResponse::fromArray($response->json());
     }
 
+    /**
+     * Get lists created by an actor
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-lists
+     */
+    #[PublicEndpoint]
     public function getLists(string $actor, int $limit = 50, ?string $cursor = null): GetListsResponse
     {
         $response = $this->atp->client->get(
···
         return GetListsResponse::fromArray($response->json());
     }
 
+    /**
+     * Get relationships between actors
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-relationships
+     */
+    #[PublicEndpoint]
     public function getRelationships(string $actor, array $others = []): GetRelationshipsResponse
     {
         $response = $this->atp->client->get(
···
         return GetRelationshipsResponse::fromArray($response->json());
     }
 
+    /**
+     * Get a starter pack by URI
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-starter-pack
+     */
+    #[PublicEndpoint]
     public function getStarterPack(string $starterPack): StarterPackView
     {
         $response = $this->atp->client->get(
···
         return StarterPackView::fromArray($response->json()['starterPack']);
     }
 
+    /**
+     * Get multiple starter packs
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-starter-packs
+     */
+    #[PublicEndpoint]
     public function getStarterPacks(array $uris): GetStarterPacksResponse
     {
         $response = $this->atp->client->get(
···
         return GetStarterPacksResponse::fromArray($response->json());
     }
 
+    /**
+     * Get suggested follows based on an actor
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-graph-get-suggested-follows-by-actor
+     */
+    #[PublicEndpoint]
     public function getSuggestedFollowsByActor(string $actor): GetSuggestedFollowsByActorResponse
     {
         $response = $this->atp->client->get(

src/Client/Public/Requests/Bsky/LabelerPublicRequestClient.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public\Requests\Bsky;
-
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-use SocialDept\AtpClient\Data\Responses\Bsky\Labeler\GetServicesResponse;
-use SocialDept\AtpClient\Enums\Nsid\BskyLabeler;
-
-class LabelerPublicRequestClient extends PublicRequest
-{
-    public function getServices(array $dids, bool $detailed = false): GetServicesResponse
-    {
-        $response = $this->atp->client->get(
-            endpoint: BskyLabeler::GetServices,
-            params: compact('dids', 'detailed')
-        );
-
-        return GetServicesResponse::fromArray($response->json(), $detailed);
-    }
-}

src/Client/Public/Requests/PublicRequest.php

···
-<?php
-
-namespace SocialDept\AtpClient\Client\Public\Requests;
-
-use SocialDept\AtpClient\Client\Public\AtpPublicClient;
-
-class PublicRequest
-{
-    protected AtpPublicClient $atp;
-
-    public function __construct($parent)
-    {
-        $this->atp = $parent->root();
-    }
-}

src/Client/Records/FollowRecordClient.php

···
 namespace SocialDept\AtpClient\Client\Records;
 
 use DateTimeInterface;
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\StrongRef;
 use SocialDept\AtpClient\Enums\Nsid\BskyGraph;
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.createRecord AND repo:app.bsky.graph.follow?action=create)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.graph.follow?action=create')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.graph.follow?action=create')]
     public function create(
         string $subject,
         ?DateTimeInterface $createdAt = null
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.deleteRecord AND repo:app.bsky.graph.follow?action=delete)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.deleteRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.graph.follow?action=delete')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.deleteRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.graph.follow?action=delete')]
     public function delete(string $rkey): void
     {
         $this->atp->atproto->repo->deleteRecord(
···
      *
      * @requires transition:generic (rpc:com.atproto.repo.getRecord)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
     public function get(string $rkey, ?string $cid = null): array
     {
         $response = $this->atp->atproto->repo->getRecord(

src/Client/Records/LikeRecordClient.php

···
 namespace SocialDept\AtpClient\Client\Records;
 
 use DateTimeInterface;
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\StrongRef;
 use SocialDept\AtpClient\Enums\Nsid\BskyFeed;
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.createRecord AND repo:app.bsky.feed.like?action=create)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.like?action=create')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.like?action=create')]
     public function create(
         StrongRef $subject,
         ?DateTimeInterface $createdAt = null
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.deleteRecord AND repo:app.bsky.feed.like?action=delete)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.deleteRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.like?action=delete')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.deleteRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.like?action=delete')]
     public function delete(string $rkey): void
     {
         $this->atp->atproto->repo->deleteRecord(
···
      *
      * @requires transition:generic (rpc:com.atproto.repo.getRecord)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
     public function get(string $rkey, ?string $cid = null): array
     {
         $response = $this->atp->atproto->repo->getRecord(

src/Client/Records/PostRecordClient.php

···
 namespace SocialDept\AtpClient\Client\Records;
 
 use DateTimeInterface;
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Contracts\Recordable;
 use SocialDept\AtpClient\Data\StrongRef;
 use SocialDept\AtpClient\Enums\Nsid\BskyFeed;
 use SocialDept\AtpClient\Enums\Scope;
 use SocialDept\AtpClient\RichText\TextBuilder;
+use SocialDept\AtpSchema\Generated\App\Bsky\Feed\Defs\PostView;
 
 class PostRecordClient extends Request
 {
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.createRecord AND repo:app.bsky.feed.post?action=create)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
     public function create(
         string|array|Recordable $content,
         ?array $facets = null,
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.putRecord AND repo:app.bsky.feed.post?action=update)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=update')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=update')]
     public function update(string $rkey, array $record): StrongRef
     {
         // Ensure $type is set
···
             record: $record
         );
 
-        return StrongRef::fromResponse($response->json());
+        return StrongRef::fromResponse($response->toArray());
     }
 
     /**
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.deleteRecord AND repo:app.bsky.feed.post?action=delete)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.deleteRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=delete')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.deleteRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=delete')]
     public function delete(string $rkey): void
     {
         $this->atp->atproto->repo->deleteRecord(
···
      *
      * @requires transition:generic (rpc:com.atproto.repo.getRecord)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
-    public function get(string $rkey, ?string $cid = null): array
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
+    public function get(string $rkey, ?string $cid = null): PostView
     {
         $response = $this->atp->atproto->repo->getRecord(
             repo: $this->atp->client->session()->did(),
···
             cid: $cid
         );
 
-        return $response->json('value');
+        return PostView::fromArray($response->value);
     }
 
     /**
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.createRecord AND repo:app.bsky.feed.post?action=create)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
     public function reply(
         StrongRef $parent,
         StrongRef $root,
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.createRecord AND repo:app.bsky.feed.post?action=create)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
     public function quote(
         StrongRef $quotedPost,
         string|array|Recordable $content,
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.createRecord AND repo:app.bsky.feed.post?action=create)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
     public function withImages(
         string|array|Recordable $content,
         array $images,
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.createRecord AND repo:app.bsky.feed.post?action=create)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.createRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.feed.post?action=create')]
     public function withLink(
         string|array|Recordable $content,
         string $uri,

src/Client/Records/ProfileRecordClient.php

···
 
 namespace SocialDept\AtpClient\Client\Records;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\StrongRef;
 use SocialDept\AtpClient\Enums\Nsid\BskyActor;
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.putRecord AND repo:app.bsky.actor.profile?action=update)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
     public function update(array $profile): StrongRef
     {
         // Ensure $type is set
···
      *
      * @requires transition:generic (rpc:com.atproto.repo.getRecord)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
     public function get(): array
     {
         $response = $this->atp->atproto->repo->getRecord(
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.putRecord AND repo:app.bsky.actor.profile?action=update)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
     public function updateDisplayName(string $displayName): StrongRef
     {
         $profile = $this->getOrCreateProfile();
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.putRecord AND repo:app.bsky.actor.profile?action=update)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
     public function updateDescription(string $description): StrongRef
     {
         $profile = $this->getOrCreateProfile();
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.putRecord AND repo:app.bsky.actor.profile?action=update)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
     public function updateAvatar(array $avatarBlob): StrongRef
     {
         $profile = $this->getOrCreateProfile();
···
      *
      * @requires transition:generic OR (rpc:com.atproto.repo.putRecord AND repo:app.bsky.actor.profile?action=update)
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.putRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'repo:app.bsky.actor.profile?action=update')]
     public function updateBanner(array $bannerBlob): StrongRef
     {
         $profile = $this->getOrCreateProfile();

src/Client/Requests/Atproto/IdentityRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Atproto;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Enums\Nsid\AtprotoIdentity;
 use SocialDept\AtpClient\Enums\Scope;
···
     /**
      * Resolve handle to DID
      *
-     * @requires transition:generic (rpc:com.atproto.identity.resolveHandle)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-identity-resolve-handle
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.identity.resolveHandle')]
+    #[PublicEndpoint]
     public function resolveHandle(string $handle): string
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-identity-update-handle
      */
-    #[RequiresScope(Scope::Atproto, granular: 'identity:handle')]
+    #[ScopedEndpoint(Scope::Atproto, granular: 'identity:handle')]
     public function updateHandle(string $handle): void
     {
         $this->atp->client->post(

src/Client/Requests/Atproto/RepoRequestClient.php

···
 use BackedEnum;
 use Illuminate\Http\UploadedFile;
 use InvalidArgumentException;
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Auth\ScopeChecker;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Atproto\Repo\CreateRecordResponse;
···
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-repo-create-record
      */
-    #[RequiresScope(Scope::TransitionGeneric, description: 'Create records in repository')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, description: 'Create records in repository')]
     public function createRecord(
         string $repo,
         string|BackedEnum $collection,
···
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-repo-delete-record
      */
-    #[RequiresScope(Scope::TransitionGeneric, description: 'Delete records from repository')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, description: 'Delete records from repository')]
     public function deleteRecord(
         string $repo,
         string|BackedEnum $collection,
···
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-repo-put-record
      */
-    #[RequiresScope(Scope::TransitionGeneric, description: 'Update records in repository')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, description: 'Update records in repository')]
     public function putRecord(
         string $repo,
         string|BackedEnum $collection,
···
     /**
      * Get a record
      *
-     * @requires transition:generic (rpc:com.atproto.repo.getRecord)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-repo-get-record
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.getRecord')]
+    #[PublicEndpoint]
     public function getRecord(
         string $repo,
         string|BackedEnum $collection,
···
     /**
      * List records in a collection
      *
-     * @requires transition:generic (rpc:com.atproto.repo.listRecords)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-repo-list-records
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.listRecords')]
+    #[PublicEndpoint]
     public function listRecords(
         string $repo,
         string|BackedEnum $collection,
···
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-repo-upload-blob
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'blob:*/*')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'blob:*/*')]
     public function uploadBlob(UploadedFile|SplFileInfo|string $file, ?string $mimeType = null): BlobReference
     {
         // Handle different input types
···
     /**
      * Describe the repository
      *
-     * @requires transition:generic (rpc:com.atproto.repo.describeRepo)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-repo-describe-repo
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:com.atproto.repo.describeRepo')]
+    #[PublicEndpoint]
     public function describeRepo(string $repo): DescribeRepoResponse
     {
         $response = $this->atp->client->get(

src/Client/Requests/Atproto/ServerRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Atproto;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Atproto\Server\DescribeServerResponse;
 use SocialDept\AtpClient\Data\Responses\Atproto\Server\GetSessionResponse;
···
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-server-get-session
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.server.getSession')]
+    #[ScopedEndpoint(Scope::Atproto, granular: 'rpc:com.atproto.server.getSession')]
     public function getSession(): GetSessionResponse
     {
         $response = $this->atp->client->get(
···
     /**
      * Describe server
      *
-     * @requires atproto (rpc:com.atproto.server.describeServer)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-server-describe-server
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.server.describeServer')]
+    #[PublicEndpoint]
     public function describeServer(): DescribeServerResponse
     {
         $response = $this->atp->client->get(

src/Client/Requests/Atproto/SyncRequestClient.php

···
 namespace SocialDept\AtpClient\Client\Requests\Atproto;
 
 use BackedEnum;
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Atproto\Sync\GetRepoStatusResponse;
 use SocialDept\AtpClient\Data\Responses\Atproto\Sync\ListBlobsResponse;
+use SocialDept\AtpClient\Data\Responses\Atproto\Sync\ListReposByCollectionResponse;
 use SocialDept\AtpClient\Data\Responses\Atproto\Sync\ListReposResponse;
 use SocialDept\AtpClient\Enums\Nsid\AtprotoSync;
-use SocialDept\AtpClient\Enums\Scope;
 use SocialDept\AtpClient\Http\Response;
 use SocialDept\AtpSchema\Generated\Com\Atproto\Repo\Defs\CommitMeta;
 
···
     /**
      * Get a blob associated with a given account
      *
-     * @requires atproto (rpc:com.atproto.sync.getBlob)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-get-blob
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.getBlob')]
+    #[PublicEndpoint]
     public function getBlob(string $did, string $cid): Response
     {
         return $this->atp->client->get(
···
     /**
      * Download a repository export as CAR file
      *
-     * @requires atproto (rpc:com.atproto.sync.getRepo)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-get-repo
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.getRepo')]
+    #[PublicEndpoint]
     public function getRepo(string $did, ?string $since = null): Response
     {
         return $this->atp->client->get(
···
     /**
      * Enumerates all the DID, rev, and commit CID for all repos hosted by this service
      *
-     * @requires atproto (rpc:com.atproto.sync.listRepos)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-list-repos
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.listRepos')]
+    #[PublicEndpoint]
     public function listRepos(int $limit = 500, ?string $cursor = null): ListReposResponse
     {
         $response = $this->atp->client->get(
···
     }
 
     /**
+     * Enumerates all the DIDs with records in a specific collection
+     *
+     * @see https://docs.bsky.app/docs/api/com-atproto-sync-list-repos-by-collection
+     */
+    #[PublicEndpoint]
+    public function listReposByCollection(
+        string|BackedEnum $collection,
+        int $limit = 500,
+        ?string $cursor = null
+    ): ListReposByCollectionResponse {
+        $collection = $collection instanceof BackedEnum ? $collection->value : $collection;
+
+        $response = $this->atp->client->get(
+            endpoint: AtprotoSync::ListReposByCollection,
+            params: compact('collection', 'limit', 'cursor')
+        );
+
+        return ListReposByCollectionResponse::fromArray($response->json());
+    }
+
+    /**
      * Get the current commit CID & revision of the specified repo
-     *
-     * @requires atproto (rpc:com.atproto.sync.getLatestCommit)
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-get-latest-commit
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.getLatestCommit')]
+    #[PublicEndpoint]
     public function getLatestCommit(string $did): CommitMeta
     {
         $response = $this->atp->client->get(
···
 
     /**
      * Get data blocks needed to prove the existence or non-existence of record
-     *
-     * @requires atproto (rpc:com.atproto.sync.getRecord)
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-get-record
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.getRecord')]
+    #[PublicEndpoint]
     public function getRecord(string $did, string|BackedEnum $collection, string $rkey): Response
     {
         $collection = $collection instanceof BackedEnum ? $collection->value : $collection;
···
 
     /**
      * List blob CIDs for an account, since some repo revision
-     *
-     * @requires atproto (rpc:com.atproto.sync.listBlobs)
      *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-list-blobs
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.listBlobs')]
+    #[PublicEndpoint]
     public function listBlobs(
         string $did,
         ?string $since = null,
···
     /**
      * Get data blocks from a given repo, by CID
      *
-     * @requires atproto (rpc:com.atproto.sync.getBlocks)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-get-blocks
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.getBlocks')]
+    #[PublicEndpoint]
     public function getBlocks(string $did, array $cids): Response
     {
         return $this->atp->client->get(
···
     /**
      * Get the hosting status for a repository, on this server
      *
-     * @requires atproto (rpc:com.atproto.sync.getRepoStatus)
-     *
      * @see https://docs.bsky.app/docs/api/com-atproto-sync-get-repo-status
      */
-    #[RequiresScope(Scope::Atproto, granular: 'rpc:com.atproto.sync.getRepoStatus')]
+    #[PublicEndpoint]
     public function getRepoStatus(string $did): GetRepoStatusResponse
     {
         $response = $this->atp->client->get(

src/Client/Requests/Bsky/ActorRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Bsky;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
+use SocialDept\AtpClient\Data\Responses\Bsky\Actor\GetProfilesResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Actor\GetSuggestionsResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Actor\SearchActorsResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Actor\SearchActorsTypeaheadResponse;
 use SocialDept\AtpClient\Enums\Nsid\BskyActor;
-use SocialDept\AtpClient\Enums\Scope;
 use SocialDept\AtpSchema\Generated\App\Bsky\Actor\Defs\ProfileViewDetailed;
 
 class ActorRequestClient extends Request
···
     /**
      * Get actor profile
      *
-     * @requires transition:generic (rpc:app.bsky.actor.getProfile)
-     *
      * @see https://docs.bsky.app/docs/api/app-bsky-actor-get-profile
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:app.bsky.actor.getProfile')]
+    #[PublicEndpoint]
     public function getProfile(string $actor): ProfileViewDetailed
     {
         $response = $this->atp->client->get(
···
         );
 
         return ProfileViewDetailed::fromArray($response->json());
+    }
+
+    /**
+     * Get multiple actor profiles
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-actor-get-profiles
+     */
+    #[PublicEndpoint]
+    public function getProfiles(array $actors): GetProfilesResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::GetProfiles,
+            params: compact('actors')
+        );
+
+        return GetProfilesResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get suggestions for actors to follow
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-actor-get-suggestions
+     */
+    #[PublicEndpoint]
+    public function getSuggestions(int $limit = 50, ?string $cursor = null): GetSuggestionsResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::GetSuggestions,
+            params: compact('limit', 'cursor')
+        );
+
+        return GetSuggestionsResponse::fromArray($response->json());
+    }
+
+    /**
+     * Search for actors
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-actor-search-actors
+     */
+    #[PublicEndpoint]
+    public function searchActors(string $q, int $limit = 25, ?string $cursor = null): SearchActorsResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::SearchActors,
+            params: compact('q', 'limit', 'cursor')
+        );
+
+        return SearchActorsResponse::fromArray($response->json());
+    }
+
+    /**
+     * Search for actors matching a prefix (typeahead/autocomplete)
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-actor-search-actors-typeahead
+     */
+    #[PublicEndpoint]
+    public function searchActorsTypeahead(string $q, int $limit = 10): SearchActorsTypeaheadResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::SearchActorsTypeahead,
+            params: compact('q', 'limit')
+        );
+
+        return SearchActorsTypeaheadResponse::fromArray($response->json());
     }
 }

src/Client/Requests/Bsky/FeedRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Bsky;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\DescribeFeedGeneratorResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetActorFeedsResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetActorLikesResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetAuthorFeedResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetFeedGeneratorResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetFeedGeneratorsResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetFeedResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetLikesResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetPostsResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetPostThreadResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetQuotesResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetRepostedByResponse;
+use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetSuggestedFeedsResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Feed\GetTimelineResponse;
 use SocialDept\AtpClient\Data\Responses\Bsky\Feed\SearchPostsResponse;
 use SocialDept\AtpClient\Enums\Nsid\BskyFeed;
···
 class FeedRequestClient extends Request
 {
     /**
-     * Get timeline feed
+     * Describe feed generator
      *
-     * @requires transition:generic (rpc:app.bsky.feed.getTimeline)
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-describe-feed-generator
+     */
+    #[PublicEndpoint]
+    public function describeFeedGenerator(): DescribeFeedGeneratorResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::DescribeFeedGenerator
+        );
+
+        return DescribeFeedGeneratorResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get timeline feed (requires authentication)
      *
      * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-timeline
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getTimeline')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getTimeline')]
     public function getTimeline(int $limit = 50, ?string $cursor = null): GetTimelineResponse
     {
         $response = $this->atp->client->get(
···
     /**
      * Get author feed
      *
-     * @requires transition:generic (rpc:app.bsky.feed.getAuthorFeed)
-     *
      * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-author-feed
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getAuthorFeed')]
+    #[PublicEndpoint]
     public function getAuthorFeed(
         string $actor,
         int $limit = 50,
-        ?string $cursor = null
+        ?string $cursor = null,
+        ?string $filter = null
     ): GetAuthorFeedResponse {
         $response = $this->atp->client->get(
             endpoint: BskyFeed::GetAuthorFeed,
+            params: compact('actor', 'limit', 'cursor', 'filter')
+        );
+
+        return GetAuthorFeedResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get feeds created by an actor
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-actor-feeds
+     */
+    #[PublicEndpoint]
+    public function getActorFeeds(string $actor, int $limit = 50, ?string $cursor = null): GetActorFeedsResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetActorFeeds,
             params: compact('actor', 'limit', 'cursor')
         );
 
-        return GetAuthorFeedResponse::fromArray($response->json());
+        return GetActorFeedsResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get posts liked by an actor
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-actor-likes
+     */
+    #[PublicEndpoint]
+    public function getActorLikes(string $actor, int $limit = 50, ?string $cursor = null): GetActorLikesResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetActorLikes,
+            params: compact('actor', 'limit', 'cursor')
+        );
+
+        return GetActorLikesResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get a feed
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-feed
+     */
+    #[PublicEndpoint]
+    public function getFeed(string $feed, int $limit = 50, ?string $cursor = null): GetFeedResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetFeed,
+            params: compact('feed', 'limit', 'cursor')
+        );
+
+        return GetFeedResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get a feed generator
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-feed-generator
+     */
+    #[PublicEndpoint]
+    public function getFeedGenerator(string $feed): GetFeedGeneratorResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetFeedGenerator,
+            params: compact('feed')
+        );
+
+        return GetFeedGeneratorResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get multiple feed generators
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-feed-generators
+     */
+    #[PublicEndpoint]
+    public function getFeedGenerators(array $feeds): GetFeedGeneratorsResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetFeedGenerators,
+            params: compact('feeds')
+        );
+
+        return GetFeedGeneratorsResponse::fromArray($response->json());
     }
 
     /**
      * Get post thread
      *
-     * @requires transition:generic (rpc:app.bsky.feed.getPostThread)
-     *
      * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-post-thread
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getPostThread')]
-    public function getPostThread(string $uri, int $depth = 6): GetPostThreadResponse
+    #[PublicEndpoint]
+    public function getPostThread(string $uri, int $depth = 6, int $parentHeight = 80): GetPostThreadResponse
     {
         $response = $this->atp->client->get(
             endpoint: BskyFeed::GetPostThread,
-            params: compact('uri', 'depth')
+            params: compact('uri', 'depth', 'parentHeight')
         );
 
         return GetPostThreadResponse::fromArray($response->json());
     }
 
     /**
-     * Search posts
+     * Get multiple posts by URI
      *
-     * @requires transition:generic (rpc:app.bsky.feed.searchPosts)
-     *
-     * @see https://docs.bsky.app/docs/api/app-bsky-feed-search-posts
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-posts
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.searchPosts')]
-    public function searchPosts(
-        string $q,
-        int $limit = 25,
-        ?string $cursor = null
-    ): SearchPostsResponse {
+    #[PublicEndpoint]
+    public function getPosts(array $uris): GetPostsResponse
+    {
         $response = $this->atp->client->get(
-            endpoint: BskyFeed::SearchPosts,
-            params: compact('q', 'limit', 'cursor')
+            endpoint: BskyFeed::GetPosts,
+            params: compact('uris')
         );
 
-        return SearchPostsResponse::fromArray($response->json());
+        return GetPostsResponse::fromArray($response->json());
     }
 
     /**
      * Get likes for a post
-     *
-     * @requires transition:generic (rpc:app.bsky.feed.getLikes)
      *
      * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-likes
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getLikes')]
+    #[PublicEndpoint]
     public function getLikes(
         string $uri,
         int $limit = 50,
-        ?string $cursor = null
+        ?string $cursor = null,
+        ?string $cid = null
     ): GetLikesResponse {
         $response = $this->atp->client->get(
             endpoint: BskyFeed::GetLikes,
-            params: compact('uri', 'limit', 'cursor')
+            params: compact('uri', 'limit', 'cursor', 'cid')
         );
 
         return GetLikesResponse::fromArray($response->json());
     }
 
     /**
+     * Get quotes of a post
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-quotes
+     */
+    #[PublicEndpoint]
+    public function getQuotes(
+        string $uri,
+        int $limit = 50,
+        ?string $cursor = null,
+        ?string $cid = null
+    ): GetQuotesResponse {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetQuotes,
+            params: compact('uri', 'limit', 'cursor', 'cid')
+        );
+
+        return GetQuotesResponse::fromArray($response->json());
+    }
+
+    /**
      * Get reposts for a post
      *
-     * @requires transition:generic (rpc:app.bsky.feed.getRepostedBy)
-     *
      * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-reposted-by
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:app.bsky.feed.getRepostedBy')]
+    #[PublicEndpoint]
     public function getRepostedBy(
         string $uri,
         int $limit = 50,
-        ?string $cursor = null
+        ?string $cursor = null,
+        ?string $cid = null
     ): GetRepostedByResponse {
         $response = $this->atp->client->get(
             endpoint: BskyFeed::GetRepostedBy,
-            params: compact('uri', 'limit', 'cursor')
+            params: compact('uri', 'limit', 'cursor', 'cid')
         );
 
         return GetRepostedByResponse::fromArray($response->json());
+    }
+
+    /**
+     * Get suggested feeds
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-get-suggested-feeds
+     */
+    #[PublicEndpoint]
+    public function getSuggestedFeeds(int $limit = 50, ?string $cursor = null): GetSuggestedFeedsResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetSuggestedFeeds,
+            params: compact('limit', 'cursor')
+        );
+
+        return GetSuggestedFeedsResponse::fromArray($response->json());
+    }
+
+    /**
+     * Search posts
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-feed-search-posts
+     */
+    #[PublicEndpoint]
+    public function searchPosts(
+        string $q,
+        int $limit = 25,
+        ?string $cursor = null,
+        ?string $sort = null
+    ): SearchPostsResponse {
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::SearchPosts,
+            params: compact('q', 'limit', 'cursor', 'sort')
+        );
+
+        return SearchPostsResponse::fromArray($response->json());
     }
 }

src/Client/Requests/Bsky/LabelerRequestClient.php

···
+<?php
+
+namespace SocialDept\AtpClient\Client\Requests\Bsky;
+
+use SocialDept\AtpClient\Attributes\PublicEndpoint;
+use SocialDept\AtpClient\Client\Requests\Request;
+use SocialDept\AtpClient\Data\Responses\Bsky\Labeler\GetServicesResponse;
+use SocialDept\AtpClient\Enums\Nsid\BskyLabeler;
+
+class LabelerRequestClient extends Request
+{
+    /**
+     * Get labeler services
+     *
+     * @see https://docs.bsky.app/docs/api/app-bsky-labeler-get-services
+     */
+    #[PublicEndpoint]
+    public function getServices(array $dids, bool $detailed = false): GetServicesResponse
+    {
+        $response = $this->atp->client->get(
+            endpoint: BskyLabeler::GetServices,
+            params: compact('dids', 'detailed')
+        );
+
+        return GetServicesResponse::fromArray($response->json(), $detailed);
+    }
+}

src/Client/Requests/Chat/ActorRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Chat;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Enums\Nsid\ChatActor;
 use SocialDept\AtpClient\Enums\Scope;
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-actor-export-account-data
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.actor.getActorMetadata')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.actor.getActorMetadata')]
     public function getActorMetadata(): Response
     {
         return $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-actor-export-account-data
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.actor.exportAccountData')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.actor.exportAccountData')]
     public function exportAccountData(): Response
     {
         return $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-actor-delete-account
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.actor.deleteAccount')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.actor.deleteAccount')]
     public function deleteAccount(): void
     {
         $this->atp->client->post(

src/Client/Requests/Chat/ConvoRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Chat;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Chat\Convo\GetLogResponse;
 use SocialDept\AtpClient\Data\Responses\Chat\Convo\GetMessagesResponse;
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-get-convo
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getConvo')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getConvo')]
     public function getConvo(string $convoId): ConvoView
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-get-convo-for-members
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getConvoForMembers')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getConvoForMembers')]
     public function getConvoForMembers(array $members): ConvoView
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-list-convos
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.listConvos')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.listConvos')]
     public function listConvos(int $limit = 50, ?string $cursor = null): ListConvosResponse
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-get-messages
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getMessages')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getMessages')]
     public function getMessages(
         string $convoId,
         int $limit = 50,
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-send-message
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.sendMessage')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.sendMessage')]
     public function sendMessage(string $convoId, array $message): MessageView
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-send-message-batch
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.sendMessageBatch')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.sendMessageBatch')]
     public function sendMessageBatch(array $items): SendMessageBatchResponse
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-delete-message-for-self
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.deleteMessageForSelf')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.deleteMessageForSelf')]
     public function deleteMessageForSelf(string $convoId, string $messageId): DeletedMessageView
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-update-read
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.updateRead')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.updateRead')]
     public function updateRead(string $convoId, ?string $messageId = null): ConvoView
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-mute-convo
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.muteConvo')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.muteConvo')]
     public function muteConvo(string $convoId): ConvoView
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-unmute-convo
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.unmuteConvo')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.unmuteConvo')]
     public function unmuteConvo(string $convoId): ConvoView
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-leave-convo
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.leaveConvo')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.leaveConvo')]
     public function leaveConvo(string $convoId): LeaveConvoResponse
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/chat-bsky-convo-get-log
      */
-    #[RequiresScope(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getLog')]
+    #[ScopedEndpoint(Scope::TransitionChat, granular: 'rpc:chat.bsky.convo.getLog')]
     public function getLog(?string $cursor = null): GetLogResponse
     {
         $response = $this->atp->client->get(

src/Client/Requests/Ozone/ModerationRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Ozone;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Ozone\Moderation\QueryEventsResponse;
 use SocialDept\AtpClient\Data\Responses\Ozone\Moderation\QueryStatusesResponse;
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-get-event
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getEvent')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getEvent')]
     public function getModerationEvent(int $id): ModEventViewDetail
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-query-events
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getEvents')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getEvents')]
     public function getModerationEvents(
         ?string $subject = null,
         ?array $types = null,
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-get-record
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getRecord')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getRecord')]
     public function getRecord(string $uri, ?string $cid = null): RecordViewDetail
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-get-repo
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getRepo')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.getRepo')]
     public function getRepo(string $did): RepoViewDetail
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-query-events
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.queryEvents')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.queryEvents')]
     public function queryEvents(
         ?array $types = null,
         ?string $createdBy = null,
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-query-statuses
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.queryStatuses')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.queryStatuses')]
     public function queryStatuses(
         ?string $subject = null,
         ?array $tags = null,
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-search-repos
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.searchRepos')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.searchRepos')]
     public function searchRepos(
         ?string $term = null,
         ?string $invitedBy = null,
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-moderation-emit-event
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.emitEvent')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.moderation.emitEvent')]
     public function emitEvent(
         array $event,
         string $subject,

src/Client/Requests/Ozone/ServerRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Ozone;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Ozone\Server\GetConfigResponse;
 use SocialDept\AtpClient\Enums\Nsid\OzoneServer;
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-server-get-config
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.server.getBlob')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.server.getBlob')]
     public function getBlob(string $did, string $cid): Response
     {
         return $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-server-get-config
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.server.getConfig')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.server.getConfig')]
     public function getConfig(): GetConfigResponse
     {
         $response = $this->atp->client->get(

src/Client/Requests/Ozone/TeamRequestClient.php

···
 
 namespace SocialDept\AtpClient\Client\Requests\Ozone;
 
-use SocialDept\AtpClient\Attributes\RequiresScope;
+use SocialDept\AtpClient\Attributes\ScopedEndpoint;
 use SocialDept\AtpClient\Client\Requests\Request;
 use SocialDept\AtpClient\Data\Responses\Ozone\Team\ListMembersResponse;
 use SocialDept\AtpClient\Enums\Nsid\OzoneTeam;
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-team-list-members
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.getMember')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.getMember')]
     public function getTeamMember(string $did): array
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-team-list-members
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.listMembers')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.listMembers')]
     public function listTeamMembers(int $limit = 50, ?string $cursor = null): ListMembersResponse
     {
         $response = $this->atp->client->get(
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-team-add-member
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.addMember')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.addMember')]
     public function addTeamMember(string $did, string $role): array
     {
         $response = $this->atp->client->post(
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-team-update-member
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.updateMember')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.updateMember')]
     public function updateTeamMember(
         string $did,
         ?bool $disabled = null,
···
      *
      * @see https://docs.bsky.app/docs/api/tools-ozone-team-delete-member
      */
-    #[RequiresScope(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.deleteMember')]
+    #[ScopedEndpoint(Scope::TransitionGeneric, granular: 'rpc:tools.ozone.team.deleteMember')]
     public function deleteTeamMember(string $did): void
     {
         $this->atp->client->post(

src/Console/MakeAtpClientCommand.php

···
 {
     protected $signature = 'make:atp-client
                             {name : The name of the client class}
-                            {--public : Generate a public client extension instead of authenticated}
                             {--force : Overwrite existing file}';
 
     protected $description = 'Create a new ATP domain client extension';
···
     public function handle(): int
     {
         $name = $this->argument('name');
-        $isPublic = $this->option('public');
 
         if (! Str::endsWith($name, 'Client')) {
             $name .= 'Client';
         }
 
-        $path = $this->getPath($name, $isPublic);
+        $path = $this->getPath($name);
 
         if ($this->files->exists($path) && ! $this->option('force')) {
             $this->components->error("Client [{$name}] already exists!");
···
 
         $this->makeDirectory($path);
 
-        $stub = $isPublic ? $this->getPublicStub() : $this->getStub();
-        $content = $this->populateStub($stub, $name, $isPublic);
+        $content = $this->populateStub($this->getStub(), $name);
 
         $this->files->put($path, $content);
 
         $this->components->info("Client [{$path}] created successfully.");
 
-        $this->outputRegistrationHint($name, $isPublic);
+        $this->outputRegistrationHint($name);
 
         return self::SUCCESS;
     }
 
-    protected function getPath(string $name, bool $isPublic = false): string
+    protected function getPath(string $name): string
     {
-        $basePath = $isPublic
-            ? config('client.generators.client_public_path', 'app/Services/Clients/Public')
-            : config('client.generators.client_path', 'app/Services/Clients');
+        $basePath = config('client.generators.client_path', 'app/Services/Clients');
 
         return base_path($basePath.'/'.$name.'.php');
     }
···
         }
     }
 
-    protected function getNamespace(bool $isPublic = false): string
+    protected function getNamespace(): string
     {
-        $basePath = $isPublic
-            ? config('client.generators.client_public_path', 'app/Services/Clients/Public')
-            : config('client.generators.client_path', 'app/Services/Clients');
+        $basePath = config('client.generators.client_path', 'app/Services/Clients');
 
         return Str::of($basePath)
             ->replace('/', '\\')
···
             ->toString();
     }
 
-    protected function populateStub(string $stub, string $name, bool $isPublic = false): string
+    protected function populateStub(string $stub, string $name): string
     {
         return str_replace(
             ['{{ namespace }}', '{{ class }}'],
-            [$this->getNamespace($isPublic), $name],
+            [$this->getNamespace(), $name],
             $stub
         );
     }
 
-    protected function outputRegistrationHint(string $name, bool $isPublic): void
+    protected function outputRegistrationHint(string $name): void
     {
         $this->newLine();
         $this->components->info('Register the extension in your AppServiceProvider:');
         $this->newLine();
 
-        $namespace = $this->getNamespace($isPublic);
+        $namespace = $this->getNamespace();
         $extensionName = Str::of($name)->before('Client')->camel()->toString();
-        $clientClass = $isPublic ? 'AtpPublicClient' : 'AtpClient';
 
         $this->line("use {$namespace}\\{$name};");
-        $this->line("use SocialDept\\AtpClient\\".($isPublic ? 'Client\\Public\\' : '').$clientClass.';');
+        $this->line("use SocialDept\\AtpClient\\AtpClient;");
         $this->newLine();
         $this->line("// In boot() method:");
-        $this->line("{$clientClass}::extend('{$extensionName}', fn({$clientClass} \$atp) => new {$name}(\$atp));");
+        $this->line("AtpClient::extend('{$extensionName}', fn(AtpClient \$atp) => new {$name}(\$atp));");
     }
 
     protected function getStub(): string
···
     protected AtpClient $atp;
 
     public function __construct(AtpClient $parent)
-    {
-        $this->atp = $parent;
-    }
-
-    //
-}
-STUB;
-    }
-
-    protected function getPublicStub(): string
-    {
-        return <<<'STUB'
-<?php
-
-namespace {{ namespace }};
-
-use SocialDept\AtpClient\Client\Public\AtpPublicClient;
-
-class {{ class }}
-{
-    protected AtpPublicClient $atp;
-
-    public function __construct(AtpPublicClient $parent)
     {
         $this->atp = $parent;
     }

src/Console/MakeAtpRequestCommand.php

···
     protected $signature = 'make:atp-request
                             {name : The name of the request client class}
                             {--domain=bsky : The domain to extend (bsky, atproto, chat, ozone)}
-                            {--public : Generate a public request client instead of authenticated}
                             {--force : Overwrite existing file}';
 
     protected $description = 'Create a new ATP request client extension for an existing domain';
···
     {
         $name = $this->argument('name');
         $domain = $this->option('domain');
-        $isPublic = $this->option('public');
 
         if (! in_array($domain, $this->validDomains)) {
             $this->components->error("Invalid domain [{$domain}]. Valid domains: ".implode(', ', $this->validDomains));
···
             $name .= 'Client';
         }
 
-        $path = $this->getPath($name, $isPublic);
+        $path = $this->getPath($name);
 
         if ($this->files->exists($path) && ! $this->option('force')) {
             $this->components->error("Request client [{$name}] already exists!");
···
 
         $this->makeDirectory($path);
 
-        $stub = $isPublic ? $this->getPublicStub() : $this->getStub();
-        $content = $this->populateStub($stub, $name, $isPublic);
+        $content = $this->populateStub($this->getStub(), $name);
 
         $this->files->put($path, $content);
 
         $this->components->info("Request client [{$path}] created successfully.");
 
-        $this->outputRegistrationHint($name, $domain, $isPublic);
+        $this->outputRegistrationHint($name, $domain);
 
         return self::SUCCESS;
     }
 
-    protected function getPath(string $name, bool $isPublic = false): string
+    protected function getPath(string $name): string
     {
-        $basePath = $isPublic
-            ? config('client.generators.request_public_path', 'app/Services/Clients/Public/Requests')
-            : config('client.generators.request_path', 'app/Services/Clients/Requests');
+        $basePath = config('client.generators.request_path', 'app/Services/Clients/Requests');
 
         return base_path($basePath.'/'.$name.'.php');
     }
···
         }
     }
 
-    protected function getNamespace(bool $isPublic = false): string
+    protected function getNamespace(): string
     {
-        $basePath = $isPublic
-            ? config('client.generators.request_public_path', 'app/Services/Clients/Public/Requests')
-            : config('client.generators.request_path', 'app/Services/Clients/Requests');
+        $basePath = config('client.generators.request_path', 'app/Services/Clients/Requests');
 
         return Str::of($basePath)
             ->replace('/', '\\')
···
             ->toString();
     }
 
-    protected function populateStub(string $stub, string $name, bool $isPublic = false): string
+    protected function populateStub(string $stub, string $name): string
     {
         return str_replace(
             ['{{ namespace }}', '{{ class }}'],
-            [$this->getNamespace($isPublic), $name],
+            [$this->getNamespace(), $name],
             $stub
         );
     }
 
-    protected function outputRegistrationHint(string $name, string $domain, bool $isPublic): void
+    protected function outputRegistrationHint(string $name, string $domain): void
     {
         $this->newLine();
         $this->components->info('Register the extension in your AppServiceProvider:');
         $this->newLine();
 
-        $namespace = $this->getNamespace($isPublic);
+        $namespace = $this->getNamespace();
         $extensionName = Str::of($name)->before('Client')->camel()->toString();
-        $clientClass = $isPublic ? 'AtpPublicClient' : 'AtpClient';
 
         $this->line("use {$namespace}\\{$name};");
-        $this->line("use SocialDept\\AtpClient\\".($isPublic ? 'Client\\Public\\' : '').$clientClass.';');
+        $this->line("use SocialDept\\AtpClient\\AtpClient;");
         $this->newLine();
         $this->line("// In boot() method:");
-        $this->line("{$clientClass}::extendDomain('{$domain}', '{$extensionName}', fn(\$domain) => new {$name}(\$domain));");
+        $this->line("AtpClient::extendDomain('{$domain}', '{$extensionName}', fn(\$domain) => new {$name}(\$domain));");
     }
 
     protected function getStub(): string
···
 use SocialDept\AtpClient\Client\Requests\Request;
 
 class {{ class }} extends Request
-{
-    //
-}
-STUB;
-    }
-
-    protected function getPublicStub(): string
-    {
-        return <<<'STUB'
-<?php
-
-namespace {{ namespace }};
-
-use SocialDept\AtpClient\Client\Public\Requests\PublicRequest;
-
-class {{ class }} extends PublicRequest
 {
     //
 }

src/Data/Responses/Atproto/Sync/ListReposByCollectionResponse.php

···
+<?php
+
+namespace SocialDept\AtpClient\Data\Responses\Atproto\Sync;
+
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Collection;
+
+/**
+ * @implements Arrayable<string, mixed>
+ */
+class ListReposByCollectionResponse implements Arrayable
+{
+    /**
+     * @param  Collection<int, array{did: string, rev: string}>  $repos
+     */
+    public function __construct(
+        public readonly Collection $repos,
+        public readonly ?string $cursor = null,
+    ) {}
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            repos: collect($data['repos'] ?? []),
+            cursor: $data['cursor'] ?? null,
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'repos' => $this->repos->all(),
+            'cursor' => $this->cursor,
+        ];
+    }
+}

src/Enums/Nsid/AtprotoSync.php

···
     case GetBlob = 'com.atproto.sync.getBlob';
     case GetRepo = 'com.atproto.sync.getRepo';
     case ListRepos = 'com.atproto.sync.listRepos';
+    case ListReposByCollection = 'com.atproto.sync.listReposByCollection';
     case GetLatestCommit = 'com.atproto.sync.getLatestCommit';
     case GetRecord = 'com.atproto.sync.getRecord';
     case ListBlobs = 'com.atproto.sync.listBlobs';

src/Facades/Atp.php

···
 namespace SocialDept\AtpClient\Facades;
 
 use Illuminate\Support\Facades\Facade;
+use SocialDept\AtpClient\AtpClient;
 use SocialDept\AtpClient\Auth\OAuthEngine;
-use SocialDept\AtpClient\Client\AtpClient;
-use SocialDept\AtpClient\Client\Public\AtpPublicClient;
 use SocialDept\AtpClient\Contracts\CredentialProvider;
 
 /**
  * @method static AtpClient as(string $actor)
  * @method static AtpClient login(string $actor, string $password)
  * @method static OAuthEngine oauth()
- * @method static AtpPublicClient public(?string $service = null)
+ * @method static AtpClient public(?string $service = null)
  * @method static void setDefaultProvider(CredentialProvider $provider)
  *
  * @see \SocialDept\AtpClient\AtpClientServiceProvider

src/Http/HasHttp.php

···
 
 trait HasHttp
 {
-    protected SessionManager $sessions;
+    protected ?SessionManager $sessions = null;
 
-    protected string $did;
+    protected ?string $did = null;
 
-    protected DPoPClient $dpopClient;
+    protected ?DPoPClient $dpopClient = null;
 
     protected ?ScopeChecker $scopeChecker = null;