refactor: use `@atcute/identity` family of packages

package.json

···
 		"@atcute/cbor": "^2.1.3",
 		"@atcute/client": "^2.0.8",
 		"@atcute/crypto": "^2.2.0",
+		"@atcute/did-plc": "^0.1.0",
+		"@atcute/identity": "^0.1.1",
+		"@atcute/identity-resolver": "^0.1.2",
 		"@atcute/multibase": "^1.1.2",
 		"@badrap/valita": "^0.4.3",
 		"@mary/array-fns": "npm:@jsr/mary__array-fns@^0.1.4",

pnpm-lock.yaml

···
       '@atcute/crypto':
         specifier: ^2.2.0
         version: 2.2.0
+      '@atcute/did-plc':
+        specifier: ^0.1.0
+        version: 0.1.0
+      '@atcute/identity':
+        specifier: ^0.1.1
+        version: 0.1.1
+      '@atcute/identity-resolver':
+        specifier: ^0.1.2
+        version: 0.1.2(@atcute/identity@0.1.1)
       '@atcute/multibase':
         specifier: ^1.1.2
         version: 1.1.2
···
   '@atcute/crypto@2.2.0':
     resolution: {integrity: sha512-Q/64Qn1AI8J0ZNy4hPDPpW/3poKf4OWRUxIYceCDI+btEOcIG5YMlhEQeZd6ojnI3oBMXy03sbOktekaBYRK9Q==}
 
+  '@atcute/did-plc@0.1.0':
+    resolution: {integrity: sha512-ORW9s9etge/icaJEcbAMiZEFWbydljqHngqU0fSR94KZiK2bXRZxMec7ktpO9oXLDKuSeFH9H23i1xlyqCwjjw==}
+
+  '@atcute/identity-resolver@0.1.2':
+    resolution: {integrity: sha512-fP2VbHD04kVcCdNi/Kszo6jFzqM7Pg3p33oGhfp2zVkwFKaVBlwCaFRWEga/Xvu/IDLwNdASGWnLqoA34SFeSg==}
+    peerDependencies:
+      '@atcute/identity': ^0.1.0
+
+  '@atcute/identity@0.1.1':
+    resolution: {integrity: sha512-TijKOgvvOfp/QoMAqaiKLn+FnQi5XrxsWLVcVnvr5JoKlgF2yppNvVo0y62XEXZbgDuEMSav1v1tEjC4Hn7MzQ==}
+
   '@atcute/multibase@1.1.2':
     resolution: {integrity: sha512-KFX+c7a/u2jSNcRw0rLaUHG/XEKf1A1c8XF5soHnsb1JMCShihf/anfZ1kJ4no/IlIp9HEHV3PQRQO2sWL6ASQ==}
 
   '@atcute/uint8array@1.0.1':
     resolution: {integrity: sha512-AAnlFKyfDRgb9GNZJbhQ6OuMhbmNPirQyapb8KnmcEhxQZ3+tt+4NcwqekEegY4MpNqSTYeeTdyxq0wGZv1JHg==}
+
+  '@atcute/util-fetch@1.0.0':
+    resolution: {integrity: sha512-Mjt5Bow3NApiEhgwuXWwvdZ4fBGgsgXju41MeJvAag1nhg2qObgg19FNccpC63QfXrKdXMGUOJOiZkxIw6wILA==}
 
   '@atcute/varint@1.0.2':
     resolution: {integrity: sha512-0O31hePzzr4O3NGWHUKKOyta6CGSL+AtN8iir8grGxu9jXyI7DBARlw6PbgKA6uTAvsXdpmRmF8MX+p0TsLnNg==}
···
       '@atcute/uint8array': 1.0.1
       '@noble/secp256k1': 2.2.3
 
+  '@atcute/did-plc@0.1.0':
+    dependencies:
+      '@atcute/cbor': 2.1.3
+      '@atcute/cid': 2.1.0
+      '@atcute/crypto': 2.2.0
+      '@atcute/multibase': 1.1.2
+      '@atcute/uint8array': 1.0.1
+      '@badrap/valita': 0.4.3
+
+  '@atcute/identity-resolver@0.1.2(@atcute/identity@0.1.1)':
+    dependencies:
+      '@atcute/identity': 0.1.1
+      '@atcute/util-fetch': 1.0.0
+      '@badrap/valita': 0.4.3
+
+  '@atcute/identity@0.1.1':
+    dependencies:
+      '@badrap/valita': 0.4.3
+
   '@atcute/multibase@1.1.2':
     dependencies:
       '@atcute/uint8array': 1.0.1
 
   '@atcute/uint8array@1.0.1': {}
+
+  '@atcute/util-fetch@1.0.0':
+    dependencies:
+      '@badrap/valita': 0.4.3
 
   '@atcute/varint@1.0.2': {}
 

src/api/queries/did-doc.ts

···
-import { At } from '@atcute/client/lexicons';
+import type { AtprotoDid, DidDocument } from '@atcute/identity';
+import {
+	CompositeDidDocumentResolver,
+	PlcDidDocumentResolver,
+	WebDidDocumentResolver,
+} from '@atcute/identity-resolver';
 
