feat(tap): initial commit

README.md

···
 | [`client`](./packages/clients/client): XRPC HTTP client                                                     |
 | [`firehose`](./packages/clients/firehose): XRPC subscription client                                         |
 | [`jetstream`](./packages/clients/jetstream): Jetstream WebSocket client                                     |
+| [`tap`](./packages/clients/tap): Tap WebSocket client                                                       |
 | [`cache`](./packages/clients/cache): normalized cache store                                                 |
 | **Server packages**                                                                                         |
 | [`xrpc-server`](./packages/servers/xrpc-server): XRPC web framework                                         |
···
 | [`xrpc-server-node`](./packages/servers/xrpc-server-node): Node.js WebSocket adapter                        |
 | **OAuth packages**                                                                                          |
 | [`oauth-browser-client`](./packages/oauth/browser-client): minimal OAuth client for SPAs                    |
+| [`oauth-node-client`](./packages/oauth/node-client): OAuth client for Node.js                               |
 | **Lexicon packages**                                                                                        |
 | [`lex-cli`](./packages/lexicons/lex-cli): generate TypeScript from lexicon schemas                          |
 | [`lexicon-doc`](./packages/lexicons/lexicon-doc): parse and author lexicon documents                        |

packages/clients/tap/README.md

···
+# @atcute/tap
+
+an atproto Tap client.
+
+```sh
+npm install @atcute/tap
+```
+
+Tap is a sync utility that connects to the relay firehose, verifies data, performs backfill, and
+streams simple JSON events to clients over a local websocket.
+
+## usage
+
+```ts
+import { TapClient } from '@atcute/tap';
+
+const tap = new TapClient({
+	url: 'http://localhost:2480',
+	// adminPassword: process.env.TAP_ADMIN_PASSWORD,
+});
+
+await tap.addRepos(['did:plc:...']);
+
+for await (const { event, ack } of tap.subscribe()) {
+	// process event idempotently
+	await ack();
+}
+```
+
+## acks
+
+Tap’s default mode requires that clients acknowledge each event after it has been processed. if you
+don’t call `ack()`, Tap will retry delivery later.

packages/clients/tap/lib/dev-index.ts

···
+import { TapClient } from './tap-client.js';
+
+const tap = new TapClient({ url: 'http://localhost:2480' });
+
+const subscription = tap.subscribe({
+	onConnectionOpen() {
+		console.log(`ws open`);
+	},
+	onConnectionClose() {
+		console.log(`ws close`);
+	},
+	onConnectionError(ev) {
+		console.log(`ws error`, ev);
+	},
+	onError(err) {
+		console.error('tap subscription error', err);
+	},
+});
+
+for await (const { event, ack } of subscription) {
+	console.log(event);
+
+	await ack();
+}

packages/clients/tap/lib/index.ts

···
+export { TapClient } from './tap-client.js';
+export { TapSubscription } from './tap-subscription.js';
+
+export * as defs from './typedefs.js';
+export type * from './types.js';

packages/clients/tap/lib/tap-client.ts

