chore: upgrade to latest atcute

package.json

···
 		"wrangler": "^4.22.0"
 	},
 	"dependencies": {
-		"@atcute/bluesky": "^2.1.1",
+		"@atcute/atproto": "^3.1.0",
+		"@atcute/bluesky": "^3.1.4",
 		"@atcute/bluesky-richtext-parser": "^1.0.7",
 		"@atcute/bluesky-richtext-segmenter": "^2.0.3",
-		"@atcute/client": "^3.1.0",
+		"@atcute/client": "^4.0.3",
+		"@atcute/lexicons": "^1.1.0",
 		"@badrap/valita": "^0.4.5",
 		"@mary/array-fns": "jsr:^0.1.4",
 		"@mary/date-fns": "jsr:^0.1.3",

pnpm-lock.yaml

···
 
   .:
     dependencies:
+      '@atcute/atproto':
+        specifier: ^3.1.0
+        version: 3.1.0
       '@atcute/bluesky':
-        specifier: ^2.1.1
-        version: 2.1.1(@atcute/client@3.1.0)
+        specifier: ^3.1.4
+        version: 3.1.4
       '@atcute/bluesky-richtext-parser':
         specifier: ^1.0.7
         version: 1.0.7
···
         specifier: ^2.0.3
         version: 2.0.3
       '@atcute/client':
-        specifier: ^3.1.0
-        version: 3.1.0
+        specifier: ^4.0.3
+        version: 4.0.3
+      '@atcute/lexicons':
+        specifier: ^1.1.0
+        version: 1.1.0
       '@badrap/valita':
         specifier: ^0.4.5
         version: 0.4.5
···
   '@atcute/bluesky-richtext-segmenter@2.0.3':
     resolution: {integrity: sha512-8Jy2EHdqx0mKI0k8l4h2cnaBN1pGgSzSazO0Gp85ttIQmgynZsQX6l4OWgaQx0aNZFmqZRXJ7N0rj/b2dlO1eQ==}
 
-  '@atcute/bluesky@2.1.1':
-    resolution: {integrity: sha512-wEZfFW58J6yC1SqHcVJOn4qbHENTTzjeCEWthRT5HvKovADLqk54HSMSAuXDMBUbintSTBr0khQNZQ3ZdgzDdQ==}
-    peerDependencies:
-      '@atcute/client': ^3.0.0
-
   '@atcute/bluesky@3.1.4':
     resolution: {integrity: sha512-iSdZGk/UktgKpT/lI0/YxRjM3E5dkd6/vIa2mgH82lgRjI0jH5LJAfLXPyr2mPeZ/qku1gf2/KrkqJ9dfiNxVw==}
 
-  '@atcute/client@3.1.0':
-    resolution: {integrity: sha512-+rQPsHXSf0DUm8XoHoaH7Y2E8tIpbsW84djyPj7dqAyrFIjvGuJ1X1DvMufwbTIcmLerdy+dzl34iZcz/h3Vhg==}
+  '@atcute/client@4.0.3':
+    resolution: {integrity: sha512-RIOZWFVLca/HiPAAUDqQPOdOreCxTbL5cb+WUf5yqQOKIu5yEAP3eksinmlLmgIrlr5qVOE7brazUUzaskFCfw==}
+
+  '@atcute/identity@1.0.3':
+    resolution: {integrity: sha512-mNMxbKHFGys03A8JXKk0KfMBzdd0vrYMzZZWjpw1nYTs0+ea6bo5S1hwqVUZxHdo1gFHSe/t63jxQIF4yL9aKw==}
 
   '@atcute/lexicons@1.1.0':
     resolution: {integrity: sha512-LFqwnria78xLYb62Ri/+WwQpUTgZp2DuyolNGIIOV1dpiKhFFFh//nscHMA6IExFLQRqWDs3tTjy7zv0h3sf1Q==}
···
       '@atcute/bluesky': 3.1.4
       '@atcute/lexicons': 1.1.0
 
-  '@atcute/bluesky@2.1.1(@atcute/client@3.1.0)':
-    dependencies:
-      '@atcute/client': 3.1.0
-
   '@atcute/bluesky@3.1.4':
     dependencies:
       '@atcute/atproto': 3.1.0
       '@atcute/lexicons': 1.1.0
 
-  '@atcute/client@3.1.0': {}
+  '@atcute/client@4.0.3':
+    dependencies:
+      '@atcute/identity': 1.0.3
+      '@atcute/lexicons': 1.1.0
+
+  '@atcute/identity@1.0.3':
+    dependencies:
+      '@atcute/lexicons': 1.1.0
+      '@badrap/valita': 0.4.5
 
   '@atcute/lexicons@1.1.0':
     dependencies:

src/hooks.server.ts

···
-import { XRPCError } from '@atcute/client';
+import { ClientResponseError } from '@atcute/client';
 import type { HandleServerError } from '@sveltejs/kit';
 
 export const handleError: HandleServerError = async ({ error, event, status, message }) => {
 	console.error(error);
 
-	if (error instanceof XRPCError) {
+	if (error instanceof ClientResponseError) {
 		if (error.status === 403) {
 			return {
 				message: `Upstream server is forbidding access to this resource`,
 			};
 		}
 
-		if (error.kind === 'AuthRequired' || error.kind === 'auth required') {
+		if (error.error === 'AuthRequired' || error.error === 'auth required') {
 			return {
 				message: `Upstream server is requiring authentication to access this resource`,
 			};
 		}
 
-		if (error.kind === 'InternalServerError' || error.description === 'Internal Server Error') {
+		if (error.error === 'InternalServerError' || error.description === 'Internal Server Error') {
 			return {
 				message: `Upstream server returned an internal error`,
 			};

src/lib/components/avatar.svelte

···
 </script>
 
 <script lang="ts">
-	import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+	import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 	interface Props {
 		profile?:

src/lib/components/embeds/embeds.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import { unwrapEmbed, type AppBskyFeedDefs, type MediaEmbed, type RecordEmbed } from '@atcute/bluesky';
 
 	import { findLabel, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
-	import { unwrapEmbedView, type MediaEmbed, type RecordEmbed } from '$lib/utils/bluesky/embeds';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { collectionToLabel } from '$lib/utils/bluesky/records';
 
 	import ContentHider from '../content-hider.svelte';
···
 
 	const { embed, large = false, post }: Props = $props();
 
-	const { media, record } = $derived(unwrapEmbedView(embed));
+	const { media, record } = $derived(unwrapEmbed(embed));
 </script>
 
 <div class="embeds">
···
 {/snippet}
 
 {#snippet Record(embed: RecordEmbed)}
-	{@const record = embed.record}
-
-	{#if record.$type === 'app.bsky.embed.record#viewRecord'}
-		<QuoteEmbed embed={record} {large} />
-	{:else if record.$type === 'app.bsky.feed.defs#generatorView'}
-		<FeedEmbed embed={record} />
-	{:else if record.$type === 'app.bsky.graph.defs#listView'}
-		<ListEmbed embed={record} />
-	{:else if record.$type === 'app.bsky.graph.defs#starterPackViewBasic'}
-		<StarterpackEmbed embed={record} {large} />
+	{#if embed.$type === 'app.bsky.embed.record#viewRecord'}
+		<QuoteEmbed {embed} {large} />
+	{:else if embed.$type === 'app.bsky.feed.defs#generatorView'}
+		<FeedEmbed {embed} />
+	{:else if embed.$type === 'app.bsky.graph.defs#listView'}
+		<ListEmbed {embed} />
+	{:else if embed.$type === 'app.bsky.graph.defs#starterPackViewBasic'}
+		<StarterpackEmbed {embed} {large} />
 	{:else}
-		{@const uri = parseAddressedAtUri(record.uri)}
+		{@const uri = assertCanonicalResourceUri(embed.uri)}
 
-		{#if uri.collection === 'app.bsky.feed.post' && (record.$type === 'app.bsky.embed.record#viewBlocked' || record.$type === 'app.bsky.embed.record#viewDetached')}
-			<QuoteBlockedEmbed embed={record} {uri} />
+		{#if uri.collection === 'app.bsky.feed.post' && (embed.$type === 'app.bsky.embed.record#viewBlocked' || embed.$type === 'app.bsky.embed.record#viewDetached')}
+			<QuoteBlockedEmbed {embed} {uri} />
 		{:else}
 			{@const resource = collectionToLabel(uri.collection)}
 			{@const isUnavailable =
 				resource &&
-				(record.$type === 'app.bsky.embed.record#viewNotFound' ||
-					record.$type === 'app.bsky.embed.record#viewBlocked')}
+				(embed.$type === 'app.bsky.embed.record#viewNotFound' ||
+					embed.$type === 'app.bsky.embed.record#viewBlocked')}
 
 			{@render Message(isUnavailable ? `This ${resource} is unavailable` : `Unsupported record embed`)}
 		{/if}

src/lib/components/embeds/external-embed.svelte

···
 <script lang="ts">
-	import type { AppBskyEmbedExternal } from '@atcute/client/lexicons';
+	import type { AppBskyEmbedExternal } from '@atcute/bluesky';
 
 	import { redirectBskyUrl } from '$lib/redirector';
 	import { truncateRight } from '$lib/utils/strings';

src/lib/components/embeds/feed-embed.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
 	import { findLabel, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { truncateRight } from '$lib/utils/strings';
···
 	const blurAvi = $derived(!!findLabel(feed.labels, creator.did, FlagsBlurMedia));
 </script>
 
-<a href="{base}/{creator.did}/feeds/{parseAddressedAtUri(feed.uri).rkey}" class="feed-embed">
+<a href="{base}/{creator.did}/feeds/{assertCanonicalResourceUri(feed.uri).rkey}" class="feed-embed">
 	<div class="main">
 		<Avatar type="generator" src={feed.avatar} blur={blurAvi} />
 

src/lib/components/embeds/image-embed.svelte

···
 </script>
 
 <script lang="ts">
-	import type { AppBskyEmbedImages } from '@atcute/client/lexicons';
+	import type { AppBskyEmbedImages } from '@atcute/bluesky';
 
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 

src/lib/components/embeds/list-embed.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
 	import { findLabel, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { purposeToLabel } from '$lib/utils/bluesky/lists';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
···
 	const blurAvi = $derived(!!findLabel(list.labels, creator.did, FlagsBlurMedia));
 </script>
 
-<a href="{base}/{creator.did}/lists/{parseAddressedAtUri(list.uri).rkey}" class="list-embed">
+<a href="{base}/{creator.did}/lists/{assertCanonicalResourceUri(list.uri).rkey}" class="list-embed">
 	<div class="main">
 		<Avatar type="list" src={list.avatar} blur={blurAvi} />
 

src/lib/components/embeds/quote-blocked-embed.svelte

···
 <script lang="ts">
-	import type { AppBskyEmbedRecord, Brand } from '@atcute/client/lexicons';
+	import type { AppBskyEmbedRecord } from '@atcute/bluesky';
+	import type { $type, ParsedCanonicalResourceUri } from '@atcute/lexicons';
 
 	import { base } from '$app/paths';
-
-	import type { AddressedAtUri } from '$lib/types/at-uri';
 
 	import CircleBanSignOutlined from '$lib/components/central-icons/circle-ban-sign-outlined.svelte';
 
 	interface Props {
-		embed: Brand.Union<AppBskyEmbedRecord.ViewBlocked | AppBskyEmbedRecord.ViewDetached>;
-		uri: AddressedAtUri;
+		embed: $type.enforce<AppBskyEmbedRecord.ViewBlocked | AppBskyEmbedRecord.ViewDetached>;
+		uri: ParsedCanonicalResourceUri;
 	}
 
 	const { embed, uri }: Props = $props();

src/lib/components/embeds/quote-embed.svelte

···
 <script lang="ts">
-	import type { AppBskyEmbedRecord, AppBskyFeedPost } from '@atcute/client/lexicons';
+	import { unwrapMediaEmbed, type AppBskyEmbedRecord, type AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
 	import { findLabel, FlagsBlurContent, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
-	import { unwrapMediaEmbedView } from '$lib/utils/bluesky/embeds';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 
 	import Avatar from '$lib/components/avatar.svelte';
···
 
 	const { embed: quote, large = false }: Props = $props();
 
-	const record = $derived(quote.value as AppBskyFeedPost.Record);
+	const record = $derived(quote.value as AppBskyFeedPost.Main);
 	const text = $derived(trimRichText(record.text));
 
 	const author = $derived(quote.author);
 	const authorName = $derived(normalizeDisplayName(author.displayName ?? ''));
 
 	const embed = $derived(quote.embeds?.[0]);
-	const media = $derived(unwrapMediaEmbedView(embed));
+	const media = $derived(unwrapMediaEmbed(embed));
 
 	const blurAvi = $derived(!!findLabel(author.labels, author.did, FlagsBlurMedia));
 	const blurContent = $derived(findLabel(quote.labels, author.did, FlagsBlurContent));
···
 </script>
 
 <ContentHider blur={blurContent}>
-	<a href="{base}/{author.did}/{parseAddressedAtUri(quote.uri).rkey}#main" class="quote-embed">
+	<a href="{base}/{author.did}/{assertCanonicalResourceUri(quote.uri).rkey}#main" class="quote-embed">
 		<div class="meta">
 			<Avatar profile={author} src={author.avatar} size="xs" blur={blurAvi} />
 

src/lib/components/embeds/starterpack-embed.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { truncateRight } from '$lib/utils/strings';
···
 
 	const { embed: pack, large = false }: Props = $props();
 
-	const record = pack.record as AppBskyGraphStarterpack.Record;
+	const record = pack.record as AppBskyGraphStarterpack.Main;
 
 	const creator = $derived(pack.creator);
 
-	const rkey = $derived(parseAddressedAtUri(pack.uri).rkey);
+	const rkey = $derived(assertCanonicalResourceUri(pack.uri).rkey);
 </script>
 
 <a href="{base}/{creator.did}/packs/{rkey}" class="starterpack-embed">

src/lib/components/embeds/video-standalone-embed.svelte

···
 </script>
 
 <script lang="ts">
-	import type { AppBskyEmbedVideo } from '@atcute/client/lexicons';
+	import type { AppBskyEmbedVideo } from '@atcute/bluesky';
 
 	import { dev } from '$app/environment';
 	import { base } from '$app/paths';

src/lib/components/embeds/video-thumbnail-embed.svelte

···
 <script lang="ts">
 	// This is meant to be used inside quote embeds, so it's non-standalone.
 
-	import type { AppBskyEmbedVideo } from '@atcute/client/lexicons';
+	import type { AppBskyEmbedVideo } from '@atcute/bluesky';
 
 	import { replaceVideoCdnUrl } from '$lib/utils/bluesky/videos';
 

src/lib/components/feeds/feed-item.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { formatLongNumber } from '$lib/utils/intl/number';
···
 
 	const creator = $derived(feed.creator);
 
-	const href = $derived(`${base}/${creator.did}/feeds/${parseAddressedAtUri(feed.uri).rkey}`);
+	const href = $derived(`${base}/${creator.did}/feeds/${assertCanonicalResourceUri(feed.uri).rkey}`);
 </script>
 
 <div class="feed-item">

src/lib/components/lists/list-item.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { purposeToLabel } from '$lib/utils/bluesky/lists';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
···
 
 	const creator = $derived(list.creator);
 
-	const href = $derived(`${base}/${creator.did}/lists/${parseAddressedAtUri(list.uri).rkey}`);
+	const href = $derived(`${base}/${creator.did}/lists/${assertCanonicalResourceUri(list.uri).rkey}`);
 </script>
 
 <div class="list-item">

src/lib/components/profiles/profile-item.svelte

···
 <script lang="ts">
-	import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+	import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 

src/lib/components/starterpacks/starterpack-item.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { truncateMiddle } from '$lib/utils/strings';
···
 
 	const creator = $derived(pack.creator);
 
-	const record = $derived(pack.record as AppBskyGraphStarterpack.Record);
-	const href = $derived(`${base}/${creator.did}/packs/${parseAddressedAtUri(pack.uri).rkey}`);
+	const record = $derived(pack.record as AppBskyGraphStarterpack.Main);
+	const href = $derived(`${base}/${creator.did}/packs/${assertCanonicalResourceUri(pack.uri).rkey}`);
 </script>
 
 <div class="starterpack-item">

src/lib/components/timeline/post-feed-item.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+	import type { AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
 	import type { UiTimelineItem } from '$lib/models/timeline';
 	import { findLabel, FlagsBlurContent, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 
 	import ArrowsRepeatRightLeftOutlined from '$lib/components/central-icons/arrows-repeat-right-left-outlined.svelte';
···
 	const author = $derived(post.author);
 	const authorUrl = $derived(`${base}/${author.did}`);
 
-	const record = $derived(post.record as AppBskyFeedPost.Record);
-	const postUrl = $derived(`${base}/${author.did}/${parseAddressedAtUri(post.uri).rkey}#main`);
+	const record = $derived(post.record as AppBskyFeedPost.Main);
+	const postUrl = $derived(`${base}/${author.did}/${assertCanonicalResourceUri(post.uri).rkey}#main`);
 
 	const isAviBlurred = $derived(!!findLabel(author.labels, author.did, FlagsBlurMedia));
 	const blur = $derived(findLabel(post.labels, author.did, FlagsBlurContent));

src/lib/components/timeline/post-meta.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 
···
 	const author = $derived(post.author);
 	const authorName = $derived(normalizeDisplayName(author.displayName ?? ''));
 
-	const createdAt = $derived((post.record as AppBskyFeedPost.Record).createdAt);
+	const createdAt = $derived((post.record as AppBskyFeedPost.Main).createdAt);
 </script>
 
 <div class={['post-meta', gutterBottom && 'has-bottom-gutter']}>

src/lib/components/timeline/post-metrics.svelte

···
 <script lang="ts">
 	import type { Component } from 'svelte';
 
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 	import { formatCompactNumber, formatLongNumber } from '$lib/utils/intl/number';
 

src/lib/constants.ts

···
-import type { At } from '@atcute/client/lexicons';
+import type { CanonicalResourceUri } from '@atcute/lexicons';
 
 // Popular feeds that requires authentication to view
-export const AUTHENTICATED_FEEDS: At.CanonicalResourceUri[] = [
+export const AUTHENTICATED_FEEDS: CanonicalResourceUri[] = [
 	// "Popular With Friends" by @bsky.app
 	`at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.generator/with-friends`,
 	// "Mutuals" by @skyfeed.xyz

src/lib/models/timeline.ts

···
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { mapDefined } from '@mary/array-fns';
 
 export type TimelineItem = AppBskyFeedDefs.FeedViewPost;

src/lib/moderation.ts

···
-import type { At, ComAtprotoLabelDefs } from '@atcute/client/lexicons';
+import type { ComAtprotoLabelDefs } from '@atcute/atproto';
+import type { Did } from '@atcute/lexicons';
 
 export const FlagsNone = 0;
 
···
 
 export const findLabel = (
 	labels: Label[] | undefined,
-	authorDid: At.Did,
+	authorDid: Did,
 	mask: number,
 ): LabelDefinition | undefined => {
 	if (labels?.length) {

src/lib/queries/constellation.ts

···
 import { error } from '@sveltejs/kit';
 
-import type { Records } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
+import type { Records } from '@atcute/lexicons/ambient';
 
 import * as v from '@badrap/valita';
 
 import { PUBLIC_APP_USER_AGENT, PUBLIC_CONSTELLATION_URL } from '$env/static/public';
 
-import type { Did } from '$lib/types/identity';
 import { didString, integer, nsidString, recordKeyString } from '$lib/types/valita';
 
 const linkResponse = v.object({

src/lib/queries/handle.ts

···
-import type { XRPC } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import { ok, type Client } from '@atcute/client';
+import type { Did, Handle } from '@atcute/lexicons';
 
-import type { Did } from '$lib/types/identity';
+export const resolveHandle = async ({ client, handle }: { client: Client; handle: Handle }): Promise<Did> => {
+	const data = await ok(
+		client.get('com.atproto.identity.resolveHandle', {
+			params: { handle },
+		}),
+	);
 
-export const resolveHandle = async ({ rpc, handle }: { rpc: XRPC; handle: At.Handle }): Promise<Did> => {
-	const { data } = await rpc.get('com.atproto.identity.resolveHandle', {
-		params: { handle },
-	});
-
-	// because my types are stricter than atcute's
-	return data.did as Did;
+	return data.did;
 };

src/lib/queries/post.ts

···
-import { XRPC, XRPCError } from '@atcute/client';
-import type { AppBskyFeedDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
+import { type Client, ClientResponseError, ok } from '@atcute/client';
+import type { ResourceUri } from '@atcute/lexicons';
 
 export interface GetPostReturn {
 	post: AppBskyFeedDefs.PostView;
 	threadgate?: AppBskyFeedDefs.ThreadgateView;
 }
 
-export const getPost = async ({ rpc, uri }: { rpc: XRPC; uri: At.ResourceUri }): Promise<GetPostReturn> => {
-	const { data } = await rpc.get('app.bsky.feed.getPostThread', {
-		params: {
-			uri: uri,
-			depth: 0,
-			parentHeight: 0,
-		},
-	});
+export const getPost = async ({
+	client,
+	uri,
+}: {
+	client: Client;
+	uri: ResourceUri;
+}): Promise<GetPostReturn> => {
+	const data = await ok(
+		client.get('app.bsky.feed.getPostThread', {
+			params: {
+				uri: uri,
+				depth: 0,
+				parentHeight: 0,
+			},
+		}),
+	);
 
 	const { thread, threadgate } = data;
 	switch (thread.$type) {
 		case 'app.bsky.feed.defs#notFoundPost':
 		case 'app.bsky.feed.defs#blockedPost': {
-			throw new XRPCError(400, { kind: 'NotFound', description: 'Post not found' });
+			throw new ClientResponseError({
+				status: 400,
+				data: { error: 'NotFound', message: `Post not found` },
+			});
 		}
 	}
 

src/lib/queries/timeline.ts

···
-import type { XRPC } from '@atcute/client';
-import type { AppBskyActorDefs, AppBskyFeedDefs, AppBskyFeedGetTimeline, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs, AppBskyFeedDefs, AppBskyFeedGetTimeline } from '@atcute/bluesky';
+import { type Client, ok } from '@atcute/client';
 
 import {
 	buildTimelineSlices,
···
 	type TimelineSlice,
 	type UiTimelineItem,
 } from '$lib/models/timeline';
-import type { Did } from '$lib/types/identity';
 import { assertNever } from '$lib/utils/invariant';
+import type { Did, ResourceUri } from '@atcute/lexicons';
 
 export const enum TimelineType {
 	PROFILE,
···
 
 export interface CustomFeedTimelineParams {
 	type: TimelineType.CUSTOM_FEED;
-	feed: At.ResourceUri;
+	feed: ResourceUri;
 	cursor?: string;
 }
 
 export interface UserListTimelineParams {
 	type: TimelineType.USER_LIST;
-	list: At.ResourceUri;
+	list: ResourceUri;
 	cursor?: string;
 }
 
···
 const PAGE_LIMIT = 50;
 
 export const fetchTimeline = async ({
-	rpc,
+	client,
 	params,
 }: {
-	rpc: XRPC;
+	client: Client;
 	params: TimelineParams;
 }): Promise<TimelinePage> => {
 	let sliceFilter: SliceFilter | undefined;
 	let postFilter: PostFilter | undefined;
 
-	let timeline: AppBskyFeedGetTimeline.Output;
+	let timeline: AppBskyFeedGetTimeline.$output;
 
 	switch (params.type) {
 		case TimelineType.PROFILE: {
-			const { data } = await rpc.get('app.bsky.feed.getAuthorFeed', {
-				params: {
-					actor: params.actor,
-					cursor: params.cursor,
-					limit: PAGE_LIMIT,
-					includePins: params.pinned ?? params.filter !== ProfileFilter.MEDIA,
-					filter:
-						params.filter === ProfileFilter.MEDIA
-							? 'posts_with_media'
-							: params.filter === ProfileFilter.POSTS_WITH_REPLIES
-								? 'posts_with_replies'
-								: 'posts_and_author_threads',
-				},
-			});
+			const data = await ok(
+				client.get('app.bsky.feed.getAuthorFeed', {
+					params: {
+						actor: params.actor,
+						cursor: params.cursor,
+						limit: PAGE_LIMIT,
+						includePins: params.pinned ?? params.filter !== ProfileFilter.MEDIA,
+						filter:
+							params.filter === ProfileFilter.MEDIA
+								? 'posts_with_media'
+								: params.filter === ProfileFilter.POSTS_WITH_REPLIES
+									? 'posts_with_replies'
+									: 'posts_and_author_threads',
+					},
+				}),
+			);
 
 			timeline = data;
 
···
 			break;
 		}
 		case TimelineType.CUSTOM_FEED: {
-			const { data } = await rpc.get('app.bsky.feed.getFeed', {
-				params: {
-					feed: params.feed,
-					cursor: params.cursor,
-					limit: PAGE_LIMIT,
-				},
-			});
+			const data = await ok(
+				client.get('app.bsky.feed.getFeed', {
+					params: {
+						feed: params.feed,
+						cursor: params.cursor,
+						limit: PAGE_LIMIT,
+					},
+				}),
+			);
 
 			timeline = {
 				// Discover feed, wooo.
···
 			break;
 		}
 		case TimelineType.USER_LIST: {
-			const { data } = await rpc.get('app.bsky.feed.getListFeed', {
-				params: {
-					list: params.list,
-					cursor: params.cursor,
-					limit: PAGE_LIMIT,
-				},
-			});
+			const data = await ok(
+				client.get('app.bsky.feed.getListFeed', {
+					params: {
+						list: params.list,
+						cursor: params.cursor,
+						limit: PAGE_LIMIT,
+					},
+				}),
+			);
 
 			timeline = data;
 			break;

src/lib/redirector.ts

···
 import { base } from '$app/paths';
-import { type PartialAtUri, parsePartialAtUri } from './types/at-uri';
+
+import { isDid, isHandle, isRecordKey, isTid, parseResourceUri } from '@atcute/lexicons/syntax';
 
-import { isDid, isHandle } from './types/identity';
-import { isRecordKey, isTid } from './types/rkey';
 import {
 	BSKY_FEED_LINK_RE,
 	BSKY_GO_SHORTLINK_RE,
···
 };
 
 export const redirectAtUri = (raw: string): RedirectResult => {
-	let uri: PartialAtUri;
-	try {
-		uri = parsePartialAtUri(raw);
-	} catch (e) {
+	const result = parseResourceUri(raw);
+	if (!result.ok) {
 		return;
 	}
+
+	const uri = result.value;
 
 	if (uri.rkey) {
 		switch (uri.collection) {

src/lib/rss.ts

···
+import {
+	unwrapEmbed,
+	type AppBskyFeedDefs,
+	type AppBskyFeedPost,
+	type AppBskyRichtextFacet,
+} from '@atcute/bluesky';
 import { segmentize } from '@atcute/bluesky-richtext-segmenter';
-import type { AppBskyFeedDefs, AppBskyFeedPost, AppBskyRichtextFacet } from '@atcute/client/lexicons';
 
 import { PUBLIC_APP_URL } from '$env/static/public';
 
 import { findLabel, FlagsBlurMedia } from './moderation';
-import { parseAddressedAtUri } from './types/at-uri';
-import { getQuoteEmbedView, unwrapEmbedView } from './utils/bluesky/embeds';
+import { assertCanonicalResourceUri } from './types/at-uri';
+import { getQuoteEmbed } from './utils/bluesky/embeds';
 import { assertNever } from './utils/invariant';
 import type { UnwrapArray } from './utils/types';
 
···
 	const post = item.post;
 	const author = post.author;
 
-	const record = post.record as AppBskyFeedPost.Record;
+	const record = post.record as AppBskyFeedPost.Main;
 
-	const { media, record: recordEmbed } = unwrapEmbedView(post.embed);
-	const quote = getQuoteEmbedView(recordEmbed);
+	const { media, record: recordEmbed } = unwrapEmbed(post.embed);
+	const quote = getQuoteEmbed(recordEmbed);
 
 	const shouldBlurMedia = !!findLabel(post.labels, author.did, FlagsBlurMedia);
 
···
 		switch (quote.$type) {
 			case 'app.bsky.embed.record#viewRecord': {
 				const author = quote.author;
-				const record = quote.value as AppBskyFeedPost.Record;
+				const record = quote.value as AppBskyFeedPost.Main;
 
-				const postUrl = `${PUBLIC_APP_URL}/${author.did}/${parseAddressedAtUri(quote.uri).rkey}`;
+				const uri = assertCanonicalResourceUri(quote.uri);
+
+				const postUrl = `${PUBLIC_APP_URL}/${author.did}/${uri.rkey}`;
 
 				html += `<blockquote>`;
 				html += `<b><a href="${escapeAttribute(postUrl)}">`;
···
 
 	return {
 		id: `${post.uri}|${post.cid}`,
-		url: `${PUBLIC_APP_URL}/${author.did}/${parseAddressedAtUri(post.uri).rkey}`,
+		url: `${PUBLIC_APP_URL}/${author.did}/${assertCanonicalResourceUri(post.uri).rkey}`,
 		date: new Date(post.indexedAt),
 		description: { html },
 		images:

src/lib/types/at-uri.ts

···
-import type { At, Records } from '@atcute/client/lexicons';
+import {
+	parseCanonicalResourceUri,
+	type Did,
+	type Handle,
+	type Nsid,
+	type ParsedCanonicalResourceUri,
+	type ResourceUri,
+} from '@atcute/lexicons';
+import type { Records } from '@atcute/lexicons/ambient';
 
 import { assert } from '$lib/utils/invariant';
 
-import { isDid, isHandle, type Did, type Handle } from './identity';
-import { isNsid, type Nsid } from './nsid';
-import { isRecordKey, type RecordKey } from './rkey';
-
-const ATURI_RE =
-	/^at:\/\/([a-zA-Z0-9._:%-]+)(?:\/([a-zA-Z0-9-.]+)(?:\/([a-zA-Z0-9._~:@!$&%')(*+,;=-]+))?)?(?:#(\/[a-zA-Z0-9._~:@!$&%')(*+,;=\-[\]/\\]*))?$/;
-
-export type AddressedAtUri = {
-	repo: Did;
-	collection: Nsid;
-	rkey: RecordKey;
-	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,
-	};
-};
-
-export type PartialAtUri =
-	| { repo: Did | Handle; collection: undefined; rkey: undefined; fragment: string | undefined }
-	| { repo: Did | Handle; collection: Nsid; rkey: undefined; fragment: string | undefined }
-	| { repo: Did | Handle; collection: Nsid; rkey: RecordKey; fragment: string | undefined };
-
-export const parsePartialAtUri = (str: string): PartialAtUri => {
-	const match = ATURI_RE.exec(str);
-	assert(match !== null, `invalid partial-at-uri: ${str}`);
-
-	const [, r, c, k, f] = match;
-	assert(isDid(r) || isHandle(r), `invalid repo in partial-at-uri: ${r}`);
-	assert(c === undefined || isNsid(c), `invalid collection in partial-at-uri: ${c}`);
-	assert(k === undefined || isRecordKey(k), `invalid rkey in partial-at-uri: ${k}`);
-
-	return {
-		repo: r,
-		collection: c,
-		rkey: k,
-		fragment: f,
-	};
-};
-
 export const makeAtUri = (
 	repo: Did | Handle,
 	collection: keyof Records | (Nsid & {}),
 	rkey: string,
-): At.ResourceUri => {
+): ResourceUri => {
 	return `at://${repo}/${collection as Nsid}/${rkey}`;
 };
+
+export const assertCanonicalResourceUri = (input: string): ParsedCanonicalResourceUri => {
+	const result = parseCanonicalResourceUri(input);
+	if (!result.ok) {
+		assert(false, result.error);
+	}
+
+	return result.value;
+};

src/lib/types/identity.ts

···
-export type Handle = `${string}.${string}`;
-
-const HANDLE_RE =
-	/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+([a-zA-Z][a-zA-Z0-9-]{0,61}[a-zA-Z])$/;
-
-export const isHandle = (input: unknown): input is Handle => {
-	return typeof input === 'string' && input.length >= 3 && input.length <= 253 && HANDLE_RE.test(input);
-};
-
-export type Did<TMethod extends string = string> = `did:${TMethod}:${string}`;
-export type AtprotoDid = Did<'plc' | 'web'>;
-
-const DID_RE = /^did:([a-z]+):([a-zA-Z0-9._:%\-]*[a-zA-Z0-9._\-])$/;
-
-export const isDid = (input: unknown): input is Did => {
-	return typeof input === 'string' && input.length >= 7 && input.length <= 2048 && DID_RE.test(input);
-};
-
-const ATPROTO_WEB_DID_RE =
-	/^did:web:([a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*(?:\.[a-zA-Z]{2,})|localhost(?:%3[aA]\d+)?)$/;
-
-export const isAtprotoWebDid = (input: unknown): input is Did<'web'> => {
-	return typeof input === 'string' && input.length >= 12 && ATPROTO_WEB_DID_RE.test(input);
-};
-
-const PLC_DID_RE = /^did:plc:([a-z2-7]{24})$/;
-
-export const isPlcDid = (input: unknown): input is Did<'plc'> => {
-	return typeof input === 'string' && input.length === 32 && PLC_DID_RE.test(input);
-};
-
-export const isAtprotoDid = (input: unknown): input is AtprotoDid => {
-	return isPlcDid(input) || isAtprotoWebDid(input);
-};

src/lib/types/nsid.ts

···
-export type Nsid = `${string}.${string}.${string}`;
-
-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})?)$/;
-
-export const isNsid = (input: unknown): input is Nsid => {
-	return typeof input === 'string' && input.length >= 5 && input.length <= 317 && NSID_RE.test(input);
-};

src/lib/types/rkey.ts

···
-const RECORD_KEY_RE = /^(?!\.{1,2}$)[a-zA-Z0-9_~.:-]{1,512}$/;
-
-export type RecordKey = string;
-
-export const isRecordKey = (input: unknown): input is RecordKey => {
-	return typeof input === 'string' && input.length >= 1 && input.length <= 512 && RECORD_KEY_RE.test(input);
-};
-
-const TID_RE = /^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$/;
-
-export const isTid = (input: string) => {
-	return input.length === 13 && TID_RE.test(input);
-};

src/lib/types/valita.ts

···
-import * as v from '@badrap/valita';
+import { isDid, isNsid, isRecordKey } from '@atcute/lexicons/syntax';
 
-import { isDid } from './identity';
-import { isNsid } from './nsid';
-import { isRecordKey } from './rkey';
+import * as v from '@badrap/valita';
 
 export const didString = v.string().assert(isDid);
 

src/lib/utils/bluesky/embeds.ts

···
-import type { AppBskyEmbedRecordWithMedia, AppBskyFeedDefs } from '@atcute/client/lexicons';
-
-import { parseAddressedAtUri } from '$lib/types/at-uri';
-
-export interface Embed {
-	media?: AppBskyEmbedRecordWithMedia.View['media'];
-	record?: AppBskyEmbedRecordWithMedia.View['record'];
-}
-
-export type MediaEmbed = NonNullable<Embed['media']>;
-export type RecordEmbed = NonNullable<Embed['record']>;
-
-export const unwrapMediaEmbedView = (embed: AppBskyFeedDefs.PostView['embed']): Embed['media'] => {
-	switch (embed?.$type) {
-		case 'app.bsky.embed.recordWithMedia#view':
-			return embed.media;
-		case 'app.bsky.embed.record#view':
-			return;
-	}
-
-	return embed;
-};
+import type { RecordEmbed } from '@atcute/bluesky';
+import { parseCanonicalResourceUri } from '@atcute/lexicons';
 
-export const unwrapRecordEmbedView = (embed: AppBskyFeedDefs.PostView['embed']): Embed['record'] => {
+export const getQuoteEmbed = (embed: RecordEmbed | undefined) => {
 	switch (embed?.$type) {
-		case 'app.bsky.embed.recordWithMedia#view':
-			return embed.record;
-
-		case 'app.bsky.embed.record#view':
-			return embed;
-	}
-};
-
-export const unwrapEmbedView = (embed: AppBskyFeedDefs.PostView['embed']): Embed => {
-	return {
-		media: unwrapMediaEmbedView(embed),
-		record: unwrapRecordEmbedView(embed),
-	};
-};
-
-export const getQuoteEmbedView = (embed: RecordEmbed | undefined) => {
-	const record = embed?.record;
-
-	switch (record?.$type) {
 		case 'app.bsky.embed.record#viewRecord': {
-			return record;
+			return embed;
 		}
 
 		case 'app.bsky.embed.record#viewNotFound':
 		case 'app.bsky.embed.record#viewDetached':
 		case 'app.bsky.embed.record#viewBlocked': {
-			const uri = parseAddressedAtUri(record.uri);
+			const result = parseCanonicalResourceUri(embed.uri);
+			if (!result.ok) {
+				return;
+			}
+
+			const uri = result.value;
 			if (uri.collection === 'app.bsky.feed.post') {
-				return record;
+				return embed;
 			}
 		}
 	}

src/lib/utils/bluesky/lists.ts

···
-import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
 
 export const purposeToLabel = (purpose: AppBskyGraphDefs.ListView['purpose']): string => {
 	switch (purpose) {

src/params/did.ts

···
 import type { ParamMatcher } from '@sveltejs/kit';
 
-import { isDid } from '$lib/types/identity';
+import { isDid } from '@atcute/lexicons/syntax';
 
 export const match = isDid satisfies ParamMatcher;

src/params/didOrHandle.ts

···
 import type { ParamMatcher } from '@sveltejs/kit';
 
-import { isDid, isHandle, type Did, type Handle } from '$lib/types/identity';
+import { isActorIdentifier } from '@atcute/lexicons/syntax';
 
-export const match = ((param: string): param is Did | Handle => {
-	return isDid(param) || isHandle(param);
-}) satisfies ParamMatcher;
+export const match = isActorIdentifier satisfies ParamMatcher;

src/params/handle.ts

···
 import type { ParamMatcher } from '@sveltejs/kit';
 
-import { isHandle } from '$lib/types/identity';
+import { isHandle } from '@atcute/lexicons/syntax';
 
 export const match = isHandle satisfies ParamMatcher;

src/params/rkey.ts

···
 import type { ParamMatcher } from '@sveltejs/kit';
 
-import { isRecordKey } from '$lib/types/rkey';
+import { isRecordKey } from '@atcute/lexicons/syntax';
 
 export const match = isRecordKey satisfies ParamMatcher;

src/params/tid.ts

···
 import type { ParamMatcher } from '@sveltejs/kit';
 
-import { isTid } from '$lib/types/rkey';
+import { isTid } from '@atcute/lexicons/syntax';
 
 export const match = isTid satisfies ParamMatcher;

src/routes/(app)/(profile)/[actor=didOrHandle]/(timeline)/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 import { fetchTimeline, ProfileFilter, TimelineType } from '$lib/queries/timeline';
-import { isDid, type Did } from '$lib/types/identity';
 
 export const load: PageLoad = async ({ url, params, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
···
 	}
 
 	const timeline = await fetchTimeline({
-		rpc,
+		client,
 		params: {
 			type: TimelineType.PROFILE,
 			actor: did,

src/routes/(app)/(profile)/[actor=didOrHandle]/(timeline)/media/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
-import { fetchTimeline, ProfileFilter, TimelineType } from '$lib/queries/timeline';
-import { isDid, type Did } from '$lib/types/identity';
-
 import type { PageLoad } from './$types';
 
+import { fetchTimeline, ProfileFilter, TimelineType } from '$lib/queries/timeline';
+
 export const load: PageLoad = async ({ url, params, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
···
 	}
 
 	const timeline = await fetchTimeline({
-		rpc,
+		client,
 		params: {
 			type: TimelineType.PROFILE,
 			actor: did,

src/routes/(app)/(profile)/[actor=didOrHandle]/(timeline)/rss/+server.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APP_URL, PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { RequestHandler } from './$types';
···
 import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 
 export const GET: RequestHandler = async ({ params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const [profile, timeline] = await Promise.all([
 		(async () => {
-			const { data } = await rpc.get('app.bsky.actor.getProfile', {
-				params: {
-					actor: params.actor,
-				},
-			});
+			const data = await ok(
+				client.get('app.bsky.actor.getProfile', {
+					params: {
+						actor: params.actor,
+					},
+				}),
+			);
 
 			return data;
 		})(),
 
 		(async () => {
-			const { data } = await rpc.get('app.bsky.feed.getAuthorFeed', {
-				params: {
-					actor: params.actor,
-					limit: 100,
-					filter: 'posts_and_author_threads',
-					includePins: false,
-				},
-			});
+			const data = await ok(
+				client.get('app.bsky.feed.getAuthorFeed', {
+					params: {
+						actor: params.actor,
+						limit: 100,
+						filter: 'posts_and_author_threads',
+						includePins: false,
+					},
+				}),
+			);
 
 			// Build into slices so we can filter out non-self threads
 			const slices = buildTimelineSlices(

src/routes/(app)/(profile)/[actor=didOrHandle]/(timeline)/with_replies/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
-import { fetchTimeline, ProfileFilter, TimelineType } from '$lib/queries/timeline';
-import { isDid, type Did } from '$lib/types/identity';
-
 import type { PageLoad } from './$types';
 
+import { fetchTimeline, ProfileFilter, TimelineType } from '$lib/queries/timeline';
+
 export const load: PageLoad = async ({ url, params, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
···
 	}
 
 	const timeline = await fetchTimeline({
-		rpc,
+		client,
 		params: {
 			type: TimelineType.PROFILE,
 			actor: did,

src/routes/(app)/(profile)/[actor=didOrHandle]/+layout.ts

···
-import { XRPC, XRPCError, simpleFetchHandler } from '@atcute/client';
+import { Client, ClientResponseError, simpleFetchHandler } from '@atcute/client';
 import { error } from '@sveltejs/kit';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
···
 import type { LayoutLoad } from './$types';
 
 export const load: LayoutLoad = async ({ params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	try {
-		const { data } = await rpc.get('app.bsky.actor.getProfile', {
-			params: {
-				actor: params.actor,
-			},
-		});
+	const response = await client.get('app.bsky.actor.getProfile', {
+		params: {
+			actor: params.actor,
+		},
+	});
 
-		return {
-			profile: data,
-		};
-	} catch (err) {
-		if (err instanceof XRPCError) {
-			switch (err.kind) {
-				case 'InvalidRequest': {
-					error(404, `Account doesn't exist`);
-				}
-				case 'AccountTakedown': {
-					error(404, `Account is taken down`);
-				}
-				case 'AccountDeactivated': {
-					error(404, `Account is deactivated`);
-				}
+	if (!response.ok) {
+		const err = response.data;
+		switch (err.error) {
+			case 'InvalidRequest': {
+				error(404, `Account doesn't exist`);
+			}
+			case 'AccountTakedown': {
+				error(404, `Account is taken down`);
+			}
+			case 'AccountDeactivated': {
+				error(404, `Account is deactivated`);
 			}
 		}
 
-		throw err;
+		throw new ClientResponseError(response);
 	}
+
+	return { profile: response.data };
 };

src/routes/(app)/(profile)/[actor=didOrHandle]/components/profile-aside.svelte

···
 <script lang="ts">
-	import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+	import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 

src/routes/(app)/(profile)/[actor=didOrHandle]/components/profile-meta-tags.svelte

···
 <script lang="ts">
-	import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+	import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 	import { PUBLIC_APP_NAME, PUBLIC_APP_URL } from '$env/static/public';
 

src/routes/(app)/(profile)/[actor=didOrHandle]/feeds/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	const { data } = await rpc.get('app.bsky.feed.getActorFeeds', {
-		params: {
-			actor: params.actor,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.feed.getActorFeeds', {
+			params: {
+				actor: params.actor,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { feeds: { cursor: data.cursor, items: data.feeds } };
 };

src/routes/(app)/(profile)/[actor=didOrHandle]/followers/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	const { data } = await rpc.get('app.bsky.graph.getFollowers', {
-		params: {
-			actor: params.actor,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.graph.getFollowers', {
+			params: {
+				actor: params.actor,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { followers: { cursor: data.cursor, items: data.followers } };
 };

src/routes/(app)/(profile)/[actor=didOrHandle]/following/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	const { data } = await rpc.get('app.bsky.graph.getFollows', {
-		params: {
-			actor: params.actor,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.graph.getFollows', {
+			params: {
+				actor: params.actor,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { following: { cursor: data.cursor, items: data.follows } };
 };

src/routes/(app)/(profile)/[actor=didOrHandle]/lists/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	const { data } = await rpc.get('app.bsky.graph.getLists', {
-		params: {
-			actor: params.actor,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.graph.getLists', {
+			params: {
+				actor: params.actor,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { lists: { cursor: data.cursor, items: data.lists } };
 };

src/routes/(app)/(profile)/[actor=didOrHandle]/packs/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	const { data } = await rpc.get('app.bsky.graph.getActorStarterPacks', {
-		params: {
-			actor: params.actor,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.graph.getActorStarterPacks', {
+			params: {
+				actor: params.actor,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { packs: { cursor: data.cursor, items: data.starterPacks } };
 };

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/+page.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+	import type { AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 	import { PUBLIC_APP_NAME } from '$env/static/public';
 	import type { PageProps } from './$types';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { truncateMiddle, truncateRight } from '$lib/utils/strings';
 
 	import BlockedAscendantItem from './components/blocked-ascendant-item.svelte';
···
 	const { data }: PageProps = $props();
 
 	const main = $derived(data.thread.post);
-	const uri = $derived(parseAddressedAtUri(main.uri));
+	const uri = $derived(assertCanonicalResourceUri(main.uri));
 
 	const title = $derived.by(() => {
 		const author = `@${truncateMiddle(main.author.handle, 29)}`;
-		const content = truncateRight((main.record as AppBskyFeedPost.Record).text.trim(), 70);
+		const content = truncateRight((main.record as AppBskyFeedPost.Main).text.trim(), 70);
 
 		return `${author}: "${content}" — ${PUBLIC_APP_NAME}`;
 	});
···
 			{#if item.type === 'post'}
 				<PostAscendantItem {item} />
 			{:else if item.type === 'overflow'}
-				{@const uri = parseAddressedAtUri(item.uri)}
+				{@const uri = assertCanonicalResourceUri(item.uri)}
 
 				<OverflowAscendantItem postUrl="{base}/{uri.repo}/{uri.rkey}#main" />
 			{:else if item.type === 'blocked'}
-				{@const uri = parseAddressedAtUri(item.uri)}
+				{@const uri = assertCanonicalResourceUri(item.uri)}
 
 				<BlockedAscendantItem postUrl="{base}/{uri.repo}/{uri.rkey}#main" />
 			{:else if item.type === 'nonexistent'}
-				{@const uri = parseAddressedAtUri(item.uri)}
+				{@const uri = assertCanonicalResourceUri(item.uri)}
 
 				<NonexistentAscendantPost postUrl="{base}/{uri.repo}/{uri.rkey}#main" />
 			{/if}

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/+page.ts

···
-import { simpleFetchHandler, XRPC, XRPCError } from '@atcute/client';
-import type { AppBskyFeedGetPostThread } from '@atcute/client/lexicons';
+import type { AppBskyFeedGetPostThread } from '@atcute/bluesky';
+import { Client, ClientResponseError, ok, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
+
 import { error } from '@sveltejs/kit';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
···
 
 import { resolveHandle } from '$lib/queries/handle';
 import { makeAtUri } from '$lib/types/at-uri';
-import { isDid, type Did } from '$lib/types/identity';
 
 export const load: PageLoad = async ({ params }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (!isDid(params.actor)) {
 		try {
-			did = await resolveHandle({ rpc, handle: params.actor });
+			did = await resolveHandle({ client: client, handle: params.actor });
 		} catch (err) {
-			if (err instanceof XRPCError) {
-				switch (err.kind) {
+			if (err instanceof ClientResponseError) {
+				switch (err.error) {
 					case 'InvalidRequest': {
 						error(404, `Account doesn't exist`);
 					}
···
 
 	const uri = makeAtUri(did, 'app.bsky.feed.post', params.rkey);
 
-	let data: AppBskyFeedGetPostThread.Output;
+	let data: AppBskyFeedGetPostThread.$output;
 
 	try {
-		const response = await rpc.get('app.bsky.feed.getPostThread', {
-			params: {
-				uri: uri,
-				depth: 4,
-				parentHeight: 10,
-			},
-		});
-
-		data = response.data;
+		data = await ok(
+			client.get('app.bsky.feed.getPostThread', {
+				params: {
+					uri: uri,
+					depth: 4,
+					parentHeight: 10,
+				},
+			}),
+		);
 	} catch (err) {
-		if (err instanceof XRPCError) {
-			switch (err.kind) {
+		if (err instanceof ClientResponseError) {
+			switch (err.error) {
 				case 'NotFound': {
 					error(404, `Post not found`);
 				}

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/descendants.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs, AppBskyFeedThreadgate } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs, AppBskyFeedThreadgate } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	import { createReplyCollator } from '../utils';
 
···
 
 	const { thread: root, threadgate }: Props = $props();
 
-	const gate = $derived(threadgate?.record as AppBskyFeedThreadgate.Record | undefined);
+	const gate = $derived(threadgate?.record as AppBskyFeedThreadgate.Main | undefined);
 	const sort = $derived(createReplyCollator(threadgate));
 </script>
 
···
 				</div>
 			{/if}
 
-			<OverflowDescendantItem postUrl="{base}/{post.author.did}/{parseAddressedAtUri(post.uri).rkey}#main" />
+			<OverflowDescendantItem
+				postUrl="{base}/{post.author.did}/{assertCanonicalResourceUri(post.uri).rkey}#main"
+			/>
 		{/if}
 	{/each}
 {/snippet}

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/interaction-state.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs, AppBskyFeedThreadgate } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs, AppBskyFeedThreadgate } from '@atcute/bluesky';
 
 	import type { UnwrapArray } from '$lib/utils/types';
 
···
 	import Group_2Outlined from '$lib/components/central-icons/group-2-outlined.svelte';
 	import CircleBanSignOutlined from '$lib/components/central-icons/circle-ban-sign-outlined.svelte';
 	import { base } from '$app/paths';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	interface Props {
 		threadgate: AppBskyFeedDefs.ThreadgateView | undefined;
 	}
 
-	type GateRecord = AppBskyFeedThreadgate.Record;
+	type GateRecord = AppBskyFeedThreadgate.Main;
 	type Allow = UnwrapArray<GateRecord['allow']>;
 
 	const { threadgate }: Props = $props();
 
 	const id = $props.id();
 
-	const record = $derived(threadgate?.record as AppBskyFeedThreadgate.Record | undefined);
+	const record = $derived(threadgate?.record as AppBskyFeedThreadgate.Main | undefined);
 
 	const allow = $derived.by(() => {
 		const order: Record<Allow['$type'], number> = {
···
 					{@const hydrated = threadgate!.lists?.find((list) => list.uri === rule.list)}
 
 					{#if hydrated}
-						{@const uri = parseAddressedAtUri(rule.list)}
+						{@const uri = assertCanonicalResourceUri(rule.list)}
 
 						<li>
 							Users in <a class="link" href="{base}/{uri.repo}/lists/{uri.rkey}">{hydrated.name}</a> list

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/main-post-metrics.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { formatCompactNumber } from '$lib/utils/intl/number';
 
 	interface Props {
···
 
 	const { post }: Props = $props();
 
-	const baseUrl = $derived(`${base}/${post.author.did}/${parseAddressedAtUri(post.uri).rkey}`);
+	const baseUrl = $derived(`${base}/${post.author.did}/${assertCanonicalResourceUri(post.uri).rkey}`);
 </script>
 
 {#snippet Stat(count: number | undefined, one: string, many: string, href: string)}

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/main-post.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
 	import { findLabel, FlagsBlurContent, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 
 	import Avatar from '$lib/components/avatar.svelte';
···
 
 	const { post, threadgate, prev = false }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(post.uri));
+	const uri = $derived(assertCanonicalResourceUri(post.uri));
 
 	const author = $derived(post.author);
 	const authorName = $derived(normalizeDisplayName(author.displayName ?? ''));
 
-	const record = $derived(post.record as AppBskyFeedPost.Record);
+	const record = $derived(post.record as AppBskyFeedPost.Main);
 
 	const authorUrl = $derived(`${base}/${author.did}`);
 	const postUrl = $derived(`${base}/${author.did}/${uri.rkey}#main`);

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/missing-descendant-item.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	interface Props {
 		count: number;
···
 
 <div class="missing-descendant-item">
 	<span class="label">{count === 1 ? `${count} missing reply` : `${count} missing replies`}</span>
-	<a href="{base}/{post.author.did}/{parseAddressedAtUri(post.uri).rkey}/all-replies" class="link">View</a>
+	<a href="{base}/{post.author.did}/{assertCanonicalResourceUri(post.uri).rkey}/all-replies" class="link"
+		>View</a
+	>
 </div>
 
 <style>

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/post-ascendant-item.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+	import type { AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
 	import { findLabel, FlagsBlurContent, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	import Avatar from '$lib/components/avatar.svelte';
 	import RichtextRenderer from '$lib/components/richtext-renderer.svelte';
···
 	const author = $derived(post.author);
 	const authorUrl = $derived(`${base}/${author.did}`);
 
-	const record = $derived(post.record as AppBskyFeedPost.Record);
-	const postUrl = $derived(`${base}/${author.did}/${parseAddressedAtUri(post.uri).rkey}#main`);
+	const record = $derived(post.record as AppBskyFeedPost.Main);
+	const postUrl = $derived(`${base}/${author.did}/${assertCanonicalResourceUri(post.uri).rkey}#main`);
 
 	const isAviBlurred = $derived(!!findLabel(author.labels, author.did, FlagsBlurMedia));
 	const blur = $derived(findLabel(post.labels, author.did, FlagsBlurContent));

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/post-descendant-item.svelte

···
 <script lang="ts">
 	import type { Snippet } from 'svelte';
 
-	import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
 	import { findLabel, FlagsBlurContent, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	import Avatar from '$lib/components/avatar.svelte';
 	import ContentHider from '$lib/components/content-hider.svelte';
···
 	const author = $derived(post.author);
 	const authorUrl = $derived(`${base}/${author.did}`);
 
-	const record = $derived(post.record as AppBskyFeedPost.Record);
-	const postUrl = $derived(`${base}/${author.did}/${parseAddressedAtUri(post.uri).rkey}#main`);
+	const record = $derived(post.record as AppBskyFeedPost.Main);
+	const postUrl = $derived(`${base}/${author.did}/${assertCanonicalResourceUri(post.uri).rkey}#main`);
 
 	const isAviBlurred = $derived(!!findLabel(author.labels, author.did, FlagsBlurMedia));
 	const blur = $derived(findLabel(post.labels, author.did, FlagsBlurContent));

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/components/post-meta-tags.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
+	import { unwrapEmbed, type AppBskyFeedDefs, type AppBskyFeedPost } from '@atcute/bluesky';
 
 	import { PUBLIC_APP_NAME, PUBLIC_APP_URL } from '$env/static/public';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
-	import { unwrapEmbedView } from '$lib/utils/bluesky/embeds';
 	import { collectionToLabel } from '$lib/utils/bluesky/records';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { truncateMiddle } from '$lib/utils/strings';
···
 
 	const { post }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(post.uri));
+	const uri = $derived(assertCanonicalResourceUri(post.uri));
 
 	const author = $derived(post.author);
 	const displayName = $derived(normalizeDisplayName(author.displayName ?? ''));
 	const handle = $derived(truncateMiddle(author.handle, 29));
 
-	const { media, record } = $derived(unwrapEmbedView(post.embed));
+	const { media, record } = $derived(unwrapEmbed(post.embed));
 
 	const description = $derived.by(() => {
-		const content = trimRichText((post.record as AppBskyFeedPost.Record).text);
+		const content = trimRichText((post.record as AppBskyFeedPost.Main).text);
 		let footer = '';
 
 		switch (media?.$type) {
···
 		}
 
 		if (record) {
-			const view = record.record;
-			switch (view.$type) {
+			switch (record.$type) {
 				case 'app.bsky.embed.record#viewRecord': {
 					footer && (footer += '\n');
-					footer += `[quoting @${truncateMiddle(view.author.handle, 29)}]`;
+					footer += `[quoting @${truncateMiddle(record.author.handle, 29)}]`;
 					break;
 				}
 				case 'app.bsky.feed.defs#generatorView': {
···
 					break;
 				}
 				default: {
-					const uri = parseAddressedAtUri(view.uri);
+					const uri = assertCanonicalResourceUri(record.uri);
 					const resource = collectionToLabel(uri.collection);
 
 					const isUnavailable =
 						resource &&
-						(view.$type === 'app.bsky.embed.record#viewNotFound' ||
-							view.$type === 'app.bsky.embed.record#viewBlocked' ||
-							view.$type === 'app.bsky.embed.record#viewDetached');
+						(record.$type === 'app.bsky.embed.record#viewNotFound' ||
+							record.$type === 'app.bsky.embed.record#viewBlocked' ||
+							record.$type === 'app.bsky.embed.record#viewDetached');
 
 					footer && (footer += '\n');
 					footer += isUnavailable ? `[contains unavailable ${resource} embed]` : `[contains unknown embed]`;

src/routes/(app)/[actor=didOrHandle]/[rkey=tid]/utils.ts

···
-import type { AppBskyFeedDefs, AppBskyFeedPost, AppBskyFeedThreadgate } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs, AppBskyFeedPost, AppBskyFeedThreadgate } from '@atcute/bluesky';
 
 import type { UnwrapArray } from '$lib/utils/types';
 
···
 		return likeOrder / timePenalty;
 	};
 
-	const gate = threadgateView?.record as AppBskyFeedThreadgate.Record | undefined;
+	const gate = threadgateView?.record as AppBskyFeedThreadgate.Main | undefined;
 
 	return (parent: AppBskyFeedDefs.PostView, a: ReplyItem, b: ReplyItem) => {
 		if (a.$type !== 'app.bsky.feed.defs#threadViewPost') {
···
 
 		if (last && last.type === 'post') {
 			const post = last.post;
-			const reply = (post.record as AppBskyFeedPost.Record).reply;
+			const reply = (post.record as AppBskyFeedPost.Main).reply;
 
 			if (reply) {
 				const uri = reply.parent.uri;

src/routes/(app)/[actor=didOrHandle]/feeds/[rkey=rkey]/+layout.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { LayoutLoad } from './$types';
 
 import { resolveHandle } from '$lib/queries/handle';
 import { makeAtUri } from '$lib/types/at-uri';
-import { isDid, type Did } from '$lib/types/identity';
 
 export const load: LayoutLoad = async ({ params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
 		did = params.actor;
 	} else {
-		did = await resolveHandle({ rpc, handle: params.actor });
+		did = await resolveHandle({ client: client, handle: params.actor });
 	}
 
-	const { data } = await rpc.get('app.bsky.feed.getFeedGenerator', {
-		params: {
-			feed: makeAtUri(did, 'app.bsky.feed.generator', params.rkey),
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.feed.getFeedGenerator', {
+			params: {
+				feed: makeAtUri(did, 'app.bsky.feed.generator', params.rkey),
+			},
+		}),
+	);
 
 	const view = data.view;
 

src/routes/(app)/[actor=didOrHandle]/feeds/[rkey=rkey]/+page.svelte

···
 	import { PUBLIC_APP_NAME } from '$env/static/public';
 	import type { PageProps } from './$types';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { paginate } from '$lib/utils/pagination';
 
 	import PageListing from '$lib/components/page/page-listing.svelte';
···
 
 	const { data }: PageProps = $props();
 
-	const rkey = $derived(parseAddressedAtUri(data.feed.uri).rkey);
+	const rkey = $derived(assertCanonicalResourceUri(data.feed.uri).rkey);
 
 	const { rootUrl, nextUrl } = $derived(
 		paginate(page.url, data.timeline.cursor, `${base}/${data.feed.creator.did}/feeds/${rkey}`),

src/routes/(app)/[actor=didOrHandle]/feeds/[rkey=rkey]/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 import { fetchTimeline, TimelineType } from '$lib/queries/timeline';
 import { makeAtUri } from '$lib/types/at-uri';
-import { isDid, type Did } from '$lib/types/identity';
 
 export const load: PageLoad = async ({ url, params, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
···
 	}
 
 	const timeline = await fetchTimeline({
-		rpc,
+		client: client,
 		params: {
 			type: TimelineType.CUSTOM_FEED,
 			feed: makeAtUri(did, 'app.bsky.feed.generator', params.rkey),

src/routes/(app)/[actor=didOrHandle]/feeds/[rkey=rkey]/components/feed-aside.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { formatLongNumber } from '$lib/utils/intl/number';
···
 
 	const { feed }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(feed.uri));
+	const uri = $derived(assertCanonicalResourceUri(feed.uri));
 
 	const creatorUrl = $derived(`${base}/${feed.creator.did}`);
 	const feedUrl = $derived(`${creatorUrl}/feeds/${uri.rkey}`);

src/routes/(app)/[actor=didOrHandle]/feeds/[rkey=rkey]/components/feed-meta-tags.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+	import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 	import { PUBLIC_APP_NAME, PUBLIC_APP_URL } from '$env/static/public';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { truncateMiddle } from '$lib/utils/strings';
···
 
 	const { feed }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(feed.uri));
+	const uri = $derived(assertCanonicalResourceUri(feed.uri));
 
 	const description = $derived.by(() => {
 		const desc = trimRichText(feed.description ?? '');

src/routes/(app)/[actor=didOrHandle]/feeds/[rkey=rkey]/likes/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 import { makeAtUri } from '$lib/types/at-uri';
-import { isDid, type Did } from '$lib/types/identity';
 
 export const load: PageLoad = async ({ url, params, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
···
 		did = parentData.feed.creator.did as Did;
 	}
 
-	const { data } = await rpc.get('app.bsky.feed.getLikes', {
-		params: {
-			uri: makeAtUri(did, 'app.bsky.feed.generator', params.rkey),
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.feed.getLikes', {
+			params: {
+				uri: makeAtUri(did, 'app.bsky.feed.generator', params.rkey),
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { likes: { cursor: data.cursor, items: data.likes.map((like) => like.actor) } };
 };

src/routes/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/+layout.svelte

···
 	import { page } from '$app/state';
 	import type { LayoutProps } from './$types';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	import ListAside from './components/list-aside.svelte';
 	import ListMetaTags from './components/list-meta-tags.svelte';
···
 
 	const currentRouteId = $derived(page.route.id);
 
-	const uri = $derived(parseAddressedAtUri(data.list.uri));
+	const uri = $derived(assertCanonicalResourceUri(data.list.uri));
 	const listUrl = $derived.by(() => {
 		return `${base}/${uri.repo}/lists/${uri.rkey}`;
 	});

src/routes/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/+layout.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
+import type { Did } from '@atcute/lexicons';
+import { isDid } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { LayoutLoad } from './$types';
 
 import { resolveHandle } from '$lib/queries/handle';
 import { makeAtUri } from '$lib/types/at-uri';
-import { isDid, type Did } from '$lib/types/identity';
 
 export const load: LayoutLoad = async ({ url, route, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
 		did = params.actor;
 	} else {
-		did = await resolveHandle({ rpc, handle: params.actor });
+		did = await resolveHandle({ client: client, handle: params.actor });
 	}
 
 	const isListing = route.id === '/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/members';
 	const cursor = url.searchParams.get('cursor') || undefined;
-	const { data } = await rpc.get('app.bsky.graph.getList', {
-		params: {
-			list: makeAtUri(did, 'app.bsky.graph.list', params.rkey),
-			limit: isListing ? 50 : 1,
-			cursor: isListing ? cursor : undefined,
-		},
-	});
+
+	const data = await ok(
+		client.get('app.bsky.graph.getList', {
+			params: {
+				list: makeAtUri(did, 'app.bsky.graph.list', params.rkey),
+				limit: isListing ? 50 : 1,
+				cursor: isListing ? cursor : undefined,
+			},
+		}),
+	);
 
 	const view = data.list;
 

src/routes/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/components/list-aside.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { formatLongNumber } from '$lib/utils/intl/number';
···
 
 	const { list }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(list.uri));
+	const uri = $derived(assertCanonicalResourceUri(list.uri));
 
 	const creatorUrl = $derived(`${base}/${list.creator.did}`);
 </script>

src/routes/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/components/list-meta-tags.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs } from '@atcute/bluesky';
 
 	import { PUBLIC_APP_NAME, PUBLIC_APP_URL } from '$env/static/public';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { purposeToLabel } from '$lib/utils/bluesky/lists';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
···
 
 	const { list }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(list.uri));
+	const uri = $derived(assertCanonicalResourceUri(list.uri));
 
 	const description = $derived.by(() => {
 		const desc = trimRichText(list.description ?? '');

src/routes/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/posts/+page.svelte

···
 
 	import PageListing from '$lib/components/page/page-listing.svelte';
 	import PostFeedItem from '$lib/components/timeline/post-feed-item.svelte';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	const { data }: PageProps = $props();
 
-	const uri = $derived(parseAddressedAtUri(data.list.uri));
+	const uri = $derived(assertCanonicalResourceUri(data.list.uri));
 
 	const { rootUrl, nextUrl } = $derived(
 		paginate(page.url, data.timeline.cursor, `${base}/${uri.repo}/lists/${uri.rkey}/posts`),

src/routes/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/posts/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, simpleFetchHandler } from '@atcute/client';
+import { isDid, type Did } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
-import { isDid, type Did } from '$lib/types/identity';
-import { makeAtUri } from '$lib/types/at-uri';
 import { fetchTimeline, TimelineType } from '$lib/queries/timeline';
+import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: PageLoad = async ({ url, params, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
···
 	}
 
 	const timeline = await fetchTimeline({
-		rpc,
+		client: client,
 		params: {
 			type: TimelineType.USER_LIST,
 			list: makeAtUri(did, 'app.bsky.graph.list', params.rkey),

src/routes/(app)/[actor=didOrHandle]/lists/[rkey=rkey]/posts/rss/+server.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
+
+import type { Did } from '@atcute/lexicons';
+import { isDid } from '@atcute/lexicons/syntax';
 
 import { PUBLIC_APP_URL, PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { RequestHandler } from './$types';
···
 import { resolveHandle } from '$lib/queries/handle';
 import { createRssFeed, feedPostToFeedItem } from '$lib/rss';
 import { makeAtUri } from '$lib/types/at-uri';
-import { isDid, type Did } from '$lib/types/identity';
 
 export const GET: RequestHandler = async ({ params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let did: Did;
 	if (isDid(params.actor)) {
 		did = params.actor;
 	} else {
-		did = await resolveHandle({ rpc, handle: params.actor });
+		did = await resolveHandle({ client: client, handle: params.actor });
 	}
 
 	const uri = makeAtUri(did, 'app.bsky.graph.list', params.rkey);
 
 	const [list, timeline] = await Promise.all([
 		(async () => {
-			const { data } = await rpc.get('app.bsky.graph.getList', {
-				params: {
-					list: uri,
-					limit: 1,
-				},
-			});
+			const data = await ok(
+				client.get('app.bsky.graph.getList', {
+					params: {
+						list: uri,
+						limit: 1,
+					},
+				}),
+			);
 
 			return data.list;
 		})(),
 
 		(async () => {
-			const { data } = await rpc.get('app.bsky.feed.getListFeed', {
-				params: {
-					list: uri,
-					limit: 100,
-				},
-			});
+			const data = await ok(
+				client.get('app.bsky.feed.getListFeed', {
+					params: {
+						list: uri,
+						limit: 100,
+					},
+				}),
+			);
 
 			const slices = buildTimelineSlices(data.feed);
 

src/routes/(app)/[actor=didOrHandle]/packs/[rkey=rkey]/+layout.svelte

···
 <script lang="ts">
 	import type { ClassValue } from 'svelte/elements';
 
-	import type { AppBskyGraphStarterpack } from '@atcute/client/lexicons';
+	import type { AppBskyGraphStarterpack } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 	import { page } from '$app/state';
 	import { PUBLIC_APP_NAME } from '$env/static/public';
 	import type { LayoutProps } from './$types';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	import PackAside from './components/pack-aside.svelte';
 	import PackMetaTags from './components/pack-meta-tags.svelte';
···
 
 	const currentRouteId = $derived(page.route.id);
 
-	const record = $derived(data.pack.record as AppBskyGraphStarterpack.Record);
-	const uri = $derived(parseAddressedAtUri(data.pack.uri));
+	const record = $derived(data.pack.record as AppBskyGraphStarterpack.Main);
+	const uri = $derived(assertCanonicalResourceUri(data.pack.uri));
 
 	const listUrl = $derived.by(() => {
 		return `${base}/${uri.repo}/packs/${uri.rkey}`;

src/routes/(app)/[actor=didOrHandle]/packs/[rkey=rkey]/+layout.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { LayoutLoad } from './$types';
···
 import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: LayoutLoad = async ({ params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	const { data } = await rpc.get('app.bsky.graph.getStarterPack', {
-		params: {
-			starterPack: makeAtUri(params.actor, 'app.bsky.graph.starterpack', params.rkey),
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.graph.getStarterPack', {
+			params: {
+				starterPack: makeAtUri(params.actor, 'app.bsky.graph.starterpack', params.rkey),
+			},
+		}),
+	);
 
 	const view = data.starterPack;
 

src/routes/(app)/[actor=didOrHandle]/packs/[rkey=rkey]/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ url, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const { pack } = await parent();
 
···
 		}
 	}
 
-	const { data } = await rpc.get('app.bsky.graph.getList', {
-		params: {
-			list: pack.list.uri,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.graph.getList', {
+			params: {
+				list: pack.list.uri,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { members: { cursor: data.cursor, items: data.items } };
 };

src/routes/(app)/[actor=didOrHandle]/packs/[rkey=rkey]/components/pack-aside.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/bluesky';
 
 	import { base } from '$app/paths';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 
···
 
 	const { pack }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(pack.uri));
-	const record = $derived(pack.record as AppBskyGraphStarterpack.Record);
+	const uri = $derived(assertCanonicalResourceUri(pack.uri));
+	const record = $derived(pack.record as AppBskyGraphStarterpack.Main);
 
 	const creatorUrl = $derived(`${base}/${pack.creator.did}`);
 </script>

src/routes/(app)/[actor=didOrHandle]/packs/[rkey=rkey]/components/pack-meta-tags.svelte

···
 <script lang="ts">
-	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/client/lexicons';
+	import type { AppBskyGraphDefs, AppBskyGraphStarterpack } from '@atcute/bluesky';
 
 	import { PUBLIC_APP_NAME, PUBLIC_APP_URL } from '$env/static/public';
 
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { normalizeDisplayName } from '$lib/utils/bluesky/display';
 	import { trimRichText } from '$lib/utils/bluesky/richtext';
 	import { truncateMiddle } from '$lib/utils/strings';
···
 
 	const { pack }: Props = $props();
 
-	const uri = $derived(parseAddressedAtUri(pack.uri));
-	const record = $derived(pack.record as AppBskyGraphStarterpack.Record);
+	const uri = $derived(assertCanonicalResourceUri(pack.uri));
+	const record = $derived(pack.record as AppBskyGraphStarterpack.Main);
 
 	const description = $derived.by(() => {
 		const desc = trimRichText(record.description ?? '');

src/routes/(app)/[actor=didOrHandle]/packs/[rkey=rkey]/posts/+page.svelte

···
 
 	import PageListing from '$lib/components/page/page-listing.svelte';
 	import PostFeedItem from '$lib/components/timeline/post-feed-item.svelte';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 
 	const { data }: PageProps = $props();
 
-	const uri = $derived(parseAddressedAtUri(data.pack.uri));
+	const uri = $derived(assertCanonicalResourceUri(data.pack.uri));
 
 	const { rootUrl, nextUrl } = $derived(
 		paginate(page.url, data.timeline.cursor, `${base}/${uri.repo}/packs/${uri.rkey}/posts`),

src/routes/(app)/[actor=didOrHandle]/packs/[rkey=rkey]/posts/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { simpleFetchHandler, Client } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
···
 import { fetchTimeline, TimelineType } from '$lib/queries/timeline';
 
 export const load: PageLoad = async ({ url, fetch, parent }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const { pack } = await parent();
 
···
 	}
 
 	const timeline = await fetchTimeline({
-		rpc,
+		client: client,
 		params: {
 			type: TimelineType.USER_LIST,
 			list: pack.list.uri,

src/routes/(app)/[actor=did]/[rkey=tid]/all-quotes/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
···
 import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const parentUri = makeAtUri(params.actor, 'app.bsky.feed.post', params.rkey);
 
···
 	});
 
 	const items = await (async () => {
-		const { data } = await rpc.get('app.bsky.feed.getPosts', {
-			params: {
-				uris: linking_records.map((link) => makeAtUri(link.did, 'app.bsky.feed.post', link.rkey)),
-			},
-		});
+		const data = await ok(
+			client.get('app.bsky.feed.getPosts', {
+				params: {
+					uris: linking_records.map((link) => makeAtUri(link.did, 'app.bsky.feed.post', link.rkey)),
+				},
+			}),
+		);
 
 		return data.posts;
 	})();

src/routes/(app)/[actor=did]/[rkey=tid]/all-replies/+page.ts

···
-import { simpleFetchHandler, XRPC, XRPCError } from '@atcute/client';
-import type { AppBskyFeedDefs, AppBskyFeedGetPostThread } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
+import { Client, ClientResponseError, simpleFetchHandler } from '@atcute/client';
 import { definite } from '@mary/array-fns';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
···
 import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const parentUri = makeAtUri(params.actor, 'app.bsky.feed.post', params.rkey);
 
 	// Fetch the parent post, but don't block.
-	const postPromise = getPost({ rpc, uri: parentUri });
+	const postPromise = getPost({ client, uri: parentUri });
 	void postPromise.catch(() => {});
 
 	// Get links from Constellation
···
 	// Hydrate the links
 	const resolvedReplies = await Promise.all(
 		linking_records.map(async (link) => {
-			let data: AppBskyFeedGetPostThread.Output;
-			try {
-				const response = await rpc.get('app.bsky.feed.getPostThread', {
-					params: {
-						uri: makeAtUri(link.did, 'app.bsky.feed.post', link.rkey),
-						depth: 3,
-						parentHeight: 0,
-					},
-				});
+			const response = await client.get('app.bsky.feed.getPostThread', {
+				params: {
+					uri: makeAtUri(link.did, 'app.bsky.feed.post', link.rkey),
+					depth: 3,
+					parentHeight: 0,
+				},
+			});
 
-				data = response.data;
-			} catch (err) {
-				if (err instanceof XRPCError) {
-					// ignore if AppView says it's not found
-					if (err.kind === 'NotFound') {
-						return null;
-					}
+			if (!response.ok) {
+				// AppView says not found, carry on
+				if (response.data.error === 'NotFound') {
+					return null;
 				}
 
-				throw err;
+				throw new ClientResponseError(response);
 			}
 
-			const thread = data.thread;
+			const thread = response.data.thread;
 			switch (thread.$type) {
 				// same goes for this union
 				case 'app.bsky.feed.defs#notFoundPost':

src/routes/(app)/[actor=did]/[rkey=tid]/likes/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
···
 import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const uri = makeAtUri(params.actor, 'app.bsky.feed.post', params.rkey);
 
-	const { data } = await rpc.get('app.bsky.feed.getLikes', {
-		params: {
-			uri,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.feed.getLikes', {
+			params: {
+				uri,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { likes: { cursor: data.cursor, items: data.likes.map((like) => like.actor) } };
 };

src/routes/(app)/[actor=did]/[rkey=tid]/quotes/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
···
 import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const uri = makeAtUri(params.actor, 'app.bsky.feed.post', params.rkey);
 
-	const { data } = await rpc.get('app.bsky.feed.getQuotes', {
-		params: {
-			uri,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.feed.getQuotes', {
+			params: {
+				uri,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { quotes: { cursor: data.cursor, items: data.posts } };
 };

src/routes/(app)/[actor=did]/[rkey=tid]/reposts/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
···
 import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: PageLoad = async ({ url, params, fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const uri = makeAtUri(params.actor, 'app.bsky.feed.post', params.rkey);
 
-	const { data } = await rpc.get('app.bsky.feed.getRepostedBy', {
-		params: {
-			uri,
-			limit: 50,
-			cursor: url.searchParams.get('cursor') || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.feed.getRepostedBy', {
+			params: {
+				uri,
+				limit: 50,
+				cursor: url.searchParams.get('cursor') || undefined,
+			},
+		}),
+	);
 
 	return { reposts: { cursor: data.cursor, items: data.repostedBy } };
 };

src/routes/(app)/[actor=did]/[rkey=tid]/unroll/+page.svelte

···
 <script lang="ts">
-	import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+	import type { AppBskyFeedPost } from '@atcute/bluesky';
 	import { cluster } from '@mary/array-fns';
 
 	import { base } from '$app/paths';
···
 	import type { PageProps } from './$types';
 
 	import { findLabel, FlagsBlurMedia } from '$lib/moderation';
-	import { parseAddressedAtUri } from '$lib/types/at-uri';
+	import { assertCanonicalResourceUri } from '$lib/types/at-uri';
 	import { truncateMiddle, truncateRight } from '$lib/utils/strings';
 
 	import Avatar from '$lib/components/avatar.svelte';
···
 	const author = $derived(main.author);
 	const authorName = $derived(author.displayName?.trim());
 
-	const uri = $derived(parseAddressedAtUri(main.uri));
+	const uri = $derived(assertCanonicalResourceUri(main.uri));
 	const postUrl = $derived(`${base}/${uri.repo}/${uri.rkey}#main`);
 	const authorUrl = $derived(`${base}/${uri.repo}`);
 
···
 
 	const title = $derived.by(() => {
 		const author = `@${truncateMiddle(main.author.handle, 29)}`;
-		const content = truncateRight((main.record as AppBskyFeedPost.Record).text.trim(), 70);
+		const content = truncateRight((main.record as AppBskyFeedPost.Main).text.trim(), 70);
 
 		return `${author}: "${content}" — ${PUBLIC_APP_NAME}`;
 	});
···
 						</p>
 
 						{#each cluster as post}
-							{@const record = post.record as AppBskyFeedPost.Record}
+							{@const record = post.record as AppBskyFeedPost.Main}
 
 							<div class="subitem">
 								<RichtextRenderer text={record.text} facets={record.facets} />

src/routes/(app)/[actor=did]/[rkey=tid]/unroll/+page.ts

···
 import { error } from '@sveltejs/kit';
 
-import { simpleFetchHandler, XRPC } from '@atcute/client';
-import type { AppBskyFeedDefs, Brand } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
+import type { $type } from '@atcute/lexicons';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
 import type { PageLoad } from './$types';
···
 import { makeAtUri } from '$lib/types/at-uri';
 
 export const load: PageLoad = async ({ params }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	let currentUri = makeAtUri(params.actor, 'app.bsky.feed.post', params.rkey);
 	const items: AppBskyFeedDefs.ThreadViewPost[] = [];
 
 	while (true) {
-		const { data } = await rpc.get('app.bsky.feed.getPostThread', {
-			params: {
-				uri: currentUri,
-				// The max is 1000, but the AppView only returns 10.
-				depth: 1000,
-				parentHeight: 0,
-			},
-		});
+		const data = await ok(
+			client.get('app.bsky.feed.getPostThread', {
+				params: {
+					uri: currentUri,
+					// The max is 1000, but the AppView only returns 10.
+					depth: 1000,
+					parentHeight: 0,
+				},
+			}),
+		);
 
 		switch (data.thread.$type) {
 			case 'app.bsky.feed.defs#notFoundPost': {
···
 				break;
 			}
 
-			const replies = tail.replies.filter((reply): reply is Brand.Union<AppBskyFeedDefs.ThreadViewPost> => {
+			const replies = tail.replies.filter((reply): reply is $type.enforce<AppBskyFeedDefs.ThreadViewPost> => {
 				if (reply.$type !== 'app.bsky.feed.defs#threadViewPost') {
 					return false;
 				}

src/routes/(app)/search/+server.ts

···
 import { redirect, type RequestHandler } from '@sveltejs/kit';
 
-import { isDid, isHandle } from '$lib/types/identity';
-import { isRecordKey, isTid } from '$lib/types/rkey';
+import { isDid, isHandle, isRecordKey, isTid } from '@atcute/lexicons/syntax';
+
 import {
 	BSKY_FEED_LINK_RE,
 	BSKY_LIST_LINK_RE,

src/routes/(app)/search/feeds/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { AUTHENTICATED_FEEDS } from '$lib/constants';
 import { asString, useSearchParams } from '$lib/utils/search-params';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
+import type { CanonicalResourceUri } from '@atcute/lexicons';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ url }) => {
···
 		cursor: asString,
 	});
 
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const query = q.trim();
-	const { data } = await rpc.get('app.bsky.unspecced.getPopularFeedGenerators', {
-		params: {
-			query: query,
-			limit: 50,
-			cursor: cursor || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.unspecced.getPopularFeedGenerators', {
+			params: {
+				query: query,
+				limit: 50,
+				cursor: cursor || undefined,
+			},
+		}),
+	);
 
 	let feeds = data.feeds;
 	if (query.length === 0) {
-		feeds = feeds.filter((feed) => !AUTHENTICATED_FEEDS.includes(feed.uri as At.CanonicalResourceUri));
+		feeds = feeds.filter((feed) => !AUTHENTICATED_FEEDS.includes(feed.uri as CanonicalResourceUri));
 	}
 
 	return {

src/routes/(app)/search/posts/+page.ts

···
-import { simpleFetchHandler, XRPC, XRPCError } from '@atcute/client';
+import { Client, ClientResponseError, simpleFetchHandler } from '@atcute/client';
 
 import { asString, asStringUnion, useSearchParams } from '$lib/utils/search-params';
 
···
 		cursor: asString,
 	});
 
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const query = q.trim();
 	if (query.length === 0) {
 		return { query, posts: { cursor: undefined, items: [] } };
 	}
 
-	try {
-		const { data } = await rpc.get(randomCase('app.bsky.feed.searchPosts', !!cursor), {
-			params: {
-				q: query,
-				limit: 50,
-				sort: sort,
-				cursor: cursor || undefined,
-			},
-		});
+	const response = await client.get('app.bsky.feed.searchPosts', {
+		params: {
+			q: query,
+			limit: 50,
+			sort: sort,
+			cursor: cursor || undefined,
+		},
+	});
 
-		return {
-			query,
-			posts: {
-				cursor: data.cursor,
-				items: data.posts,
-			},
-		};
-	} catch (err) {
-		if (err instanceof XRPCError) {
-			if (err.status === 403) {
-				return { query, posts: { cursor: undefined, items: [] } };
-			}
+	if (!response.ok) {
+		if (response.status === 403) {
+			return { query, posts: { cursor: undefined, items: [] } };
 		}
 
-		throw err;
+		throw new ClientResponseError(response);
 	}
-};
 
-const randomCase = <T extends string>(str: T, enabled: boolean): T => {
-	if (!enabled) {
-		return str;
-	}
+	const data = response.data;
 
-	let result: string;
-
-	do {
-		result = str
-			.split('')
-			.map((char) => (Math.random() < 0.5 ? char.toLowerCase() : char.toUpperCase()))
-			.join('');
-	} while (result === str);
-
-	return result as T;
+	return { query, posts: { cursor: data.cursor, items: data.posts } };
 };

src/routes/(app)/search/users/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 
 import { asString, useSearchParams } from '$lib/utils/search-params';
 
···
 		cursor: asString,
 	});
 
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
 	const query = q.trim();
 	if (query.length === 0) {
 		return { query, profiles: { cursor: undefined, items: [] } };
 	}
 
-	const { data } = await rpc.get('app.bsky.actor.searchActors', {
-		params: {
-			q: query,
-			limit: 50,
-			cursor: cursor || undefined,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.actor.searchActors', {
+			params: {
+				q: query,
+				limit: 50,
+				cursor: cursor || undefined,
+			},
+		}),
+	);
 
 	return {
 		query,

src/routes/(app)/trending/+page.ts

···
-import { simpleFetchHandler, XRPC } from '@atcute/client';
+import { Client, ok, simpleFetchHandler } from '@atcute/client';
 import { mapDefined } from '@mary/array-fns';
 
 import { PUBLIC_APPVIEW_URL } from '$env/static/public';
···
 import { mapTopic } from './utils';
 
 export const load: PageLoad = async ({ fetch }) => {
-	const rpc = new XRPC({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
+	const client = new Client({ handler: simpleFetchHandler({ service: PUBLIC_APPVIEW_URL }) });
 
-	const { data } = await rpc.get('app.bsky.unspecced.getTrendingTopics', {
-		params: {
-			limit: 14,
-		},
-	});
+	const data = await ok(
+		client.get('app.bsky.unspecced.getTrendingTopics', {
+			params: {
+				limit: 14,
+			},
+		}),
+	);
 
 	return {
 		suggested: mapDefined(data.suggested, mapTopic),

src/routes/(app)/trending/utils.ts

···
-import type { AppBskyUnspeccedDefs } from '@atcute/client/lexicons';
-
-import { isDid, isHandle } from '$lib/types/identity';
-import { isRecordKey } from '$lib/types/rkey';
+import type { AppBskyUnspeccedDefs } from '@atcute/bluesky';
+import { isDid, isHandle, isRecordKey } from '@atcute/lexicons/syntax';
 
 // /profile/jaz.bsky.social/feed/cv:cat
 // /profile/bossett.social/feed/for-science

tsconfig.json

···
 {
 	"extends": "./.svelte-kit/tsconfig.json",
 	"compilerOptions": {
+		"types": ["@atcute/bluesky"],
 		"allowJs": true,
 		"checkJs": true,
 		"esModuleInterop": true,

vite.config.ts

···
 
 						return code;
 					} else if (id.includes('node_modules/svelte/') && code.includes('<!--')) {
-						code = code.replace(/<!--.*?-->/g, '');
+						// code = code.replace(/<!--.*?-->/g, '');
 
 						return code;
 					}