@atproto-labs/handle-resolver 0.0.1 → 0.1.0

package/dist/internal-resolvers/dns-handle-resolver.d.ts

@@ -0,0 +1,12 @@
+import { HandleResolver, ResolvedHandle } from '../types';
+/**
+ * DNS TXT record resolver. Return `null` if the hostname successfully does not
+ * resolve to a valid DID. Throw an error if an unexpected error occurs.
+ */
+export type ResolveTxt = (hostname: string) => Promise<null | string[]>;
+export declare class DnsHandleResolver implements HandleResolver {
+    protected resolveTxt: ResolveTxt;
+    constructor(resolveTxt: ResolveTxt);
+    resolve(handle: string): Promise<ResolvedHandle>;
+}
+//# sourceMappingURL=dns-handle-resolver.d.ts.map

package/dist/internal-resolvers/dns-handle-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns-handle-resolver.d.ts","sourceRoot":"","sources":["../../src/internal-resolvers/dns-handle-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAoB,MAAM,UAAU,CAAA;AAK3E;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,GAAG,MAAM,EAAE,CAAC,CAAA;AAEvE,qBAAa,iBAAkB,YAAW,cAAc;IAC1C,SAAS,CAAC,UAAU,EAAE,UAAU;gBAAtB,UAAU,EAAE,UAAU;IAEtC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;CAuBvD"}

package/dist/internal-resolvers/dns-handle-resolver.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsHandleResolver = void 0;
+const types_1 = require("../types");
+const SUBDOMAIN = '_atproto';
+const PREFIX = 'did=';
+class DnsHandleResolver {
+    constructor(resolveTxt) {
+        Object.defineProperty(this, "resolveTxt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: resolveTxt
+        });
+    }
+    async resolve(handle) {
+        const results = await this.resolveTxt.call(null, `${SUBDOMAIN}.${handle}`);
+        if (!results)
+            return null;
+        for (let i = 0; i < results.length; i++) {
+            // If the line does not start with "did=", skip it
+            if (!results[i].startsWith(PREFIX))
+                continue;
+            // Ensure no other entry starting with "did=" follows
+            for (let j = i + 1; j < results.length; j++) {
+                if (results[j].startsWith(PREFIX))
+                    return null;
+            }
+            // Note: No trimming (to be consistent with spec)
+            const did = results[i].slice(PREFIX.length);
+            // Invalid DBS record
+            return (0, types_1.isResolvedHandle)(did) ? did : null;
+        }
+        return null;
+    }
+}
+exports.DnsHandleResolver = DnsHandleResolver;
+//# sourceMappingURL=dns-handle-resolver.js.map

package/dist/internal-resolvers/dns-handle-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns-handle-resolver.js","sourceRoot":"","sources":["../../src/internal-resolvers/dns-handle-resolver.ts"],"names":[],"mappings":";;;AAAA,oCAA2E;AAE3E,MAAM,SAAS,GAAG,UAAU,CAAA;AAC5B,MAAM,MAAM,GAAG,MAAM,CAAA;AAQrB,MAAa,iBAAiB;IAC5B,YAAsB,UAAsB;QAAhC;;;;mBAAU,UAAU;WAAY;IAAG,CAAC;IAEhD,KAAK,CAAC,OAAO,CAAC,MAAc;QAC1B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,SAAS,IAAI,MAAM,EAAE,CAAC,CAAA;QAE1E,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAA;QAEzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,kDAAkD;YAClD,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;gBAAE,SAAQ;YAE5C,qDAAqD;YACrD,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5C,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;oBAAE,OAAO,IAAI,CAAA;YAChD,CAAC;YAED,iDAAiD;YACjD,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;YAE3C,qBAAqB;YACrB,OAAO,IAAA,wBAAgB,EAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAA;QAC3C,CAAC;QAED,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AA1BD,8CA0BC"}

