From a38c3686c8f022cb861ed7b9bd2cfceb610134d2 Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Sat, 17 Jan 2026 13:38:51 +0000
Subject: [PATCH] feat: implement runtime discovery of post (#1796)

---
 app/components/BlueskyComment.vue             | 113 ++--------
 app/pages/blog/[article].vue                  |  19 +-
 modules/bsky-comments.ts                      | 201 ++++++++++++------
 .../server/discover-bluesky-post.get.ts       |  46 ++++
 package.json                                  |   1 +
 pnpm-lock.yaml                                |   8 +
 shared/utils/bluesky.ts                       |  76 +++++++
 test/unit/bundle.spec.ts                      |   6 +-
 8 files changed, 299 insertions(+), 171 deletions(-)
 create mode 100644 modules/runtime/server/discover-bluesky-post.get.ts
 create mode 100644 shared/utils/bluesky.ts

diff --git a/app/components/BlueskyComment.vue b/app/components/BlueskyComment.vue
index 85f1b271..21026785 100644
--- a/app/components/BlueskyComment.vue
+++ b/app/components/BlueskyComment.vue
@@ -1,11 +1,10 @@
 <script setup lang="ts">
 import type {
-  AppBskyRichtextFacet,
   AppBskyEmbedImages,
   AppBskyEmbedExternal,
 } from '@atproto/api'
-
-type Facet = AppBskyRichtextFacet.Main
+import type { Facet, BlueskyFacetFeature } from '#shared/utils/bluesky'
+import { segmentize, atUriToWebUrl } from '#shared/utils/bluesky'
 
 interface CommentEmbed {
   type: 'images' | 'external'
@@ -23,7 +22,7 @@ interface Comment {
     avatar?: string
   }
   text: string
-  facets?: Facet[]
+  facets?: Facet<BlueskyFacetFeature>[]
   embed?: CommentEmbed
   createdAt: string
   likeCount: number
@@ -32,93 +31,15 @@ interface Comment {
   replies: Comment[]
 }
 
-// Rich text segment for rendering
-interface TextSegment {
-  text: string
-  type: 'text' | 'link' | 'mention' | 'tag'
-  url?: string
-}
-
-function parseRichText (text: string, facets?: Facet[]): TextSegment[] {
-  if (!facets || facets.length === 0) {
-    return [{ text, type: 'text' }]
-  }
-
-  // Convert string to bytes for proper indexing (Bluesky uses byte offsets)
-  const encoder = new TextEncoder()
-  const decoder = new TextDecoder()
-  const bytes = encoder.encode(text)
-
-  // Sort facets by start index
-  const sortedFacets = [...facets].sort((a, b) => a.index.byteStart - b.index.byteStart)
-
-  const segments: TextSegment[] = []
-  let lastEnd = 0
-
-  for (const facet of sortedFacets) {
-    const { byteStart, byteEnd } = facet.index
-
-    // Add plain text before this facet
-    if (byteStart > lastEnd) {
-      segments.push({
-        text: decoder.decode(bytes.slice(lastEnd, byteStart)),
-        type: 'text',
-      })
-    }
-
-    const facetText = decoder.decode(bytes.slice(byteStart, byteEnd))
-    const feature = facet.features[0] as
-      | { $type: 'app.bsky.richtext.facet#link', uri: string }
-      | { $type: 'app.bsky.richtext.facet#mention', did: string }
-      | { $type: 'app.bsky.richtext.facet#tag', tag: string }
-      | undefined
-
-    if (feature?.$type === 'app.bsky.richtext.facet#link') {
-      segments.push({
-        text: facetText,
-        type: 'link',
-        url: feature.uri,
-      })
-    }
-    else if (feature?.$type === 'app.bsky.richtext.facet#mention') {
-      segments.push({
-        text: facetText,
-        type: 'mention',
-        url: `https://bsky.app/profile/${feature.did}`,
-      })
-    }
-    else if (feature?.$type === 'app.bsky.richtext.facet#tag') {
-      segments.push({
-        text: facetText,
-        type: 'tag',
-        url: `https://bsky.app/hashtag/${feature.tag}`,
-      })
-    }
-    else {
-      segments.push({ text: facetText, type: 'text' })
-    }
-
-    lastEnd = byteEnd
-  }
-
-  // Add remaining text after last facet
-  if (lastEnd < bytes.length) {
-    segments.push({
-      text: decoder.decode(bytes.slice(lastEnd)),
-      type: 'text',
-    })
-  }
-
-  return segments
+function getCommentUrl (comment: Comment): string {
+  return atUriToWebUrl(comment.uri) ?? '#'
 }
 
-function getCommentUrl (comment: Comment): string {
-  const match = comment.uri.match(/at:\/\/([^/]+)\/app\.bsky\.feed\.post\/(.+)/)
-  if (match) {
-    const [, did, rkey] = match
-    return `https://bsky.app/profile/${did}/post/${rkey}`
-  }
-  return '#'
+function getFeatureUrl (feature: BlueskyFacetFeature): string | undefined {
+  if (feature.$type === 'app.bsky.richtext.facet#link') return feature.uri
+  if (feature.$type === 'app.bsky.richtext.facet#mention') return `https://bsky.app/profile/${feature.did}`
+  if (feature.$type === 'app.bsky.richtext.facet#tag') return `https://bsky.app/hashtag/${feature.tag}`
+  return undefined
 }
 
 const props = defineProps<{
@@ -127,7 +48,7 @@ const props = defineProps<{
 }>()
 
 const commentUrl = computed(() => getCommentUrl(props.comment))
-const richText = computed(() => parseRichText(props.comment.text, props.comment.facets))
+const segments = computed(() => segmentize(props.comment.text, props.comment.facets))
 const maxDepth = 4
 </script>
 
@@ -190,12 +111,12 @@ const maxDepth = 4
 
       <p class="mt-1 whitespace-pre-wrap break-words">
         <template
-          v-for="(segment, i) in richText"
+          v-for="(segment, i) in segments"
           :key="i"
         >
           <a
-            v-if="segment.type === 'link' || segment.type === 'mention' || segment.type === 'tag'"
-            :href="segment.url"
+            v-if="segment.features?.[0] && getFeatureUrl(segment.features[0])"
+            :href="getFeatureUrl(segment.features[0])"
             target="_blank"
             rel="noopener"
             class="text-blue-400 hover:underline"
@@ -335,12 +256,12 @@ const maxDepth = 4
 
     <p class="mt-1 whitespace-pre-wrap break-words">
       <template
-        v-for="(segment, i) in richText"
+        v-for="(segment, i) in segments"
         :key="i"
       >
         <a
-          v-if="segment.type === 'link' || segment.type === 'mention' || segment.type === 'tag'"
-          :href="segment.url"
+          v-if="segment.features?.[0] && getFeatureUrl(segment.features[0])"
+          :href="getFeatureUrl(segment.features[0])"
           target="_blank"
           rel="noopener"
           class="text-blue-400 hover:underline"
diff --git a/app/pages/blog/[article].vue b/app/pages/blog/[article].vue
index ceeb34f9..605f8968 100644
--- a/app/pages/blog/[article].vue
+++ b/app/pages/blog/[article].vue
@@ -48,14 +48,16 @@
         :path="path"
       />
     </section>
-    <BlueskyComments
-      v-if="page?.bluesky"
-      :uri="page.bluesky"
+    <LazyBlueskyComments
+      v-if="blueskyUri"
+      :uri="blueskyUri"
     />
   </main>
 </template>
 
 <script lang="ts" setup>
+import { needsRuntimeDiscovery, newestPostPath } from '#build/bsky-runtime-discovery.mjs'
+
 const route = useRoute('blog-article')
 const slug = route.params.article
 if (!slug) navigateTo('/blog')
@@ -97,6 +99,17 @@ defineOgImageComponent('DefaultImage', {
 if (import.meta.server) {
   useRoute().meta.description = page.value.description
 }
+
+const blueskyUri = shallowRef(page.value.bluesky)
+
+if (import.meta.client && needsRuntimeDiscovery && !blueskyUri.value && newestPostPath === path.value) {
+  onMounted(async () => {
+    const { uri } = await $fetch<{ uri: string | null }>('/api/discover-bluesky-post').catch(() => ({ uri: null }))
+    if (uri) {
+      blueskyUri.value = uri
+    }
+  })
+}
 </script>
 
 <style scoped>
diff --git a/modules/bsky-comments.ts b/modules/bsky-comments.ts
index 46264ac3..be1f5dc8 100644
--- a/modules/bsky-comments.ts
+++ b/modules/bsky-comments.ts
@@ -1,8 +1,12 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
 
-import { defineNuxtModule, useNuxt } from 'nuxt/kit'
+import { addServerHandler, addServerTemplate, addTemplate, addTypeTemplate, createResolver, defineNuxtModule, useNuxt } from 'nuxt/kit'
 import { joinURL, withoutTrailingSlash } from 'ufo'
 import { join } from 'pathe'
+import { filename } from 'pathe/utils'
+import { glob } from 'tinyglobby'
+import grayMatter from 'gray-matter'
 import { AtpAgent, AppBskyFeedPost } from '@atproto/api'
 
 // when I created my Bluesky account - don't judge me for hard coding it!
@@ -14,117 +18,174 @@ interface ParsedPost {
   links: string[] // URLs found in facets and embeds
 }
 
+interface BlogPost {
+  slug: string
+  path: string
+  url: string
+  date: Date
+  blueskyUri: string | null
+}
+
 export default defineNuxtModule({
   meta: {
     name: 'bsky-comments',
   },
-  setup () {
+  async setup () {
     const nuxt = useNuxt()
+
+    addTypeTemplate({
+      filename: 'types/bsky-runtime-discovery.d.ts',
+      getContents: () => `
+declare module '#build/bsky-runtime-discovery.mjs' {
+  export const needsRuntimeDiscovery: boolean
+  export const newestPostPath: string | null
+}
+`,
+    }, { nuxt: true })
+
     if (nuxt.options._prepare) {
       return
     }
 
+    const resolver = createResolver(import.meta.url)
     const agent = new AtpAgent({ service: 'https://public.api.bsky.app' })
 
     const cacheDir = join(nuxt.options.rootDir, 'node_modules', '.cache', 'bluesky-comments')
     if (!existsSync(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true })
+      await mkdir(cacheDir, { recursive: true })
     }
     const blueskyHandle = nuxt.options.social.networks.bluesky!.identifier
 
-    // Shared feed iterator - fetches posts on demand and grows as needed
+    // Read all blog posts from markdown files
+    const files = await glob('./content/blog/**/*.md', { cwd: nuxt.options.rootDir, absolute: true })
+    const blogPosts: BlogPost[] = []
     const feedIterator = createFeedIterator(agent, blueskyHandle)
 
-    nuxt.hook('content:file:afterParse', async ctx => {
-      const content = ctx.content as { path?: string, date?: string | Date, bluesky?: string }
+    for (const filePath of files) {
+      const contents = await readFile(filePath, 'utf-8')
+      const { data } = grayMatter(contents)
 
-      if (!content.path?.startsWith('/blog/')) return
+      if (!data.date) continue
 
-      const blogPath = content.path
+      const slug = filename(filePath)!
+      const blogPath = `/blog/${slug}`
       const blogUrl = withoutTrailingSlash(joinURL(nuxt.options.site.url, blogPath))
+      const blogDate = new Date(data.date)
+      const cacheFile = join(cacheDir, `${slug}.json`)
 
-      const safeName = blogPath.replace(/[^a-z0-9]/gi, '-')
-      const cacheFile = join(cacheDir, `${safeName}.json`)
+      const blueskyUri = await discoverBlueskyUri()
+      blogPosts.push({ slug, path: blogPath, url: blogUrl, date: blogDate, blueskyUri })
 
-      if (existsSync(cacheFile)) {
-        try {
-          const cached = JSON.parse(readFileSync(cacheFile, 'utf-8')) as { uri: string | null }
-          if (cached.uri) {
-            content.bluesky = cached.uri
+      async function discoverBlueskyUri (): Promise<string | null> {
+        // Check cache first
+        if (existsSync(cacheFile)) {
+          try {
+            const cacheData = JSON.parse(await readFile(cacheFile, 'utf-8')) as { uri: string | null }
+            return cacheData.uri
+          }
+          catch {
+            // Continue to discover
           }
-          return
         }
-        catch {
-          // Continue to fetch
+
+        // 1. explicit bluesky URL in frontmatter
+        if (data.bluesky?.startsWith('https://bsky.app/')) {
+          const match = data.bluesky.match(/bsky\.app\/profile\/([^/]+)\/post\/([^/]+)/)
+          if (match) {
+            const [, handle, rkey] = match
+            try {
+              const { data: resolved } = await agent.resolveHandle({ handle: handle! })
+              const uri = `at://${resolved.did}/app.bsky.feed.post/${rkey}`
+              await saveCache(cacheFile, uri)
+              return uri
+            }
+            catch (error) {
+              console.warn(`Failed to resolve Bluesky handle for ${blogPath}:`, error)
+            }
+          }
+          await saveCache(cacheFile, null)
+          return null
         }
-      }
 
-      let discoveredUri: string | null = null
+        // 2. blog post date is before Bluesky account creation
+        if (blogDate < BLUESKY_ACCOUNT_CREATED) {
+          await saveCache(cacheFile, null)
+          return null
+        }
 
-      // 1. explicit bluesky URL in frontmatter - simply resolve
-      if (content.bluesky?.startsWith('https://bsky.app/')) {
-        const match = content.bluesky.match(/bsky\.app\/profile\/([^/]+)\/post\/([^/]+)/)
-        if (match) {
-          const [, handle, rkey] = match
-          try {
-            const { data } = await agent.resolveHandle({ handle: handle! })
-            content.bluesky = `at://${data.did}/app.bsky.feed.post/${rkey}`
-            discoveredUri = content.bluesky
-          }
-          catch (error) {
-            console.warn(`Failed to resolve Bluesky handle for ${blogPath}:`, error)
+        // 3. auto-discover posts linking to this blog URL
+        const searchCutoff = new Date(blogDate.getTime() - 24 * 60 * 60 * 1000)
+
+        while (!feedIterator.isExhausted()) {
+          const oldestFetchedDate = feedIterator.getOldestPostDate()
+          if (oldestFetchedDate && oldestFetchedDate < searchCutoff) {
+            break
           }
+          await feedIterator.fetchMore()
         }
-        saveCache(cacheDir, cacheFile, discoveredUri)
-      }
 
-      // 2. auto-discover posts linking to this blog URL
-      const blogDate = content.date ? new Date(content.date) : null
+        const matchingPosts = feedIterator.posts
+          .filter(post => {
+            const postDate = new Date(post.createdAt)
+            if (postDate < searchCutoff) return false
+            return post.links.some(link => withoutTrailingSlash(link) === blogUrl)
+          })
+          .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime())
 
-      if (blogDate && blogDate < BLUESKY_ACCOUNT_CREATED) {
-        saveCache(cacheDir, cacheFile, null)
-        return
+        const uri = matchingPosts[0]?.uri ?? null
+        if (uri) {
+          console.log(`Auto-discovered Bluesky post for ${blogPath}`)
+        }
+        await saveCache(cacheFile, uri)
+        return uri
       }
+    }
 
-      const searchCutoff = blogDate
-        ? new Date(blogDate.getTime() - 24 * 60 * 60 * 1000)
-        : BLUESKY_ACCOUNT_CREATED
+    // Sort by date descending to find newest
+    blogPosts.sort((a, b) => b.date.getTime() - a.date.getTime())
+    const newestPost = blogPosts[0]
+    const needsRuntimeDiscovery = newestPost && !newestPost.blueskyUri
+
+    // Add virtual file for runtime discovery flag (client-side)
+    addTemplate({
+      filename: 'bsky-runtime-discovery.mjs',
+      getContents: () => `export const needsRuntimeDiscovery = ${!!needsRuntimeDiscovery}
+export const newestPostPath = ${newestPost ? JSON.stringify(newestPost.path) : 'null'}`,
+      write: true,
+    })
 
-      while (!feedIterator.isExhausted()) {
-        const oldestFetchedDate = feedIterator.getOldestPostDate()
-        if (oldestFetchedDate && oldestFetchedDate < searchCutoff) {
-          break
-        }
-        await feedIterator.fetchMore()
-      }
+    // Add server template with the blog URL and date
+    addServerTemplate({
+      filename: 'bsky-runtime-discovery-server.mjs',
+      getContents: () => `
+export const newestPostUrl = ${needsRuntimeDiscovery ? JSON.stringify(newestPost.url) : 'null'}
+export const newestPostDate = ${needsRuntimeDiscovery ? JSON.stringify(newestPost.date.toISOString()) : 'null'}`,
+    })
 
-      const matchingPosts: ParsedPost[] = []
-      for (const post of feedIterator.posts) {
-        const postDate = new Date(post.createdAt)
-        const hasMatchingLink = post.links.some(link => withoutTrailingSlash(link) === blogUrl)
-        if (postDate >= searchCutoff && hasMatchingLink) {
-          matchingPosts.push(post)
-        }
-      }
+    // Conditionally add the server endpoint only when needed
+    if (needsRuntimeDiscovery) {
+      addServerHandler({
+        route: '/api/discover-bluesky-post',
+        handler: resolver.resolve('./runtime/server/discover-bluesky-post.get'),
+      })
+    }
 
-      if (matchingPosts.length > 0) {
-        // Sort by `createdAt` ascending to get the first announcement)
-        matchingPosts.sort((a, b) =>
-          new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime(),
-        )
-        content.bluesky = matchingPosts[0]!.uri
-        discoveredUri = content.bluesky
-        console.log(`Auto-discovered Bluesky post for ${blogPath}`)
-      }
+    // Still use the content hook to inject the bluesky URI into content
+    nuxt.hook('content:file:afterParse', ctx => {
+      const content = ctx.content as { path?: string, bluesky?: string }
+      if (!content.path?.startsWith('/blog/')) return
 
-      saveCache(cacheDir, cacheFile, discoveredUri)
+      const post = blogPosts.find(p => p.path === content.path)
+      if (post?.blueskyUri) {
+        content.bluesky = post.blueskyUri
+      }
     })
   },
 })
 
-function saveCache (cacheDir: string, cacheFile: string, uri: string | null) {
+async function saveCache (cacheFile: string, uri: string | null) {
   try {
-    writeFileSync(cacheFile, JSON.stringify({ uri }))
+    await writeFile(cacheFile, JSON.stringify({ uri }))
   }
   catch {
     // Ignore cache write errors
diff --git a/modules/runtime/server/discover-bluesky-post.get.ts b/modules/runtime/server/discover-bluesky-post.get.ts
new file mode 100644
index 00000000..9b752ea6
--- /dev/null
+++ b/modules/runtime/server/discover-bluesky-post.get.ts
@@ -0,0 +1,46 @@
+// @ts-expect-error virtual file generated by bsky-comments module
+import { newestPostUrl, newestPostDate } from 'bsky-runtime-discovery-server.mjs'
+import { BLUESKY_API, postLinksToUrl, type BlueskyFeedResponse } from '#shared/utils/bluesky'
+
+export default defineEventHandler(async event => {
+  if (!newestPostUrl) {
+    return { uri: null }
+  }
+
+  const bskyHandle = useRuntimeConfig(event).social.networks.bluesky.identifier
+  const searchCutoff = newestPostDate ? new Date(new Date(newestPostDate).getTime() - 24 * 60 * 60 * 1000) : null
+
+  let cursor: string | undefined
+
+  // Iterate through feed until we find a match or reach the day before the post
+  do {
+    const response = await $fetch<BlueskyFeedResponse>('/xrpc/app.bsky.feed.getAuthorFeed', {
+      baseURL: BLUESKY_API,
+      query: {
+        actor: bskyHandle,
+        limit: 100,
+        cursor,
+      },
+    })
+
+    for (const item of response.feed) {
+      if (item.reason) continue
+
+      // Check if we've gone past the search cutoff
+      if (searchCutoff) {
+        const postDate = new Date(item.post.record.createdAt)
+        if (postDate < searchCutoff) {
+          return { uri: null }
+        }
+      }
+
+      if (postLinksToUrl(item.post, newestPostUrl)) {
+        return { uri: item.post.uri }
+      }
+    }
+
+    cursor = response.cursor
+  } while (cursor)
+
+  return { uri: null }
+})
diff --git a/package.json b/package.json
index d72bfcb1..5fa6dc97 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,7 @@
     "*.{css,vue}": "stylelint"
   },
   "dependencies": {
+    "@atcute/bluesky-richtext-segmenter": "^3.0.0",
     "@atproto/api": "^0.18.0",
     "@iconify-json/ri": "^1.2.6",
     "@iconify-json/svg-spinners": "^1.2.4",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index bd9a80d6..b92ed717 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -11,6 +11,9 @@ importers:
 
   .:
     dependencies:
+      '@atcute/bluesky-richtext-segmenter':
+        specifier: ^3.0.0
+        version: 3.0.0
       '@atproto/api':
         specifier: ^0.18.0
         version: 0.18.16
@@ -332,6 +335,9 @@ packages:
   '@asamuzakjp/css-color@3.2.0':
     resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==}
 
+  '@atcute/bluesky-richtext-segmenter@3.0.0':
+    resolution: {integrity: sha512-NhZTUKtFpeBBbILwAcxj5u4RobIoHOmGw3CAaaEFNebKYSvmTecrXJ7XufHw5DFOUdr8SiKXQVRQxGAxulMNWg==}
+
   '@atproto/api@0.18.16':
     resolution: {integrity: sha512-tRGKSWr83pP5CQpSboePU21pE+GqLDYy1XHae4HH4hjaT0pr5V8wNgu70kbKB0B02GVUumeDRpJnlHKD+eMzLg==}
 
@@ -11133,6 +11139,8 @@ snapshots:
       '@csstools/css-tokenizer': 3.0.4
       lru-cache: 10.4.3
 
+  '@atcute/bluesky-richtext-segmenter@3.0.0': {}
+
   '@atproto/api@0.18.16':
     dependencies:
       '@atproto/common-web': 0.4.12
diff --git a/shared/utils/bluesky.ts b/shared/utils/bluesky.ts
new file mode 100644
index 00000000..c7b3858a
--- /dev/null
+++ b/shared/utils/bluesky.ts
@@ -0,0 +1,76 @@
+import { withoutTrailingSlash } from 'ufo'
+
+export const BLUESKY_API = 'https://public.api.bsky.app'
+
+export interface BlueskyFacetFeature {
+  $type?: string
+  uri?: string
+  did?: string
+  tag?: string
+}
+
+export interface BlueskyFacet {
+  index: { byteStart: number, byteEnd: number }
+  features: BlueskyFacetFeature[]
+}
+
+export interface BlueskyPostRecord {
+  createdAt: string
+  text?: string
+  facets?: BlueskyFacet[]
+}
+
+export interface BlueskyEmbed {
+  external?: { uri?: string }
+}
+
+export interface BlueskyFeedPost {
+  uri: string
+  record: BlueskyPostRecord
+  embed?: BlueskyEmbed
+}
+
+export interface BlueskyFeedItem {
+  post: BlueskyFeedPost
+  reason?: unknown
+}
+
+export interface BlueskyFeedResponse {
+  feed: BlueskyFeedItem[]
+  cursor?: string
+}
+
+export function extractLinksFromPost (post: BlueskyFeedPost): string[] {
+  const links: string[] = []
+
+  if (post.record.facets) {
+    for (const facet of post.record.facets) {
+      for (const feature of facet.features) {
+        if (feature.$type === 'app.bsky.richtext.facet#link' && feature.uri) {
+          links.push(feature.uri)
+        }
+      }
+    }
+  }
+
+  if (post.embed?.external?.uri) {
+    links.push(post.embed.external.uri)
+  }
+
+  return links
+}
+
+export function postLinksToUrl (post: BlueskyFeedPost, targetUrl: string): boolean {
+  const normalizedTarget = withoutTrailingSlash(targetUrl)
+  return extractLinksFromPost(post).some(link => withoutTrailingSlash(link) === normalizedTarget)
+}
+
+export function atUriToWebUrl (atUri: string): string | null {
+  const match = atUri.match(/at:\/\/([^/]+)\/app\.bsky\.feed\.post\/(.+)/)
+  if (!match) return null
+  const [, did, rkey] = match
+  return `https://bsky.app/profile/${did}/post/${rkey}`
+}
+
+export type { RichtextSegment, Facet } from '@atcute/bluesky-richtext-segmenter'
+export { segmentize } from '@atcute/bluesky-richtext-segmenter'
diff --git a/test/unit/bundle.spec.ts b/test/unit/bundle.spec.ts
index c62d5053..fc7f8ba4 100644
--- a/test/unit/bundle.spec.ts
+++ b/test/unit/bundle.spec.ts
@@ -40,6 +40,7 @@ describe('project sizes', () => {
     expect.soft(stats.client.files.map(f => f.replace(/\..*\.js/, '.js').replace(/_scripts\/.*\.js/, '_scripts/script.js')).sort())
       .toMatchInlineSnapshot(`
         [
+          "_nuxt/BlueskyComments.js",
           "_nuxt/CalSchedule.js",
           "_nuxt/ProseA.js",
           "_nuxt/ProseBlockquote.js",
@@ -77,12 +78,12 @@ describe('project sizes', () => {
     stats.server = await analyzeSizes(['**/*.mjs', '!node_modules'], serverDir)
     expect
       .soft(roundToKilobytes(stats.server.totalBytes))
-      .toMatchInlineSnapshot(`"929k"`)
+      .toMatchInlineSnapshot(`"930k"`)
 
     const modules = await analyzeSizes('node_modules/**/*', serverDir)
     expect
       .soft(roundToKilobytes(modules.totalBytes))
-      .toMatchInlineSnapshot(`"10985k"`)
+      .toMatchInlineSnapshot(`"10989k"`)
 
     const packages = modules.files
       .filter(m => m.endsWith('package.json'))
@@ -90,6 +91,7 @@ describe('project sizes', () => {
       .sort()
     expect.soft(packages).toMatchInlineSnapshot(`
       [
+        "@atcute/bluesky-richtext-segmenter",
         "@atproto/api",
         "@atproto/common-web",
         "@atproto/lex-data",
-- 
2.51.2