@atproto/identity 0.5.2 → 0.5.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atproto/identity
 
+## 0.5.3
+
+### Patch Changes
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add missing `@types` dependencies
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update TypeScript build to rely on references to composite internal projects
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Bundle only necessary files in the NPM tarball, including the `CHANGELOG.md` and `README.md` files (if present).
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Build with `noImplicitAny` enabled
+
+- Updated dependencies [[`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07)]:
+  - @atproto/common-web@0.5.3
+  - @atproto/crypto@0.5.3
+
 ## 0.5.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/identity",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "license": "MIT",
   "description": "Library for decentralized identities in atproto using DIDs and handles",
   "keywords": [
@@ -14,29 +14,36 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/identity"
   },
+  "files": [
+    "./dist",
+    "./README.md",
+    "./CHANGELOG.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
-    "@atproto/crypto": "^0.5.2",
-    "@atproto/common-web": "^0.5.2"
+    "@atproto/common-web": "^0.5.3",
+    "@atproto/crypto": "^0.5.3"
   },
   "devDependencies": {
     "@did-plc/lib": "^0.0.1",
     "@did-plc/server": "^0.0.1",
     "@jest/globals": "^30.0.0",
+    "@types/express": "^4.17.21",
+    "@types/cors": "^2.8.19",
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "get-port": "^6.1.2",
     "jest": "^30.0.0"
   },
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
   "scripts": {
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
     "test:log": "cat test.log | pino-pretty",

package/jest.config.cjs

@@ -1,21 +0,0 @@
-/** @type {import('jest').Config} */
-module.exports = {
-  displayName: 'Identity',
-  transform: {
-    '^.+\\.(t|j)s$': [
-      '@swc/jest',
-      {
-        jsc: {
-          parser: { syntax: 'typescript', importAttributes: true },
-          experimental: { keepImportAttributes: true },
-          transform: {},
-        },
-        module: { type: 'es6' },
-      },
-    ],
-  },
-  extensionsToTreatAsEsm: ['.ts'],
-  transformIgnorePatterns: [],
-  setupFiles: ['<rootDir>/../../test.setup.ts'],
-  moduleNameMapper: { '^(\\.\\.?\\/.+)\\.js$': ['$1.ts', '$1.js'] },
-}

package/src/did/atproto-data.ts

@@ -1,78 +0,0 @@
-import {
-  getDid,
-  getFeedGenEndpoint,
-  getHandle,
-  getNotifEndpoint,
-  getPdsEndpoint,
-  getSigningKey,
-} from '@atproto/common-web'
-import * as crypto from '@atproto/crypto'
-import { AtprotoData, DidDocument } from '../types.js'
-
-export {
-  getDid,
-  getFeedGenEndpoint as getFeedGen,
-  getHandle,
-  getNotifEndpoint as getNotif,
-  getPdsEndpoint as getPds,
-}
-
-export const getKey = (doc: DidDocument): string | undefined => {
-  const key = getSigningKey(doc)
-  if (!key) return undefined
-  return getDidKeyFromMultibase(key)
-}
-
-export const getDidKeyFromMultibase = (key: {
-  type: string
-  publicKeyMultibase: string
-}): string | undefined => {
-  const keyBytes = crypto.multibaseToBytes(key.publicKeyMultibase)
-  let didKey: string | undefined = undefined
-  if (key.type === 'EcdsaSecp256r1VerificationKey2019') {
-    didKey = crypto.formatDidKey(crypto.P256_JWT_ALG, keyBytes)
-  } else if (key.type === 'EcdsaSecp256k1VerificationKey2019') {
-    didKey = crypto.formatDidKey(crypto.SECP256K1_JWT_ALG, keyBytes)
-  } else if (key.type === 'Multikey') {
-    const parsed = crypto.parseMultikey(key.publicKeyMultibase)
-    didKey = crypto.formatDidKey(parsed.jwtAlg, parsed.keyBytes)
-  }
-  return didKey
-}
-
-export const parseToAtprotoDocument = (
-  doc: DidDocument,
-): Partial<AtprotoData> => {
-  const did = getDid(doc)
-  return {
-    did,
-    signingKey: getKey(doc),
-    handle: getHandle(doc),
-    pds: getPdsEndpoint(doc),
-  }
-}
-
-export const ensureAtpDocument = (doc: DidDocument): AtprotoData => {
-  const { did, signingKey, handle, pds } = parseToAtprotoDocument(doc)
-  if (!did) {
-    throw new Error(`Could not parse id from doc: ${doc}`)
-  }
-  if (!signingKey) {
-    throw new Error(`Could not parse signingKey from doc: ${doc}`)
-  }
-  if (!handle) {
-    throw new Error(`Could not parse handle from doc: ${doc}`)
-  }
-  if (!pds) {
-    throw new Error(`Could not parse pds from doc: ${doc}`)
-  }
-  return { did, signingKey, handle, pds }
-}
-
-export const ensureAtprotoKey = (doc: DidDocument): string => {
-  const { signingKey } = parseToAtprotoDocument(doc)
-  if (!signingKey) {
-    throw new Error(`Could not parse signingKey from doc: ${doc}`)
-  }
-  return signingKey
-}

package/src/did/base-resolver.ts

@@ -1,100 +0,0 @@
-import { check } from '@atproto/common-web'
-import * as crypto from '@atproto/crypto'
-import { DidNotFoundError, PoorlyFormattedDidDocumentError } from '../errors.js'
-import {
-  AtprotoData,
-  CacheResult,
-  DidCache,
-  DidDocument,
-  didDocument,
-} from '../types.js'
-import * as atprotoData from './atproto-data.js'
-
-export abstract class BaseResolver {
-  constructor(public cache?: DidCache) {}
-
-  abstract resolveNoCheck(did: string): Promise<unknown | null>
-
-  validateDidDoc(did: string, val: unknown): DidDocument {
-    if (!check.is(val, didDocument)) {
-      throw new PoorlyFormattedDidDocumentError(did, val)
-    }
-    if (val.id !== did) {
-      throw new PoorlyFormattedDidDocumentError(did, val)
-    }
-    return val
-  }
-
-  async resolveNoCache(did: string): Promise<DidDocument | null> {
-    const got = await this.resolveNoCheck(did)
-    if (got === null) return null
-    return this.validateDidDoc(did, got)
-  }
-
-  async refreshCache(did: string, prevResult?: CacheResult): Promise<void> {
-    await this.cache?.refreshCache(
-      did,
-      () => this.resolveNoCache(did),
-      prevResult,
-    )
-  }
-
-  async resolve(
-    did: string,
-    forceRefresh = false,
-  ): Promise<DidDocument | null> {
-    let fromCache: CacheResult | null = null
-    if (this.cache && !forceRefresh) {
-      fromCache = await this.cache.checkCache(did)
-      if (fromCache && !fromCache.expired) {
-        if (fromCache?.stale) {
-          await this.refreshCache(did, fromCache)
-        }
-        return fromCache.doc
-      }
-    }
-
-    const got = await this.resolveNoCache(did)
-    if (got === null) {
-      await this.cache?.clearEntry(did)
-      return null
-    }
-    await this.cache?.cacheDid(did, got, fromCache ?? undefined)
-    return got
-  }
-
-  async ensureResolve(did: string, forceRefresh = false): Promise<DidDocument> {
-    const result = await this.resolve(did, forceRefresh)
-    if (result === null) {
-      throw new DidNotFoundError(did)
-    }
-    return result
-  }
-
-  async resolveAtprotoData(
-    did: string,
-    forceRefresh = false,
-  ): Promise<AtprotoData> {
-    const didDocument = await this.ensureResolve(did, forceRefresh)
-    return atprotoData.ensureAtpDocument(didDocument)
-  }
-
-  async resolveAtprotoKey(did: string, forceRefresh = false): Promise<string> {
-    if (did.startsWith('did:key:')) {
-      return did
-    } else {
-      const didDocument = await this.ensureResolve(did, forceRefresh)
-      return atprotoData.ensureAtprotoKey(didDocument)
-    }
-  }
-
-  async verifySignature(
-    did: string,
-    data: Uint8Array,
-    sig: Uint8Array,
-    forceRefresh = false,
-  ): Promise<boolean> {
-    const signingKey = await this.resolveAtprotoKey(did, forceRefresh)
-    return crypto.verifySignature(signingKey, data, sig)
-  }
-}

package/src/did/did-resolver.ts

@@ -1,38 +0,0 @@
-import {
-  PoorlyFormattedDidError,
-  UnsupportedDidMethodError,
-} from '../errors.js'
-import { DidResolverOpts } from '../types.js'
-import { BaseResolver } from './base-resolver.js'
-import { DidPlcResolver } from './plc-resolver.js'
-import { DidWebResolver } from './web-resolver.js'
-
-export class DidResolver extends BaseResolver {
-  methods: Map<string, BaseResolver>
-
-  constructor(opts: DidResolverOpts) {
-    super(opts.didCache)
-    const { timeout = 3000, plcUrl = 'https://plc.directory' } = opts
-    // do not pass cache to sub-methods or we will be double caching
-    this.methods = new Map([
-      ['plc', new DidPlcResolver(plcUrl, timeout)],
-      ['web', new DidWebResolver(timeout)],
-    ])
-  }
-
-  async resolveNoCheck(did: string): Promise<unknown> {
-    if (!did.startsWith('did:')) {
-      throw new PoorlyFormattedDidError(did)
-    }
-    const methodSepIdx = did.indexOf(':', 4)
-    if (methodSepIdx === -1) {
-      throw new PoorlyFormattedDidError(did)
-    }
-    const methodName = did.slice(4, methodSepIdx)
-    const method = this.methods.get(methodName)
-    if (!method) {
-      throw new UnsupportedDidMethodError(did)
-    }
-    return method.resolveNoCheck(did)
-  }
-}

package/src/did/index.ts

@@ -1,5 +0,0 @@
-export * from './web-resolver.js'
-export * from './plc-resolver.js'
-export * from './did-resolver.js'
-export * from './atproto-data.js'
-export * from './memory-cache.js'

package/src/did/memory-cache.ts

@@ -1,54 +0,0 @@
-import { DAY, HOUR } from '@atproto/common-web'
-import { CacheResult, DidCache, DidDocument } from '../types.js'
-
-type CacheVal = {
-  doc: DidDocument
-  updatedAt: number
-}
-
-export class MemoryCache implements DidCache {
-  public staleTTL: number
-  public maxTTL: number
-  constructor(staleTTL?: number, maxTTL?: number) {
-    this.staleTTL = staleTTL ?? HOUR
-    this.maxTTL = maxTTL ?? DAY
-  }
-
-  public cache: Map<string, CacheVal> = new Map()
-
-  async cacheDid(did: string, doc: DidDocument): Promise<void> {
-    this.cache.set(did, { doc, updatedAt: Date.now() })
-  }
-
-  async refreshCache(
-    did: string,
-    getDoc: () => Promise<DidDocument | null>,
-  ): Promise<void> {
-    const doc = await getDoc()
-    if (doc) {
-      await this.cacheDid(did, doc)
-    }
-  }
-
-  async checkCache(did: string): Promise<CacheResult | null> {
-    const val = this.cache.get(did)
-    if (!val) return null
-    const now = Date.now()
-    const expired = now > val.updatedAt + this.maxTTL
-    const stale = now > val.updatedAt + this.staleTTL
-    return {
-      ...val,
-      did,
-      stale,
-      expired,
-    }
-  }
-
-  async clearEntry(did: string): Promise<void> {
-    this.cache.delete(did)
-  }
-
-  async clear(): Promise<void> {
-    this.cache.clear()
-  }
-}

package/src/did/plc-resolver.ts

@@ -1,33 +0,0 @@
-import { DidCache } from '../types.js'
-import { BaseResolver } from './base-resolver.js'
-import { timed } from './util.js'
-
-export class DidPlcResolver extends BaseResolver {
-  constructor(
-    public plcUrl: string,
-    public timeout: number,
-    public cache?: DidCache,
-  ) {
-    super(cache)
-  }
-
-  async resolveNoCheck(did: string): Promise<unknown> {
-    return timed(this.timeout, async (signal) => {
-      const url = new URL(`/${encodeURIComponent(did)}`, this.plcUrl)
-      const res = await fetch(url, {
-        redirect: 'error',
-        headers: { accept: 'application/did+ld+json,application/json' },
-        signal,
-      })
-
-      // Positively not found, versus due to e.g. network error
-      if (res.status === 404) return null
-
-      if (!res.ok) {
-        throw Object.assign(new Error(res.statusText), { status: res.status })
-      }
-
-      return res.json()
-    })
-  }
-}

package/src/did/util.ts

@@ -1,15 +0,0 @@
-export async function timed<F extends (signal: AbortSignal) => unknown>(
-  ms: number,
-  fn: F,
-): Promise<Awaited<ReturnType<F>>> {
-  const abortController = new AbortController()
-  const timer = setTimeout(() => abortController.abort(), ms)
-  const signal = abortController.signal
-
-  try {
-    return (await fn(signal)) as Awaited<ReturnType<F>>
-  } finally {
-    clearTimeout(timer)
-    abortController.abort()
-  }
-}

package/src/did/web-resolver.ts

@@ -1,51 +0,0 @@
-import {
-  PoorlyFormattedDidError,
-  UnsupportedDidWebPathError,
-} from '../errors.js'
-import { DidCache } from '../types.js'
-import { BaseResolver } from './base-resolver.js'
-import { timed } from './util.js'
-
-export const DOC_PATH = '/.well-known/did.json'
-
-export class DidWebResolver extends BaseResolver {
-  constructor(
-    public timeout: number,
-    public cache?: DidCache,
-  ) {
-    super(cache)
-  }
-
-  async resolveNoCheck(did: string): Promise<unknown> {
-    const parsedId = did.split(':').slice(2).join(':')
-    const parts = parsedId.split(':').map(decodeURIComponent)
-    let path: string
-    if (parts.length < 1) {
-      throw new PoorlyFormattedDidError(did)
-    } else if (parts.length === 1) {
-      path = parts[0] + DOC_PATH
-    } else {
-      // how we *would* resolve a did:web with path, if atproto supported it
-      //path = parts.join('/') + '/did.json'
-      throw new UnsupportedDidWebPathError(did)
-    }
-
-    const url = new URL(`https://${path}`)
-    if (url.hostname === 'localhost') {
-      url.protocol = 'http'
-    }
-
-    return timed(this.timeout, async (signal) => {
-      const res = await fetch(url, {
-        signal,
-        redirect: 'error',
-        headers: { accept: 'application/did+ld+json,application/json' },
-      })
-
-      // Positively not found, versus due to e.g. network error
-      if (!res.ok) return null
-
-      return res.json()
-    })
-  }
-}