···
+import { defs as identityDefs, type DidDocument } from '@atcute/identity';
+
+import type { Did } from '@atcute/lexicons';
+
+import { TapSubscription } from './tap-subscription.js';
+import { repoInfoSchema } from './typedefs.js';
+import type { RepoInfo, TapClientOptions, TapSubscribeOptions } from './types.js';
+import { formatAdminAuthHeader } from './utils.js';
+
+export class TapClient {
+	#url: URL;
+	#fetch: typeof globalThis.fetch;
+	#adminPassword?: string;
+	#authHeader?: string;
+
+	constructor(options: TapClientOptions) {
+		const url = typeof options.url === 'string' ? new URL(options.url) : new URL(options.url);
+
+		if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+			throw new Error(`invalid url protocol, expected http: or https:, got ${url.protocol}`);
+		}
+
+		this.#url = url;
+		this.#fetch = options.fetch ?? fetch;
+
+		if (options.adminPassword) {
+			this.#adminPassword = options.adminPassword;
+			this.#authHeader = formatAdminAuthHeader(options.adminPassword);
+		}
+	}
+
+	subscribe(options?: TapSubscribeOptions): TapSubscription {
+		const wsUrl = new URL(this.#url);
+		wsUrl.protocol = wsUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+		wsUrl.pathname = '/channel';
+
+		return new TapSubscription({
+			url: wsUrl.toString(),
+			adminPassword: this.#adminPassword,
+			...options,
+		});
+	}
+
+	async addRepos(dids: Did[]): Promise<void> {
+		const response = await this.#fetch(new URL('/repos/add', this.#url), {
+			method: 'POST',
+			headers: this.#getHeaders(),
+			body: JSON.stringify({ dids }),
+		});
+
+		await response.body?.cancel();
+		if (!response.ok) {
+			throw new Error(`failed to add repos: ${response.status} ${response.statusText}`);
+		}
+	}
+
+	async removeRepos(dids: Did[]): Promise<void> {
+		const response = await this.#fetch(new URL('/repos/remove', this.#url), {
+			method: 'POST',
+			headers: this.#getHeaders(),
+			body: JSON.stringify({ dids }),
+		});
+
+		await response.body?.cancel();
+		if (!response.ok) {
+			throw new Error(`failed to remove repos: ${response.status} ${response.statusText}`);
+		}
+	}
+
+	async resolveDid(did: Did): Promise<DidDocument | null> {
+		const response = await this.#fetch(new URL(`/resolve/${did}`, this.#url), {
+			method: 'GET',
+			headers: this.#getHeaders(),
+		});
+
+		if (response.status === 404) {
+			await response.body?.cancel();
+			return null;
+		}
+
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new Error(`failed to resolve did: ${response.status} ${response.statusText}`);
+		}
+
+		return identityDefs.didDocument.parse(await response.json());
+	}
+
+	async getRepoInfo(did: Did): Promise<RepoInfo> {
+		const response = await this.#fetch(new URL(`/info/${did}`, this.#url), {
+			method: 'GET',
+			headers: this.#getHeaders(),
+		});
+
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new Error(`failed to get repo info: ${response.status} ${response.statusText}`);
+		}
+
+		return repoInfoSchema.parse(await response.json());
+	}
+
+	#getHeaders(): Record<string, string> {
+		const headers: Record<string, string> = {
+			'Content-Type': 'application/json',
+		};
+
+		if (this.#authHeader) {
+			headers['Authorization'] = this.#authHeader;
+		}
+
+		return headers;
+	}
+}

packages/clients/tap/lib/tap-subscription.test.ts