package/dist/internal-resolvers/well-known-handler-resolver.d.ts

@@ -0,0 +1,18 @@
+import { ResolveOptions, HandleResolver, ResolvedHandle } from '../types.js';
+export type WellKnownHandleResolverOptions = {
+    /**
+     * Fetch function to use for HTTP requests. Allows customizing the request
+     * behavior, e.g. adding headers, setting a timeout, mocking, etc. The
+     * provided fetch function will be wrapped with a safeFetchWrap function that
+     * adds SSRF protection.
+     *
+     * @default `globalThis.fetch`
+     */
+    fetch?: typeof globalThis.fetch;
+};
+export declare class WellKnownHandleResolver implements HandleResolver {
+    protected readonly fetch: typeof globalThis.fetch;
+    constructor(options?: WellKnownHandleResolverOptions);
+    resolve(handle: string, options?: ResolveOptions): Promise<ResolvedHandle>;
+}
+//# sourceMappingURL=well-known-handler-resolver.d.ts.map

package/dist/internal-resolvers/well-known-handler-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"well-known-handler-resolver.d.ts","sourceRoot":"","sources":["../../src/internal-resolvers/well-known-handler-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,cAAc,EACd,cAAc,EAEf,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,8BAA8B,GAAG;IAC3C;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;CAChC,CAAA;AAED,qBAAa,uBAAwB,YAAW,cAAc;IAC5D,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;gBAErC,OAAO,CAAC,EAAE,8BAA8B;IAIvC,OAAO,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,cAAc,CAAC;CA0B3B"}

package/dist/{well-known-handler-resolver.js → internal-resolvers/well-known-handler-resolver.js}