package/src/errors.ts

@@ -1,32 +0,0 @@
-export class DidNotFoundError extends Error {
-  constructor(public did: string) {
-    super(`Could not resolve DID: ${did}`)
-  }
-}
-
-export class PoorlyFormattedDidError extends Error {
-  constructor(public did: string) {
-    super(`Poorly formatted DID: ${did}`)
-  }
-}
-
-export class UnsupportedDidMethodError extends Error {
-  constructor(public did: string) {
-    super(`Unsupported DID method: ${did}`)
-  }
-}
-
-export class PoorlyFormattedDidDocumentError extends Error {
-  constructor(
-    public did: string,
-    public doc: unknown,
-  ) {
-    super(`Poorly formatted DID Document: ${doc}`)
-  }
-}
-
-export class UnsupportedDidWebPathError extends Error {
-  constructor(public did: string) {
-    super(`Unsupported did:web paths: ${did}`)
-  }
-}

package/src/handle/index.ts

@@ -1,102 +0,0 @@
-import * as dns from 'node:dns/promises'
-import { HandleResolverOpts } from '../types.js'
-
-const SUBDOMAIN = '_atproto'
-const PREFIX = 'did='
-
-export class HandleResolver {
-  public timeout: number
-  private backupNameservers: string[] | undefined
-  private backupNameserverIps: string[] | undefined
-
-  constructor(opts: HandleResolverOpts = {}) {
-    this.timeout = opts.timeout ?? 3000
-    this.backupNameservers = opts.backupNameservers
-  }
-
-  async resolve(handle: string): Promise<string | undefined> {
-    const dnsPromise = this.resolveDns(handle)
-    const httpAbort = new AbortController()
-    const httpPromise = this.resolveHttp(handle, httpAbort.signal).catch(
-      () => undefined,
-    )
-
-    const dnsRes = await dnsPromise
-    if (dnsRes) {
-      httpAbort.abort()
-      return dnsRes
-    }
-    const res = await httpPromise
-    if (res) {
-      return res
-    }
-    return this.resolveDnsBackup(handle)
-  }
-
-  async resolveDns(handle: string): Promise<string | undefined> {
-    let chunkedResults: string[][]
-    try {
-      chunkedResults = await dns.resolveTxt(`${SUBDOMAIN}.${handle}`)
-    } catch (err) {
-      return undefined
-    }
-    return this.parseDnsResult(chunkedResults)
-  }
-
-  async resolveHttp(
-    handle: string,
-    signal?: AbortSignal,
-  ): Promise<string | undefined> {
-    const url = new URL('/.well-known/atproto-did', `https://${handle}`)
-    try {
-      const res = await fetch(url, { signal })
-      const did = (await res.text()).split('\n')[0].trim()
-      if (typeof did === 'string' && did.startsWith('did:')) {
-        return did
-      }
-      return undefined
-    } catch (err) {
-      return undefined
-    }
-  }
-
-  async resolveDnsBackup(handle: string): Promise<string | undefined> {
-    let chunkedResults: string[][]
-    try {
-      const backupIps = await this.getBackupNameserverIps()
-      if (!backupIps || backupIps.length < 1) return undefined
-      const resolver = new dns.Resolver()
-      resolver.setServers(backupIps)
-      chunkedResults = await resolver.resolveTxt(`${SUBDOMAIN}.${handle}`)
-    } catch (err) {
-      return undefined
-    }
-    return this.parseDnsResult(chunkedResults)
-  }
-
-  parseDnsResult(chunkedResults: string[][]): string | undefined {
-    const results = chunkedResults.map((chunks) => chunks.join(''))
-    const found = results.filter((i) => i.startsWith(PREFIX))
-    if (found.length !== 1) {
-      return undefined
-    }
-    return found[0].slice(PREFIX.length)
-  }
-
-  private async getBackupNameserverIps(): Promise<string[] | undefined> {
-    if (!this.backupNameservers) {
-      return undefined
-    } else if (!this.backupNameserverIps) {
-      const responses = await Promise.allSettled(
-        this.backupNameservers.map((h) => dns.lookup(h)),
-      )
-      for (const res of responses) {
-        if (res.status === 'fulfilled') {
-          this.backupNameserverIps ??= []
-          this.backupNameserverIps.push(res.value.address)
-        }
-      }
-    }
-    return this.backupNameserverIps
-  }
-}