···
+import { describe, expect, it } from 'vitest';
+import { WebSocketServer, type RawData, type WebSocket } from 'ws';
+
+import * as v from '@badrap/valita';
+import { TapSubscription } from './tap-subscription.js';
+import { tapRecordEventWireSchema } from './typedefs.js';
+
+import { decodeUtf8From } from '@atcute/uint8array';
+
+type RecordEventWire = v.Infer<typeof tapRecordEventWireSchema>;
+
+const createRecordEvent = (id: number): RecordEventWire => ({
+	id,
+	type: 'record',
+	record: {
+		did: 'did:plc:ewvi7nxzyoun6zhxrhs64oiz',
+		rev: '3k3m5z2zq2f2x',
+		collection: 'app.bsky.feed.post',
+		rkey: '3k3m5z2zq2f2x',
+		action: 'create',
+		record: { text: 'hello', $type: 'app.bsky.feed.post' },
+		cid: 'bafyreigkq6j3o7v2xq2xq2xq2xq2xq2xq2xq2xq2xq2xq2xq2xq2x',
+		live: true,
+	},
+});
+
+describe('tap subscription', () => {
+	it('receives events and sends acks', async () => {
+		const server = new WebSocketServer({ port: 0 });
+		const address = server.address();
+		if (typeof address === 'string' || address === null) {
+			throw new Error(`unexpected ws address`);
+		}
+
+		const receivedAcks: number[] = [];
+
+		server.on('connection', (socket: WebSocket) => {
+			socket.send(JSON.stringify(createRecordEvent(42)));
+			socket.on('message', (data: RawData) => {
+				const msg = JSON.parse(typeof data === 'string' ? data : decodeUtf8From(data as Uint8Array));
+				if (msg.type === 'ack') {
+					receivedAcks.push(msg.id);
+					socket.close();
+				}
+			});
+		});
+
+		const subscription = new TapSubscription({
+			url: `ws://127.0.0.1:${address.port}/channel`,
+		});
+
+		const iterator = subscription[Symbol.asyncIterator]();
+		const next = await iterator.next();
+		if (next.done) {
+			throw new Error(`expected message`);
+		}
+
+		expect(next.value.event.type).toBe('record');
+		await next.value.ack();
+
+		await iterator.return?.();
+
+		await new Promise<void>((resolve) => server.close(() => resolve()));
+		expect(receivedAcks).toEqual([42]);
+	});
+
+	it('drops malformed messages', async () => {
+		const server = new WebSocketServer({ port: 0 });
+		const address = server.address();
+		if (typeof address === 'string' || address === null) {
+			throw new Error(`unexpected ws address`);
+		}
+
+		let errors = 0;
+
+		server.on('connection', (socket: WebSocket) => {
+			socket.send('not json');
+			setTimeout(() => socket.close(), 25);
+		});
+
+		const subscription = new TapSubscription({
+			url: `ws://127.0.0.1:${address.port}/channel`,
+			onError: () => {
+				errors++;
+			},
+		});
+
+		const iterator = subscription[Symbol.asyncIterator]();
+		await new Promise((resolve) => setTimeout(resolve, 75));
+		await iterator.return?.();
+
+		await new Promise<void>((resolve) => server.close(() => resolve()));
+		expect(errors).toBeGreaterThan(0);
+	});
+});

packages/clients/tap/lib/tap-subscription.ts

