chadtmiller.com/pds.js
An atproto PDS in JavaScript, for Cloudflare Workers and Node
0
0
# Lexicon Resolver Rewrite Implementation Plan
> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
**Goal:** Replace `@atproto/lexicon` and `@atproto/lex-resolver` with `@bigmoves/lexicon` and custom resolver logic for full AT Protocol spec compliance.
**Architecture:** Custom DNS-over-HTTPS resolver extracts NSID authority, looks up `_atproto.{domain}` TXT record, resolves DID to PDS endpoint, fetches lexicon. Validation uses `@bigmoves/lexicon` zero-dependency validator. Universal runtime support (Node, Cloudflare Workers, Deno).
**Tech Stack:** `@bigmoves/lexicon` (validation), DNS-over-HTTPS (Cloudflare), PLC directory (DID resolution)
---
## Task 1: Create authority.js module
**Files:**
- Create: `packages/lexicon-resolver/src/authority.js`
- Test: `packages/lexicon-resolver/test/authority.test.js`
**Step 1: Write the failing test**
Create `packages/lexicon-resolver/test/authority.test.js`:
```javascript
import { describe, expect, test } from 'vitest';
import { nsidToDomain, domainToAtprotoDns } from '../src/authority.js';
describe('authority', () => {
describe('nsidToDomain', () => {
test('converts app.bsky.feed.post to bsky.app', () => {
expect(nsidToDomain('app.bsky.feed.post')).toBe('bsky.app');
});
test('converts com.atproto.repo.createRecord to atproto.com', () => {
expect(nsidToDomain('com.atproto.repo.createRecord')).toBe('atproto.com');
});
test('converts org.example.lexicon.test to example.org', () => {
expect(nsidToDomain('org.example.lexicon.test')).toBe('example.org');
});
});
describe('domainToAtprotoDns', () => {
test('prepends _atproto to domain', () => {
expect(domainToAtprotoDns('bsky.app')).toBe('_atproto.bsky.app');
});
});
});
```
**Step 2: Run test to verify it fails**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test packages/lexicon-resolver/test/authority.test.js
```
Expected: FAIL with "Cannot find module '../src/authority.js'"
**Step 3: Write minimal implementation**
Create `packages/lexicon-resolver/src/authority.js`:
```javascript
/**
* Extract authority from NSID and convert to domain.
* NSID format: tld.domain.name (e.g., app.bsky.feed.post)
* Authority is everything except the last segment, reversed.
*
* @param {string} nsid - e.g., "app.bsky.feed.post"
* @returns {string} - e.g., "bsky.app"
*/
export function nsidToDomain(nsid) {
const parts = nsid.split('.');
// Remove the last segment (the name), take first two for domain
const authority = parts.slice(0, -1);
// Reverse: [app, bsky] -> [bsky, app] -> "bsky.app"
return authority.slice(0, 2).reverse().join('.');
}
/**
* Convert domain to AT Protocol DNS lookup name.
*
* @param {string} domain - e.g., "bsky.app"
* @returns {string} - e.g., "_atproto.bsky.app"
*/
export function domainToAtprotoDns(domain) {
return `_atproto.${domain}`;
}
```
**Step 4: Run test to verify it passes**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test packages/lexicon-resolver/test/authority.test.js
```
Expected: PASS (3 tests)
**Step 5: Commit**
```bash
git add packages/lexicon-resolver/src/authority.js packages/lexicon-resolver/test/authority.test.js
git commit -m "feat(lexicon-resolver): add authority module for NSID to domain conversion
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
```
---
## Task 2: Create dns.js module
**Files:**
- Create: `packages/lexicon-resolver/src/dns.js`
- Test: `packages/lexicon-resolver/test/dns.test.js`
**Step 1: Write the failing test**
Create `packages/lexicon-resolver/test/dns.test.js`:
```javascript
import { describe, expect, test, vi } from 'vitest';
import { lookupTxt, parseDidFromTxt } from '../src/dns.js';
describe('dns', () => {
describe('parseDidFromTxt', () => {
test('extracts DID from TXT record value', () => {
expect(parseDidFromTxt('did=did:plc:xyz123')).toBe('did:plc:xyz123');
});
test('handles quoted TXT record', () => {
expect(parseDidFromTxt('"did=did:plc:xyz123"')).toBe('did:plc:xyz123');
});
test('returns null for invalid format', () => {
expect(parseDidFromTxt('invalid')).toBeNull();
});
test('returns null for empty string', () => {
expect(parseDidFromTxt('')).toBeNull();
});
});
describe('lookupTxt', () => {
test('fetches TXT records via DoH', async () => {
const mockFetch = vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({
Answer: [
{ type: 16, data: '"did=did:plc:z72i7hdynmk6r22z27h6tvur"' },
],
}),
});
const records = await lookupTxt('_atproto.bsky.app', { fetch: mockFetch });
expect(mockFetch).toHaveBeenCalledWith(
'https://cloudflare-dns.com/dns-query?name=_atproto.bsky.app&type=TXT',
expect.objectContaining({
headers: { Accept: 'application/dns-json' },
}),
);
expect(records).toEqual(['did=did:plc:z72i7hdynmk6r22z27h6tvur']);
});
test('returns empty array on network error', async () => {
const mockFetch = vi.fn().mockRejectedValue(new Error('Network error'));
const records = await lookupTxt('_atproto.example.com', { fetch: mockFetch });
expect(records).toEqual([]);
});
test('returns empty array when no Answer', async () => {
const mockFetch = vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({}),
});
const records = await lookupTxt('_atproto.example.com', { fetch: mockFetch });
expect(records).toEqual([]);
});
});
});
```
**Step 2: Run test to verify it fails**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test packages/lexicon-resolver/test/dns.test.js
```
Expected: FAIL with "Cannot find module '../src/dns.js'"
**Step 3: Write minimal implementation**
Create `packages/lexicon-resolver/src/dns.js`:
```javascript
const DEFAULT_DOH_URL = 'https://cloudflare-dns.com/dns-query';
/**
* Parse DID from AT Protocol TXT record value.
* Format: "did=did:plc:xyz123" or did=did:plc:xyz123
*
* @param {string} txt - TXT record value
* @returns {string|null} - DID or null if invalid
*/
export function parseDidFromTxt(txt) {
if (!txt) return null;
// Remove surrounding quotes if present
const unquoted = txt.replace(/^"|"$/g, '');
const match = unquoted.match(/^did=(.+)$/);
return match ? match[1] : null;
}
/**
* Lookup TXT records via DNS-over-HTTPS.
*
* @param {string} domain - Domain to lookup (e.g., "_atproto.bsky.app")
* @param {Object} [opts]
* @param {string} [opts.dohUrl] - DoH endpoint URL
* @param {typeof fetch} [opts.fetch] - Fetch implementation
* @returns {Promise<string[]>} - Array of TXT record values
*/
export async function lookupTxt(domain, opts = {}) {
const dohUrl = opts.dohUrl ?? DEFAULT_DOH_URL;
const fetchFn = opts.fetch ?? globalThis.fetch;
try {
const url = `${dohUrl}?name=${encodeURIComponent(domain)}&type=TXT`;
const response = await fetchFn(url, {
headers: { Accept: 'application/dns-json' },
});
if (!response.ok) return [];
const data = await response.json();
if (!data.Answer) return [];
// Extract TXT record values (type 16 = TXT)
return data.Answer
.filter((record) => record.type === 16)
.map((record) => {
// Remove surrounding quotes from data field
const value = record.data?.replace(/^"|"$/g, '') ?? '';
return value;
});
} catch {
return [];
}
}
```
**Step 4: Run test to verify it passes**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test packages/lexicon-resolver/test/dns.test.js
```
Expected: PASS (6 tests)
**Step 5: Commit**
```bash
git add packages/lexicon-resolver/src/dns.js packages/lexicon-resolver/test/dns.test.js
git commit -m "feat(lexicon-resolver): add dns module for DoH TXT lookups
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
```
---
## Task 3: Create did.js module
**Files:**
- Create: `packages/lexicon-resolver/src/did.js`
- Test: `packages/lexicon-resolver/test/did.test.js`
**Step 1: Write the failing test**
Create `packages/lexicon-resolver/test/did.test.js`:
```javascript
import { describe, expect, test, vi } from 'vitest';
import { resolveDid, extractPdsEndpoint } from '../src/did.js';
describe('did', () => {
describe('extractPdsEndpoint', () => {
test('extracts PDS endpoint from DID document', () => {
const didDoc = {
service: [
{
id: '#atproto_pds',
type: 'AtprotoPersonalDataServer',
serviceEndpoint: 'https://pds.example.com',
},
],
};
expect(extractPdsEndpoint(didDoc)).toBe('https://pds.example.com');
});
test('finds PDS by type if id differs', () => {
const didDoc = {
service: [
{
id: '#pds',
type: 'AtprotoPersonalDataServer',
serviceEndpoint: 'https://pds.example.com',
},
],
};
expect(extractPdsEndpoint(didDoc)).toBe('https://pds.example.com');
});
test('returns null if no PDS service', () => {
const didDoc = { service: [] };
expect(extractPdsEndpoint(didDoc)).toBeNull();
});
test('returns null if no service array', () => {
const didDoc = {};
expect(extractPdsEndpoint(didDoc)).toBeNull();
});
});
describe('resolveDid', () => {
test('resolves did:plc via PLC directory', async () => {
const mockFetch = vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({
service: [
{
id: '#atproto_pds',
type: 'AtprotoPersonalDataServer',
serviceEndpoint: 'https://bsky.social',
},
],
}),
});
const endpoint = await resolveDid('did:plc:xyz123', { fetch: mockFetch });
expect(mockFetch).toHaveBeenCalledWith('https://plc.directory/did:plc:xyz123');
expect(endpoint).toBe('https://bsky.social');
});
test('resolves did:web via .well-known', async () => {
const mockFetch = vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({
service: [
{
id: '#atproto_pds',
type: 'AtprotoPersonalDataServer',
serviceEndpoint: 'https://example.com',
},
],
}),
});
const endpoint = await resolveDid('did:web:example.com', { fetch: mockFetch });
expect(mockFetch).toHaveBeenCalledWith('https://example.com/.well-known/did.json');
expect(endpoint).toBe('https://example.com');
});
test('returns null for unknown DID method', async () => {
const endpoint = await resolveDid('did:unknown:xyz', { fetch: vi.fn() });
expect(endpoint).toBeNull();
});
test('returns null on fetch error', async () => {
const mockFetch = vi.fn().mockRejectedValue(new Error('Network error'));
const endpoint = await resolveDid('did:plc:xyz', { fetch: mockFetch });
expect(endpoint).toBeNull();
});
});
});
```
**Step 2: Run test to verify it fails**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test packages/lexicon-resolver/test/did.test.js
```
Expected: FAIL with "Cannot find module '../src/did.js'"
**Step 3: Write minimal implementation**
Create `packages/lexicon-resolver/src/did.js`:
```javascript
const DEFAULT_PLC_URL = 'https://plc.directory';
/**
* Extract PDS service endpoint from DID document.
*
* @param {Object} didDoc - DID document
* @returns {string|null} - PDS endpoint URL or null
*/
export function extractPdsEndpoint(didDoc) {
if (!didDoc?.service || !Array.isArray(didDoc.service)) {
return null;
}
const pdsService = didDoc.service.find(
(s) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer',
);
return pdsService?.serviceEndpoint ?? null;
}
/**
* Resolve a DID to its PDS service endpoint.
*
* @param {string} did - DID string (did:plc:... or did:web:...)
* @param {Object} [opts]
* @param {string} [opts.plcUrl] - PLC directory URL
* @param {typeof fetch} [opts.fetch] - Fetch implementation
* @returns {Promise<string|null>} - PDS endpoint URL or null
*/
export async function resolveDid(did, opts = {}) {
const plcUrl = opts.plcUrl ?? DEFAULT_PLC_URL;
const fetchFn = opts.fetch ?? globalThis.fetch;
try {
let didDocUrl;
if (did.startsWith('did:plc:')) {
didDocUrl = `${plcUrl}/${did}`;
} else if (did.startsWith('did:web:')) {
const domain = did.slice('did:web:'.length);
didDocUrl = `https://${domain}/.well-known/did.json`;
} else {
return null;
}
const response = await fetchFn(didDocUrl);
if (!response.ok) return null;
const didDoc = await response.json();
return extractPdsEndpoint(didDoc);
} catch {
return null;
}
}
```
**Step 4: Run test to verify it passes**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test packages/lexicon-resolver/test/did.test.js
```
Expected: PASS (8 tests)
**Step 5: Commit**
```bash
git add packages/lexicon-resolver/src/did.js packages/lexicon-resolver/test/did.test.js
git commit -m "feat(lexicon-resolver): add did module for DID resolution
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
```
---
## Task 4: Update package.json dependencies
**Files:**
- Modify: `packages/lexicon-resolver/package.json`
**Step 1: Update dependencies**
Replace contents of `packages/lexicon-resolver/package.json`:
```json
{
"name": "@pdsjs/lexicon-resolver",
"version": "0.1.0",
"type": "module",
"main": "src/index.js",
"exports": {
".": "./src/index.js",
"./resolver": "./src/resolver.js",
"./dns": "./src/dns.js",
"./did": "./src/did.js",
"./authority": "./src/authority.js"
},
"dependencies": {
"@bigmoves/lexicon": "^0.1.2"
},
"devDependencies": {
"vitest": "^2.1.8"
}
}
```
**Step 2: Install new dependencies**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm install
```
Expected: Installs `@bigmoves/lexicon`, removes `@atproto/lexicon` and `@atproto/lex-resolver`
**Step 3: Commit**
```bash
git add packages/lexicon-resolver/package.json pnpm-lock.yaml
git commit -m "chore(lexicon-resolver): switch to @bigmoves/lexicon
Remove @atproto/lexicon and @atproto/lex-resolver dependencies.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
```
---
## Task 5: Rewrite resolver.js
**Files:**
- Modify: `packages/lexicon-resolver/src/resolver.js`
- Modify: `packages/lexicon-resolver/test/resolver.test.js`
**Step 1: Rewrite resolver.js**
Replace contents of `packages/lexicon-resolver/src/resolver.js`:
```javascript
import { validateRecord } from '@bigmoves/lexicon';
import { lookupTxt, parseDidFromTxt } from './dns.js';
import { resolveDid } from './did.js';
import { nsidToDomain, domainToAtprotoDns } from './authority.js';
/**
* @typedef {import('@pdsjs/core/ports').ValidationStatus} ValidationStatus
*/
/**
* Lexicon resolver with full AT Protocol spec compliance.
* Resolves schemas via DNS authority lookup, DID resolution, and PDS fetch.
* Validates records using @bigmoves/lexicon.
*
* Implements LexiconResolverPort.
*/
export class LexiconResolver {
/**
* @param {Object} [opts]
* @param {number} [opts.ttl=3600000] - Cache TTL in ms (default 1 hour)
* @param {typeof fetch} [opts.fetch] - Fetch implementation
* @param {string} [opts.dohUrl] - DNS-over-HTTPS endpoint
* @param {string} [opts.plcUrl] - PLC directory URL
* @param {Array<{id: string, defs: Object}>} [opts.schemas] - Pre-loaded static schemas
*/
constructor(opts = {}) {
/** @type {Map<string, {id: string, defs: Object}>} */
this.schemas = new Map();
/** @type {Map<string, {fetchedAt: number}>} */
this.cache = new Map();
this.ttl = opts.ttl ?? 3600000;
this.fetch = opts.fetch ?? globalThis.fetch;
this.dohUrl = opts.dohUrl;
this.plcUrl = opts.plcUrl;
// Pre-load static schemas
for (const schema of opts.schemas ?? []) {
this.schemas.set(schema.id, schema);
this.cache.set(schema.id, { fetchedAt: Date.now() });
}
}
/**
* Validate a record against its schema.
* @param {string} collection - The collection/NSID (e.g., 'app.bsky.feed.post')
* @param {object} record - The record to validate
* @returns {Promise<ValidationStatus>}
*/
async assertValid(collection, record) {
const hasSchema = await this.ensureSchema(collection);
if (!hasSchema) {
return 'unknown';
}
const schema = this.schemas.get(collection);
const error = validateRecord([schema], collection, record);
if (error) {
const path = error.path ? `${error.path}: ` : '';
throw new Error(`${path}${error.message}`);
}
return 'valid';
}
/**
* Ensure a schema is loaded, fetching if necessary.
* @param {string} nsid
* @returns {Promise<boolean>} - true if schema is available
*/
async ensureSchema(nsid) {
// Check if already loaded and not stale
const cached = this.cache.get(nsid);
if (cached && Date.now() - cached.fetchedAt < this.ttl) {
return this.schemas.has(nsid);
}
// Already have it, just not checking staleness
if (this.schemas.has(nsid)) {
return true;
}
// Try to resolve via DNS -> DID -> PDS
try {
const lexicon = await this.fetchLexicon(nsid);
if (lexicon) {
this.schemas.set(nsid, lexicon);
this.cache.set(nsid, { fetchedAt: Date.now() });
return true;
}
} catch {
// Resolution failed
}
return false;
}
/**
* Fetch a lexicon via the AT Protocol resolution chain.
* @param {string} nsid
* @returns {Promise<{id: string, defs: Object}|null>}
*/
async fetchLexicon(nsid) {
// 1. Convert NSID to domain
const domain = nsidToDomain(nsid);
const dnsName = domainToAtprotoDns(domain);
// 2. DNS TXT lookup
const txtRecords = await lookupTxt(dnsName, {
dohUrl: this.dohUrl,
fetch: this.fetch,
});
// 3. Parse DID from TXT record
let did = null;
for (const txt of txtRecords) {
did = parseDidFromTxt(txt);
if (did) break;
}
if (!did) return null;
// 4. Resolve DID to PDS endpoint
const pdsEndpoint = await resolveDid(did, {
plcUrl: this.plcUrl,
fetch: this.fetch,
});
if (!pdsEndpoint) return null;
// 5. Fetch lexicon from PDS
const url = `${pdsEndpoint}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(did)}&collection=com.atproto.lexicon.schema&rkey=${encodeURIComponent(nsid)}`;
const response = await this.fetch(url);
if (!response.ok) return null;
const data = await response.json();
return data.value ?? null;
}
}
```
**Step 2: Update test file**
Replace contents of `packages/lexicon-resolver/test/resolver.test.js`:
```javascript
import { describe, expect, test, vi } from 'vitest';
import { LexiconResolver } from '../src/resolver.js';
/** @type {import('@bigmoves/lexicon').Lexicon} */
const postSchema = {
lexicon: 1,
id: 'app.bsky.feed.post',
defs: {
main: {
type: 'record',
key: 'tid',
record: {
type: 'object',
required: ['text', 'createdAt'],
properties: {
text: { type: 'string', maxLength: 3000 },
createdAt: { type: 'string', format: 'datetime' },
},
},
},
},
};
describe('LexiconResolver', () => {
describe('with static schemas', () => {
test('validates record against pre-loaded schema', async () => {
const resolver = new LexiconResolver({
schemas: [postSchema],
});
const status = await resolver.assertValid('app.bsky.feed.post', {
$type: 'app.bsky.feed.post',
text: 'Hello world',
createdAt: new Date().toISOString(),
});
expect(status).toBe('valid');
});
test('throws on invalid record', async () => {
const resolver = new LexiconResolver({
schemas: [postSchema],
});
await expect(
resolver.assertValid('app.bsky.feed.post', {
$type: 'app.bsky.feed.post',
// missing required fields
}),
).rejects.toThrow();
});
test('returns unknown for unloaded schema', async () => {
const resolver = new LexiconResolver({
schemas: [postSchema],
});
const status = await resolver.assertValid('com.example.unknown', {
$type: 'com.example.unknown',
});
expect(status).toBe('unknown');
});
});
describe('ensureSchema', () => {
test('returns true for pre-loaded schema', async () => {
const resolver = new LexiconResolver({
schemas: [postSchema],
});
const result = await resolver.ensureSchema('app.bsky.feed.post');
expect(result).toBe(true);
});
test('returns false for unknown schema when resolution fails', async () => {
const mockFetch = vi.fn().mockRejectedValue(new Error('Network error'));
const resolver = new LexiconResolver({ fetch: mockFetch });
const result = await resolver.ensureSchema('com.example.unknown');
expect(result).toBe(false);
});
});
describe('fetchLexicon', () => {
test('resolves lexicon via DNS -> DID -> PDS chain', async () => {
const mockFetch = vi
.fn()
// DNS lookup
.mockResolvedValueOnce({
ok: true,
json: () =>
Promise.resolve({
Answer: [{ type: 16, data: '"did=did:plc:testdid"' }],
}),
})
// DID resolution
.mockResolvedValueOnce({
ok: true,
json: () =>
Promise.resolve({
service: [
{
id: '#atproto_pds',
type: 'AtprotoPersonalDataServer',
serviceEndpoint: 'https://pds.example.com',
},
],
}),
})
// Lexicon fetch
.mockResolvedValueOnce({
ok: true,
json: () => Promise.resolve({ value: postSchema }),
});
const resolver = new LexiconResolver({ fetch: mockFetch });
const lexicon = await resolver.fetchLexicon('app.bsky.feed.post');
expect(lexicon).toEqual(postSchema);
expect(mockFetch).toHaveBeenCalledTimes(3);
});
});
});
```
**Step 3: Run tests**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test packages/lexicon-resolver/
```
Expected: PASS (all tests in lexicon-resolver)
**Step 4: Commit**
```bash
git add packages/lexicon-resolver/src/resolver.js packages/lexicon-resolver/test/resolver.test.js
git commit -m "feat(lexicon-resolver): rewrite resolver with custom DNS/DID resolution
- Use @bigmoves/lexicon for validation
- Custom DNS-over-HTTPS authority resolution
- Custom DID resolution (PLC + did:web)
- Full AT Protocol spec compliance
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
```
---
## Task 6: Update index.js exports
**Files:**
- Modify: `packages/lexicon-resolver/src/index.js`
**Step 1: Update exports**
Replace contents of `packages/lexicon-resolver/src/index.js`:
```javascript
export { LexiconResolver } from './resolver.js';
export { lookupTxt, parseDidFromTxt } from './dns.js';
export { resolveDid, extractPdsEndpoint } from './did.js';
export { nsidToDomain, domainToAtprotoDns } from './authority.js';
```
**Step 2: Commit**
```bash
git add packages/lexicon-resolver/src/index.js
git commit -m "feat(lexicon-resolver): export utility functions
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
```
---
## Task 7: Run full test suite and typecheck
**Step 1: Run all tests**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm test
```
Expected: All tests pass
**Step 2: Run typecheck**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm typecheck
```
Expected: No errors
**Step 3: Run lint**
```bash
cd /Users/chadmiller/code/pds-experiment && pnpm lint
```
Expected: No errors
---
## Summary
After completing all tasks:
1. **`@pdsjs/lexicon-resolver`** now uses:
- `@bigmoves/lexicon` for validation (zero dependencies)
- Custom `dns.js` for DNS-over-HTTPS TXT lookups
- Custom `did.js` for DID resolution (PLC + did:web)
- Custom `authority.js` for NSID to domain conversion
2. **Removed dependencies:**
- `@atproto/lexicon`
- `@atproto/lex-resolver`
3. **Universal runtime support:** Node, Cloudflare Workers, Deno
4. **Usage unchanged:**
```javascript
import { LexiconResolver } from '@pdsjs/lexicon-resolver';
const resolver = new LexiconResolver({
schemas: [/* optional static schemas */],
});
// Validates via DNS -> DID -> PDS resolution chain
const status = await resolver.assertValid('app.bsky.feed.post', record);
```