Rename package from `Beacon` to `Resovler`

README.md

···
-[![Beacon Header](./header.png)](https://github.com/socialdept/atp-signals)
+[![Resolver Header](./header.png)](https://github.com/socialdept/atp-signals)
 
 <h3 align="center">
     Resolve AT Protocol identities in your Laravel application.
···
 
 <p align="center">
     <br>
-    <a href="https://packagist.org/packages/socialdept/atp-beacon" title="Latest Version on Packagist"><img src="https://img.shields.io/packagist/v/socialdept/atp-beacon.svg?style=flat-square"></a>
-    <a href="https://packagist.org/packages/socialdept/atp-beacon" title="Total Downloads"><img src="https://img.shields.io/packagist/dt/socialdept/atp-beacon.svg?style=flat-square"></a>
-    <a href="https://github.com/socialdept/atp-beacon/actions/workflows/tests.yml" title="GitHub Tests Action Status"><img src="https://img.shields.io/github/actions/workflow/status/socialdept/atp-beacon/tests.yml?branch=main&label=tests&style=flat-square"></a>
-    <a href="LICENSE" title="Software License"><img src="https://img.shields.io/github/license/socialdept/atp-beacon?style=flat-square"></a>
+    <a href="https://packagist.org/packages/socialdept/atp-resolver" title="Latest Version on Packagist"><img src="https://img.shields.io/packagist/v/socialdept/atp-resolver.svg?style=flat-square"></a>
+    <a href="https://packagist.org/packages/socialdept/atp-resolver" title="Total Downloads"><img src="https://img.shields.io/packagist/dt/socialdept/atp-resolver.svg?style=flat-square"></a>
+    <a href="https://github.com/socialdept/atp-resolver/actions/workflows/tests.yml" title="GitHub Tests Action Status"><img src="https://img.shields.io/github/actions/workflow/status/socialdept/atp-resolver/tests.yml?branch=main&label=tests&style=flat-square"></a>
+    <a href="LICENSE" title="Software License"><img src="https://img.shields.io/github/license/socialdept/atp-resolver?style=flat-square"></a>
 </p>
 
 ---
 
-## What is Beacon?
+## What is Resolver?
 
-**Beacon** is a Laravel package that resolves AT Protocol identities. Convert DIDs to handles, find PDS endpoints, and resolve DID documents with automatic caching and fallback support for both `did:plc` and `did:web` methods.
+**Resolver** is a Laravel package that resolves AT Protocol identities. Convert DIDs to handles, find PDS endpoints, and resolve DID documents with automatic caching and fallback support for both `did:plc` and `did:web` methods.
 
 Think of it as a Swiss Army knife for AT Protocol identity resolution.
 
-## Why use Beacon?
+## Why use Resolver?
 
 - **Simple API** - Resolve DIDs and handles with one method call
 - **Automatic caching** - Smart caching with configurable TTLs
···
 ## Quick Example
 
 ```php
-use SocialDept\Beacon\Facades\Beacon;
+use SocialDept\Resolver\Facades\Resolver;
 
 // Resolve a DID to its document
-$document = Beacon::resolveDid('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
+$document = Resolver::resolveDid('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
 $handle = $document->getHandle(); // "user.bsky.social"
 $pds = $document->getPdsEndpoint(); // "https://bsky.social"
 
 // Convert a handle to its DID
-$did = Beacon::handleToDid('user.bsky.social');
+$did = Resolver::handleToDid('user.bsky.social');
 // "did:plc:ewvi7nxzyoun6zhxrhs64oiz"
 
 // Resolve any identity (DID or handle) to a document
-$document = Beacon::resolveIdentity('alice.bsky.social');
+$document = Resolver::resolveIdentity('alice.bsky.social');
 
 // Find someone's PDS endpoint
-$pds = Beacon::resolvePds('alice.bsky.social');
+$pds = Resolver::resolvePds('alice.bsky.social');
 // "https://bsky.social"
 ```
 
 ## Installation
 
 ```bash
-composer require socialdept/atp-beacon
+composer require socialdept/atp-resolver
 ```
 
-Beacon will auto-register with Laravel. Optionally publish the config:
+Resolver will auto-register with Laravel. Optionally publish the config:
 
 ```bash
-php artisan vendor:publish --tag=beacon-config
+php artisan vendor:publish --tag=resolver-config
 ```
 
 ## Basic Usage
 
 ### Resolving DIDs
 
-Beacon supports both `did:plc` and `did:web` methods:
+Resolver supports both `did:plc` and `did:web` methods:
 
 ```php
-use SocialDept\Beacon\Facades\Beacon;
+use SocialDept\Resolver\Facades\Resolver;
 
 // PLC directory resolution
-$document = Beacon::resolveDid('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
+$document = Resolver::resolveDid('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
 
 // Web DID resolution
-$document = Beacon::resolveDid('did:web:example.com');
+$document = Resolver::resolveDid('did:web:example.com');
 
 // Access document data
 $handle = $document->getHandle();
···
 
 ```php
 // Convert handle to DID string
-$did = Beacon::handleToDid('alice.bsky.social');
+$did = Resolver::handleToDid('alice.bsky.social');
 // "did:plc:ewvi7nxzyoun6zhxrhs64oiz"
 
 // Resolve handle to full DID document
-$document = Beacon::resolveHandle('alice.bsky.social');
+$document = Resolver::resolveHandle('alice.bsky.social');
 $handle = $document->getHandle();
 $pds = $document->getPdsEndpoint();
 ```
···
 
 ```php
 // Works with DIDs
-$document = Beacon::resolveIdentity('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
+$document = Resolver::resolveIdentity('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
 
 // Works with handles
-$document = Beacon::resolveIdentity('alice.bsky.social');
+$document = Resolver::resolveIdentity('alice.bsky.social');
 
 // Perfect for user input where type is unknown
 $actor = $request->input('actor'); // Could be DID or handle
-$document = Beacon::resolveIdentity($actor);
+$document = Resolver::resolveIdentity($actor);
 ```
 
 ### Finding PDS Endpoints
···
 
 ```php
 // From a DID
-$pds = Beacon::resolvePds('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
+$pds = Resolver::resolvePds('did:plc:ewvi7nxzyoun6zhxrhs64oiz');
 
 // From a handle
-$pds = Beacon::resolvePds('alice.bsky.social');
+$pds = Resolver::resolvePds('alice.bsky.social');
 
 // Returns: "https://bsky.social" or user's custom PDS
 ```
···
 
 ```php
 // Clear specific DID cache
-Beacon::clearDidCache('did:plc:abc123');
+Resolver::clearDidCache('did:plc:abc123');
 
 // Clear specific handle cache
-Beacon::clearHandleCache('alice.bsky.social');
+Resolver::clearHandleCache('alice.bsky.social');
 
 // Clear specific PDS cache
-Beacon::clearPdsCache('alice.bsky.social');
+Resolver::clearPdsCache('alice.bsky.social');
 
 // Clear all cached data
-Beacon::clearCache();
+Resolver::clearCache();
 ```
 
 ### Disable Caching
···
 Pass `false` as the second parameter to bypass cache:
 
 ```php
-$document = Beacon::resolveDid('did:plc:abc123', useCache: false);
-$did = Beacon::handleToDid('alice.bsky.social', useCache: false);
-$document = Beacon::resolveIdentity('alice.bsky.social', useCache: false);
-$pds = Beacon::resolvePds('alice.bsky.social', useCache: false);
+$document = Resolver::resolveDid('did:plc:abc123', useCache: false);
+$did = Resolver::handleToDid('alice.bsky.social', useCache: false);
+$document = Resolver::resolveIdentity('alice.bsky.social', useCache: false);
+$pds = Resolver::resolvePds('alice.bsky.social', useCache: false);
 ```
 
 ### Identity Validation
···
 Beacon includes static helper methods to validate DIDs and handles:
 
 ```php
-use SocialDept\Beacon\Support\Identity;
+use SocialDept\Resolver\Support\Identity;
 
 // Validate handles
 Identity::isHandle('alice.bsky.social'); // true
···
 
 ## Configuration
 
-Beacon works great with zero configuration, but you can customize behavior in `config/beacon.php`:
+Beacon works great with zero configuration, but you can customize behavior in `config/resolver.php`:
 
 ```php
 return [
     // PLC directory for did:plc resolution
-    'plc_directory' => env('BEACON_PLC_DIRECTORY', 'https://plc.directory'),
+    'plc_directory' => env('RESOLVER_PLC_DIRECTORY', 'https://plc.directory'),
 
     // Default PDS endpoint for handle resolution
-    'pds_endpoint' => env('BEACON_PDS_ENDPOINT', 'https://bsky.social'),
+    'pds_endpoint' => env('RESOLVER_PDS_ENDPOINT', 'https://bsky.social'),
 
     // HTTP request timeout
-    'timeout' => env('BEACON_TIMEOUT', 10),
+    'timeout' => env('RESOLVER_TIMEOUT', 10),
 
     // Cache configuration
     'cache' => [
-        'enabled' => env('BEACON_CACHE_ENABLED', true),
+        'enabled' => env('RESOLVER_CACHE_ENABLED', true),
 
         // Cache TTL for DID documents (1 hour)
-        'did_ttl' => env('BEACON_CACHE_DID_TTL', 3600),
+        'did_ttl' => env('RESOLVER_CACHE_DID_TTL', 3600),
 
         // Cache TTL for handle resolutions (1 hour)
-        'handle_ttl' => env('BEACON_CACHE_HANDLE_TTL', 3600),
+        'handle_ttl' => env('RESOLVER_CACHE_HANDLE_TTL', 3600),
 
         // Cache TTL for PDS endpoints (1 hour)
-        'pds_ttl' => env('BEACON_CACHE_PDS_TTL', 3600),
+        'pds_ttl' => env('RESOLVER_CACHE_PDS_TTL', 3600),
     ],
 ];
 ```
···
 
 ```php
 // DID Resolution
-Beacon::resolveDid(string $did, bool $useCache = true): DidDocument
+Resolver::resolveDid(string $did, bool $useCache = true): DidDocument
 
 // Handle Resolution
-Beacon::handleToDid(string $handle, bool $useCache = true): string
-Beacon::resolveHandle(string $handle, bool $useCache = true): DidDocument
+Resolver::handleToDid(string $handle, bool $useCache = true): string
+Resolver::resolveHandle(string $handle, bool $useCache = true): DidDocument
 
 // Identity Resolution
-Beacon::resolveIdentity(string $actor, bool $useCache = true): DidDocument
+Resolver::resolveIdentity(string $actor, bool $useCache = true): DidDocument
 
 // PDS Resolution
-Beacon::resolvePds(string $actor, bool $useCache = true): ?string
+Resolver::resolvePds(string $actor, bool $useCache = true): ?string
 
 // Cache Management
-Beacon::clearDidCache(string $did): void
-Beacon::clearHandleCache(string $handle): void
-Beacon::clearPdsCache(string $actor): void
-Beacon::clearCache(): void
+Resolver::clearDidCache(string $did): void
+Resolver::clearHandleCache(string $handle): void
+Resolver::clearPdsCache(string $actor): void
+Resolver::clearCache(): void
 
 // Identity Validation (static helpers)
 Identity::isHandle(?string $handle): bool
···
 Beacon throws descriptive exceptions when resolution fails:
 
 ```php
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Exceptions\HandleResolutionException;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Exceptions\HandleResolutionException;
 
 try {
-    $document = Beacon::resolveDid('did:invalid:format');
+    $document = Resolver::resolveDid('did:invalid:format');
 } catch (DidResolutionException $e) {
     // Handle DID resolution errors
     logger()->error('DID resolution failed', [
···
 }
 
 try {
-    $did = Beacon::handleToDid('invalid-handle');
+    $did = Resolver::handleToDid('invalid-handle');
 } catch (HandleResolutionException $e) {
     // Handle handle resolution errors
 }
···
 
 ```php
 // Resolve user identity from DID
-$document = Beacon::resolveDid($event->did);
+$document = Resolver::resolveDid($event->did);
 $handle = $document->getHandle();
 
 // Make authenticated requests to their PDS
-$pds = Beacon::resolvePds($event->did);
+$pds = Resolver::resolvePds($event->did);
 $client = new AtProtoClient($pds);
 ```
 
···
 ```php
 // Resolve multiple handles efficiently (caching kicks in)
 $dids = collect(['alice.bsky.social', 'bob.bsky.social'])
-    ->map(fn($handle) => Beacon::handleToDid($handle))
+    ->map(fn($handle) => Resolver::handleToDid($handle))
     ->all();
 ```
 
···
 
 ```php
 // Get complete identity information
-$document = Beacon::resolveIdentity($username);
+$document = Resolver::resolveIdentity($username);
 
 $profile = [
     'did' => $document->id,
···
 ### Input Validation
 
 ```php
-use SocialDept\Beacon\Support\Identity;
-use SocialDept\Beacon\Facades\Beacon;
+use SocialDept\Resolver\Support\Identity;
+use SocialDept\Resolver\Facades\Resolver;
 
 // Validate user input before resolving
 $actor = request()->input('actor');
 
 if (Identity::isHandle($actor) || Identity::isDid($actor)) {
-    $document = Beacon::resolveIdentity($actor);
+    $document = Resolver::resolveIdentity($actor);
 } else {
     abort(422, 'Invalid handle or DID');
 }
 
 // Or convert handle to DID
 if (Identity::isHandle($actor)) {
-    $did = Beacon::handleToDid($actor);
+    $did = Resolver::handleToDid($actor);
 }
 ```
 
···
 
 ## Support & Contributing
 
-Found a bug or have a feature request? [Open an issue](https://github.com/socialdept/atp-beacon/issues).
+Found a bug or have a feature request? [Open an issue](https://github.com/socialdept/atp-resolver/issues).
 
 Want to contribute? We'd love your help! Check out the [contribution guidelines](CONTRIBUTING.md).
 
 ## Credits
 
 - [Miguel Batres](https://batres.co) - founder & lead maintainer
-- [All contributors](https://github.com/socialdept/atp-beacon/graphs/contributors)
+- [All contributors](https://github.com/socialdept/atp-resolver/graphs/contributors)
 
 ## License
 

composer.json

···
 {
-    "name": "socialdept/atp-beacon",
-    "description": "Resolve AT Protocol DIDs, handles, and lexicon schemas in Laravel",
+    "name": "socialdept/atp-resolver",
+    "description": "Resolve AT Protocol DIDs and handles in Laravel",
     "type": "library",
     "license": "MIT",
     "require": {
···
     },
     "autoload": {
         "psr-4": {
-            "SocialDept\\Beacon\\": "src/"
+            "SocialDept\\Resolver\\": "src/"
         }
     },
     "autoload-dev": {
         "psr-4": {
-            "SocialDept\\Beacon\\Tests\\": "tests/"
+            "SocialDept\\Resolver\\Tests\\": "tests/"
         }
     },
     "extra": {
         "laravel": {
             "providers": [
-                "SocialDept\\Beacon\\BeaconServiceProvider"
+                "SocialDept\\Resolver\\ResolverServiceProvider"
             ],
             "aliases": {
-                "Beacon": "SocialDept\\Beacon\\Facades\\Beacon"
+                "Resolver": "SocialDept\\Resolver\\Facades\\Resolver"
             }
         }
     }

config/beacon.php config/resolver.php

···
     |
     */
 
-    'plc_directory' => env('BEACON_PLC_DIRECTORY', 'https://plc.directory'),
+    'plc_directory' => env('RESOLVER_PLC_DIRECTORY', 'https://plc.directory'),
 
     /*
     |--------------------------------------------------------------------------
···
     |
     */
 
-    'pds_endpoint' => env('BEACON_PDS_ENDPOINT', 'https://bsky.social'),
+    'pds_endpoint' => env('RESOLVER_PDS_ENDPOINT', 'https://bsky.social'),
 
     /*
     |--------------------------------------------------------------------------
···
     |--------------------------------------------------------------------------
     |
     | The timeout in seconds for HTTP requests to external services when
-    | resolving DIDs, handles, and lexicons.
+    | resolving DIDs and handles.
     |
     */
 
-    'timeout' => env('BEACON_TIMEOUT', 10),
+    'timeout' => env('RESOLVER_TIMEOUT', 10),
 
     /*
     |--------------------------------------------------------------------------
     | Cache Configuration
     |--------------------------------------------------------------------------
     |
-    | Configure caching behavior for resolved DIDs, handles, and lexicons.
+    | Configure caching behavior for resolved DIDs and handles.
     | TTL values are in seconds.
     |
     */
···
     'cache' => [
 
         // Enable or disable caching globally
-        'enabled' => env('BEACON_CACHE_ENABLED', true),
+        'enabled' => env('RESOLVER_CACHE_ENABLED', true),
 
         // Cache TTL for DID documents (1 hour default)
-        'did_ttl' => env('BEACON_CACHE_DID_TTL', 3600),
+        'did_ttl' => env('RESOLVER_CACHE_DID_TTL', 3600),
 
         // Cache TTL for handle resolutions (1 hour default)
-        'handle_ttl' => env('BEACON_CACHE_HANDLE_TTL', 3600),
+        'handle_ttl' => env('RESOLVER_CACHE_HANDLE_TTL', 3600),
 
         // Cache TTL for PDS endpoints (1 hour default)
-        'pds_ttl' => env('BEACON_CACHE_PDS_TTL', 3600),
-
-        // Cache TTL for lexicon schemas (24 hours default)
-        'lexicon_ttl' => env('BEACON_CACHE_LEXICON_TTL', 86400),
+        'pds_ttl' => env('RESOLVER_CACHE_PDS_TTL', 3600),
 
     ],
 
-];
+];

src/Beacon.php src/Resolver.php

···
 <?php
 
-namespace SocialDept\Beacon;
+namespace SocialDept\Resolver;
 
-use SocialDept\Beacon\Contracts\CacheStore;
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Contracts\HandleResolver;
-use SocialDept\Beacon\Data\DidDocument;
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Exceptions\HandleResolutionException;
-use SocialDept\Beacon\Support\Concerns\HasConfig;
-use SocialDept\Beacon\Support\Identity;
+use SocialDept\Resolver\Contracts\CacheStore;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Contracts\HandleResolver;
+use SocialDept\Resolver\Data\DidDocument;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Exceptions\HandleResolutionException;
+use SocialDept\Resolver\Support\Concerns\HasConfig;
+use SocialDept\Resolver\Support\Identity;
 
-class Beacon
+class Resolver
 {
     use HasConfig;
 
     /**
-     * Create a new Beacon instance.
+     * Create a new Resolver instance.
      */
     public function __construct(
         protected DidResolver $didResolver,
···
         $document = $this->didResolver->resolve($did);
 
         if ($useCache) {
-            $ttl = $this->getConfig('beacon.cache.did_ttl', 3600);
+            $ttl = $this->getConfig('resolver.cache.did_ttl', 3600);
             $this->cache->put($cacheKey, $document, $ttl);
         }
 
···
         $did = $this->handleResolver->resolve($handle);
 
         if ($useCache) {
-            $ttl = $this->getConfig('beacon.cache.handle_ttl', 3600);
+            $ttl = $this->getConfig('resolver.cache.handle_ttl', 3600);
             $this->cache->put($cacheKey, $did, $ttl);
         }
 
···
         $pdsEndpoint = $document->getPdsEndpoint();
 
         if ($useCache && $pdsEndpoint !== null) {
-            $ttl = $this->getConfig('beacon.cache.pds_ttl', 3600);
+            $ttl = $this->getConfig('resolver.cache.pds_ttl', 3600);
             $this->cache->put($cacheKey, $pdsEndpoint, $ttl);
         }
 

src/BeaconServiceProvider.php src/ResolverServiceProvider.php

···
 <?php
 
-namespace SocialDept\Beacon;
+namespace SocialDept\Resolver;
 
 use Illuminate\Support\ServiceProvider;
-use SocialDept\Beacon\Cache\LaravelCacheStore;
-use SocialDept\Beacon\Contracts\CacheStore;
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Contracts\HandleResolver;
-use SocialDept\Beacon\Resolvers\AtProtoHandleResolver;
-use SocialDept\Beacon\Resolvers\DidResolverManager;
+use SocialDept\Resolver\Cache\LaravelCacheStore;
+use SocialDept\Resolver\Contracts\CacheStore;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Contracts\HandleResolver;
+use SocialDept\Resolver\Resolvers\AtProtoHandleResolver;
+use SocialDept\Resolver\Resolvers\DidResolverManager;
 
-class BeaconServiceProvider extends ServiceProvider
+class ResolverServiceProvider extends ServiceProvider
 {
     /**
      * Register any package services.
      */
     public function register(): void
     {
-        $this->mergeConfigFrom(__DIR__.'/../config/beacon.php', 'beacon');
+        $this->mergeConfigFrom(__DIR__.'/../config/resolver.php', 'resolver');
 
         // Register cache store
         $this->app->singleton(CacheStore::class, function ($app) {
···
             return new AtProtoHandleResolver();
         });
 
-        // Register Beacon service
-        $this->app->singleton('beacon', function ($app) {
-            return new Beacon(
+        // Register Resolver service
+        $this->app->singleton('resolver', function ($app) {
+            return new Resolver(
                 $app->make(DidResolver::class),
                 $app->make(HandleResolver::class),
                 $app->make(CacheStore::class),
             );
         });
 
-        $this->app->alias('beacon', Beacon::class);
+        $this->app->alias('resolver', Resolver::class);
     }
 
     /**
···
      */
     public function provides(): array
     {
-        return ['beacon', Beacon::class];
+        return ['resolver', Resolver::class];
     }
 
     /**
···
     {
         // Publish config
         $this->publishes([
-            __DIR__.'/../config/beacon.php' => config_path('beacon.php'),
-        ], 'beacon-config');
+            __DIR__.'/../config/resolver.php' => config_path('resolver.php'),
+        ], 'resolver-config');
     }
 }

src/Cache/LaravelCacheStore.php

···
 <?php
 
-namespace SocialDept\Beacon\Cache;
+namespace SocialDept\Resolver\Cache;
 
 use Illuminate\Contracts\Cache\Repository;
-use SocialDept\Beacon\Contracts\CacheStore;
+use SocialDept\Resolver\Contracts\CacheStore;
 
 class LaravelCacheStore implements CacheStore
 {

src/Contracts/CacheStore.php

···
 <?php
 
-namespace SocialDept\Beacon\Contracts;
+namespace SocialDept\Resolver\Contracts;
 
 interface CacheStore
 {

src/Contracts/DidResolver.php

···
 <?php
 
-namespace SocialDept\Beacon\Contracts;
+namespace SocialDept\Resolver\Contracts;
 
-use SocialDept\Beacon\Data\DidDocument;
+use SocialDept\Resolver\Data\DidDocument;
 
 interface DidResolver
 {
···
      * @param  string  $did  The DID to resolve (e.g., "did:plc:abc123" or "did:web:example.com")
      * @return DidDocument
      *
-     * @throws \SocialDept\Beacon\Exceptions\DidResolutionException
+     * @throws \SocialDept\Resolver\Exceptions\DidResolutionException
      */
     public function resolve(string $did): DidDocument;
 

src/Contracts/HandleResolver.php

···
 <?php
 
-namespace SocialDept\Beacon\Contracts;
+namespace SocialDept\Resolver\Contracts;
 
 interface HandleResolver
 {
···
      * @param  string  $handle  The handle to resolve (e.g., "user.bsky.social")
      * @return string The resolved DID
      *
-     * @throws \SocialDept\Beacon\Exceptions\HandleResolutionException
+     * @throws \SocialDept\Resolver\Exceptions\HandleResolutionException
      */
     public function resolve(string $handle): string;
 }

src/Data/DidDocument.php

···
 <?php
 
-namespace SocialDept\Beacon\Data;
+namespace SocialDept\Resolver\Data;
 
 class DidDocument
 {

src/Exceptions/BeaconException.php

···
-<?php
-
-namespace SocialDept\Beacon\Exceptions;
-
-use Exception;
-
-class BeaconException extends Exception
-{
-    //
-}

src/Exceptions/DidResolutionException.php

···
 <?php
 
-namespace SocialDept\Beacon\Exceptions;
+namespace SocialDept\Resolver\Exceptions;
 
-class DidResolutionException extends BeaconException
+class DidResolutionException extends ResolverException
 {
     /**
      * Create a new exception for unsupported DID method.

src/Exceptions/HandleResolutionException.php

···
 <?php
 
-namespace SocialDept\Beacon\Exceptions;
+namespace SocialDept\Resolver\Exceptions;
 
-class HandleResolutionException extends BeaconException
+class HandleResolutionException extends ResolverException
 {
     /**
      * Create a new exception for invalid handle format.

src/Exceptions/ResolverException.php

···
+<?php
+
+namespace SocialDept\Resolver\Exceptions;
+
+use Exception;
+
+class ResolverException extends Exception
+{
+    //
+}

src/Facades/Beacon.php src/Facades/Resolver.php

···
 <?php
 
-namespace SocialDept\Beacon\Facades;
+namespace SocialDept\Resolver\Facades;
 
 use Illuminate\Support\Facades\Facade;
 
-class Beacon extends Facade
+class Resolver extends Facade
 {
     /**
      * Get the registered name of the component.
···
      */
     protected static function getFacadeAccessor(): string
     {
-        return 'beacon';
+        return 'resolver';
     }
 }

src/Resolvers/AtProtoHandleResolver.php

···
 <?php
 
-namespace SocialDept\Beacon\Resolvers;
+namespace SocialDept\Resolver\Resolvers;
 
 use GuzzleHttp\Client;
 use GuzzleHttp\Exception\GuzzleException;
-use SocialDept\Beacon\Contracts\HandleResolver;
-use SocialDept\Beacon\Exceptions\HandleResolutionException;
-use SocialDept\Beacon\Support\Concerns\HasConfig;
+use SocialDept\Resolver\Contracts\HandleResolver;
+use SocialDept\Resolver\Exceptions\HandleResolutionException;
+use SocialDept\Resolver\Support\Concerns\HasConfig;
 
 class AtProtoHandleResolver implements HandleResolver
 {
···
      */
     public function __construct(?string $pdsEndpoint = null, ?int $timeout = null)
     {
-        $this->pdsEndpoint = $pdsEndpoint ?? $this->getConfig('beacon.pds_endpoint', 'https://bsky.social');
+        $this->pdsEndpoint = $pdsEndpoint ?? $this->getConfig('resolver.pds_endpoint', 'https://bsky.social');
         $this->client = new Client([
-            'timeout' => $timeout ?? $this->getConfig('beacon.timeout', 10),
+            'timeout' => $timeout ?? $this->getConfig('resolver.timeout', 10),
             'headers' => [
                 'Accept' => 'application/json',
                 'User-Agent' => 'Beacon/1.0',

src/Resolvers/DidResolverManager.php

···
 <?php
 
-namespace SocialDept\Beacon\Resolvers;
+namespace SocialDept\Resolver\Resolvers;
 
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Data\DidDocument;
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Support\Concerns\ParsesDid;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Data\DidDocument;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Support\Concerns\ParsesDid;
 
 class DidResolverManager implements DidResolver
 {

src/Resolvers/PlcDidResolver.php

···
 <?php
 
-namespace SocialDept\Beacon\Resolvers;
+namespace SocialDept\Resolver\Resolvers;
 
 use GuzzleHttp\Client;
 use GuzzleHttp\Exception\GuzzleException;
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Data\DidDocument;
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Support\Concerns\HasConfig;
-use SocialDept\Beacon\Support\Concerns\ParsesDid;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Data\DidDocument;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Support\Concerns\HasConfig;
+use SocialDept\Resolver\Support\Concerns\ParsesDid;
 
 class PlcDidResolver implements DidResolver
 {
···
      */
     public function __construct(?string $plcDirectory = null, ?int $timeout = null)
     {
-        $this->plcDirectory = $plcDirectory ?? $this->getConfig('beacon.plc_directory', 'https://plc.directory');
+        $this->plcDirectory = $plcDirectory ?? $this->getConfig('resolver.plc_directory', 'https://plc.directory');
         $this->client = new Client([
-            'timeout' => $timeout ?? $this->getConfig('beacon.timeout', 10),
+            'timeout' => $timeout ?? $this->getConfig('resolver.timeout', 10),
             'headers' => [
                 'Accept' => 'application/json',
                 'User-Agent' => 'Beacon/1.0',

src/Resolvers/WebDidResolver.php

···
 <?php
 
-namespace SocialDept\Beacon\Resolvers;
+namespace SocialDept\Resolver\Resolvers;
 
 use GuzzleHttp\Client;
 use GuzzleHttp\Exception\GuzzleException;
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Data\DidDocument;
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Support\Concerns\HasConfig;
-use SocialDept\Beacon\Support\Concerns\ParsesDid;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Data\DidDocument;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Support\Concerns\HasConfig;
+use SocialDept\Resolver\Support\Concerns\ParsesDid;
 
 class WebDidResolver implements DidResolver
 {
···
     public function __construct(?int $timeout = null)
     {
         $this->client = new Client([
-            'timeout' => $timeout ?? $this->getConfig('beacon.timeout', 10),
+            'timeout' => $timeout ?? $this->getConfig('resolver.timeout', 10),
             'headers' => [
                 'Accept' => 'application/json',
                 'User-Agent' => 'Beacon/1.0',

src/Support/Concerns/HasConfig.php

···
 <?php
 
-namespace SocialDept\Beacon\Support\Concerns;
+namespace SocialDept\Resolver\Support\Concerns;
 
 trait HasConfig
 {

src/Support/Concerns/ParsesDid.php

···
 <?php
 
-namespace SocialDept\Beacon\Support\Concerns;
+namespace SocialDept\Resolver\Support\Concerns;
 
-use SocialDept\Beacon\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
 
 trait ParsesDid
 {

src/Support/Identity.php

···
 <?php
 
-namespace SocialDept\Beacon\Support;
+namespace SocialDept\Resolver\Support;
 
 class Identity
 {

tests/Unit/BeaconIdentityTest.php tests/Unit/ResolverIdentityTest.php

···
 <?php
 
-namespace SocialDept\Beacon\Tests\Unit;
+namespace SocialDept\Resolver\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use SocialDept\Beacon\Beacon;
-use SocialDept\Beacon\Contracts\CacheStore;
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Contracts\HandleResolver;
-use SocialDept\Beacon\Data\DidDocument;
+use SocialDept\Resolver\Resolver;
+use SocialDept\Resolver\Contracts\CacheStore;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Contracts\HandleResolver;
+use SocialDept\Resolver\Data\DidDocument;
 
-class BeaconIdentityTest extends TestCase
+class ResolverIdentityTest extends TestCase
 {
     public function test_it_can_convert_handle_to_did(): void
     {
···
             ->method('put')
             ->with('handle:user.bsky.social', 'did:plc:abc123', $this->anything());
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $did = $beacon->handleToDid('user.bsky.social');
 
         $this->assertSame('did:plc:abc123', $did);
···
 
         $cache->method('has')->willReturn(false);
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $document = $beacon->resolveHandle('user.bsky.social');
 
         $this->assertInstanceOf(DidDocument::class, $document);
···
         $cache->method('has')->willReturn(false);
         $handleResolver->expects($this->never())->method('resolve');
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $document = $beacon->resolveIdentity('did:plc:abc123');
 
         $this->assertInstanceOf(DidDocument::class, $document);
···
 
         $cache->method('has')->willReturn(false);
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $document = $beacon->resolveIdentity('user.bsky.social');
 
         $this->assertInstanceOf(DidDocument::class, $document);

tests/Unit/BeaconTest.php tests/Unit/ResolverTest.php

···
 <?php
 
-namespace SocialDept\Beacon\Tests\Unit;
+namespace SocialDept\Resolver\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use SocialDept\Beacon\Beacon;
-use SocialDept\Beacon\Contracts\CacheStore;
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Contracts\HandleResolver;
-use SocialDept\Beacon\Data\DidDocument;
+use SocialDept\Resolver\Resolver;
+use SocialDept\Resolver\Contracts\CacheStore;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Contracts\HandleResolver;
+use SocialDept\Resolver\Data\DidDocument;
 
-class BeaconTest extends TestCase
+class ResolverTest extends TestCase
 {
     public function test_it_can_resolve_pds_from_did(): void
     {
···
                 return null;
             });
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $pds = $beacon->resolvePds('did:plc:abc123');
 
         $this->assertSame('https://pds.example.com', $pds);
···
                 return null;
             });
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $pds = $beacon->resolvePds('user.bsky.social');
 
         $this->assertSame('https://pds.example.com', $pds);
···
             ->method('put')
             ->with('did:did:plc:abc123', $didDocument, $this->anything());
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $pds = $beacon->resolvePds('did:plc:abc123');
 
         $this->assertNull($pds);
···
 
         $didResolver->expects($this->never())->method('resolve');
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $pds = $beacon->resolvePds('did:plc:abc123');
 
         $this->assertSame('https://cached-pds.example.com', $pds);
···
             ->method('forget')
             ->with('pds:did:plc:abc123');
 
-        $beacon = new Beacon($didResolver, $handleResolver, $cache);
+        $beacon = new Resolver($didResolver, $handleResolver, $cache);
         $beacon->clearPdsCache('did:plc:abc123');
     }
 }

tests/Unit/DidDocumentTest.php

···
 <?php
 
-namespace SocialDept\Beacon\Tests\Unit;
+namespace SocialDept\Resolver\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use SocialDept\Beacon\Data\DidDocument;
+use SocialDept\Resolver\Data\DidDocument;
 
 class DidDocumentTest extends TestCase
 {

tests/Unit/DidResolverManagerTest.php

···
 <?php
 
-namespace SocialDept\Beacon\Tests\Unit;
+namespace SocialDept\Resolver\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use SocialDept\Beacon\Contracts\DidResolver;
-use SocialDept\Beacon\Data\DidDocument;
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Resolvers\DidResolverManager;
+use SocialDept\Resolver\Contracts\DidResolver;
+use SocialDept\Resolver\Data\DidDocument;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Resolvers\DidResolverManager;
 
 class DidResolverManagerTest extends TestCase
 {

tests/Unit/IdentityTest.php

···
 <?php
 
-namespace SocialDept\Beacon\Tests\Unit;
+namespace SocialDept\Resolver\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use SocialDept\Beacon\Support\Identity;
+use SocialDept\Resolver\Support\Identity;
 
 class IdentityTest extends TestCase
 {

tests/Unit/PlcDidResolverTest.php

···
 <?php
 
-namespace SocialDept\Beacon\Tests\Unit;
+namespace SocialDept\Resolver\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Resolvers\PlcDidResolver;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Resolvers\PlcDidResolver;
 
 class PlcDidResolverTest extends TestCase
 {

tests/Unit/WebDidResolverTest.php

···
 <?php
 
-namespace SocialDept\Beacon\Tests\Unit;
+namespace SocialDept\Resolver\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use SocialDept\Beacon\Exceptions\DidResolutionException;
-use SocialDept\Beacon\Resolvers\WebDidResolver;
+use SocialDept\Resolver\Exceptions\DidResolutionException;
+use SocialDept\Resolver\Resolvers\WebDidResolver;
 
 class WebDidResolverTest extends TestCase
 {