···
+import { EventIterator } from '@mary-ext/event-iterator';
+import { SimpleEventEmitter } from '@mary-ext/simple-event-emitter';
+import { WebSocket as ReconnectingWebSocket } from 'partysocket';
+
+import type { ReadonlyDeep } from 'type-fest';
+
+import { decodeUtf8From } from '@atcute/uint8array';
+
+import { flattenTapEvent, tapEventWireSchema } from './typedefs.js';
+import type { TapEvent, TapSubscribeOptions, TapSubscriptionMessage } from './types.js';
+import { formatAdminAuthHeader } from './utils.js';
+
+export interface TapSubscriptionOptions extends TapSubscribeOptions {
+	url: string;
+	adminPassword?: string;
+}
+
+type BufferedAck = {
+	id: number;
+	promise: Promise<void>;
+	resolve: (value: void) => void;
+	reject: (reason?: unknown) => void;
+};
+
+const PARSE_OPTIONS = { mode: 'passthrough' } as const;
+
+export class TapSubscription {
+	#listening = 0;
+	#ws?: ReconnectingWebSocket;
+
+	#emitter = new SimpleEventEmitter<[message: TapSubscriptionMessage]>();
+	#bufferedAcks: BufferedAck[] = [];
+
+	#options: TapSubscriptionOptions;
+	#closed = false;
+
+	constructor(options: TapSubscriptionOptions) {
+		this.#options = options;
+	}
+
+	#sendAck(id: number): boolean {
+		const ws = this.#ws;
+		if (ws === undefined) {
+			return false;
+		}
+
+		if (ws.readyState !== 1) {
+			return false;
+		}
+
+		ws.send(JSON.stringify({ type: 'ack', id }));
+		return true;
+	}
+
+	async #ackEvent(id: number): Promise<void> {
+		if (this.#closed) {
+			throw new Error(`tap subscription is closed`);
+		}
+
+		try {
+			if (this.#sendAck(id)) {
+				return;
+			}
+		} catch {
+			// fall through to buffering
+		}
+
+		const { promise, resolve, reject } = Promise.withResolvers<void>();
+		this.#bufferedAcks.push({ id, promise, resolve, reject });
+		return await promise;
+	}
+
+	#flushBufferedAcks() {
+		while (this.#bufferedAcks.length > 0) {
+			const ack = this.#bufferedAcks[0];
+			if (ack === undefined) {
+				return;
+			}
+
+			try {
+				if (!this.#sendAck(ack.id)) {
+					return;
+				}
+
+				ack.resolve(undefined);
+				this.#bufferedAcks = this.#bufferedAcks.slice(1);
+			} catch (err) {
+				this.#options.onError?.(err);
+				return;
+			}
+		}
+	}
+
+	#create() {
+		if (this.#ws !== undefined) {
+			return;
+		}
+
+		const {
+			url,
+			adminPassword,
+			ws: wsOptions,
+			validateEvents = true,
+			onConnectionClose,
+			onConnectionError,
+			onConnectionOpen,
+			onError,
+		} = this.#options;
+
+		const emitter = this.#emitter;
+
+		const authHeader = adminPassword ? formatAdminAuthHeader(adminPassword) : undefined;
+
+		const mergedWsOptions =
+			authHeader !== undefined && wsOptions?.WebSocket === undefined
+				? {
+						...wsOptions,
+						WebSocket: createAuthedWebSocket(authHeader),
+					}
+				: wsOptions;
+
+		const ws = new ReconnectingWebSocket(() => url, null, mergedWsOptions);
+		this.#ws = ws;
+
+		ws.binaryType = 'arraybuffer';
+
+		ws.onclose = onConnectionClose ?? null;
+		ws.onerror = onConnectionError ?? null;
+
+		ws.onopen = (ev) => {
+			this.#flushBufferedAcks();
+			onConnectionOpen?.(ev);
+		};
+
+		ws.onmessage = (ev) => {
+			let raw: unknown;
+			try {
+				const data = toMessageText(ev.data);
+				raw = JSON.parse(data);
+			} catch (err) {
+				onError?.(new Error(`failed to parse tap message`, { cause: err }));
+				return;
+			}
+
+			let evt: TapEvent;
+			if (validateEvents) {
+				const result = tapEventWireSchema.try(raw, PARSE_OPTIONS);
+				if (!result.ok) {
+					onError?.(result);
+					return;
+				}
+
+				evt = flattenTapEvent(result.value);
+			} else {
+				try {
+					evt = flattenTapEvent(raw as any);
+				} catch (err) {
+					onError?.(err);
+					return;
+				}
+			}
+
+			let acked = false;
+			let ackPromise: Promise<void> | undefined;
+
+			emitter.emit({
+				event: evt,
+				ack: () => {
+					if (!acked) {
+						acked = true;
+						ackPromise = this.#ackEvent(evt.id);
+					}
+					return ackPromise!;
+				},
+			});
+		};
+	}
+
+	#destroy() {
+		const ws = this.#ws;
+		if (ws) {
+			ws.close();
+			this.#ws = undefined;
+		}
+
+		this.#closed = true;
+
+		if (this.#bufferedAcks.length > 0) {
+			const err = new Error(`tap subscription closed before ack was sent`);
+			for (const ack of this.#bufferedAcks) {
+				ack.reject(err);
+			}
+			this.#bufferedAcks = [];
+		}
+	}
+
+	[Symbol.asyncIterator]() {
+		return new EventIterator<TapSubscriptionMessage>((emit) => {
+			if (this.#listening === 0) {
+				this.#closed = false;
+				this.#create();
+			}
+
+			this.#listening++;
+			this.#emitter.subscribe(emit);
+
+			return () => {
+				if (this.#listening === 1) {
+					this.#destroy();
+				}
+
+				this.#listening--;
+				this.#emitter.unsubscribe(emit);
+			};
+		});
+	}
+
+	getOptions(): ReadonlyDeep<TapSubscriptionOptions> {
+		return this.#options;
+	}
+
+	updateOptions(options: Partial<TapSubscriptionOptions>): void {
+		this.#options = { ...this.#options, ...options };
+
+		if (this.#ws !== undefined) {
+			this.#destroy();
+			this.#closed = false;
+			this.#create();
+		}
+	}
+}
+
+const toMessageText = (data: unknown): string => {
+	if (typeof data === 'string') {
+		return data;
+	}
+
+	if (data instanceof ArrayBuffer) {
+		return decodeUtf8From(new Uint8Array(data));
+	}
+
+	if (ArrayBuffer.isView(data)) {
+		return decodeUtf8From(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+	}
+
+	return String(data);
+};
+
+const createAuthedWebSocket = (authorization: string) => {
+	const WebSocketCtor = WebSocket as unknown as {
+		new (
+			url: string | URL,
+			protocols?: string | string[],
+			options?: { headers?: Record<string, string> },
+		): WebSocket;
+	};
+
+	return class AuthedWebSocket extends WebSocketCtor {
+		constructor(url: string | URL, protocols?: string | string[]) {
+			super(url, protocols as any, {
+				headers: {
+					Authorization: authorization,
+				},
+			});
+		}
+	};
+};

packages/clients/tap/lib/typedefs.ts

···
+import * as v from '@badrap/valita';
+
+import { isDid, isHandle, isNsid, isRecordKey, isTid } from '@atcute/lexicons/syntax';
+
+import type * as t from './types.js';
+
+const didString = v.string().assert(isDid, `must be a did`);
+const handleString = v.string().assert(isHandle, `must be a handle`);
+const nsidString = v.string().assert(isNsid, `must be an nsid`);
+const rkeyString = v.string().assert(isRecordKey, `must be a record key`);
+const tidString = v.string().assert(isTid, `must be a tid`);
+
+const integer = v
+	.number()
+	.assert((input) => input >= 0 && Number.isSafeInteger(input), `must be a nonnegative integer`);
+
+const recordEventDataSchema = v.object({
+	did: didString,
+	rev: tidString,
+	collection: nsidString,
+	rkey: rkeyString,
+	action: v.union(v.literal('create'), v.literal('update'), v.literal('delete')),
+	record: v.record(v.unknown()).optional(),
+	cid: v.string().optional(),
+	live: v.boolean(),
+});
+
+const identityEventDataSchema = v.object({
+	did: didString,
+	handle: handleString,
+	is_active: v.boolean(),
+	status: v.union(
+		v.literal('active'),
+		v.literal('takendown'),
+		v.literal('suspended'),
+		v.literal('deactivated'),
+		v.literal('deleted'),
+	),
+});
+
+export const tapRecordEventWireSchema = v.object({
+	id: integer,
+	type: v.literal('record'),
+	record: recordEventDataSchema,
+});
+
+export const tapIdentityEventWireSchema = v.object({
+	id: integer,
+	type: v.literal('identity'),
+	identity: identityEventDataSchema,
+});
+
+export const tapEventWireSchema = v.union(tapRecordEventWireSchema, tapIdentityEventWireSchema);
+
+export const repoInfoSchema: v.Type<t.RepoInfo> = v.object({
+	did: didString,
+	handle: handleString,
+	state: v.string(),
+	rev: tidString,
+	records: integer,
+	error: v.string().optional(),
+	retries: integer.optional(),
+});
+
+export const flattenTapEvent = (wire: v.Infer<typeof tapEventWireSchema>): t.TapEvent => {
+	switch (wire.type) {
+		case 'identity': {
+			return {
+				id: wire.id,
+				type: 'identity',
+
+				did: wire.identity.did,
+				handle: wire.identity.handle,
+				isActive: wire.identity.is_active,
+				status: wire.identity.status,
+			};
+		}
+
+		case 'record': {
+			return {
+				id: wire.id,
+				type: 'record',
+				live: wire.record.live,
+
+				rev: wire.record.rev,
+				did: wire.record.did,
+				collection: wire.record.collection,
+				rkey: wire.record.rkey,
+				cid: wire.record.cid,
+				action: wire.record.action,
+				record: wire.record.record,
+			};
+		}
+
+		default: {
+			wire satisfies never;
+
+			const obj = wire as any;
+			throw new Error(`unknown "${obj.type}" type`);
+		}
+	}
+};

packages/clients/tap/lib/types.ts

···
+import type { Did, Handle, Nsid, RecordKey, Tid } from '@atcute/lexicons/syntax';
+import type { CloseEvent, ErrorEvent, Options } from 'partysocket/ws';
+
+export type TapRecordAction = 'create' | 'update' | 'delete';
+
+export type TapRepoStatus = 'active' | 'takendown' | 'suspended' | 'deactivated' | 'deleted';
+
+export interface TapRecordEvent {
+	id: number;
+	type: 'record';
+
+	live: boolean;
+	did: Did;
+	rev: Tid;
+	collection: Nsid;
+	rkey: RecordKey;
+	action: TapRecordAction;
+	record?: Record<string, unknown>;
+	cid?: string;
+}
+
+export interface TapIdentityEvent {
+	id: number;
+	type: 'identity';
+
+	did: Did;
+	handle: Handle;
+	isActive: boolean;
+	status: TapRepoStatus;
+}
+
+export type TapEvent = TapRecordEvent | TapIdentityEvent;
+
+export interface RepoInfo {
+	did: Did;
+	handle: Handle;
+	state: string;
+	rev: Tid;
+	records: number;
+	error?: string;
+	retries?: number;
+}
+
+export interface TapClientOptions {
+	url: string | URL;
+	adminPassword?: string;
+	fetch?: typeof globalThis.fetch;
+}
+
+export interface TapSubscribeOptions {
+	/**
+	 * whether to validate incoming events.
+	 * @default true
+	 */
+	validateEvents?: boolean;
+
+	onConnectionOpen?: (event: Event) => void;
+	onConnectionClose?: (event: CloseEvent) => void;
+	onConnectionError?: (event: ErrorEvent) => void;
+	onError?: (error: unknown) => void;
+
+	ws?: Options;
+}
+
+export interface TapSubscriptionMessage {
+	event: TapEvent;
+	ack: () => Promise<void>;
+}

packages/clients/tap/lib/utils.ts

···
+import { toBase64Pad } from '@atcute/multibase';
+import { encodeUtf8 } from '@atcute/uint8array';
+
+export const formatAdminAuthHeader = (password: string): string => {
+	return `Basic ${toBase64Pad(encodeUtf8(`admin:${password}`))}`;
+};

packages/clients/tap/package.json

···
+{
+	"type": "module",
+	"name": "@atcute/tap",
+	"version": "0.1.0",
+	"description": "an atproto Tap client",
+	"license": "0BSD",
+	"repository": {
+		"url": "https://github.com/mary-ext/atcute",
+		"directory": "packages/clients/tap"
+	},
+	"files": [
+		"dist/",
+		"lib/",
+		"!lib/**/*.bench.ts",
+		"!lib/**/*.test.ts"
+	],
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"scripts": {
+		"build": "tsgo --project tsconfig.build.json",
+		"test": "vitest run",
+		"prepublish": "rm -rf dist; pnpm run build"
+	},
+	"dependencies": {
+		"@atcute/multibase": "workspace:^",
+		"@atcute/uint8array": "workspace:^",
+		"@atcute/identity": "workspace:^",
+		"@atcute/lexicons": "workspace:^",
+		"@badrap/valita": "^0.4.6",
+		"@mary-ext/event-iterator": "^1.0.0",
+		"@mary-ext/simple-event-emitter": "^1.0.0",
+		"partysocket": "^1.1.6",
+		"type-fest": "^4.41.0"
+	},
+	"devDependencies": {
+		"@types/ws": "^8.18.1",
+		"vitest": "^4.0.14",
+		"ws": "^8.18.3"
+	}
+}

packages/clients/tap/tsconfig.build.json

···
+{
+	"extends": "./tsconfig.json",
+	"exclude": ["**/*.test.ts"]
+}
+

packages/clients/tap/tsconfig.json

···
+{
+	"compilerOptions": {
+		"outDir": "dist/",
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"target": "ESNext",
+		"allowJs": true,
+		"resolveJsonModule": true,
+		"moduleDetection": "force",
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"strict": true,
+		"noImplicitOverride": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"useDefineForClassFields": false,
+		"noFallthroughCasesInSwitch": true,
+		"module": "NodeNext",
+		"sourceMap": true,
+		"declaration": true,
+		"declarationMap": true
+	},
+	"include": ["lib"]
+}
+

packages/clients/tap/vitest.config.ts

···
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+	test: {
+		include: ['lib/**/*.test.ts'],
+	},
+});

