chore: fix type errors and formatting

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/pds.js

···
    * Validate OAuth authorization request parameters.
    * Shared between PAR and direct authorization flows.
    * @param {Object} params - The authorization parameters
-   * @param {string} params.clientId - The client_id
-   * @param {string} params.redirectUri - The redirect_uri
-   * @param {string} params.responseType - The response_type
-   * @param {string} [params.responseMode] - The response_mode
-   * @param {string} [params.scope] - The scope
-   * @param {string} [params.state] - The state
-   * @param {string} params.codeChallenge - The code_challenge
-   * @param {string} params.codeChallengeMethod - The code_challenge_method
-   * @param {string} [params.loginHint] - The login_hint
+   * @param {string | undefined | null} params.clientId - The client_id
+   * @param {string | undefined | null} params.redirectUri - The redirect_uri
+   * @param {string | undefined | null} params.responseType - The response_type
+   * @param {string | undefined | null} params.codeChallenge - The code_challenge
+   * @param {string | undefined | null} params.codeChallengeMethod - The code_challenge_method
    * @returns {Promise<{error: Response} | {clientMetadata: ClientMetadata}>}
    */
   async validateAuthorizationParameters({
···
     codeChallengeMethod,
   }) {
     if (!clientId) {
-      return { error: errorResponse('invalid_request', 'client_id required', 400) };
+      return {
+        error: errorResponse('invalid_request', 'client_id required', 400),
+      };
     }
     if (!redirectUri) {
-      return { error: errorResponse('invalid_request', 'redirect_uri required', 400) };
+      return {
+        error: errorResponse('invalid_request', 'redirect_uri required', 400),
+      };
     }
     if (responseType !== 'code') {
       return {
···
       };
     }
     if (!codeChallenge || codeChallengeMethod !== 'S256') {
-      return { error: errorResponse('invalid_request', 'PKCE with S256 required', 400) };
+      return {
+        error: errorResponse('invalid_request', 'PKCE with S256 required', 400),
+      };
     }
 
     let clientMetadata;
···
         return new Response('Missing client_id parameter', { status: 400 });
       }
 
-      const match = requestUri.match(/^urn:ietf:params:oauth:request_uri:(.+)$/);
+      const match = requestUri.match(
+        /^urn:ietf:params:oauth:request_uri:(.+)$/,
+      );
       if (!match) return new Response('Invalid request_uri', { status: 400 });
 
       const rows = this.sql
···
         .toArray();
       const authRequest = rows[0];
 
-      if (!authRequest) return new Response('Request not found', { status: 400 });
+      if (!authRequest)
+        return new Response('Request not found', { status: 400 });
       if (new Date(/** @type {string} */ (authRequest.expires_at)) < new Date())
         return new Response('Request expired', { status: 400 });
       if (authRequest.code)
···
           scope: parameters.scope || 'atproto',
           requestUri: requestUri || '',
         }),
-        { status: 200, headers: { 'Content-Type': 'text/html; charset=utf-8' } },
+        {
+          status: 200,
+          headers: { 'Content-Type': 'text/html; charset=utf-8' },
+        },
       );
     }
 

test/e2e.test.js

···
       authorizeUrl.searchParams.set('login_hint', DID);
 
       const getRes = await fetch(authorizeUrl.toString());
-      assert.strictEqual(getRes.status, 200, 'Direct authorize GET should succeed');
+      assert.strictEqual(
+        getRes.status,
+        200,
+        'Direct authorize GET should succeed',
+      );
 
       const html = await getRes.text();
       assert.ok(html.includes('Authorize'), 'Should show consent page');
-      assert.ok(html.includes('request_uri'), 'Should include request_uri in form');
+      assert.ok(
+        html.includes('request_uri'),
+        'Should include request_uri in form',
+      );
     });
 
     it('completes full direct authorization flow', async () => {