package/src/id-resolver.ts

@@ -1,17 +0,0 @@
-import { DidResolver } from './did/did-resolver.js'
-import { HandleResolver } from './handle/index.js'
-import { IdentityResolverOpts } from './types.js'
-
-export class IdResolver {
-  public handle: HandleResolver
-  public did: DidResolver
-
-  constructor(opts: IdentityResolverOpts = {}) {
-    const { timeout = 3000, plcUrl, didCache } = opts
-    this.handle = new HandleResolver({
-      timeout,
-      backupNameservers: opts.backupNameservers,
-    })
-    this.did = new DidResolver({ timeout, plcUrl, didCache })
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './did/index.js'
-export * from './handle/index.js'
-export * from './id-resolver.js'
-export * from './errors.js'
-export * from './types.js'

package/src/types.ts

@@ -1,53 +0,0 @@
-import { DidDocument } from '@atproto/common-web'
-
-export { didDocument } from '@atproto/common-web'
-export type { DidDocument } from '@atproto/common-web'
-
-export type IdentityResolverOpts = {
-  timeout?: number
-  plcUrl?: string
-  didCache?: DidCache
-  backupNameservers?: string[]
-}
-
-export type HandleResolverOpts = {
-  timeout?: number
-  backupNameservers?: string[]
-}
-
-export type DidResolverOpts = {
-  timeout?: number
-  plcUrl?: string
-  didCache?: DidCache
-}
-
-export type AtprotoData = {
-  did: string
-  signingKey: string
-  handle: string
-  pds: string
-}
-
-export type CacheResult = {
-  did: string
-  doc: DidDocument
-  updatedAt: number
-  stale: boolean
-  expired: boolean
-}
-
-export interface DidCache {
-  cacheDid(
-    did: string,
-    doc: DidDocument,
-    prevResult?: CacheResult,
-  ): Promise<void>
-  checkCache(did: string): Promise<CacheResult | null>
-  refreshCache(
-    did: string,
-    getDoc: () => Promise<DidDocument | null>,
-    prevResult?: CacheResult,
-  ): Promise<void>
-  clearEntry(did: string): Promise<void>
-  clear(): Promise<void>
-}

package/test.env

@@ -1,2 +0,0 @@
-LOG_ENABLED=true
-LOG_DESTINATION=test.log

package/tests/did-cache.test.ts

@@ -1,103 +0,0 @@
-import * as plc from '@did-plc/lib'
-import { Database as DidPlcDb, PlcServer } from '@did-plc/server'
-import getPort from 'get-port'
-import { wait } from '@atproto/common-web'
-import { Secp256k1Keypair } from '@atproto/crypto'
-import { MemoryCache } from '../src/did/memory-cache.js'
-import { DidResolver } from '../src/index.js'
-
-describe('did cache', () => {
-  let close: () => Promise<void>
-  let plcUrl: string
-  let did: string
-
-  let didCache: MemoryCache
-  let didResolver: DidResolver
-
-  beforeAll(async () => {
-    const plcDB = DidPlcDb.mock()
-    const plcPort = await getPort()
-    const plcServer = PlcServer.create({ db: plcDB, port: plcPort })
-    await plcServer.start()
-
-    plcUrl = 'http://localhost:' + plcPort
-
-    const signingKey = await Secp256k1Keypair.create()
-    const rotationKey = await Secp256k1Keypair.create()
-    const plcClient = new plc.Client(plcUrl)
-    did = await plcClient.createDid({
-      signingKey: signingKey.did(),
-      handle: 'alice.test',
-      pds: 'https://bsky.social',
-      rotationKeys: [rotationKey.did()],
-      signer: rotationKey,
-    })
-
-    didCache = new MemoryCache()
-    didResolver = new DidResolver({ plcUrl, didCache })
-
-    close = async () => {
-      await plcServer.destroy()
-    }
-  })
-
-  afterAll(async () => {
-    await close()
-  })
-
-  it('caches dids on lookup', async () => {
-    const resolved = await didResolver.resolve(did)
-    expect(resolved?.id).toBe(did)
-
-    const cached = await didResolver.cache?.checkCache(did)
-    expect(cached?.did).toBe(did)
-    expect(cached?.doc).toEqual(resolved)
-  })
-
-  it('clears cache and repopulates', async () => {
-    await didResolver.cache?.clear()
-    await didResolver.resolve(did)
-
-    const cached = await didResolver.cache?.checkCache(did)
-    expect(cached?.did).toBe(did)
-    expect(cached?.doc.id).toEqual(did)
-  })
-
-  it('accurately reports stale dids & refreshes the cache', async () => {
-    const didCache = new MemoryCache(1)
-    const shortCacheResolver = new DidResolver({ plcUrl, didCache })
-    const doc = await shortCacheResolver.resolve(did)
-
-    // let's mess with the cached doc so we get something different
-    await didCache.cacheDid(did, { ...doc, id: 'did:example:alice' })
-    await wait(5)
-
-    // first check the cache & see that we have the stale value
-    const cached = await shortCacheResolver.cache?.checkCache(did)
-    expect(cached?.stale).toBe(true)
-    expect(cached?.doc.id).toEqual('did:example:alice')
-    // see that the resolver gives us the stale value while it revalidates
-    const staleGet = await shortCacheResolver.resolve(did)
-    expect(staleGet?.id).toEqual('did:example:alice')
-
-    // since it revalidated, ensure we have the new value
-    const updatedCache = await shortCacheResolver.cache?.checkCache(did)
-    expect(updatedCache?.doc.id).toEqual(did)
-    const updatedGet = await shortCacheResolver.resolve(did)
-    expect(updatedGet?.id).toEqual(did)
-  })
-
-  it('does not return expired dids & refreshes the cache', async () => {
-    const didCache = new MemoryCache(0, 1)
-    const shortExpireResolver = new DidResolver({ plcUrl, didCache })
-    const doc = await shortExpireResolver.resolve(did)
-
-    // again, we mess with the cached doc so we get something different
-    await didCache.cacheDid(did, { ...doc, id: 'did:example:alice' })
-    await wait(5)
-
-    // see that the resolver does not return expired value & instead force refreshes
-    const staleGet = await shortExpireResolver.resolve(did)
-    expect(staleGet?.id).toEqual(did)
-  })
-})

package/tests/did-document.test.ts

@@ -1,103 +0,0 @@
-import { DidResolver, ensureAtpDocument } from '../src/index.js'
-
-describe('did parsing', () => {
-  it('throws on bad DID document', async () => {
-    const did = 'did:plc:yk4dd2qkboz2yv6tpubpc6co'
-    const docJson = `{
-  "ideep": "did:plc:yk4dd2qkboz2yv6tpubpc6co",
-  "blah": [
-    "https://dholms.xyz"
-  ],
-  "zoot": [
-    {
-      "id": "#elsewhere",
-      "type": "EcdsaSecp256k1VerificationKey2019",
-      "controller": "did:plc:yk4dd2qkboz2yv6tpubpc6co",
-      "publicKeyMultibase": "zQYEBzXeuTM9UR3rfvNag6L3RNAs5pQZyYPsomTsgQhsxLdEgCrPTLgFna8yqCnxPpNT7DBk6Ym3dgPKNu86vt9GR"
-    }
-  ],
-  "yarg": [ ]
-}`
-    const resolver = new DidResolver({})
-    expect(() => {
-      resolver.validateDidDoc(did, JSON.parse(docJson))
-    }).toThrow()
-  })
-
-  it('parses legacy DID format, extracts atpData', async () => {
-    const did = 'did:plc:yk4dd2qkboz2yv6tpubpc6co'
-    const docJson = `{
-  "@context": [
-    "https://www.w3.org/ns/did/v1",
-    "https://w3id.org/security/suites/secp256k1-2019/v1"
-  ],
-  "id": "did:plc:yk4dd2qkboz2yv6tpubpc6co",
-  "alsoKnownAs": [
-    "at://dholms.xyz"
-  ],
-  "verificationMethod": [
-    {
-      "id": "#atproto",
-      "type": "EcdsaSecp256k1VerificationKey2019",
-      "controller": "did:plc:yk4dd2qkboz2yv6tpubpc6co",
-      "publicKeyMultibase": "zQYEBzXeuTM9UR3rfvNag6L3RNAs5pQZyYPsomTsgQhsxLdEgCrPTLgFna8yqCnxPpNT7DBk6Ym3dgPKNu86vt9GR"
-    }
-  ],
-  "service": [
-    {
-      "id": "#atproto_pds",
-      "type": "AtprotoPersonalDataServer",
-      "serviceEndpoint": "https://bsky.social"
-    }
-  ]
-}`
-    const resolver = new DidResolver({})
-    const doc = resolver.validateDidDoc(did, JSON.parse(docJson))
-    const atpData = ensureAtpDocument(doc)
-    expect(atpData.did).toEqual(did)
-    expect(atpData.handle).toEqual('dholms.xyz')
-    expect(atpData.pds).toEqual('https://bsky.social')
-    expect(atpData.signingKey).toEqual(
-      'did:key:zQ3shXjHeiBuRCKmM36cuYnm7YEMzhGnCmCyW92sRJ9pribSF',
-    )
-  })
-
-  it('parses newer Multikey DID format, extracts atpData', async () => {
-    const did = 'did:plc:yk4dd2qkboz2yv6tpubpc6co'
-    const docJson = `{
-  "@context": [
-    "https://www.w3.org/ns/did/v1",
-    "https://w3id.org/security/multikey/v1",
-    "https://w3id.org/security/suites/secp256k1-2019/v1"
-  ],
-  "id": "did:plc:yk4dd2qkboz2yv6tpubpc6co",
-  "alsoKnownAs": [
-    "at://dholms.xyz"
-  ],
-  "verificationMethod": [
-    {
-      "id": "did:plc:yk4dd2qkboz2yv6tpubpc6co#atproto",
-      "type": "Multikey",
-      "controller": "did:plc:yk4dd2qkboz2yv6tpubpc6co",
-      "publicKeyMultibase": "zQ3shXjHeiBuRCKmM36cuYnm7YEMzhGnCmCyW92sRJ9pribSF"
-    }
-  ],
-  "service": [
-    {
-      "id": "#atproto_pds",
-      "type": "AtprotoPersonalDataServer",
-      "serviceEndpoint": "https://bsky.social"
-    }
-  ]
-}`
-    const resolver = new DidResolver({})
-    const doc = resolver.validateDidDoc(did, JSON.parse(docJson))
-    const atpData = ensureAtpDocument(doc)
-    expect(atpData.did).toEqual(did)
-    expect(atpData.handle).toEqual('dholms.xyz')
-    expect(atpData.pds).toEqual('https://bsky.social')
-    expect(atpData.signingKey).toEqual(
-      'did:key:zQ3shXjHeiBuRCKmM36cuYnm7YEMzhGnCmCyW92sRJ9pribSF',
-    )
-  })
-})

package/tests/did-resolver.test.ts

@@ -1,116 +0,0 @@
-import * as plc from '@did-plc/lib'
-import { Database as DidPlcDb, PlcServer } from '@did-plc/server'
-import getPort from 'get-port'
-import { Secp256k1Keypair } from '@atproto/crypto'
-import { DidDocument, DidResolver } from '../src/index.js'
-import { DidWebDb } from './web/db.js'
-import { DidWebServer } from './web/server.js'
-
-describe('did resolver', () => {
-  let close: () => Promise<void>
-  let webServer: DidWebServer
-  let plcUrl: string
-  let resolver: DidResolver
-
-  beforeAll(async () => {
-    const webDb = DidWebDb.memory()
-    webServer = DidWebServer.create(webDb, await getPort())
-    await new Promise((resolve, reject) => {
-      webServer._httpServer?.on('listening', resolve)
-      webServer._httpServer?.on('error', reject)
-    })
-
-    const plcDB = DidPlcDb.mock()
-    const plcPort = await getPort()
-    const plcServer = PlcServer.create({ db: plcDB, port: plcPort })
-    await plcServer.start()
-
-    plcUrl = 'http://localhost:' + plcPort
-    resolver = new DidResolver({ plcUrl })
-
-    close = async () => {
-      await webServer.close()
-      await plcServer.destroy()
-    }
-  })
-
-  afterAll(async () => {
-    await close()
-  })
-
-  const handle = 'alice.test'
-  const pds = 'https://service.test'
-  let signingKey: Secp256k1Keypair
-  let rotationKey: Secp256k1Keypair
-  let webDid: string
-  let plcDid: string
-  let didWebDoc: DidDocument
-  let didPlcDoc: DidDocument
-
-  it('creates the did on did:web & did:plc', async () => {
-    signingKey = await Secp256k1Keypair.create()
-    rotationKey = await Secp256k1Keypair.create()
-    const client = new plc.Client(plcUrl)
-    plcDid = await client.createDid({
-      signingKey: signingKey.did(),
-      handle,
-      pds,
-      rotationKeys: [rotationKey.did()],
-      signer: rotationKey,
-    })
-    didPlcDoc = await client.getDocument(plcDid)
-    const domain = encodeURIComponent(`localhost:${webServer.port}`)
-    webDid = `did:web:${domain}`
-    didWebDoc = {
-      ...didPlcDoc,
-      id: webDid,
-    }
-
-    await webServer.put(didWebDoc)
-  })
-
-  it('resolve valid did:web', async () => {
-    const didRes = await resolver.ensureResolve(webDid)
-    expect(didRes).toEqual(didWebDoc)
-  })
-
-  it('resolve valid atpData from did:web', async () => {
-    const atpData = await resolver.resolveAtprotoData(webDid)
-    expect(atpData.did).toEqual(webDid)
-    expect(atpData.handle).toEqual(handle)
-    expect(atpData.pds).toEqual(pds)
-    expect(atpData.signingKey).toEqual(signingKey.did())
-    expect(atpData.handle).toEqual(handle)
-  })
-
-  it('throws on malformed did:webs', async () => {
-    await expect(resolver.ensureResolve(`did:web:asdf`)).rejects.toThrow()
-    await expect(resolver.ensureResolve(`did:web:`)).rejects.toThrow()
-    await expect(resolver.ensureResolve(``)).rejects.toThrow()
-  })
-
-  it('throws on did:web with path components', async () => {
-    await expect(
-      resolver.ensureResolve(`did:web:example.com:u:bob`),
-    ).rejects.toThrow()
-  })
-
-  it('resolve valid did:plc', async () => {
-    const didRes = await resolver.ensureResolve(plcDid)
-    expect(didRes).toEqual(didPlcDoc)
-  })
-
-  it('resolve valid atpData from did:plc', async () => {
-    const atpData = await resolver.resolveAtprotoData(plcDid)
-    expect(atpData.did).toEqual(plcDid)
-    expect(atpData.handle).toEqual(handle)
-    expect(atpData.pds).toEqual(pds)
-    expect(atpData.signingKey).toEqual(signingKey.did())
-    expect(atpData.handle).toEqual(handle)
-  })
-
-  it('throws on malformed did:plc', async () => {
-    await expect(resolver.ensureResolve(`did:plc:asdf`)).rejects.toThrow()
-    await expect(resolver.ensureResolve(`did:plc`)).rejects.toThrow()
-  })
-})

package/tests/handle-resolver.test.ts

@@ -1,67 +0,0 @@
-import { jest } from '@jest/globals'
-
-jest.unstable_mockModule('node:dns/promises', () => {
-  return {
-    resolveTxt: (handle: string) => {
-      if (handle === '_atproto.simple.test') {
-        return [['did=did:example:simpleDid']]
-      }
-      if (handle === '_atproto.noisy.test') {
-        return [
-          ['blah blah blah'],
-          ['did:example:fakeDid'],
-          ['atproto=did:example:fakeDid'],
-          ['did=did:example:noisyDid'],
-          [
-            'chunk long domain aspdfoiuwerpoaisdfupasodfiuaspdfoiuasdpfoiausdfpaosidfuaspodifuaspdfoiuasdpfoiasudfpasodifuaspdofiuaspdfoiuasd',
-            'apsodfiuweproiasudfpoasidfu',
-          ],
-        ]
-      }
-      if (handle === '_atproto.bad.test') {
-        return [
-          ['blah blah blah'],
-          ['did:example:fakeDid'],
-          ['atproto=did:example:fakeDid'],
-          [
-            'chunk long domain aspdfoiuwerpoaisdfupasodfiuaspdfoiuasdpfoiausdfpaosidfuaspodifuaspdfoiuasdpfoiasudfpasodifuaspdofiuaspdfoiuasd',
-            'apsodfiuweproiasudfpoasidfu',
-          ],
-        ]
-      }
-      if (handle === '_atproto.multi.test') {
-        return [['did=did:example:firstDid'], ['did=did:example:secondDid']]
-      }
-    },
-  }
-})
-
-const { HandleResolver } = await import('../src/index.js')
-
-describe('handle resolver', () => {
-  let resolver: InstanceType<typeof HandleResolver>
-
-  beforeAll(async () => {
-    resolver = new HandleResolver()
-  })
-
-  it('handles a simple DNS resolution', async () => {
-    const did = await resolver.resolveDns('simple.test')
-    expect(did).toBe('did:example:simpleDid')
-  })
-
-  it('handles a noisy DNS resolution', async () => {
-    const did = await resolver.resolveDns('noisy.test')
-    expect(did).toBe('did:example:noisyDid')
-  })
-
-  it('handles a bad DNS resolution', async () => {
-    const did = await resolver.resolveDns('bad.test')
-    expect(did).toBeUndefined()
-  })
-
-  it('throws on multiple dids under same domain', async () => {
-    const did = await resolver.resolveDns('multi.test')
-    expect(did).toBeUndefined()
-  })
-})

package/tests/web/db.ts

@@ -1,63 +0,0 @@
-import { DidDocument } from '../../src/types.js'
-
-interface DidStore {
-  put(key: string, val: string): Promise<void>
-  del(key: string): Promise<void>
-  get(key: string): Promise<string>
-}
-
-class MemoryStore implements DidStore {
-  private store: Record<string, string> = {}
-
-  async put(key: string, val: string): Promise<void> {
-    this.store[key] = val
-  }
-
-  async del(key: string): Promise<void> {
-    this.assertHas(key)
-    delete this.store[key]
-  }
-
-  async get(key: string): Promise<string> {
-    this.assertHas(key)
-    return this.store[key]
-  }
-
-  assertHas(key: string): void {
-    if (!this.store[key]) {
-      throw new Error(`No object with key: ${key}`)
-    }
-  }
-}
-
-export class DidWebDb {
-  constructor(private store: DidStore) {}
-
-  static memory(): DidWebDb {
-    const store = new MemoryStore()
-    return new DidWebDb(store)
-  }
-
-  async put(didPath: string, didDoc: DidDocument): Promise<void> {
-    await this.store.put(didPath, JSON.stringify(didDoc))
-  }
-
-  async get(didPath: string): Promise<DidDocument | null> {
-    try {
-      const got = await this.store.get(didPath)
-      return JSON.parse(got)
-    } catch (err) {
-      console.log(`Could not get did with path ${didPath}: ${err}`)
-      return null
-    }
-  }
-
-  async has(didPath: string): Promise<boolean> {
-    const got = await this.get(didPath)
-    return got !== null
-  }
-
-  async del(didPath: string): Promise<void> {
-    await this.store.del(didPath)
-  }
-}

package/tests/web/server.ts

@@ -1,105 +0,0 @@
-import http from 'node:http'
-import cors from 'cors'
-import express, { Router, json } from 'express'
-import { DidDocument } from '../../src/index.js'
-import { DidWebDb } from './db.js'
-
-const DOC_PATH = '/.well-known/did.json'
-
-const routes = Router()
-
-// Get DID Doc
-routes.get('/*', async (req, res) => {
-  const db = res.locals.db
-  const got = await db.get(req.url)
-  if (got === null) {
-    return res.status(404).send('Not found')
-  }
-  res.type('application/did+ld+json')
-  res.send(JSON.stringify(got))
-})
-
-// Write DID
-routes.post('/', async (req, res) => {
-  const { didDoc } = req.body
-  if (!didDoc) {
-    return res.status(400)
-  }
-  // @TODO add in some proof
-  // @TODO validate didDoc body
-  const db = res.locals.db
-  const path = idToPath(didDoc.id)
-  await db.put(path, didDoc)
-  res.status(200).send()
-})
-
-const idToPath = (id: string): string => {
-  const idp = id.split(':').slice(3)
-  let path =
-    idp.length > 0
-      ? idp.map(decodeURIComponent).join('/') + '/did.json'
-      : DOC_PATH
-
-  if (!path.startsWith('/')) path = `/${path}`
-  return path
-}
-
-export class DidWebServer {
-  port: number
-  private _db: DidWebDb
-  _app: express.Application
-  _httpServer: http.Server | null = null
-
-  constructor(_app: express.Application, _db: DidWebDb, port: number) {
-    this._app = _app
-    this._db = _db
-    this.port = port
-  }
-
-  static create(db: DidWebDb, port: number): DidWebServer {
-    const app = express()
-
-    app.use(cors())
-    app.use(json())
-    app.use((_req, res, next) => {
-      res.locals.db = db
-      next()
-    })
-    app.use('/', routes)
-
-    const server = new DidWebServer(app, db, port)
-    server._httpServer = app.listen(port)
-    return server
-  }
-
-  async getByPath(didPath?: string): Promise<DidDocument | null> {
-    if (!didPath) return null
-    return this._db.get(didPath)
-  }
-
-  async getById(did?: string): Promise<DidDocument | null> {
-    if (!did) return null
-    const path = idToPath(did)
-    return this.getByPath(path)
-  }
-
-  async put(didDoc: DidDocument) {
-    await this._db.put(idToPath(didDoc.id), didDoc)
-  }
-
-  async delete(didOrDoc: string | DidDocument) {
-    const did = typeof didOrDoc === 'string' ? didOrDoc : didOrDoc.id
-    const path = idToPath(did)
-    await this._db.del(path)
-  }
-
-  close(): Promise<void> {
-    return new Promise((resolve) => {
-      if (this._httpServer) {
-        this._httpServer.close(() => resolve())
-      } else {
-        resolve()
-      }
-    })
-  }
-}

package/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig/isomorphic.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist",
-  },
-  "include": ["./src"],
-}

package/tsconfig.build.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"7.0.0-dev.20260614.1","root":["./src/errors.ts","./src/id-resolver.ts","./src/index.ts","./src/types.ts","./src/did/atproto-data.ts","./src/did/base-resolver.ts","./src/did/did-resolver.ts","./src/did/index.ts","./src/did/memory-cache.ts","./src/did/plc-resolver.ts","./src/did/util.ts","./src/did/web-resolver.ts","./src/handle/index.ts"]}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "include": [],
-  "references": [
-    { "path": "./tsconfig.build.json" },
-    { "path": "./tsconfig.tests.json" },
-  ],
-}

package/tsconfig.tests.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig/tests.json",
-  "compilerOptions": {
-    "rootDir": ".",
-  },
-  "include": ["./tests"],
-}