pnpm-lock.yaml

···
         specifier: ^4.41.0
         version: 4.41.0
 
+  packages/clients/tap:
+    dependencies:
+      '@atcute/identity':
+        specifier: workspace:^
+        version: link:../../identity/identity
+      '@atcute/lexicons':
+        specifier: workspace:^
+        version: link:../../lexicons/lexicons
+      '@atcute/multibase':
+        specifier: workspace:^
+        version: link:../../utilities/multibase
+      '@atcute/uint8array':
+        specifier: workspace:^
+        version: link:../../misc/uint8array
+      '@badrap/valita':
+        specifier: ^0.4.6
+        version: 0.4.6
+      '@mary-ext/event-iterator':
+        specifier: ^1.0.0
+        version: 1.0.0
+      '@mary-ext/simple-event-emitter':
+        specifier: ^1.0.0
+        version: 1.0.0
+      partysocket:
+        specifier: ^1.1.6
+        version: 1.1.6
+      type-fest:
+        specifier: ^4.41.0
+        version: 4.41.0
+    devDependencies:
+      '@types/ws':
+        specifier: ^8.18.1
+        version: 8.18.1
+      vitest:
+        specifier: ^4.0.14
+        version: 4.0.15(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.0)
+      ws:
+        specifier: ^8.18.3
+        version: 8.18.3
+
   packages/definitions/atproto:
     dependencies:
       '@atcute/lexicons':
