@atproto/lexicon-resolver 0.4.4 → 0.4.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atproto/lexicon-resolver
 
+## 0.4.5
+
+### 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)! - 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).
+
+- Updated dependencies [[`28a0b58`](https://github.com/bluesky-social/atproto/commit/28a0b588147863eaef948cd2bb8fc0f19d08cda9), [`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), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07)]:
+  - @atproto/syntax@0.6.4
+  - @atproto/identity@0.5.3
+  - @atproto-labs/fetch-node@0.3.4
+  - @atproto/lex-document@0.1.3
+  - @atproto/lex@0.1.7
+  - @atproto/repo@0.10.3
+
 ## 0.4.4
 
 ### Patch Changes

package/package.json

@@ -1,10 +1,6 @@
 {
   "name": "@atproto/lexicon-resolver",
-  "version": "0.4.4",
-  "engines": {
-    "node": ">=22"
-  },
-  "type": "module",
+  "version": "0.4.5",
   "license": "MIT",
   "description": "ATProto Lexicon resolution",
   "keywords": [
@@ -17,28 +13,37 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/lexicon-resolver"
   },
+  "files": [
+    "./dist",
+    "./README.md",
+    "./CHANGELOG.md"
+  ],
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
   },
+  "engines": {
+    "node": ">=22"
+  },
   "dependencies": {
-    "@atproto-labs/fetch-node": "^0.3.3",
-    "@atproto/lex": "^0.1.6",
-    "@atproto/identity": "^0.5.2",
-    "@atproto/lex-document": "^0.1.2",
-    "@atproto/repo": "^0.10.2",
-    "@atproto/syntax": "^0.6.3"
+    "@atproto-labs/fetch-node": "^0.3.4",
+    "@atproto/repo": "^0.10.3",
+    "@atproto/identity": "^0.5.3",
+    "@atproto/lex-document": "^0.1.3",
+    "@atproto/lex": "^0.1.7",
+    "@atproto/syntax": "^0.6.4"
   },
   "devDependencies": {
     "vitest": "^4.0.16",
-    "@atproto/lex-cbor": "^0.1.2"
+    "@atproto/lex-cbor": "^0.1.3"
   },
   "scripts": {
     "test": "vitest run",
     "build": "tsgo --build tsconfig.build.json",
-    "prebuild": "pnpm run codegen",
-    "codegen": "lex build --clear --indexFile --lexicons ../../lexicons --include com.atproto.sync.getRecord --include com.atproto.lexicon.schema"
+    "prebuild": "pnpm run '/^(codegen:.+)$/'",
+    "codegen:lex": "lex build --clear --indexFile --lexicons ../../lexicons --include com.atproto.sync.getRecord --include com.atproto.lexicon.schema"
   }
 }

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './record.js'
-export * from './lexicon.js'

package/src/lexicon.ts

@@ -1,164 +0,0 @@
-import * as dns from 'node:dns/promises'
-import { Cid, l } from '@atproto/lex'
-import { LexiconDocument, lexiconDocumentSchema } from '@atproto/lex-document'
-import { Commit } from '@atproto/repo'
-import { AtUri, DidString, NSID, NsidString } from '@atproto/syntax'
-import * as lexiconsSchema from './lexicons/com/atproto/lexicon/schema.js'
-import {
-  BuildRecordResolverOptions,
-  ResolveRecordOptions,
-  buildRecordResolver,
-} from './record.js'
-
-const DNS_SUBDOMAIN = '_lexicon'
-const DNS_PREFIX = 'did='
-
-export type LexiconDocumentRecord = lexiconsSchema.Main & LexiconDocument
-export const LEXICON_SCHEMA_NSID = lexiconsSchema.$nsid
-
-/**
- * Resolve Lexicon from an NSID
- */
-export type LexiconResolver = (
-  nsid: NSID | NsidString,
-) => Promise<LexiconResolution>
-
-/**
- * Resolve Lexicon from an NSID using Lexicon DID authority and record resolution
- */
-export type AtprotoLexiconResolver = (
-  nsid: NSID | NsidString,
-  options?: ResolveLexiconOptions,
-) => Promise<LexiconResolution>
-
-export type BuildLexiconResolverOptions = BuildRecordResolverOptions
-
-export type ResolveLexiconOptions = ResolveRecordOptions & {
-  didAuthority?: DidString
-}
-
-export type LexiconResolution = {
-  commit: Commit
-  uri: AtUri
-  cid: Cid
-  nsid: NSID
-  lexicon: LexiconDocumentRecord
-}
-
-export { AtUri, NSID }
-export type { Cid, Commit, DidString, LexiconDocument, NsidString }
-
-/**
- * Build a Lexicon resolver function.
- */
-export function buildLexiconResolver(
-  options: BuildLexiconResolverOptions = {},
-): AtprotoLexiconResolver {
-  const resolveRecord = buildRecordResolver(options)
-  return async function (
-    input: NSID | NsidString,
-    opts: ResolveLexiconOptions = {},
-  ): Promise<LexiconResolution> {
-    const nsid = NSID.from(input)
-    const didAuthority = await getDidAuthority(nsid, opts)
-    const verified = await resolveRecord(
-      AtUri.make(didAuthority, lexiconsSchema.$nsid, nsid.toString()),
-      { forceRefresh: opts.forceRefresh },
-    ).catch((err) => {
-      throw new LexiconResolutionError(
-        nsid,
-        'Could not resolve Lexicon schema record',
-        { cause: err },
-      )
-    })
-
-    if (!lexiconsSchema.$matches(verified.record)) {
-      throw new LexiconResolutionError(nsid, 'Invalid Lexicon schema record')
-    }
-
-    const validationResult = lexiconDocumentSchema.safeValidate(verified.record)
-    if (!validationResult.success) {
-      throw new LexiconResolutionError(nsid, 'Invalid Lexicon document', {
-        cause: validationResult.reason,
-      })
-    }
-
-    const lexicon = validationResult.value
-    if (lexicon.id !== nsid.toString()) {
-      throw new LexiconResolutionError(
-        nsid,
-        `Lexicon schema record id (${lexicon.id}) does not match NSID`,
-      )
-    }
-    const { uri, cid, commit } = verified
-    return { commit, uri, cid, nsid, lexicon }
-  } satisfies LexiconResolver
-}
-
-export const resolveLexicon = buildLexiconResolver()
-
-/**
- * Resolve the DID authority for a Lexicon from the network using DNS, based on its NSID.
- * @param input NSID or string representing one for which to lookup its Lexicon DID authority.
- */
-export async function resolveLexiconDidAuthority(
-  input: NSID | NsidString,
-): Promise<DidString | undefined> {
-  const nsid = NSID.from(input)
-  const did = await resolveDns(nsid.authority)
-  if (did == null || !l.isDidString(did)) return
-  return did
-}
-
-export class LexiconResolutionError extends Error {
-  constructor(
-    public readonly nsid: NSID,
-    public readonly description = `Could not resolve Lexicon for NSID`,
-    options?: ErrorOptions,
-  ) {
-    super(`${description} (${nsid})`, options)
-    this.name = 'LexiconResolutionError'
-  }
-
-  static from(
-    input: NSID | string,
-    description?: string,
-    options?: ErrorOptions,
-  ): LexiconResolutionError {
-    const nsid = NSID.from(input)
-    return new LexiconResolutionError(nsid, description, options)
-  }
-}
-
-async function getDidAuthority(nsid: NSID, options: ResolveLexiconOptions) {
-  if (options.didAuthority) {
-    return options.didAuthority
-  }
-  const did = await resolveLexiconDidAuthority(nsid)
-  if (!did) {
-    throw new LexiconResolutionError(
-      nsid,
-      `Could not resolve a DID authority for NSID`,
-    )
-  }
-  return did
-}
-
-async function resolveDns(authority: string): Promise<string | undefined> {
-  let chunkedResults: string[][]
-  try {
-    chunkedResults = await dns.resolveTxt(`${DNS_SUBDOMAIN}.${authority}`)
-  } catch (err) {
-    return undefined
-  }
-  return parseDnsResult(chunkedResults)
-}
-
-function parseDnsResult(chunkedResults: string[][]): string | undefined {
-  const results = chunkedResults.map((chunks) => chunks.join(''))
-  const found = results.filter((i) => i.startsWith(DNS_PREFIX))
-  if (found.length !== 1) {
-    return undefined
-  }
-  return found[0].slice(DNS_PREFIX.length)
-}

package/src/record.ts

@@ -1,184 +0,0 @@
-import { IdResolver, parseToAtprotoDocument } from '@atproto/identity'
-import {
-  AgentConfig,
-  Cid,
-  Client,
-  DidString,
-  FetchHandler,
-  LexMap,
-  l,
-} from '@atproto/lex'
-import {
-  Commit,
-  MST,
-  MemoryBlockstore,
-  def as repoDef,
-  readCarWithRoot,
-  verifyCommitSig,
-} from '@atproto/repo'
-import { AtUri, AtUriString } from '@atproto/syntax'
-import { safeFetchWrap } from '@atproto-labs/fetch-node'
-import { com } from './lexicons/index.js'
-
-export { AtUri, IdResolver }
-export type {
-  AgentConfig,
-  AtUriString,
-  Cid,
-  Commit,
-  DidString,
-  FetchHandler,
-  LexMap,
-}
-
-/**
- * Resolve a record from the network.
- */
-export type RecordResolver = (
-  uri: AtUri | AtUriString,
-) => Promise<RecordResolution>
-
-/**
- * Resolve a record from the network, verifying its authenticity.
- */
-export type AtprotoRecordResolver = (
-  uri: AtUri | AtUriString,
-  options?: ResolveRecordOptions,
-) => Promise<RecordResolution>
-
-export type BuildRecordResolverOptions = {
-  idResolver?: IdResolver
-  rpc?: Partial<AgentConfig> | FetchHandler
-}
-
-export type ResolveRecordOptions = {
-  forceRefresh?: boolean
-}
-
-export type RecordResolution = {
-  commit: Commit
-  uri: AtUri
-  cid: Cid
-  record: LexMap
-}
-
-/**
- * Build a record resolver function.
- */
-export function buildRecordResolver(
-  options: BuildRecordResolverOptions = {},
-): AtprotoRecordResolver {
-  const { idResolver = new IdResolver(), rpc } = options
-  return async function resolveRecord(
-    uriStr: AtUri | AtUriString,
-    opts: ResolveRecordOptions = {},
-  ): Promise<RecordResolution> {
-    const uri = typeof uriStr === 'string' ? new AtUri(uriStr) : uriStr
-    const did = await getDidFromUri(uri, { idResolver })
-    const identityDoc = await idResolver.did
-      .ensureResolve(did, opts.forceRefresh)
-      .catch((err) => {
-        throw new RecordResolutionError('Could not resolve DID identity data', {
-          cause: err,
-        })
-      })
-    const { pds, signingKey } = parseToAtprotoDocument(identityDoc)
-    if (!pds) {
-      throw new RecordResolutionError(
-        'Incomplete DID identity data: missing pds',
-      )
-    }
-    if (!signingKey) {
-      throw new RecordResolutionError(
-        'Incomplete DID identity data: missing signing key',
-      )
-    }
-    const client = new Client(
-      typeof rpc === 'function'
-        ? { fetchHandler: rpc }
-        : {
-            ...rpc,
-            service: rpc?.service ?? pds,
-            fetch: rpc?.fetch ?? safeFetch,
-          },
-    )
-    const proofBytes = await client
-      .call(com.atproto.sync.getRecord, {
-        did,
-        collection: uri.collection as l.NsidString,
-        rkey: uri.rkey as l.RecordKeyString,
-      })
-      .catch((err) => {
-        throw new RecordResolutionError('Could not fetch record proof', {
-          cause: err,
-        })
-      })
-    const verified = await verifyRecordProof(proofBytes, {
-      uri: AtUri.make(did, uri.collection, uri.rkey),
-      signingKey,
-    })
-    return verified
-  }
-}
-
-export const resolveRecord = buildRecordResolver()
-
-export const safeFetch = safeFetchWrap({
-  allowIpHost: false,
-  allowImplicitRedirect: true,
-  responseMaxSize: (1024 + 10) * 1024, // 1MB + 10kB, just a bit larger than max record size
-})
-
-export class RecordResolutionError extends Error {
-  constructor(message?: string, options?: ErrorOptions) {
-    super(message, options)
-    this.name = 'RecordResolutionError'
-  }
-}
-
-async function getDidFromUri(
-  uri: AtUri,
-  { idResolver }: { idResolver: IdResolver },
-): Promise<DidString> {
-  if (l.isDidString(uri.host)) {
-    return uri.host
-  }
-
-  const resolved = await idResolver.handle.resolve(uri.host)
-  if (!resolved || !l.isDidString(resolved)) {
-    throw new RecordResolutionError('Could not resolve handle found in AT-URI')
-  }
-
-  return resolved
-}
-
-async function verifyRecordProof(
-  proofBytes: Uint8Array,
-  { uri, signingKey }: { uri: AtUri; signingKey: string },
-): Promise<RecordResolution> {
-  const { root, blocks } = await readCarWithRoot(proofBytes).catch((err) => {
-    throw new RecordResolutionError('Malformed record proof', { cause: err })
-  })
-  const blockstore = new MemoryBlockstore(blocks)
-  const commit = await blockstore.readObj(root, repoDef.commit).catch((err) => {
-    throw new RecordResolutionError('Invalid commit in record proof', {
-      cause: err,
-    })
-  })
-  if (commit.did !== uri.host) {
-    throw new RecordResolutionError(`Invalid repo did: ${commit.did}`)
-  }
-  const validSig = await verifyCommitSig(commit, signingKey)
-  if (!validSig) {
-    throw new RecordResolutionError(
-      `Invalid signature on commit: ${root.toString()}`,
-    )
-  }
-  const mst = MST.load(blockstore, commit.data)
-  const cid = await mst.get(`${uri.collection}/${uri.rkey}`)
-  if (!cid) {
-    throw new RecordResolutionError('Record not found in proof')
-  }
-  const record = (await blockstore.readRecord(cid)) as LexMap
-  return { commit, uri, cid, record }
-}

package/src/util.ts

@@ -1,10 +0,0 @@
-import { ensureValidDid } from '@atproto/syntax'
-
-export function isValidDid(did: string) {
-  try {
-    ensureValidDid(did)
-    return true
-  } catch {
-    return false
-  }
-}

package/tests/lexicon.test.ts

@@ -1,271 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
-import { SeedClient, TestNetworkNoAppView, usersSeed } from '@atproto/dev-env'
-import { DidString, NSID } from '@atproto/syntax'
-import {
-  AtprotoLexiconResolver,
-  buildLexiconResolver,
-  resolveLexiconDidAuthority,
-} from '../src/index.js'
-
-const dnsEntries: [entry: string, ...result: string[][]][] = []
-
-vi.mock('node:dns/promises', () => {
-  const mock = {
-    resolveTxt: (entry: string) => {
-      const found = dnsEntries.find(([e]) => e === entry)
-      if (found) return found.slice(1)
-      return []
-    },
-  }
-  return { default: mock, ...mock }
-})
-
-describe('Lexicon resolution', () => {
-  let network: TestNetworkNoAppView
-  let sc: SeedClient
-  let resolveLexicon: AtprotoLexiconResolver
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'lex_lexicon_resolution',
-    })
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    dnsEntries.push(['_lexicon.alice.example', [`did=${sc.dids.alice}`]])
-    resolveLexicon = buildLexiconResolver({
-      rpc: { fetch },
-      idResolver: network.pds.ctx.idResolver,
-    })
-  }, 20_000) // @NOTE seeding can take a while
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('resolves Lexicon.', async () => {
-    const client = network.pds.getAgent()
-    const lex = await client.com.atproto.lexicon.schema.create(
-      { repo: sc.dids.alice, rkey: 'example.alice.name1' },
-      { id: 'example.alice.name1', lexicon: 1, defs: {} },
-      sc.getHeaders(sc.dids.alice),
-    )
-    const result = await resolveLexicon('example.alice.name1', {
-      forceRefresh: true,
-    })
-    expect(result.commit.did).toEqual(sc.dids.alice)
-    expect(result.cid.toString()).toEqual(lex.cid)
-    expect(result.uri.toString()).toEqual(lex.uri)
-    expect(result.nsid.toString()).toEqual('example.alice.name1')
-    expect(result.lexicon).toEqual({
-      $type: 'com.atproto.lexicon.schema',
-      id: 'example.alice.name1',
-      lexicon: 1,
-      defs: {},
-    })
-  })
-
-  it('fails on mismatched id.', async () => {
-    const client = network.pds.getAgent()
-    await client.com.atproto.lexicon.schema.create(
-      { repo: sc.dids.alice, rkey: 'example.alice.mismatch' },
-      { id: 'example.test1.mismatch.bad', lexicon: 1, defs: {} },
-      sc.getHeaders(sc.dids.alice),
-    )
-    await expect(
-      resolveLexicon('example.alice.mismatch', {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow(
-      'Lexicon schema record id (example.test1.mismatch.bad) does not match NSID (example.alice.mismatch)',
-    )
-  })
-
-  it('fails on missing DNS entry.', async () => {
-    const client = network.pds.getAgent()
-    await client.com.atproto.lexicon.schema.create(
-      { repo: sc.dids.bob, rkey: 'example.bob.name' },
-      { id: 'example.bob.name', lexicon: 1, defs: {} },
-      sc.getHeaders(sc.dids.bob),
-    )
-    await expect(
-      resolveLexicon('example.bob.name', {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow(
-      'Could not resolve a DID authority for NSID (example.bob.name)',
-    )
-  })
-
-  it('fails on missing record.', async () => {
-    await expect(
-      resolveLexicon('example.alice.missing', {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow('Could not resolve Lexicon schema record')
-  })
-
-  it('fails on bad verification.', async () => {
-    const client = network.pds.getAgent()
-    const alicekey = await network.pds.ctx.actorStore.keypair(sc.dids.alice)
-    const bobkey = await network.pds.ctx.actorStore.keypair(sc.dids.bob)
-    await client.com.atproto.lexicon.schema.create(
-      { repo: sc.dids.alice, rkey: 'example.alice.badsig' },
-      { id: 'example.alice.badsig', lexicon: 1, defs: {} },
-      sc.getHeaders(sc.dids.alice),
-    )
-    // switch alice's key away from the one used by her pds
-    await network.pds.ctx.plcClient.updateAtprotoKey(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      bobkey.did(),
-    )
-    await expect(
-      resolveLexicon('example.alice.badsig', {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow(
-      expect.objectContaining({
-        name: 'LexiconResolutionError',
-        message:
-          'Could not resolve Lexicon schema record (example.alice.badsig)',
-        cause: expect.objectContaining({
-          name: 'RecordResolutionError',
-          message: expect.stringContaining('Invalid signature on commit'),
-        }),
-      }),
-    )
-    // reset alice's key
-    await network.pds.ctx.plcClient.updateAtprotoKey(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      alicekey.did(),
-    )
-  })
-
-  it('fails on invalid Lexicon document.', async () => {
-    const client = network.pds.getAgent()
-    await client.com.atproto.lexicon.schema.create(
-      { repo: sc.dids.alice, rkey: 'example.alice.baddoc' },
-      { id: 'example.alice.baddoc', lexicon: 999, defs: {} },
-      sc.getHeaders(sc.dids.alice),
-    )
-    await expect(
-      resolveLexicon('example.alice.baddoc', {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow(
-      expect.objectContaining({
-        name: 'LexiconResolutionError',
-        message: 'Invalid Lexicon document (example.alice.baddoc)',
-        cause: expect.objectContaining({
-          name: 'LexValidationError',
-        }),
-      }),
-    )
-  })
-
-  it('resolves Lexicon based on override authority.', async () => {
-    const client = network.pds.getAgent()
-    await client.com.atproto.lexicon.schema.create(
-      { repo: sc.dids.alice, rkey: 'example.alice.override' },
-      {
-        id: 'example.alice.override',
-        lexicon: 1,
-        defs: { alice: { type: 'string' } },
-      },
-      sc.getHeaders(sc.dids.alice),
-    )
-    const carolLex = await client.com.atproto.lexicon.schema.create(
-      { repo: sc.dids.carol, rkey: 'example.alice.override' },
-      {
-        id: 'example.alice.override',
-        lexicon: 1,
-        defs: { carol: { type: 'string' } },
-      },
-      sc.getHeaders(sc.dids.carol),
-    )
-    const result = await resolveLexicon('example.alice.override', {
-      didAuthority: sc.dids.carol as DidString,
-      forceRefresh: true,
-    })
-    expect(result.commit.did).toEqual(sc.dids.carol)
-    expect(result.cid.toString()).toEqual(carolLex.cid)
-    expect(result.uri.toString()).toEqual(carolLex.uri)
-    expect(result.nsid.toString()).toEqual('example.alice.override')
-    expect(result.lexicon).toEqual({
-      $type: 'com.atproto.lexicon.schema',
-      id: 'example.alice.override',
-      lexicon: 1,
-      defs: { carol: { type: 'string' } },
-    })
-  })
-
-  describe('DID authority', () => {
-    it('handles a simple DNS resolution', async () => {
-      dnsEntries.push(['_lexicon.simple.test', ['did=did:example:simpleDid']])
-      const did = await resolveLexiconDidAuthority('test.simple.name')
-      expect(did).toBe('did:example:simpleDid')
-    })
-
-    it('handles a noisy DNS resolution', async () => {
-      dnsEntries.push([
-        '_lexicon.noisy.test',
-        ['blah blah blah'],
-        ['did:example:fakeDid'],
-        ['atproto=did:example:fakeDid'],
-        ['did=did:example:noisyDid'],
-        [
-          'chunk long domain aspdfoiuwerpoaisdfupasodfiuaspdfoiuasdpfoiausdfpaosidfuaspodifuaspdfoiuasdpfoiasudfpasodifuaspdofiuaspdfoiuasd',
-          'apsodfiuweproiasudfpoasidfu',
-        ],
-      ])
-      const did = await resolveLexiconDidAuthority('test.noisy.name')
-      expect(did).toBe('did:example:noisyDid')
-    })
-
-    it('handles a bad DNS resolution', async () => {
-      dnsEntries.push([
-        '_lexicon.bad.test',
-        ['blah blah blah'],
-        ['did:example:fakeDid'],
-        ['atproto=did:example:fakeDid'],
-        [
-          'chunk long domain aspdfoiuwerpoaisdfupasodfiuaspdfoiuasdpfoiausdfpaosidfuaspodifuaspdfoiuasdpfoiasudfpasodifuaspdofiuaspdfoiuasd',
-          'apsodfiuweproiasudfpoasidfu',
-        ],
-      ])
-      const did = await resolveLexiconDidAuthority('test.bad.name')
-      expect(did).toBeUndefined()
-    })
-
-    it('throws on multiple dids under same domain', async () => {
-      dnsEntries.push([
-        '_lexicon.bad.test',
-        ['did=did:example:firstDid'],
-        ['did=did:example:secondDid'],
-      ])
-      const did = await resolveLexiconDidAuthority('test.multi.name')
-      expect(did).toBeUndefined()
-    })
-
-    it('fails on invalid NSID', async () => {
-      // @ts-expect-error testing invalid input
-      await expect(resolveLexiconDidAuthority('not an nsid')).rejects.toThrow(
-        'Disallowed characters in NSID',
-      )
-    })
-
-    it('fails on invalid DID result', async () => {
-      dnsEntries.push(['_lexicon.invalid.test', ['did=not:a:did']])
-      const did = await resolveLexiconDidAuthority('test.invalid.name')
-      expect(did).toBeUndefined()
-    })
-
-    it('accepts NSID object', async () => {
-      const did = await resolveLexiconDidAuthority(
-        NSID.parse('test.simple.name'),
-      )
-      expect(did).toBe('did:example:simpleDid')
-    })
-  })
-})

package/tests/record.test.ts

@@ -1,193 +0,0 @@
-import { afterAll, assert, beforeAll, describe, expect, it } from 'vitest'
-import { SeedClient, TestNetworkNoAppView, usersSeed } from '@atproto/dev-env'
-import { AtUriString, l } from '@atproto/lex'
-import { encode } from '@atproto/lex-cbor'
-import { AtprotoRecordResolver, buildRecordResolver } from '../src/index.js'
-
-describe('Record resolution', () => {
-  let network: TestNetworkNoAppView
-  let sc: SeedClient
-  let resolveRecord: AtprotoRecordResolver
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'lex_record_resolution',
-    })
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    resolveRecord = buildRecordResolver({
-      rpc: { fetch },
-      idResolver: network.pds.ctx.idResolver,
-    })
-  }, 20_000) // @NOTE seeding can take a while
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('resolves record by AT-URI object.', async () => {
-    const post = await sc.post(sc.dids.alice, 'post1')
-    const result = await resolveRecord(post.ref.uri, {
-      forceRefresh: true,
-    })
-    expect(result.commit.did).toEqual(sc.dids.alice)
-    expect(result.cid.toString()).toEqual(post.ref.cidStr)
-    expect(result.uri.toString()).toEqual(post.ref.uriStr)
-    expect(result.record.text).toEqual('post1')
-  })
-
-  it('resolves record by AT-URI string.', async () => {
-    const post = await sc.post(sc.dids.alice, 'post2')
-    assert(l.isAtUriString(post.ref.uriStr))
-    const result = await resolveRecord(post.ref.uriStr, {
-      forceRefresh: true,
-    })
-    expect(result.commit.did).toEqual(sc.dids.alice)
-    expect(result.cid.toString()).toEqual(post.ref.cidStr)
-    expect(result.uri.toString()).toEqual(post.ref.uriStr)
-    expect(result.record.text).toEqual('post2')
-  })
-
-  it("does not resolve record that doesn't exist.", async () => {
-    await expect(
-      resolveRecord(`at://${sc.dids.alice}/app.bsky.feed.post/2222222222222`, {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow('Record not found')
-  })
-
-  it('does not resolve record with bad commit signature.', async () => {
-    const alicekey = await network.pds.ctx.actorStore.keypair(sc.dids.alice)
-    const bobkey = await network.pds.ctx.actorStore.keypair(sc.dids.bob)
-    const post = await sc.post(sc.dids.alice, 'post3')
-    // switch alice's key away from the one used by her pds
-    await network.pds.ctx.plcClient.updateAtprotoKey(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      bobkey.did(),
-    )
-    await expect(
-      resolveRecord(post.ref.uri, {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow('Invalid signature on commit')
-    // reset alice's key
-    await network.pds.ctx.plcClient.updateAtprotoKey(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      alicekey.did(),
-    )
-  })
-
-  it('does not resolve record with corrupted CAR block.', async () => {
-    const post = await sc.post(sc.dids.alice, 'post4')
-    const badCbor = encode({})
-    await network.pds.ctx.actorStore.transact(sc.dids.alice, (txn) =>
-      txn.repo.db.db
-        .updateTable('repo_block')
-        .set({
-          content: badCbor,
-          size: badCbor.byteLength,
-        })
-        .where('cid', '=', post.ref.cidStr)
-        .execute(),
-    )
-    await expect(
-      resolveRecord(post.ref.uri, {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow('Malformed record proof')
-  })
-
-  it('does not resolve record with missing signing key.', async () => {
-    const post = await sc.post(sc.dids.alice, 'post5')
-    await network.pds.ctx.plcClient.updateData(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      (doc) => {
-        doc.verificationMethods = {
-          not_atproto: doc.verificationMethods.atproto,
-        }
-        return doc
-      },
-    )
-    await expect(
-      resolveRecord(post.ref.uri, {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow('Incomplete DID identity data: missing signing key')
-    // reset alice's key
-    await network.pds.ctx.plcClient.updateData(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      (doc) => {
-        doc.verificationMethods = {
-          atproto: doc.verificationMethods.not_atproto,
-        }
-        return doc
-      },
-    )
-  })
-
-  it('does not resolve record with missing pds.', async () => {
-    const post = await sc.post(sc.dids.alice, 'post6')
-    await network.pds.ctx.plcClient.updateData(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      (doc) => {
-        doc.services = {
-          not_atproto_pds: doc.services.atproto_pds,
-        }
-        return doc
-      },
-    )
-    await expect(
-      resolveRecord(post.ref.uri, {
-        forceRefresh: true,
-      }),
-    ).rejects.toThrow('Incomplete DID identity data: missing pds')
-    // reset alice's pds
-    await network.pds.ctx.plcClient.updateData(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      (doc) => {
-        doc.services = {
-          atproto_pds: doc.services.not_atproto_pds,
-        }
-        return doc
-      },
-    )
-  })
-
-  it('resolves record despite missing at:// handle.', async () => {
-    const post = await sc.post(sc.dids.alice, 'post7')
-    await network.pds.ctx.plcClient.updateData(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      (doc) => {
-        doc.alsoKnownAs = doc.alsoKnownAs.map((aka) =>
-          aka.replace('at://', 'notat://'),
-        )
-        return doc
-      },
-    )
-    const result = await resolveRecord(post.ref.uriStr as AtUriString, {
-      forceRefresh: true,
-    })
-    expect(result.commit.did).toEqual(sc.dids.alice)
-    expect(result.cid.toString()).toEqual(post.ref.cidStr)
-    expect(result.uri.toString()).toEqual(post.ref.uriStr)
-    expect(result.record.text).toEqual('post7')
-    // reset alice's handle
-    await network.pds.ctx.plcClient.updateData(
-      sc.dids.alice,
-      network.pds.ctx.plcRotationKey,
-      (doc) => {
-        doc.alsoKnownAs = doc.alsoKnownAs.map((aka) =>
-          aka.replace('notat://', 'at://'),
-        )
-        return doc
-      },
-    )
-  })
-})

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": ["../../tsconfig/node.json"],
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "noUnusedLocals": false,
-  },
-  "include": ["src"],
-}

package/tsconfig.build.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"7.0.0-dev.20260614.1","root":["./src/index.ts","./src/lexicon.ts","./src/record.ts","./src/util.ts","./src/lexicons/com.ts","./src/lexicons/index.ts","./src/lexicons/com/atproto.ts","./src/lexicons/com/atproto/lexicon.ts","./src/lexicons/com/atproto/sync.ts","./src/lexicons/com/atproto/lexicon/schema.defs.ts","./src/lexicons/com/atproto/lexicon/schema.ts","./src/lexicons/com/atproto/sync/getRecord.defs.ts","./src/lexicons/com/atproto/sync/getRecord.ts"]}

package/tsconfig.json

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

package/tsconfig.tests.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig/vitest.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "noUnusedLocals": false,
-  },
-  "include": ["./tests", "./src/**/*.test.ts"],
-}

package/vitest.config.ts

@@ -1,5 +0,0 @@
-import { defineProject } from 'vitest/config'
-
-export default defineProject({
-  test: {},
-})