@@ -1,28 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WellKnownHandleResolver = void 0;
-const handle_resolver_js_1 = require("./handle-resolver.js");
+const types_js_1 = require("../types.js");
 class WellKnownHandleResolver {
-    constructor({ fetch = globalThis.fetch, } = {}) {
+    constructor(options) {
         Object.defineProperty(this, "fetch", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.fetch = fetch;
+        this.fetch = options?.fetch ?? globalThis.fetch;
     }
     async resolve(handle, options) {
         const url = new URL('/.well-known/atproto-did', `https://${handle}`);
         const headers = new Headers();
         if (options?.noCache)
             headers.set('cache-control', 'no-cache');
-        const request = new Request(url, { headers, signal: options?.signal });
         try {
-            const response = await (0, this.fetch)(request);
+            const response = await this.fetch.call(null, url, {
+                headers,
+                signal: options?.signal,
+                redirect: 'error',
+            });
             const text = await response.text();
             const firstLine = text.split('\n')[0].trim();
-            if ((0, handle_resolver_js_1.isResolvedHandle)(firstLine))
+            if ((0, types_js_1.isResolvedHandle)(firstLine))
                 return firstLine;
             return null;
         }
@@ -30,7 +33,6 @@ class WellKnownHandleResolver {
             // The the request failed, assume the handle does not resolve to a DID,
             // unless the failure was due to the signal being aborted.
             options?.signal?.throwIfAborted();
-            // TODO: propagate some errors as-is (?)
             return null;
         }
     }

package/dist/internal-resolvers/well-known-handler-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"well-known-handler-resolver.js","sourceRoot":"","sources":["../../src/internal-resolvers/well-known-handler-resolver.ts"],"names":[],"mappings":";;;AAAA,0CAKoB;AAcpB,MAAa,uBAAuB;IAGlC,YAAY,OAAwC;QAFjC;;;;;WAA8B;QAG/C,IAAI,CAAC,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,UAAU,CAAC,KAAK,CAAA;IACjD,CAAC;IAEM,KAAK,CAAC,OAAO,CAClB,MAAc,EACd,OAAwB;QAExB,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,0BAA0B,EAAE,WAAW,MAAM,EAAE,CAAC,CAAA;QAEpE,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAA;QAC7B,IAAI,OAAO,EAAE,OAAO;YAAE,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,CAAC,CAAA;QAE9D,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE;gBAChD,OAAO;gBACP,MAAM,EAAE,OAAO,EAAE,MAAM;gBACvB,QAAQ,EAAE,OAAO;aAClB,CAAC,CAAA;YACF,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;YAClC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAE,CAAC,IAAI,EAAE,CAAA;YAE7C,IAAI,IAAA,2BAAgB,EAAC,SAAS,CAAC;gBAAE,OAAO,SAAS,CAAA;YAEjD,OAAO,IAAI,CAAA;QACb,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,uEAAuE;YACvE,0DAA0D;YAC1D,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA;YAEjC,OAAO,IAAI,CAAA;QACb,CAAC;IACH,CAAC;CACF;AApCD,0DAoCC"}

package/dist/{handle-resolver.d.ts → types.d.ts}

@@ -1,9 +1,16 @@
-import { Did } from '@atproto-labs/did';
-export type HandleResolveOptions = {
+import { Did } from '@atproto/did';
+export type ResolveOptions = {
     signal?: AbortSignal;
     noCache?: boolean;
 };
-export type ResolvedHandle = null | Did;
+/**
+ * @see {@link https://atproto.com/specs/did#blessed-did-methods}
+ */
+export type ResolvedHandle = null | Did<'plc' | 'web'>;
+export { type Did };
+/**
+ * @see {@link https://atproto.com/specs/did#blessed-did-methods}
+ */
 export declare function isResolvedHandle<T = unknown>(value: T): value is T & ResolvedHandle;
 export interface HandleResolver {
     /**
@@ -11,8 +18,8 @@ export interface HandleResolver {
      * is found. `null` should only be returned if no unexpected behavior occurred
      * during the resolution process.
      * @throws Error if the resolution method fails due to an unexpected error, or
-     * if the resolution is aborted ({@link HandleResolveOptions.signal}).
+     * if the resolution is aborted ({@link ResolveOptions}).
      */
-    resolve(handle: string, options?: HandleResolveOptions): Promise<ResolvedHandle>;
+    resolve(handle: string, options?: ResolveOptions): Promise<ResolvedHandle>;
 }
-//# sourceMappingURL=handle-resolver.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAA6B,MAAM,cAAc,CAAA;AAE7D,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAA;AAEtD,OAAO,EAAE,KAAK,GAAG,EAAE,CAAA;AAEnB;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,KAAK,EAAE,CAAC,GACP,KAAK,IAAI,CAAC,GAAG,cAAc,CAE7B;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;CAC3E"}

package/dist/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResolvedHandle = void 0;
+const did_1 = require("@atproto/did");
+/**
+ * @see {@link https://atproto.com/specs/did#blessed-did-methods}
+ */
+function isResolvedHandle(value) {
+    return value === null || (0, did_1.isDidPlc)(value) || (0, did_1.isAtprotoDidWeb)(value);
+}
+exports.isResolvedHandle = isResolvedHandle;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,sCAA6D;AAc7D;;GAEG;AACH,SAAgB,gBAAgB,CAC9B,KAAQ;IAER,OAAO,KAAK,KAAK,IAAI,IAAI,IAAA,cAAQ,EAAC,KAAK,CAAC,IAAI,IAAA,qBAAe,EAAC,KAAK,CAAC,CAAA;AACpE,CAAC;AAJD,4CAIC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto-labs/handle-resolver",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "license": "MIT",
   "description": "Isomorphic ATProto handle to DID resolver",
   "keywords": [
@@ -16,7 +16,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/bluesky-social/atproto",
-    "directory": "packages/handle-resolver"
+    "directory": "packages/internal/handle-resolver"
   },
   "type": "commonjs",
   "main": "dist/index.js",
@@ -28,11 +28,10 @@
     }
   },
   "dependencies": {
-    "lru-cache": "^10.2.0",
-    "zod": "^3.22.4",
-    "@atproto-labs/caching": "0.0.1",
-    "@atproto-labs/did": "0.0.1",
-    "@atproto-labs/fetch": "0.0.1"
+    "zod": "^3.23.8",
+    "@atproto-labs/simple-store": "0.1.0",
+    "@atproto-labs/simple-store-memory": "0.1.0",
+    "@atproto/did": "0.1.0"
   },
   "devDependencies": {
     "typescript": "^5.3.3"

package/src/{atproto-lexicon-handle-resolver.ts → app-view-handle-resolver.ts}

@@ -1,61 +1,68 @@
-import { Fetch } from '@atproto-labs/fetch'
 import z from 'zod'
 
 import {
-  HandleResolveOptions,
   HandleResolver,
+  ResolveOptions,
   ResolvedHandle,
   isResolvedHandle,
-} from './handle-resolver.js'
+} from './types.js'
 
 export const xrpcErrorSchema = z.object({
   error: z.string(),
   message: z.string().optional(),
 })
 
-export type AtprotoLexiconHandleResolverOptions = {
+export type AppViewHandleResolverOptions = {
   /**
    * Fetch function to use for HTTP requests. Allows customizing the request
    * behavior, e.g. adding headers, setting a timeout, mocking, etc.
    *
    * @default globalThis.fetch
    */
-  fetch?: Fetch
+  fetch?: typeof globalThis.fetch
+}
+
+export class AppViewHandleResolver implements HandleResolver {
+  static from(
+    service: URL | string | HandleResolver,
+    options?: AppViewHandleResolverOptions,
+  ): HandleResolver {
+    if (typeof service === 'string' || service instanceof URL) {
+      return new AppViewHandleResolver(service, options)
+    }
+    return service
+  }
 
   /**
    * URL of the atproto lexicon server. This is the base URL where the
    * `com.atproto.identity.resolveHandle` XRPC method is located.
-   *
-   * @default 'https://bsky.social'
    */
-  url?: URL | string
-}
+  protected readonly serviceUrl: URL
+  protected readonly fetch: typeof globalThis.fetch
 
-export class AtprotoLexiconHandleResolver implements HandleResolver {
-  protected readonly url: URL
-  protected readonly fetch: Fetch
-
-  constructor({
-    url = 'https://bsky.social/',
-    fetch = globalThis.fetch,
-  }: AtprotoLexiconHandleResolverOptions = {}) {
-    this.url = new URL(url)
-    this.fetch = fetch
+  constructor(service: URL | string, options?: AppViewHandleResolverOptions) {
+    this.serviceUrl = new URL(service)
+    this.fetch = options?.fetch ?? globalThis.fetch
   }
 
   public async resolve(
     handle: string,
-    options?: HandleResolveOptions,
+    options?: ResolveOptions,
   ): Promise<ResolvedHandle> {
-    const url = new URL('/xrpc/com.atproto.identity.resolveHandle', this.url)
+    const url = new URL(
+      '/xrpc/com.atproto.identity.resolveHandle',
+      this.serviceUrl,
+    )
     url.searchParams.set('handle', handle)
 
     const headers = new Headers()
     if (options?.noCache) headers.set('cache-control', 'no-cache')
 
-    const request = new Request(url, { headers, signal: options?.signal })
-
-    const response = await this.fetch.call(null, request)
+    const response = await this.fetch.call(null, url, {
+      headers,
+      signal: options?.signal,
+      redirect: 'error',
+    })
     const payload = await response.json()
 
     // The response should either be
@@ -74,13 +81,13 @@ export class AtprotoLexiconHandleResolver implements HandleResolver {
     }
 
     if (!response.ok) {
-      throw new Error('Invalid response from resolveHandle method')
+      throw new TypeError('Invalid response from resolveHandle method')
     }
 
     const value: unknown = payload?.did
 
-    if (!value || !isResolvedHandle(value)) {
-      throw new Error('Invalid DID returned from resolveHandle method')
+    if (!isResolvedHandle(value)) {
+      throw new TypeError('Invalid DID returned from resolveHandle method')
     }
 
     return value

package/src/atproto-doh-handle-resolver.ts

@@ -0,0 +1,123 @@
+import {
+  AtprotoHandleResolver,
+  AtprotoHandleResolverOptions,
+} from './atproto-handle-resolver.js'
+import { HandleResolver } from './types.js'
+import { ResolveTxt } from './internal-resolvers/dns-handle-resolver.js'
+
+export type AtprotoDohHandleResolverOptions = Omit<
+  AtprotoHandleResolverOptions,
+  'resolveTxt' | 'resolveTxtFallback'
+> & {
+  dohEndpoint: string | URL
+}
+
+export class AtprotoDohHandleResolver
+  extends AtprotoHandleResolver
+  implements HandleResolver
+{
+  constructor(options: AtprotoDohHandleResolverOptions) {
+    super({
+      ...options,
+      resolveTxt: dohResolveTxtFactory(options),
+      resolveTxtFallback: undefined,
+    })
+  }
+}
+
+/**
+ * Resolver for DNS-over-HTTPS (DoH) handles. Only works with servers supporting
+ * Google Flavoured "application/dns-json" queries.
+ *
+ * @see {@link https://developers.google.com/speed/public-dns/docs/doh/json}
+ * @see {@link https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/make-api-requests/dns-json/}
+ * @todo Add support for DoH using application/dns-message (?)
+ */
+function dohResolveTxtFactory({
+  dohEndpoint,
+  fetch = globalThis.fetch,
+}: AtprotoDohHandleResolverOptions): ResolveTxt {
+  return async (hostname) => {
+    const url = new URL(dohEndpoint)
+    url.searchParams.set('type', 'TXT')
+    url.searchParams.set('name', hostname)
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { accept: 'application/dns-json' },
+      redirect: 'follow',
+    })
+    try {
+      const contentType = response.headers.get('content-type')?.trim()
+      if (!response.ok) {
+        const message = contentType?.startsWith('text/plain')
+          ? await response.text()
+          : `Failed to resolve ${hostname}`
+        throw new TypeError(message)
+      } else if (contentType !== 'application/dns-json') {
+        throw new TypeError('Unexpected response from DoH server')
+      }
+
+      const result = asResult(await response.json())
+      return result.Answer?.filter(isAnswerTxt).map(extractTxtData) ?? null
+    } finally {
+      // Make sure to always cancel the response body as some engines (Node 👀)
+      // do not do this automatically.
+      // https://undici.nodejs.org/#/?id=garbage-collection
+      if (response.bodyUsed === false) {
+        // Handle rejection asynchronously
+        void response.body?.cancel().catch(onCancelError)
+      }
+    }
+  }
+}
+
+function onCancelError(err: unknown) {
+  if (!(err instanceof DOMException) || err.name !== 'AbortError') {
+    console.error('An error occurred while cancelling the response body:', err)
+  }
+}
+
+type Result = { Status: number; Answer?: Answer[] }
+function isResult(result: unknown): result is Result {
+  if (typeof result !== 'object' || result === null) return false
+  if (!('Status' in result) || typeof result.Status !== 'number') return false
+  if ('Answer' in result && !isArrayOf(result.Answer, isAnswer)) return false
+  return true
+}
+function asResult(result: unknown): Result {
+  if (isResult(result)) return result
+  throw new TypeError('Invalid DoH response')
+}
+
+function isArrayOf<T>(
+  value: unknown,
+  predicate: (v: unknown) => v is T,
+): value is T[] {
+  return Array.isArray(value) && value.every(predicate)
+}
+
+type Answer = { name: string; type: number; data: string; TTL: number }
+function isAnswer(answer: unknown): answer is Answer {
+  return (
+    typeof answer === 'object' &&
+    answer !== null &&
+    'name' in answer &&
+    typeof answer.name === 'string' &&
+    'type' in answer &&
+    typeof answer.type === 'number' &&
+    'data' in answer &&
+    typeof answer.data === 'string' &&
+    'TTL' in answer &&
+    typeof answer.TTL === 'number'
+  )
+}
+
+type AnswerTxt = Answer & { type: 16 }
+function isAnswerTxt(answer: Answer): answer is AnswerTxt {
+  return answer.type === 16
+}
+
+function extractTxtData(answer: AnswerTxt): string {
+  return answer.data.replace(/^"|"$/g, '').replace(/\\"/g, '"')
+}

package/src/atproto-handle-resolver.ts

@@ -0,0 +1,75 @@
+import {
+  DnsHandleResolver,
+  ResolveTxt,
+} from './internal-resolvers/dns-handle-resolver.js'
+import {
+  WellKnownHandleResolver,
+  WellKnownHandleResolverOptions,
+} from './internal-resolvers/well-known-handler-resolver.js'
+import { HandleResolver, ResolveOptions, ResolvedHandle } from './types.js'
+
+export type { ResolveTxt }
+export type AtprotoHandleResolverOptions = WellKnownHandleResolverOptions & {
+  resolveTxt: ResolveTxt
+  resolveTxtFallback?: ResolveTxt
+}
+
+const noop = () => {}
+
+/**
+ * Implementation of the official ATPROTO handle resolution strategy.
+ * This implementation relies on two primitives:
+ * - HTTP Well-Known URI resolution (requires a `fetch()` implementation)
+ * - DNS TXT record resolution (requires a `resolveTxt()` function)
+ */
+export class AtprotoHandleResolver implements HandleResolver {
+  private readonly httpResolver: HandleResolver
+  private readonly dnsResolver: HandleResolver
+  private readonly dnsResolverFallback?: HandleResolver
+
+  constructor(options: AtprotoHandleResolverOptions) {
+    this.httpResolver = new WellKnownHandleResolver(options)
+    this.dnsResolver = new DnsHandleResolver(options.resolveTxt)
+    this.dnsResolverFallback = options.resolveTxtFallback
+      ? new DnsHandleResolver(options.resolveTxtFallback)
+      : undefined
+  }
+
+  async resolve(
+    handle: string,
+    options?: ResolveOptions,
+  ): Promise<ResolvedHandle> {
+    options?.signal?.throwIfAborted()
+
+    const abortController = new AbortController()
+    const { signal } = abortController
+    options?.signal?.addEventListener('abort', () => abortController.abort(), {
+      signal,
+    })
+
+    const wrappedOptions = { ...options, signal }
+
+    try {
+      const dnsPromise = this.dnsResolver.resolve(handle, wrappedOptions)
+      const httpPromise = this.httpResolver.resolve(handle, wrappedOptions)
+
+      // Prevent uncaught promise rejection
+      httpPromise.catch(noop)
+
+      const dnsRes = await dnsPromise
+      if (dnsRes) return dnsRes
+
+      signal.throwIfAborted()
+
+      const res = await httpPromise
+      if (res) return res
+
+      signal.throwIfAborted()
+
+      return this.dnsResolverFallback?.resolve(handle, wrappedOptions) ?? null
+    } finally {
+      // Cancel pending requests, and remove "abort" listener on incoming signal
+      abortController.abort()
+    }
+  }
+}

package/src/cached-handle-resolver.ts

@@ -1,40 +1,32 @@
-import { CachedGetter, GenericStore, MemoryStore } from '@atproto-labs/caching'
-import {
-  HandleResolveOptions,
-  HandleResolver,
-  ResolvedHandle,
-} from './handle-resolver.js'
+import { CachedGetter, SimpleStore } from '@atproto-labs/simple-store'
+import { SimpleStoreMemory } from '@atproto-labs/simple-store-memory'
+import { ResolveOptions, HandleResolver, ResolvedHandle } from './types.js'
 
-export type CachedHandleResolverOptions = {
-  /**
-   * The resolver that will be used to resolve handles.
-   */
-  resolver: HandleResolver
+export type HandleCache = SimpleStore<string, ResolvedHandle>
 
-  /**
-   * A store that will be used to cache resolved values.
-   */
-  cache?: GenericStore<string, ResolvedHandle>
-}
+export class CachedHandleResolver implements HandleResolver {
+  private getter: CachedGetter<string, ResolvedHandle>
 
-export class CachedHandleResolver
-  extends CachedGetter<string, ResolvedHandle>
-  implements HandleResolver
-{
-  constructor({
-    resolver,
-    cache = new MemoryStore<string, ResolvedHandle>({
+  constructor(
+    /**
+     * The resolver that will be used to resolve handles.
+     */
+    resolver: HandleResolver,
+    cache: HandleCache = new SimpleStoreMemory<string, ResolvedHandle>({
       max: 1000,
       ttl: 10 * 60e3,
     }),
-  }: CachedHandleResolverOptions) {
-    super((handle, options) => resolver.resolve(handle, options), cache)
+  ) {
+    this.getter = new CachedGetter<string, ResolvedHandle>(
+      (handle, options) => resolver.resolve(handle, options),
+      cache,
+    )
   }
 
   async resolve(
     handle: string,
-    options?: HandleResolveOptions,
+    options?: ResolveOptions,
   ): Promise<ResolvedHandle> {
-    return this.get(handle, options)
+    return this.getter.get(handle, options)
   }
 }

package/src/index.ts

@@ -1,11 +1,9 @@
-export * from './handle-resolver.js'
+export * from './types.js'
 
-// Main export
-export * from './universal-handle-resolver.js'
-export { UniversalHandleResolver as default } from './universal-handle-resolver.js'
+// Main Handle Resolvers strategies
+export * from './app-view-handle-resolver.js'
+export * from './atproto-doh-handle-resolver.js'
+export * from './atproto-handle-resolver.js'
 
-// Utilities
+// Handle Resolver Caching utility
 export * from './cached-handle-resolver.js'
-export * from './atproto-lexicon-handle-resolver.js'
-export * from './serial-handle-resolver.js'
-export * from './well-known-handler-resolver.js'

package/src/internal-resolvers/dns-handle-resolver.ts

@@ -0,0 +1,38 @@
+import { HandleResolver, ResolvedHandle, isResolvedHandle } from '../types'
+
+const SUBDOMAIN = '_atproto'
+const PREFIX = 'did='
+
+/**
+ * DNS TXT record resolver. Return `null` if the hostname successfully does not
+ * resolve to a valid DID. Throw an error if an unexpected error occurs.
+ */
+export type ResolveTxt = (hostname: string) => Promise<null | string[]>
+
+export class DnsHandleResolver implements HandleResolver {
+  constructor(protected resolveTxt: ResolveTxt) {}
+
+  async resolve(handle: string): Promise<ResolvedHandle> {
+    const results = await this.resolveTxt.call(null, `${SUBDOMAIN}.${handle}`)
+
+    if (!results) return null
+
+    for (let i = 0; i < results.length; i++) {
+      // If the line does not start with "did=", skip it
+      if (!results[i].startsWith(PREFIX)) continue
+
+      // Ensure no other entry starting with "did=" follows
+      for (let j = i + 1; j < results.length; j++) {
+        if (results[j].startsWith(PREFIX)) return null
+      }
+
+      // Note: No trimming (to be consistent with spec)
+      const did = results[i].slice(PREFIX.length)
+
+      // Invalid DBS record
+      return isResolvedHandle(did) ? did : null
+    }
+
+    return null
+  }
+}