···
     optionalDependencies:
       vite: 7.2.4(@types/node@22.19.1)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.0)
 
+  '@vitest/mocker@4.0.15(vite@7.2.4(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.0))':
+    dependencies:
+      '@vitest/spy': 4.0.15
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.2.4(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.0)
+
   '@vitest/pretty-format@4.0.14':
     dependencies:
       tinyrainbow: 3.0.3
···
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 22.19.1
+    transitivePeerDependencies:
+      - jiti
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - terser
+      - tsx
+      - yaml
+
+  vitest@4.0.15(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.0):
+    dependencies:
+      '@vitest/expect': 4.0.15
+      '@vitest/mocker': 4.0.15(vite@7.2.4(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.0))
+      '@vitest/pretty-format': 4.0.15
+      '@vitest/runner': 4.0.15
+      '@vitest/snapshot': 4.0.15
+      '@vitest/spy': 4.0.15
+      '@vitest/utils': 4.0.15
+      es-module-lexer: 1.7.0
+      expect-type: 1.2.2
+      magic-string: 0.30.21
+      obug: 2.1.1
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 3.10.0
+      tinybench: 2.9.0
+      tinyexec: 1.0.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.0.3
+      vite: 7.2.4(@types/node@24.10.1)(jiti@2.6.1)(tsx@4.20.6)(yaml@2.8.0)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 24.10.1
     transitivePeerDependencies:
       - jiti
       - less