Use DNS lexicon lookups as fallback

src/Console/GenerateCommand.php

···
 
         try {
             $sources = config('schema.sources', []);
-            $loader = new SchemaLoader($sources);
+            $loader = new SchemaLoader(
+                sources: $sources,
+                useCache: config('schema.cache.enabled', true),
+                cacheTtl: config('schema.cache.schema_ttl', 3600),
+                cachePrefix: config('schema.cache.prefix', 'schema'),
+                dnsResolutionEnabled: config('schema.dns_resolution.enabled', true),
+                httpTimeout: config('schema.http.timeout', 10)
+            );
 
             $generator = new DTOGenerator(
                 schemaLoader: $loader,

src/Generator/DTOGenerator.php

···
         $this->outputDirectory = rtrim($outputDirectory, '/');
         $this->typeParser = $typeParser ?? new TypeParser(schemaLoader: $schemaLoader);
         $this->namespaceResolver = $namespaceResolver ?? new NamespaceResolver($baseNamespace);
-        $this->templateRenderer = $templateRenderer ?? new TemplateRenderer;
-        $this->fileWriter = $fileWriter ?? new FileWriter;
+        $this->templateRenderer = $templateRenderer ?? new TemplateRenderer();
+        $this->fileWriter = $fileWriter ?? new FileWriter();
     }
 
     /**

src/Parser/SchemaLoader.php

···
 namespace SocialDept\Schema\Parser;
 
 use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
 use SocialDept\Schema\Exceptions\SchemaNotFoundException;
 use SocialDept\Schema\Exceptions\SchemaParseException;
 
···
      * Cache key prefix.
      */
     protected string $cachePrefix;
+
+    /**
+     * Whether DNS resolution is enabled.
+     */
+    protected bool $dnsResolutionEnabled;
+
+    /**
+     * HTTP timeout for schema fetching.
+     */
+    protected int $httpTimeout;
 
     /**
      * Create a new SchemaLoader instance.
···
         array $sources,
         bool $useCache = true,
         int $cacheTtl = 3600,
-        string $cachePrefix = 'schema'
+        string $cachePrefix = 'schema',
+        bool $dnsResolutionEnabled = true,
+        int $httpTimeout = 10
     ) {
         $this->sources = $sources;
         $this->useCache = $useCache;
         $this->cacheTtl = $cacheTtl;
         $this->cachePrefix = $cachePrefix;
+        $this->dnsResolutionEnabled = $dnsResolutionEnabled;
+        $this->httpTimeout = $httpTimeout;
     }
 
     /**
···
             }
         }
 
+        // Try DNS resolution as fallback if enabled
+        if ($this->dnsResolutionEnabled) {
+            $schema = $this->loadViaDns($nsid);
+
+            if ($schema !== null) {
+                return $schema;
+            }
+        }
+
         throw SchemaNotFoundException::forNsid($nsid);
     }
 
···
     {
         // Try NSID-based path (app.bsky.feed.post -> app/bsky/feed/post.json)
         $nsidPath = $this->nsidToPath($nsid);
-        $jsonPath = $source . '/' . $nsidPath . '.json';
+        $jsonPath = $source.'/'.$nsidPath.'.json';
 
         if (file_exists($jsonPath)) {
             return $this->loadJsonFile($jsonPath, $nsid);
         }
 
         // Try PHP file
-        $phpPath = $source . '/' . $nsidPath . '.php';
+        $phpPath = $source.'/'.$nsidPath.'.php';
 
         if (file_exists($phpPath)) {
             return $this->loadPhpFile($phpPath, $nsid);
         }
 
         // Try flat structure (app.bsky.feed.post.json)
-        $flatJsonPath = $source . '/' . $nsid . '.json';
+        $flatJsonPath = $source.'/'.$nsid.'.json';
 
         if (file_exists($flatJsonPath)) {
             return $this->loadJsonFile($flatJsonPath, $nsid);
         }
 
-        $flatPhpPath = $source . '/' . $nsid . '.php';
+        $flatPhpPath = $source.'/'.$nsid.'.php';
 
         if (file_exists($flatPhpPath)) {
             return $this->loadPhpFile($flatPhpPath, $nsid);
···
     public function getCachedNsids(): array
     {
         return array_keys($this->memoryCache);
+    }
+
+    /**
+     * Load schema via DNS resolution from official sources.
+     */
+    protected function loadViaDns(string $nsid): ?array
+    {
+        // Try to fetch from official AT Protocol GitHub repository
+        $urls = $this->getOfficialSchemaUrls($nsid);
+
+        foreach ($urls as $url) {
+            try {
+                $response = Http::timeout($this->httpTimeout)
+                    ->get($url);
+
+                if ($response->successful()) {
+                    $data = $response->json();
+
+                    if (is_array($data) && isset($data['lexicon'])) {
+                        return $data;
+                    }
+                }
+            } catch (\Exception $e) {
+                // Continue to next URL
+                continue;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Get official schema URLs for an NSID.
+     *
+     * @return array<string>
+     */
+    protected function getOfficialSchemaUrls(string $nsid): array
+    {
+        $path = str_replace('.', '/', $nsid);
+
+        return [
+            // Official AT Protocol lexicons repository (main branch)
+            "https://raw.githubusercontent.com/bluesky-social/atproto/main/lexicons/{$path}.json",
+
+            // Fallback to legacy location
+            "https://raw.githubusercontent.com/bluesky-social/atproto/main/lexicons/{$nsid}.json",
+        ];
     }
 }

src/SchemaServiceProvider.php

···
             return new Parser\SchemaLoader(
                 sources: config('schema.sources', []),
                 useCache: config('schema.cache.enabled', true),
-                cacheTtl: config('schema.cache.ttl', 3600),
-                cachePrefix: config('schema.cache.prefix', 'schema')
+                cacheTtl: config('schema.cache.schema_ttl', 3600),
+                cachePrefix: config('schema.cache.prefix', 'schema'),
+                dnsResolutionEnabled: config('schema.dns_resolution.enabled', true),
+                httpTimeout: config('schema.http.timeout', 10)
             );
         });
 
···
 
         // Register AT Protocol validation rules
         $validator->extend('nsid', function ($attribute, $value) {
-            $rule = new Validation\Rules\Nsid;
+            $rule = new Validation\Rules\Nsid();
             $failed = false;
             $rule->validate($attribute, $value, function () use (&$failed) {
                 $failed = true;
···
         }, 'The :attribute is not a valid NSID.');
 
         $validator->extend('did', function ($attribute, $value) {
-            $rule = new Validation\Rules\Did;
+            $rule = new Validation\Rules\Did();
             $failed = false;
             $rule->validate($attribute, $value, function () use (&$failed) {
                 $failed = true;
···
         }, 'The :attribute is not a valid DID.');
 
         $validator->extend('handle', function ($attribute, $value) {
-            $rule = new Validation\Rules\Handle;
+            $rule = new Validation\Rules\Handle();
             $failed = false;
             $rule->validate($attribute, $value, function () use (&$failed) {
                 $failed = true;
···
         }, 'The :attribute is not a valid handle.');
 
         $validator->extend('at_uri', function ($attribute, $value) {
-            $rule = new Validation\Rules\AtUri;
+            $rule = new Validation\Rules\AtUri();
             $failed = false;
             $rule->validate($attribute, $value, function () use (&$failed) {
                 $failed = true;
···
         }, 'The :attribute is not a valid AT URI.');
 
         $validator->extend('at_datetime', function ($attribute, $value) {
-            $rule = new Validation\Rules\AtDatetime;
+            $rule = new Validation\Rules\AtDatetime();
             $failed = false;
             $rule->validate($attribute, $value, function () use (&$failed) {
                 $failed = true;
···
         }, 'The :attribute is not a valid AT Protocol datetime.');
 
         $validator->extend('cid', function ($attribute, $value) {
-            $rule = new Validation\Rules\Cid;
+            $rule = new Validation\Rules\Cid();
             $failed = false;
             $rule->validate($attribute, $value, function () use (&$failed) {
                 $failed = true;
···
         }, 'The :attribute must be at least :min_graphemes graphemes.');
 
         $validator->extend('language', function ($attribute, $value) {
-            $rule = new Validation\Rules\Language;
+            $rule = new Validation\Rules\Language();
             $failed = false;
             $rule->validate($attribute, $value, function () use (&$failed) {
                 $failed = true;

src/helpers.php

···
         return Schema::generate($nsid, $options);
     }
 }
-
-