-import { didDocument, DidDocument } from '../types/did-doc';
-import { DID_PLC_RE, DID_WEB_RE } from '../utils/strings';
+const didDocumentResolver = new CompositeDidDocumentResolver({
+	methods: {
+		plc: new PlcDidDocumentResolver(),
+		web: new WebDidDocumentResolver(),
+	},
+});
 
 export const getDidDocument = async ({
 	did,
 	signal,
 }: {
-	did: At.DID;
+	did: AtprotoDid;
 	signal?: AbortSignal;
 }): Promise<DidDocument> => {
-	const colon_index = did.indexOf(':', 4);
-
-	const type = did.slice(4, colon_index);
-	const ident = did.slice(colon_index + 1);
-
-	let rawDoc: any;
-
-	if (type === 'plc') {
-		if (!DID_PLC_RE.test(did)) {
-			throw new Error(`invalid did:plc identifier`);
-		}
-
-		const origin = import.meta.env.VITE_PLC_DIRECTORY_URL;
-		const response = await fetch(`${origin}/${did}`, { signal });
-
-		if (response.status === 404) {
-			throw new Error(`did not found in directory`);
-		} else if (!response.ok) {
-			throw new Error(`directory is unreachable`);
-		}
-
-		const json = await response.json();
-
-		rawDoc = json;
-	} else if (type === 'web') {
-		if (!DID_WEB_RE.test(did)) {
-			throw new Error(`invalid did:web identifier`);
-		}
-
-		const response = await fetch(`https://${ident}/.well-known/did.json`, { signal });
-
-		if (!response.ok) {
-			throw new Error(`did document is unreachable`);
-		}
-
-		const json = await response.json();
-
-		rawDoc = json;
-	} else {
-		throw new Error(`unsupported did method`);
-	}
-
-	return didDocument.parse(rawDoc, { mode: 'passthrough' });
+	return didDocumentResolver.resolve(did, { signal });
 };

src/api/queries/handle.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
-import { At } from '@atcute/client/lexicons';
+import { type AtprotoDid, type Handle, isHandle } from '@atcute/identity';
+import { XrpcHandleResolver } from '@atcute/identity-resolver';
 
-import { appViewRpc } from '~/globals/rpc';
+const handleResolver = new XrpcHandleResolver({
+	serviceUrl: import.meta.env.VITE_APPVIEW_URL,
+});
 
 export const resolveHandleViaAppView = async ({
 	handle,
 	signal,
 }: {
-	handle: string;
+	handle: Handle;
 	signal?: AbortSignal;
-}): Promise<At.DID> => {
-	const { data } = await appViewRpc.get('com.atproto.identity.resolveHandle', {
-		signal: signal,
-		params: { handle: handle },
-	});
+}): Promise<AtprotoDid> => {
+	if (!isHandle(handle)) {
+		throw new Error(`invalid handle: ${handle}`);
+	}
 
-	return data.did;
+	return await handleResolver.resolve(handle, { signal });
 };
 
 export const resolveHandleViaPds = async ({
···
 	signal,
 }: {
 	service: string;
-	handle: string;
+	handle: Handle;
 	signal?: AbortSignal;
-}): Promise<At.DID> => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service }) });
+}): Promise<AtprotoDid> => {
+	const resolver = new XrpcHandleResolver({ serviceUrl: service });
 
-	const { data } = await rpc.get('com.atproto.identity.resolveHandle', {
-		signal,
-		params: { handle },
-	});
-
-	return data.did;
+	return await resolver.resolve(handle, { signal });
 };

src/api/queries/plc.ts

···
-import { At } from '@atcute/client/lexicons';
+import { defs } from '@atcute/did-plc';
+import { Did } from '@atcute/identity';
 
-import { plcLogEntries } from '../types/plc';
-
-export const getPlcAuditLogs = async ({ did, signal }: { did: At.DID; signal?: AbortSignal }) => {
+export const getPlcAuditLogs = async ({ did, signal }: { did: Did<'plc'>; signal?: AbortSignal }) => {
 	const origin = import.meta.env.VITE_PLC_DIRECTORY_URL;
 	const response = await fetch(`${origin}/${did}/log/audit`, { signal });
 	if (!response.ok) {
···
 	}
 
 	const json = await response.json();
-	return plcLogEntries.parse(json);
+	return defs.indexedEntryLog.parse(json);
 };

src/api/types/did-doc.ts

···
-import * as v from '@badrap/valita';
-
-import { didString, serviceUrlString, urlString } from './strings';
-
-const PUBLIC_KEY_MULTIBASE_RE = /^z[a-km-zA-HJ-NP-Z1-9]+$/;
-
-const verificationMethod = v.object({
-	id: v.string(),
-	type: v.string(),
-	controller: didString,
-	publicKeyMultibase: v
-		.string()
-		.assert((input) => PUBLIC_KEY_MULTIBASE_RE.test(input), `must be a valid base58btc multibase key`),
-});
-
-const service = v
-	.object({
-		id: v.string(),
-		type: v.string(),
-		serviceEndpoint: v.union(urlString, v.record(urlString), v.array(urlString)),
-	})
-	.chain((input) => {
-		switch (input.type) {
-			case 'AtprotoPersonalDataServer':
-			case 'AtprotoLabeler':
-			case 'BskyFeedGenerator':
-			case 'BskyNotificationService': {
-				const result = serviceUrlString.try(input.serviceEndpoint);
-				if (!result.ok) {
-					return v.err({
-						message: `must be a valid atproto service url`,
-						path: ['serviceEndpoint'],
-					});
-				}
-			}
-		}
-
-		return v.ok(input);
-	});
-
-export const didDocument = v.object({
-	'@context': v.array(urlString),
-	id: didString,
-	alsoKnownAs: v.array(urlString).optional(() => []),
-	verificationMethod: v.array(verificationMethod).optional(() => []),
-	service: v.array(service).chain((input) => {
-		for (let i = 0, len = input.length; i < len; i++) {
-			const service = input[i];
-			const id = service.id;
-
-			for (let j = 0; j < i; j++) {
-				if (input[j].id === id) {
-					return v.err({
-						message: `duplicate service id`,
-						path: [i, 'id'],
-					});
-				}
-			}
-		}
-
-		return v.ok(input);
-	}),
-});
-
-export type DidDocument = v.Infer<typeof didDocument>;
-
-export const getPdsEndpoint = (doc: DidDocument): string | undefined => {
-	return getServiceEndpoint(doc, '#atproto_pds', 'AtprotoPersonalDataServer');
-};
-
-export const getServiceEndpoint = (
-	doc: DidDocument,
-	serviceId: string,
-	serviceType: string,
-): string | undefined => {
-	const did = doc.id;
-
-	const didServiceId = did + serviceId;
-	const found = doc.service?.find((service) => service.id === serviceId || service.id === didServiceId);
-
-	if (!found || found.type !== serviceType || typeof found.serviceEndpoint !== 'string') {
-		return undefined;
-	}
-
-	return found.serviceEndpoint;
-};

src/api/types/plc.ts

···
 import * as v from '@badrap/valita';
 
-import { didKeyString, didString, handleString, serviceUrlString, urlString } from './strings';
-
-const legacyGenesisOp = v.object({
-	type: v.literal('create'),
-	signingKey: didKeyString,
-	recoveryKey: didKeyString,
-	handle: handleString,
-	service: serviceUrlString,
-	prev: v.null(),
-	sig: v.string(),
-});
-
-const tombstoneOp = v.object({
-	type: v.literal('plc_tombstone'),
-	prev: v.string(),
-	sig: v.string(),
-});
-
-const service = v.object({
-	type: v.string().assert((input) => input.length <= 256, `service type too long (max 256)`),
-	endpoint: urlString.assert((input) => input.length <= 512, `service endpoint too long (max 512)`),
-});
-export type Service = v.Infer<typeof service>;
-
-const updateOp = v.object({
-	type: v.literal('plc_operation'),
-	prev: v.string().nullable(),
-	sig: v.string(),
-	rotationKeys: v.array(didKeyString).chain((input) => {
-		const len = input.length;
-
-		if (len === 0) {
-			return v.err({ message: `missing rotation keys` });
-		} else if (len > 10) {
-			return v.err({ message: `too many rotation keys (max 10)` });
-		}
-
-		for (let i = 0; i < len; i++) {
-			const key = input[i];
-
-			for (let j = 0; j < i; j++) {
-				if (input[j] === key) {
-					return v.err({
-						message: `duplicate rotation key`,
-						path: [i],
-					});
-				}
-			}
-		}
-
-		return v.ok(input);
-	}),
-	verificationMethods: v.record(didKeyString),
-	alsoKnownAs: v
-		.array(urlString.assert((input) => input.length <= 256, `alsoKnownAs entry too long (max 256)`))
-		.assert((input) => input.length <= 10, `too many alsoKnownAs entries (max 10)`),
-	services: v
-		.record(service)
-		.assert((input) => Object.keys(input).length <= 10, `too many service entries (max 10)`),
-});
-export type PlcUpdateOp = v.Infer<typeof updateOp>;
+import { defs, UnsignedOperation } from '@atcute/did-plc';
 
-const plcOperation = v.union(legacyGenesisOp, tombstoneOp, updateOp);
-
-export const plcLogEntry = v.object({
-	did: didString,
-	cid: v.string(),
-	operation: plcOperation,
-	nullified: v.boolean(),
-	createdAt: v
-		.string()
-		.assert((input) => !Number.isNaN(new Date(input).getTime()), `must be a valid datetime string`),
-});
-export type PlcLogEntry = v.Infer<typeof plcLogEntry>;
+import { ToValidator } from '../utils/valita';
+import { serviceUrlString } from './strings';
 
-export const plcLogEntries = v.array(plcLogEntry);
+const _unsignedOperation = defs.unsignedOperation as ToValidator<UnsignedOperation>;
 
-export const updatePayload = updateOp.omit('type', 'prev', 'sig').extend({
+export const updatePayload = _unsignedOperation.omit('type', 'prev').extend({
 	services: v
 		.record(
-			service.chain((input) => {
+			defs.service.chain((input) => {
 				switch (input.type) {
 					case 'AtprotoPersonalDataServer':
 					case 'AtprotoLabeler':
···
 				return v.ok(input);
 			}),
 		)
-		.assert((input) => Object.keys(input).length <= 10, `too many service entries (max 10)`),
+		.chain((input) => {
+			const length = Object.keys(input).length;
+
+			if (length > 10) {
+				return v.err(`too many service entries (max 10)`);
+			}
+
+			for (const id in input) {
+				if (id.length > 32) {
+					return v.err({
+						message: `service id too long (max 32 characters)`,
+						path: [id],
+					});
+				}
+			}
+
+			return v.ok(input);
+		}),
 });
-export type PlcUpdatePayload = v.Infer<typeof updatePayload>;
+
+export type UpdatePayload = v.Infer<typeof updatePayload>;

src/api/types/strings.ts

···
 import * as v from '@badrap/valita';
 
-import { DID_KEY_RE, DID_RE, HANDLE_RE } from '../utils/strings';
-
-export const didString = v
-	.string()
-	.assert((input): input is `did:${string}:${string}` => DID_RE.test(input), `must be a valid did`);
-
-export const didKeyString = v
-	.string()
-	.assert((input): input is `did:key:${string}` => DID_KEY_RE.test(input), `must be a valid did:key`);
-
-export const handleString = v.string().assert((input) => HANDLE_RE.test(input), `must be a valid handle`);
-
-export const urlString = v.string().assert((input) => URL.canParse(input), `must be a valid url`);
-
 export const serviceUrlString = v.string().assert((input) => {
 	const url = URL.parse(input);
 

src/api/utils/at-uri.ts

···
+import { assert } from '~/lib/utils/invariant';
+
+type Did<TMethod extends string = string> = `did:${TMethod}:${string}`;
+
+type Nsid = `${string}.${string}.${string}`;
+
+type RecordKey = string;
+
+const DID_RE = /^did:([a-z]+):([a-zA-Z0-9._:%\-]*[a-zA-Z0-9._\-])$/;
+
+const NSID_RE =
+	/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/;
+
+const RECORD_KEY_RE = /^(?!\.{1,2}$)[a-zA-Z0-9_~.:-]{1,512}$/;
+
+const ATURI_RE =
+	/^at:\/\/([a-zA-Z0-9._:%-]+)(?:\/([a-zA-Z0-9-.]+)(?:\/([a-zA-Z0-9._~:@!$&%')(*+,;=-]+))?)?(?:#(\/[a-zA-Z0-9._~:@!$&%')(*+,;=\-[\]/\\]*))?$/;
+
+const isDid = (input: unknown): input is Did => {
+	return typeof input === 'string' && input.length >= 7 && input.length <= 2048 && DID_RE.test(input);
+};
+
+const isNsid = (input: unknown): input is Nsid => {
+	return typeof input === 'string' && input.length >= 5 && input.length <= 317 && NSID_RE.test(input);
+};
+
+const isRecordKey = (input: unknown): input is RecordKey => {
+	return typeof input === 'string' && input.length >= 1 && input.length <= 512 && RECORD_KEY_RE.test(input);
+};
+
+export interface AddressedAtUri {
+	repo: Did;
+	collection: Nsid;
+	rkey: string;
+	fragment: string | undefined;
+}
+
+export const parseAddressedAtUri = (str: string): AddressedAtUri => {
+	const match = ATURI_RE.exec(str);
+	assert(match !== null, `invalid addressed-at-uri: ${str}`);
+
+	const [, r, c, k, f] = match;
+	assert(isDid(r), `invalid repo in addressed-at-uri: ${r}`);
+	assert(isNsid(c), `invalid collection in addressed-at-uri: ${c}`);
+	assert(isRecordKey(k), `invalid rkey in addressed-at-uri: ${k}`);
+
+	return {
+		repo: r,
+		collection: c,
+		rkey: k,
+		fragment: f,
+	};
+};

src/api/utils/strings.ts

···
-import type { At, Records } from '@atcute/client/lexicons';
-
-import { assert } from '~/lib/utils/invariant';
-
-export const ATURI_RE =
-	/^at:\/\/(did:[a-zA-Z0-9._:%\-]+|[a-zA-Z0-9-.]+)\/([a-zA-Z0-9-.]+)\/([a-zA-Z0-9._~:@!$&%')(*+,;=\-]+)(?:#(\/[a-zA-Z0-9._~:@!$&%')(*+,;=\-[\]/\\]*))?$/;
-
-export const DID_RE = /^did:([a-z]+):([a-zA-Z0-9._:%\-]*[a-zA-Z0-9._\-])$/;
-
-export const DID_WEB_RE = /^did:web:([a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*(?:\.[a-zA-Z]{2,}))$/;
-
-export const DID_PLC_RE = /^did:plc:([a-z2-7]{24})$/;
-
-export const DID_KEY_RE = /^did:key:z[a-km-zA-HJ-NP-Z1-9]+$/;
-
-export const HANDLE_RE = /^[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*(?:\.[a-zA-Z]{2,})$/;
+import type { Records } from '@atcute/client/lexicons';
 
 export const DID_OR_HANDLE_RE =
 	/^[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*(?:\.[a-zA-Z]{2,})$|^did:[a-z]+:[a-zA-Z0-9._:%\-]*[a-zA-Z0-9._\-]$/;
-
-export interface AtUri {
-	repo: string;
-	collection: string;
-	rkey: string;
-	fragment: string | undefined;
-}
-
-export const isDid = (value: string): value is At.DID => {
-	return value.length >= 7 && DID_RE.test(value);
-};
-
-export const isHandle = (value: string): boolean => {
-	return value.length >= 4 && HANDLE_RE.test(value);
-};
-
-export const parseAtUri = (str: string): AtUri => {
-	const match = ATURI_RE.exec(str);
-	assert(match !== null, `Failed to parse AT URI for ${str}`);
-
-	return {
-		repo: match[1],
-		collection: match[2],
-		rkey: match[3],
-		fragment: match[4],
-	};
-};
 
 export const makeAtUri = (repo: string, collection: keyof Records | (string & {}), rkey: string) => {
 	return `at://${repo}/${collection}/${rkey}`;

src/api/utils/valita.ts

···
+import * as v from '@badrap/valita';
+
+export type ToValidator<T> = T extends readonly [infer Head, ...infer Rest]
+	? Rest extends []
+		? v.TupleType<[ToValidator<Head>]>
+		: v.TupleType<[ToValidator<Head>, ...ToValidatorTuple<Rest>]>
+	: T extends ReadonlyArray<infer E>
+		? v.ArrayType<ToValidator<E>>
+		: T extends object
+			? ToObjectValidator<T>
+			: v.Type<T>;
+
+// Helper type for converting tuple types
+type ToValidatorTuple<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Rest]
+	? Rest extends []
+		? [ToValidator<Head>]
+		: [ToValidator<Head>, ...ToValidatorTuple<Rest>]
+	: [];
+
+// Helper type for converting object types
+type ToObjectValidator<T extends object> = v.ObjectType<
+	{
+		[K in keyof T]-?: undefined extends T[K] ? v.Optional<Exclude<T[K], undefined>> : ToValidator<T[K]>;
+	},
+	undefined
+>;

src/components/wizards/bluesky-login-step.tsx

···
 import { batch, createSignal, Match, Show, Switch } from 'solid-js';
 
 import { CredentialManager, XRPCError } from '@atcute/client';
-import { At } from '@atcute/client/lexicons';
+import { type AtprotoDid, type DidDocument, getPdsEndpoint, isAtprotoDid, isHandle } from '@atcute/identity';
 
 import { getDidDocument } from '~/api/queries/did-doc';
 import { resolveHandleViaAppView } from '~/api/queries/handle';
-import { DidDocument, getPdsEndpoint } from '~/api/types/did-doc';
 import { formatTotpCode, TOTP_RE } from '~/api/utils/auth';
-import { isDid } from '~/api/utils/strings';
 
 import { createMutation } from '~/lib/utils/mutation';
 
···
 			service = service?.trim() || undefined;
 
 			if (service === undefined) {
-				let did: At.DID;
-				if (!isDid(identifier)) {
+				let did: AtprotoDid;
+				if (isAtprotoDid(identifier)) {
+					did = identifier;
+				} else if (isHandle(identifier)) {
 					did = await resolveHandleViaAppView({ handle: identifier });
 				} else {
-					did = identifier;
+					throw new InsufficientLoginError(`Invalid identifier`);
 				}
 
 				const didDoc = await getDidDocument({ did });

src/lib/utils/search-params.ts

···
 import { batch, createSignal } from 'solid-js';
 
 import { At } from '@atcute/client/lexicons';
+import { isDid, isHandle } from '@atcute/identity';
 
-import { DID_OR_HANDLE_RE, DID_RE, HANDLE_RE } from '~/api/utils/strings';
 import { UnwrapArray } from '~/api/utils/types';
 
 export interface ParamParser<T> {
···
 
 export const asDID = createParser({
 	parse(value) {
-		if (typeof value === 'string' && DID_RE.test(value)) {
+		if (typeof value === 'string' && isDid(value)) {
 			return value as At.DID;
 		}
 
···
 
 export const asHandle = createParser({
 	parse(value) {
-		if (typeof value === 'string' && HANDLE_RE.test(value)) {
+		if (typeof value === 'string' && isHandle(value)) {
 			return value;
 		}
 
···
 
 export const asIdentifier = createParser({
 	parse(value) {
-		if (typeof value === 'string' && DID_OR_HANDLE_RE.test(value)) {
+		if (typeof value === 'string' && (isDid(value) || isHandle(value))) {
 			return value;
 		}
 

src/views/blob/blob-export.tsx

···
 import { createSignal } from 'solid-js';
 
 import { simpleFetchHandler, XRPC, XRPCError } from '@atcute/client';
-import { At } from '@atcute/client/lexicons';
+import { type AtprotoDid, getPdsEndpoint, isAtprotoDid, isHandle } from '@atcute/identity';
 import { writeTarEntry } from '@mary/tar';
 
 import { getDidDocument } from '~/api/queries/did-doc';
 import { resolveHandleViaAppView, resolveHandleViaPds } from '~/api/queries/handle';
-import { getPdsEndpoint } from '~/api/types/did-doc';
 import { isServiceUrlString } from '~/api/types/strings';
-import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings';
+import { DID_OR_HANDLE_RE } from '~/api/utils/strings';
 
 import { useTitle } from '~/lib/navigation/router';
 import { makeAbortable } from '~/lib/utils/abortable';
···
 	}) => {
 		logger.info(`Starting export for ${identifier}`);
 
-		let did: At.DID;
-		if (isDid(identifier)) {
+		let did: AtprotoDid;
+		if (isAtprotoDid(identifier)) {
 			did = identifier;
-		} else if (service) {
-			did = await resolveHandleViaPds({ service, handle: identifier, signal });
-			logger.log(`Resolved handle to ${did}`);
+		} else if (isHandle(identifier)) {
+			if (service) {
+				did = await resolveHandleViaPds({ service, handle: identifier, signal });
+				logger.log(`Resolved handle to ${did}`);
+			} else {
+				did = await resolveHandleViaAppView({ handle: identifier, signal });
+				logger.log(`Resolved handle to ${did}`);
+			}
 		} else {
-			did = await resolveHandleViaAppView({ handle: identifier, signal });
-			logger.log(`Resolved handle to ${did}`);
+			logger.error(`Invalid identifier`);
+			return;
 		}
 
 		if (!service) {

src/views/bluesky/threadgate-applicator/page.tsx

···
 
 import { CredentialManager } from '@atcute/client';
 import { AppBskyFeedDefs, AppBskyFeedThreadgate } from '@atcute/client/lexicons';
+import { DidDocument } from '@atcute/identity';
 
-import { DidDocument } from '~/api/types/did-doc';
 import { UnwrapArray } from '~/api/utils/types';
 
 import { history } from '~/globals/navigation';

src/views/bluesky/threadgate-applicator/steps/step1_handle-input.tsx

···
 import { createSignal } from 'solid-js';
 
-import type { AppBskyFeedThreadgate, At } from '@atcute/client/lexicons';
+import type { AppBskyFeedThreadgate } from '@atcute/client/lexicons';
+import { type AtprotoDid, isAtprotoDid, isHandle } from '@atcute/identity';
 
 import { getDidDocument } from '~/api/queries/did-doc';
 import { resolveHandleViaAppView } from '~/api/queries/handle';
-import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings';
+import { DID_OR_HANDLE_RE } from '~/api/utils/strings';
 
 import { appViewRpc } from '~/globals/rpc';
 
···
 		async mutationFn({ identifier }: { identifier: string }, signal) {
 			setStatus(`Resolving identity`);
 
-			let did: At.DID;
-			if (isDid(identifier)) {
+			let did: AtprotoDid;
+			if (isAtprotoDid(identifier)) {
 				did = identifier;
-			} else {
+			} else if (isHandle(identifier)) {
 				did = await resolveHandleViaAppView({ handle: identifier, signal });
+			} else {
+				throw new Error(`Invalid identifier`);
 			}
 
 			const didDoc = await getDidDocument({ did, signal });

src/views/bluesky/threadgate-applicator/steps/step4_confirmation.tsx

···
 import { createSignal, Show } from 'solid-js';
 
 import { XRPC, XRPCError } from '@atcute/client';
-import { AppBskyFeedThreadgate, ComAtprotoRepoApplyWrites } from '@atcute/client/lexicons';
+import type { AppBskyFeedThreadgate, ComAtprotoRepoApplyWrites } from '@atcute/client/lexicons';
 import { chunked } from '@mary/array-fns';
+
+import { parseAddressedAtUri } from '~/api/utils/at-uri';
 
 import { dequal } from '~/lib/utils/dequal';
 import { createMutation } from '~/lib/utils/mutation';
 
 import Button from '~/components/inputs/button';
 import ToggleInput from '~/components/inputs/toggle-input';
+import Logger, { createLogger } from '~/components/logger';
 import { Stage, StageActions, StageErrorView, WizardStepProps } from '~/components/wizard';
 
-import { parseAtUri } from '~/api/utils/strings';
-import Logger, { createLogger } from '~/components/logger';
 import { ThreadgateApplicatorConstraints } from '../page';
 
 const Step4_Confirmation = ({
···
 			for (const { post, threadgate } of data.threads) {
 				if (threadgate === null) {
 					if (rules !== undefined) {
-						const { rkey } = parseAtUri(post.uri);
+						const { rkey } = parseAddressedAtUri(post.uri);
 
 						const record: AppBskyFeedThreadgate.Record = {
 							$type: 'app.bsky.feed.threadgate',
···
 					}
 				} else {
 					if (rules === undefined && !threadgate.hiddenReplies?.length) {
-						const { rkey } = parseAtUri(threadgate.uri);
+						const { rkey } = parseAddressedAtUri(threadgate.uri);
 
 						writes.push({
 							$type: 'com.atproto.repo.applyWrites#delete',
···
 							rkey: rkey,
 						});
 					} else if (!dequal(threadgate.allow, rules)) {
-						const { rkey } = parseAtUri(threadgate.uri);
+						const { rkey } = parseAddressedAtUri(threadgate.uri);
 
 						const record: AppBskyFeedThreadgate.Record = {
 							$type: 'app.bsky.feed.threadgate',

src/views/identity/did-lookup.tsx

···
 import { Match, Switch } from 'solid-js';
 
-import { At } from '@atcute/client/lexicons';
+import { isAtprotoDid, isHandle, type AtprotoDid, type Did, type Handle } from '@atcute/identity';
 
 import { getDidDocument } from '~/api/queries/did-doc';
 import { resolveHandleViaAppView } from '~/api/queries/handle';
 import { isServiceUrlString } from '~/api/types/strings';
-import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings';
+import { DID_OR_HANDLE_RE } from '~/api/utils/strings';
 
 import { useTitle } from '~/lib/navigation/router';
 import { createQuery } from '~/lib/utils/query';
···
 	const query = createQuery(
 		() => params.q,
 		async (identifier, signal) => {
-			let did: At.DID;
-			if (isDid(identifier)) {
+			let did: AtprotoDid;
+			if (isAtprotoDid(identifier)) {
 				did = identifier;
-			} else {
+			} else if (isHandle(identifier)) {
 				did = await resolveHandleViaAppView({ handle: identifier, signal });
+			} else {
+				throw new Error(`Invalid identifier`);
 			}
 
 			const doc = await getDidDocument({ did, signal });
···
 					const formData = new FormData(ev.currentTarget);
 					ev.preventDefault();
 
-					const ident = formData.get('ident') as string;
+					const ident = formData.get('ident') as Did | Handle;
 					setParams({ q: ident });
 				}}
 				class="m-4 flex flex-col gap-4"
···
 
 									<div>
 										<p class="font-semibold text-gray-600">Identifies as</p>
-										<ol class="list-disc pl-4">
-											{doc.alsoKnownAs.map((ident) => (
-												<li>{ident}</li>
-											))}
-										</ol>
+										<ol class="list-disc pl-4">{doc.alsoKnownAs?.map((ident) => <li>{ident}</li>)}</ol>
 									</div>
 
 									<div>
 										<p class="font-semibold text-gray-600">Services</p>
 										<ol class="list-disc pl-4">
-											{doc.service.map(({ id, type, serviceEndpoint }, idx) => {
+											{doc.service?.map(({ id, type, serviceEndpoint }, idx) => {
 												const isString = typeof serviceEndpoint === 'string';
 												const isURL = isString && URL.canParse('' + serviceEndpoint);
 												const isServiceUrl = isString && isServiceUrlString(serviceEndpoint);
···
 									<div>
 										<p class="font-semibold text-gray-600">Verification methods</p>
 										<ol class="list-disc pl-4">
-											{doc.verificationMethod.map(({ id, type, publicKeyMultibase }, idx) => {
+											{doc.verificationMethod?.map(({ id, type, publicKeyMultibase }, idx) => {
 												return (
 													<li class={idx !== 0 ? `mt-3` : ``}>
 														<p class="font-medium">{id.replace(doc.id, '')}</p>

src/views/identity/plc-applicator/page.tsx

···
 import type { CredentialManager } from '@atcute/client';
 import type { ComAtprotoIdentityGetRecommendedDidCredentials } from '@atcute/client/lexicons';
 import type { P256PrivateKey, Secp256k1PrivateKey } from '@atcute/crypto';
+import type { DidDocument } from '@atcute/identity';
 
-import type { DidDocument } from '~/api/types/did-doc';
-import type { PlcUpdatePayload } from '~/api/types/plc';
+import { UpdatePayload } from '~/api/types/plc';
 
 import { history } from '~/globals/navigation';
 
···
 		info: PlcInformation;
 		method: PdsSigningMethod;
 		base: DetailedPlcEntry;
-		payload: PlcUpdatePayload;
+		payload: UpdatePayload;
 	};
 	Step5_PrivateKeyConfirmation: {
 		info: PlcInformation;
 		method: PrivateKeySigningMethod;
 		base: DetailedPlcEntry;
-		payload: PlcUpdatePayload;
+		payload: UpdatePayload;
 	};
 
 	Step6_Finished: {};

src/views/identity/plc-applicator/plc-utils.ts

···
 import * as CBOR from '@atcute/cbor';
 import { verifySigWithDidKey } from '@atcute/crypto';
+import type { IndexedEntry } from '@atcute/did-plc';
 import { fromBase64Url } from '@atcute/multibase';
 
-import { PlcLogEntry, PlcUpdatePayload } from '~/api/types/plc';
+import { UpdatePayload } from '~/api/types/plc';
 import { UnwrapArray } from '~/api/utils/types';
 
 import { assert } from '~/lib/utils/invariant';
 
-export const getPlcPayload = (entry: PlcLogEntry): PlcUpdatePayload => {
+export const getPlcPayload = (entry: IndexedEntry): UpdatePayload => {
 	const op = entry.operation;
 	assert(op.type === 'plc_operation' || op.type === 'create');
 
···
 	assert(false);
 };
 
-export const getPlcKeying = async (logs: PlcLogEntry[]) => {
+export const getPlcKeying = async (logs: IndexedEntry[]) => {
 	logs = logs.filter((entry) => !entry.nullified);
 
 	const length = logs.length;
···
 type DetailedEntries = Awaited<ReturnType<typeof getPlcKeying>>;
 export type DetailedPlcEntry = UnwrapArray<DetailedEntries>;
 
-export const getCurrentSignersFromEntry = (entry: PlcLogEntry): string[] => {
+export const getCurrentSignersFromEntry = (entry: IndexedEntry): string[] => {
 	const operation = entry.operation;
 
 	/** keys that can sign the next operation */

src/views/identity/plc-applicator/steps/step1_handle-input.tsx

···
 import { createSignal } from 'solid-js';
 
 import { XRPCError } from '@atcute/client';
-import { At } from '@atcute/client/lexicons';
+import { type Did, isHandle, isPlcDid } from '@atcute/identity';
 
 import { getDidDocument } from '~/api/queries/did-doc';
 import { resolveHandleViaAppView } from '~/api/queries/handle';
 import { getPlcAuditLogs } from '~/api/queries/plc';
-import { DID_OR_HANDLE_RE, DID_PLC_RE, isDid } from '~/api/utils/strings';
+import { DID_OR_HANDLE_RE } from '~/api/utils/strings';
 
 import { createMutation } from '~/lib/utils/mutation';
 
···
 
 	const mutation = createMutation({
 		async mutationFn({ identifier }: MutationVariables): Promise<PlcInformation> {
-			let did: At.DID;
-			if (isDid(identifier)) {
+			let did: Did<'plc'>;
+			if (isPlcDid(identifier)) {
 				did = identifier;
-			} else {
-				did = await resolveHandleViaAppView({ handle: identifier });
-			}
+			} else if (isHandle(identifier)) {
+				const resolved = await resolveHandleViaAppView({ handle: identifier });
+				if (!isPlcDid(resolved)) {
+					throw new DidIsNotPlcError(`${resolved} does not resolve to a did:plc`);
+				}
 
-			if (!DID_PLC_RE.test(did)) {
-				throw new DidIsNotPlcError(`"${did}" is not did:plc`);
+				did = resolved;
+			} else {
+				throw new DidIsNotPlcError(`${identifier} is not a valid did:plc or handle`);
 			}
 
 			const [didDoc, logs] = await Promise.all([getDidDocument({ did }), getPlcAuditLogs({ did })]);

src/views/identity/plc-applicator/steps/step2_pds-authentication.tsx

···
 
 import { AtpAccessJwt, CredentialManager, XRPC, XRPCError } from '@atcute/client';
 import { decodeJwt } from '@atcute/client/utils/jwt';
+import { getPdsEndpoint } from '@atcute/identity';
 
-import { getPdsEndpoint } from '~/api/types/did-doc';
-import { TOTP_RE, formatTotpCode } from '~/api/utils/auth';
+import { formatTotpCode, TOTP_RE } from '~/api/utils/auth';
 
 import { createMutation } from '~/lib/utils/mutation';
 

src/views/identity/plc-applicator/steps/step5_private-key-confirmation.tsx

···
 import { createSignal } from 'solid-js';
 
 import * as CBOR from '@atcute/cbor';
+import type { Operation, UnsignedOperation } from '@atcute/did-plc';
 import { toBase64Url } from '@atcute/multibase';
-
-import { PlcUpdateOp } from '~/api/types/plc';
 
 import { generateConfirmationCode } from '~/lib/utils/confirmation-code';
 import { createMutation } from '~/lib/utils/mutation';
···
 			const payload = data.payload;
 			const prev = data.base;
 
-			const operation: Omit<PlcUpdateOp, 'sig'> = {
+			const operation: UnsignedOperation = {
 				type: 'plc_operation',
 				prev: prev!.cid,
 
···
 
 			const signature = toBase64Url(sigBytes);
 
-			const signedOperation: PlcUpdateOp = {
+			const signedOperation: Operation = {
 				...operation,
 				sig: signature,
 			};
···
 
 export default Step5_PrivateKeyConfirmation;
 
-const pushPlcOperation = async (did: string, operation: PlcUpdateOp) => {
+const pushPlcOperation = async (did: string, operation: Operation) => {
 	const origin = import.meta.env.VITE_PLC_DIRECTORY_URL;
 	const response = await fetch(`${origin}/${did}`, {
 		method: 'post',

src/views/identity/plc-oplogs.tsx

···
 import { createSignal, JSX, Match, onCleanup, Switch } from 'solid-js';
 
-import { At } from '@atcute/client/lexicons';
+import type { IndexedEntry, Service } from '@atcute/did-plc';
+import { type Did, type Handle, isHandle, isPlcDid } from '@atcute/identity';
 
 import { resolveHandleViaAppView } from '~/api/queries/handle';
-import { PlcLogEntry, Service } from '~/api/types/plc';
-import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings';
+import { DID_OR_HANDLE_RE } from '~/api/utils/strings';
 
 import { getPlcAuditLogs } from '~/api/queries/plc';
 import { useTitle } from '~/lib/navigation/router';
···
 	const query = createQuery(
 		() => params.q,
 		async (identifier, signal) => {
-			let did: At.DID;
-			if (isDid(identifier)) {
+			let did: Did<'plc'>;
+			if (isPlcDid(identifier)) {
 				did = identifier;
-			} else {
-				did = await resolveHandleViaAppView({ handle: identifier, signal });
-			}
+			} else if (isHandle(identifier)) {
+				const resolved = await resolveHandleViaAppView({ handle: identifier, signal });
+				if (!isPlcDid(resolved)) {
+					throw new Error(`${identifier} is not a valid identifier`);
+				}
 
-			if (!did.startsWith('did:plc:')) {
-				throw new Error(`${did} is not plc`);
+				did = resolved;
+			} else {
+				throw new Error(`${identifier} is not a valid identifier`);
 			}
 
 			const logs = await getPlcAuditLogs({ did, signal });
···
 					const formData = new FormData(ev.currentTarget);
 					ev.preventDefault();
 
-					const ident = formData.get('ident') as string;
+					const ident = formData.get('ident') as Did | Handle;
 					setParams({ q: ident });
 				}}
 				class="m-4 flex flex-col gap-4"
···
 type DiffEntry =
 	| {
 			type: 'identity_created';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			rotationKeys: string[];
···
 	  }
 	| {
 			type: 'identity_tombstoned';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 	  }
 	| {
 			type: 'rotation_key_added';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			rotation_key: string;
 	  }
 	| {
 			type: 'rotation_key_removed';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			rotation_key: string;
 	  }
 	| {
 			type: 'verification_method_added';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			method_id: string;
···
 	  }
 	| {
 			type: 'verification_method_removed';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			method_id: string;
···
 	  }
 	| {
 			type: 'verification_method_changed';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			method_id: string;
···
 	  }
 	| {
 			type: 'handle_added';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			handle: string;
 	  }
 	| {
 			type: 'handle_removed';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			handle: string;
 	  }
 	| {
 			type: 'handle_changed';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			prev_handle: string;
···
 	  }
 	| {
 			type: 'service_added';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			service_id: string;
···
 	  }
 	| {
 			type: 'service_removed';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			service_id: string;
···
 	  }
 	| {
 			type: 'service_changed';
-			orig: PlcLogEntry;
+			orig: IndexedEntry;
 			nullified: boolean;
 			at: string;
 			service_id: string;
···
 			next_service_endpoint: string;
 	  };
 
-const createOperationHistory = (entries: PlcLogEntry[]): DiffEntry[] => {
+const createOperationHistory = (entries: IndexedEntry[]): DiffEntry[] => {
 	const history: DiffEntry[] = [];
 
 	for (let idx = 0, len = entries.length; idx < len; idx++) {

src/views/repository/repo-export.tsx

···
 import { type FileSystemFileHandle, showSaveFilePicker } from 'native-file-system-adapter';
 import { createSignal } from 'solid-js';
 
-import { At } from '@atcute/client/lexicons';
+import { type AtprotoDid, getPdsEndpoint, isAtprotoDid, isHandle } from '@atcute/identity';
 
 import { getDidDocument } from '~/api/queries/did-doc';
 import { resolveHandleViaAppView, resolveHandleViaPds } from '~/api/queries/handle';
-import { getPdsEndpoint } from '~/api/types/did-doc';
 import { isServiceUrlString } from '~/api/types/strings';
-import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings';
+import { DID_OR_HANDLE_RE } from '~/api/utils/strings';
 
 import { useTitle } from '~/lib/navigation/router';
 import { makeAbortable } from '~/lib/utils/abortable';
···
 	}) => {
 		logger.info(`Starting export for ${identifier}`);
 
-		let did: At.DID;
-		if (isDid(identifier)) {
+		let did: AtprotoDid;
+		if (isAtprotoDid(identifier)) {
 			did = identifier;
-		} else if (service) {
-			did = await resolveHandleViaPds({ service, handle: identifier, signal });
-			logger.log(`Resolved handle to ${did}`);
+		} else if (isHandle(identifier)) {
+			if (service) {
+				did = await resolveHandleViaPds({ service, handle: identifier, signal });
+				logger.log(`Resolved handle to ${did}`);
+			} else {
+				did = await resolveHandleViaAppView({ handle: identifier, signal });
+				logger.log(`Resolved handle to ${did}`);
+			}
 		} else {
-			did = await resolveHandleViaAppView({ handle: identifier, signal });
-			logger.log(`Resolved handle to ${did}`);
+			logger.error(`Invalid identifier`);
+			return;
 		}
 
 		if (!service) {