From 25cd6fd83f36a6a612d55ce95edfa561e9ebdf60 Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Wed, 26 Aug 2026 10:39:14 +0000
Subject: [PATCH] perf: cache build-time module work and persist discovered
 bluesky uris

---
 app/pages/blog/[article].vue                  |   8 +-
 content/blog/diversity.md                     |   1 +
 content/blog/governance-and-abuse.md          |   1 +
 content/blog/open-invitation.md               |   1 +
 content/blog/the-golden-thread.md             |   1 +
 content/blog/today-is-your-day.md             |   1 +
 content/blog/virtuous-circle.md               |   1 +
 content/blog/zero-sum-games.md                |   1 +
 modules/atproto/index.ts                      |  48 ++--
 modules/bsky-comments.ts                      | 236 ++++++++++--------
 modules/invites/index.ts                      |  17 +-
 modules/markdown.ts                           | 146 +++++++----
 .../server/discover-bluesky-post.get.ts       |  25 +-
 modules/shared/build-cache.ts                 |  78 ++++++
 modules/sync/index.ts                         |   4 +-
 15 files changed, 378 insertions(+), 191 deletions(-)
 create mode 100644 modules/shared/build-cache.ts

diff --git a/app/pages/blog/[article].vue b/app/pages/blog/[article].vue
index e11333c9..e5141a6a 100644
--- a/app/pages/blog/[article].vue
+++ b/app/pages/blog/[article].vue
@@ -61,7 +61,7 @@
 <script lang="ts" setup>
 import { defineLink } from '@unhead/vue'
 
-import { needsRuntimeDiscovery, newestPostPath } from '#build/bsky-runtime-discovery.mjs'
+import { needsRuntimeDiscovery, pendingDiscovery } from '#build/bsky-runtime-discovery.mjs'
 
 const standardSiteDid = useRuntimeConfig().public.atproto?.did || null
 
@@ -158,9 +158,11 @@ if (import.meta.server) {
 
 const blueskyUri = shallowRef(page.value.bluesky)
 
-if (import.meta.client && needsRuntimeDiscovery && !blueskyUri.value && newestPostPath === path.value) {
+if (import.meta.client && needsRuntimeDiscovery && !blueskyUri.value && pendingDiscovery.has(path.value)) {
   onMounted(async () => {
-    const { uri } = await $fetch<{ uri: string | null }>('/api/discover-bluesky-post').catch(() => ({ uri: null }))
+    const { uri } = await $fetch<{ uri: string | null }>('/api/discover-bluesky-post', {
+      query: { path: path.value },
+    }).catch(() => ({ uri: null }))
     if (uri) {
       blueskyUri.value = uri
     }
diff --git a/content/blog/diversity.md b/content/blog/diversity.md
index 34044b5d..afa1e73c 100644
--- a/content/blog/diversity.md
+++ b/content/blog/diversity.md
@@ -6,6 +6,7 @@ tags:
   - diversity
   - inclusion
 description: "I'm in favour of diversity, equity and inclusion in open source communities, and here's why I think it matters."
+bluesky: 'at://did:plc:jbeaa5kdaladzwq3r7f5xgwe/app.bsky.feed.post/3ljv2bmp4y62s'
 ---
 
 This really shouldn't need to be written:
diff --git a/content/blog/governance-and-abuse.md b/content/blog/governance-and-abuse.md
index 9fda0309..b96db3e6 100644
--- a/content/blog/governance-and-abuse.md
+++ b/content/blog/governance-and-abuse.md
@@ -5,6 +5,7 @@ tags:
   - governance
   - open source
 description: Whenever you have people working together, there's potential for great things. There's also potential for harm - and sadly that's something we need to think about too.
+bluesky: 'at://did:plc:jbeaa5kdaladzwq3r7f5xgwe/app.bsky.feed.post/3k3jenwgxom2l'
 ---
 
 Whenever you have people working together, there's potential for great things. There's also potential for harm - and sadly that's something we need to think about too.
diff --git a/content/blog/open-invitation.md b/content/blog/open-invitation.md
index ce3f0fdb..71838e7a 100644
--- a/content/blog/open-invitation.md
+++ b/content/blog/open-invitation.md
@@ -5,6 +5,7 @@ tags:
   - communication
   - contact
 description: If you want to have a 10-minute chat about anything, then I would love to talk to you.
+bluesky: 'at://did:plc:jbeaa5kdaladzwq3r7f5xgwe/app.bsky.feed.post/3jxw4by5jj42u'
 ---
 
 A few months ago I tweeted out an open invitation for anyone new to contributing to open source.
diff --git a/content/blog/the-golden-thread.md b/content/blog/the-golden-thread.md
index d1e48ccd..9f5da188 100644
--- a/content/blog/the-golden-thread.md
+++ b/content/blog/the-golden-thread.md
@@ -5,6 +5,7 @@ tags:
   - ai
   - life
 description: "AI can serve us as a force multiplier, augmenting our own agency and making the most of our own effort, hard work and value. Not by replacing it."
+bluesky: 'at://did:plc:jbeaa5kdaladzwq3r7f5xgwe/app.bsky.feed.post/3mcg6svsgsm2k'
 ---
 
 There is a story I read as a child, in [_The Book of Virtues_](https://en.wikipedia.org/wiki/The_Book_of_Virtues).
diff --git a/content/blog/today-is-your-day.md b/content/blog/today-is-your-day.md
index 1ab8a709..d10fcc8e 100644
--- a/content/blog/today-is-your-day.md
+++ b/content/blog/today-is-your-day.md
@@ -5,6 +5,7 @@ tags:
   - new year
   - resolutions
 description: "Reflection isn't my strong suit. I think. But I wish it were more part of my life. So I thought I'd try to piece together ... part of ...  my story in 2024."
+bluesky: 'at://did:plc:jbeaa5kdaladzwq3r7f5xgwe/app.bsky.feed.post/3lemgiwuyby2r'
 ---
 
 What a year.
diff --git a/content/blog/virtuous-circle.md b/content/blog/virtuous-circle.md
index 35d6e3bc..8506b5df 100644
--- a/content/blog/virtuous-circle.md
+++ b/content/blog/virtuous-circle.md
@@ -4,6 +4,7 @@ date: '2026-03-03T10:30:00.000Z'
 tags:
   - open source
 description: "The virtuous circle is the most powerful pattern in developer tooling. And it's the myth of the 10x developer that makes it hard to see."
+bluesky: 'at://did:plc:jbeaa5kdaladzwq3r7f5xgwe/app.bsky.feed.post/3mg5td2ny7s2l'
 ---
 
 The virtuous circle is the most powerful pattern in developer tooling. And it's the myth of the 10x developer that makes it hard to see.
diff --git a/content/blog/zero-sum-games.md b/content/blog/zero-sum-games.md
index 4e8969f3..8999ed72 100644
--- a/content/blog/zero-sum-games.md
+++ b/content/blog/zero-sum-games.md
@@ -5,6 +5,7 @@ tags:
   - profit
   - open source
 description: "Open source is about mutual giving. So how does that square with commercial open source? Or building a for-profit product on top of an open source project?"
+bluesky: 'at://did:plc:jbeaa5kdaladzwq3r7f5xgwe/app.bsky.feed.post/3lgoas7uqvc2m'
 ---
 
 Open source is about mutual giving. So how does that square with commercial open source? Or building a for-profit product _on top_ of an open source project?
diff --git a/modules/atproto/index.ts b/modules/atproto/index.ts
index 39cb0027..6634c998 100644
--- a/modules/atproto/index.ts
+++ b/modules/atproto/index.ts
@@ -11,6 +11,15 @@ import { api } from '@bsky/sdk'
 import { com } from '@bsky/sdk/lexicons'
 import { defineNuxtModule, useNuxt } from 'nuxt/kit'
 
+import { hashKey, withCache } from '../shared/build-cache'
+
+/**
+ * Resolving `handle -> did -> PDS` costs two sequential round-trips before any
+ * other module can run, and the answer changes approximately never. In dev the
+ * cached value is used immediately and refreshed in the background.
+ */
+const IDENTITY_MAX_AGE = 1000 * 60 * 60 * 24 * 7
+
 interface DidDocument {
   service?: Array<{ id: string, type: string, serviceEndpoint: string }>
 }
@@ -27,6 +36,15 @@ async function resolvePdsEndpoint (did: string): Promise<string | null> {
   return pds?.serviceEndpoint ?? null
 }
 
+async function resolveIdentity (handle: string, knownDid?: string) {
+  let did = knownDid
+  if (!did) {
+    const client = new Client(api.app.urlPublic)
+    did = (await client.call(com.atproto.identity.resolveHandle, { handle: asStringFormat(handle, 'handle') })).did
+  }
+  return { did, service: await resolvePdsEndpoint(did) }
+}
+
 export default defineNuxtModule({
   meta: { name: 'atproto' },
   async setup () {
@@ -47,21 +65,23 @@ export default defineNuxtModule({
     if (cfg.did && publicCfg.service) return
 
     try {
-      if (!cfg.did) {
-        const client = new Client(api.app.urlPublic)
-        const { did } = await client.call(com.atproto.identity.resolveHandle, { handle: asStringFormat(handle, 'handle') })
-        cfg.did = did
-        publicCfg.did = did
-      }
+      const identity = await withCache({
+        namespace: 'atproto-identity',
+        key: hashKey(handle, cfg.did),
+        maxAge: IDENTITY_MAX_AGE,
+        stale: nuxt.options.dev,
+        fetch: () => resolveIdentity(handle, cfg.did),
+      })
 
-      if (!publicCfg.service) {
-        const endpoint = await resolvePdsEndpoint(cfg.did)
-        if (!endpoint) {
-          console.warn(`[atproto] DID doc for ${cfg.did} has no #atproto_pds service entry.`)
-        }
-        else {
-          publicCfg.service = endpoint
-        }
+      if (!identity?.did) throw new Error(`could not resolve a DID for ${handle}`)
+
+      cfg.did = identity.did
+      publicCfg.did = identity.did
+      if (identity.service) {
+        publicCfg.service ||= identity.service
+      }
+      else {
+        console.warn(`[atproto] DID doc for ${identity.did} has no #atproto_pds service entry.`)
       }
 
       console.info(`[atproto] Resolved ${handle} -> ${cfg.did} @ ${publicCfg.service || '(no PDS)'}`)
diff --git a/modules/bsky-comments.ts b/modules/bsky-comments.ts
index b601ad8d..b6778e50 100644
--- a/modules/bsky-comments.ts
+++ b/modules/bsky-comments.ts
@@ -1,31 +1,49 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import process from 'node:process'
 
 import { addServerHandler, addServerTemplate, addTemplate, addTypeTemplate, createResolver, defineNuxtModule, useNuxt } from 'nuxt/kit'
 import { joinURL, withoutTrailingSlash } from 'ufo'
-import { join } from 'pathe'
 import { Client, asStringFormat } from '@atproto/lex'
 import { api } from '@bsky/sdk'
 import { app, com } from '@bsky/sdk/lexicons'
 import { toValue } from 'vue'
 
+import { createBuildCache, hashKey } from './shared/build-cache'
+
 // when I created my Bluesky account - don't judge me for hard coding it!
 const BLUESKY_ACCOUNT_CREATED = new Date('2023-04-26T05:22:14.855Z')
 
+/**
+ * A discovered `at://` URI is written back into the post's frontmatter, so
+ * discovery only ever has to run for posts published (or shared) since the
+ * last time it ran. Anything older than this window without a `bluesky` key in
+ * frontmatter is taken to have no Bluesky thread: walking the author feed back
+ * to a post's publication date costs a request per 100 posts, and the answer
+ * for old posts is already committed.
+ *
+ * Set `BSKY_DISCOVERY_WINDOW_DAYS=0` to ignore the window and backfill every
+ * post - slow, but it only needs doing once per post.
+ */
+const DISCOVERY_WINDOW_DAYS = Number(process.env.BSKY_DISCOVERY_WINDOW_DAYS ?? 30)
+
+/**
+ * How long after publication a post is still plausibly *the* announcement of an
+ * article. Without an upper bound, an article that was never announced matches
+ * whichever later post happens to cite it - which is a real post, but its
+ * replies are a conversation about something else.
+ */
+const ANNOUNCEMENT_WINDOW_DAYS = 7
+
+/** How long a fruitless search is trusted before it is worth retrying. */
+const NEGATIVE_MAX_AGE = 1000 * 60 * 60
+
 interface ParsedPost {
   uri: string
   createdAt: string
+  isReply: boolean
   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',
@@ -38,7 +56,7 @@ export default defineNuxtModule({
       getContents: () => `
 declare module '#build/bsky-runtime-discovery.mjs' {
   export const needsRuntimeDiscovery: boolean
-  export const newestPostPath: string | null
+  export const pendingDiscovery: Set<string>
 }
 `,
     }, { nuxt: true })
@@ -49,146 +67,149 @@ declare module '#build/bsky-runtime-discovery.mjs' {
 
     const resolver = createResolver(import.meta.url)
     const client = new Client(api.app.urlPublic)
+    const cache = createBuildCache('bluesky-comments')
 
-    const cacheDir = join(nuxt.options.rootDir, 'node_modules', '.cache', 'bluesky-comments')
-    if (!existsSync(cacheDir)) {
-      await mkdir(cacheDir, { recursive: true })
-    }
     const blueskyHandle = nuxt.options.runtimeConfig.atproto?.handle || null
     if (!blueskyHandle) {
       console.warn('Bluesky handle not configured (no runtimeConfig.atproto.handle). Skipping Bluesky URI discovery.')
       return
     }
 
-    // Receive blog data from the markdown module hook and discover Bluesky URIs
-    const blogPosts: BlogPost[] = []
-
     nuxt.hook('markdown:blog-entries', async entries => {
       const siteURL = nuxt.options.site && toValue(nuxt.options.site?.url)
       if (!siteURL) {
         return
       }
-      const feedIterator = createFeedIterator(client, blueskyHandle)
+
+      const feed = createFeedIterator(client, blueskyHandle)
+      const windowStart = DISCOVERY_WINDOW_DAYS > 0
+        ? new Date(Date.now() - DISCOVERY_WINDOW_DAYS * 24 * 60 * 60 * 1000)
+        : null
+      const pending: Record<string, { url: string, date: string }> = {}
 
       for (const entry of entries) {
         if (!entry.date) continue
 
-        const blogPath = entry.path
-        const blogUrl = withoutTrailingSlash(joinURL(siteURL, blogPath))
-        const blogDate = new Date(entry.date)
-        const cacheFile = join(cacheDir, `${entry.slug}.json`)
+        const url = withoutTrailingSlash(joinURL(siteURL, entry.path))
+        const date = new Date(entry.date)
 
-        const blueskyUri = await discoverBlueskyUri()
-        blogPosts.push({ slug: entry.slug, path: blogPath, url: blogUrl, date: blogDate, blueskyUri })
+        if (entry.bluesky?.startsWith('at://')) continue
 
-        // Inject the discovered URI back into the entry
-        if (blueskyUri) {
-          entry.bluesky = blueskyUri
+        // an explicit web URL in frontmatter needs no search, just a handle to
+        // resolve - and that is usually the site's own, already-resolved handle
+        if (entry.bluesky?.startsWith('https://bsky.app/')) {
+          const uri = await resolveWebUrl(entry.bluesky, entry.path)
+          entry.bluesky = uri ?? undefined
+          if (uri) await persist(entry.file, uri)
+          continue
         }
 
-        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
-            }
-          }
+        if (date < BLUESKY_ACCOUNT_CREATED) continue
+        if (windowStart && date < windowStart) continue
 
-          // 1. explicit bluesky URL in frontmatter
-          if (entry.bluesky?.startsWith('https://bsky.app/')) {
-            const match = entry.bluesky.match(/bsky\.app\/profile\/([^/]+)\/post\/([^/]+)/)
-            if (match) {
-              const [, handle, rkey] = match
-              try {
-                const { did } = await client.call(com.atproto.identity.resolveHandle, { handle: asStringFormat(handle!, 'handle') })
-                const uri = `at://${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
-          }
-
-          // 2. blog post date is before Bluesky account creation
-          if (blogDate < BLUESKY_ACCOUNT_CREATED) {
-            await saveCache(cacheFile, null)
-            return null
-          }
-
-          // 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()
-          }
+        const key = hashKey(entry.slug, url)
+        const miss = await cache.get<null>(key)
+        if (miss && Date.now() - miss.mtime < NEGATIVE_MAX_AGE) {
+          pending[entry.path] = { url, date: date.toISOString() }
+          continue
+        }
 
-          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())
-
-          const uri = matchingPosts[0]?.uri ?? null
-          if (uri) {
-            console.log(`Auto-discovered Bluesky post for ${blogPath}`)
-          }
-          await saveCache(cacheFile, uri)
-          return uri
+        const uri = await discoverInFeed(url, date)
+        if (uri) {
+          console.log(`Auto-discovered Bluesky post for ${entry.path}`)
+          entry.bluesky = uri
+          await persist(entry.file, uri)
+        }
+        else {
+          await cache.set(key, null)
+          pending[entry.path] = { url, date: date.toISOString() }
         }
       }
 
-      // 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'}`,
+        // the boolean lets the client-side discovery in `blog/[article].vue`
+        // be tree-shaken away entirely when nothing is pending
+        getContents: () => [
+          `export const needsRuntimeDiscovery = ${Object.keys(pending).length > 0}`,
+          `export const pendingDiscovery = new Set(${JSON.stringify(Object.keys(pending))})`,
+        ].join('\n'),
         write: true,
       })
 
-      // 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'}`,
+        getContents: () => `export const pendingPosts = ${JSON.stringify(pending)}`,
       })
 
-      // Conditionally add the server endpoint only when needed
-      if (needsRuntimeDiscovery) {
+      if (Object.keys(pending).length > 0) {
         addServerHandler({
           route: '/api/discover-bluesky-post',
           handler: resolver.resolve('./runtime/server/discover-bluesky-post.get'),
         })
       }
+
+      async function resolveWebUrl (webUrl: string, path: string): Promise<string | null> {
+        const match = webUrl.match(/bsky\.app\/profile\/([^/]+)\/post\/([^/]+)/)
+        if (!match) return null
+        const [, actor, rkey] = match
+        try {
+          const did = actor!.startsWith('did:')
+            ? actor!
+            : actor === blueskyHandle && nuxt.options.runtimeConfig.atproto?.did
+              ? nuxt.options.runtimeConfig.atproto.did
+              : (await client.call(com.atproto.identity.resolveHandle, { handle: asStringFormat(actor!, 'handle') })).did
+          return `at://${did}/app.bsky.feed.post/${rkey}`
+        }
+        catch (error) {
+          console.warn(`Failed to resolve Bluesky handle for ${path}:`, error)
+          return null
+        }
+      }
+
+      async function discoverInFeed (url: string, date: Date): Promise<string | null> {
+        const searchStart = new Date(date.getTime() - 24 * 60 * 60 * 1000)
+        const searchEnd = new Date(date.getTime() + ANNOUNCEMENT_WINDOW_DAYS * 24 * 60 * 60 * 1000)
+
+        while (!feed.isExhausted()) {
+          const oldestFetchedDate = feed.getOldestPostDate()
+          if (oldestFetchedDate && oldestFetchedDate < searchStart) {
+            break
+          }
+          await feed.fetchMore()
+        }
+
+        return feed.posts
+          .filter(post => {
+            // a reply cites an article in someone else's thread; it is never
+            // the thread the article's own comments belong in
+            if (post.isReply) return false
+            const postDate = new Date(post.createdAt)
+            if (postDate < searchStart || postDate > searchEnd) return false
+            return post.links.some(link => withoutTrailingSlash(link) === url)
+          })
+          .sort((a, b) => +new Date(a.createdAt) - +new Date(b.createdAt))[0]?.uri ?? null
+      }
     })
   },
 })
 
-async function saveCache (cacheFile: string, uri: string | null) {
+/** Record `uri` as the `bluesky` frontmatter key of the post at `file`. */
+async function persist (file: string, uri: string) {
   try {
-    await writeFile(cacheFile, JSON.stringify({ uri }))
+    const source = await readFile(file, 'utf8')
+    const frontmatter = source.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+    if (!frontmatter) return
+
+    const line = `bluesky: '${uri}'`
+    const updated = /^bluesky:.*$/m.test(frontmatter[1]!)
+      ? frontmatter[1]!.replace(/^bluesky:.*$/m, line)
+      : `${frontmatter[1]}\n${line}`
+
+    await writeFile(file, source.replace(frontmatter[0], `---\n${updated}\n---`))
   }
-  catch {
-    // Ignore cache write errors
+  catch (error) {
+    console.warn(`Failed to record Bluesky URI in ${file}:`, error)
   }
 }
 
@@ -252,6 +273,7 @@ function createFeedIterator (client: Client, actor: string) {
           posts.push({
             uri: post.uri,
             createdAt: record.createdAt as string,
+            isReply: !!record.reply,
             links,
           })
         }
diff --git a/modules/invites/index.ts b/modules/invites/index.ts
index 17e9a1e8..81865b25 100644
--- a/modules/invites/index.ts
+++ b/modules/invites/index.ts
@@ -12,8 +12,12 @@ import { defu } from 'defu'
 
 import { listAllRecords } from '../shared/atproto-read'
 import { decryptJSON } from '../../server/utils/admin/encryption'
+import { withCache } from '../shared/build-cache'
 import { dev } from '../../shared/lex/index.ts'
 
+/** In dev the (encrypted) invite records are re-read at most hourly. */
+const DEV_MAX_AGE = 1000 * 60 * 60
+
 export default defineNuxtModule({
   meta: {
     name: 'invites',
@@ -35,11 +39,18 @@ export default defineNuxtModule({
 
     if (process.env.NUXT_PDS_ENCRYPTION_KEY) {
       try {
-        const records = await listAllRecords(dev.roe.invite.main)
+        const records = await withCache({
+          namespace: 'invites',
+          key: 'records',
+          maxAge: nuxt.options.dev ? DEV_MAX_AGE : 0,
+          stale: nuxt.options.dev,
+          fetch: async () => (await listAllRecords(dev.roe.invite.main))
+            .map(r => ({ uri: r.uri, isActive: r.value.isActive, encrypted: r.value.encrypted })),
+        }) ?? []
         for (const r of records) {
-          if (!r.value.isActive) continue
+          if (!r.isActive) continue
           try {
-            const { slug, repo } = decryptJSON<{ slug: string, repo: string }>(r.value.encrypted)
+            const { slug, repo } = decryptJSON<{ slug: string, repo: string }>(r.encrypted)
             map[slug] = repo
           }
           catch (err) {
diff --git a/modules/markdown.ts b/modules/markdown.ts
index b2fc7389..f10f7f19 100644
--- a/modules/markdown.ts
+++ b/modules/markdown.ts
@@ -1,21 +1,37 @@
 import { readFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
 
 import { addTemplate, addTypeTemplate, defineNuxtModule, useNuxt } from 'nuxt/kit'
 import { glob } from 'tinyglobby'
 import grayMatter from 'gray-matter'
 import { filename } from 'pathe/utils'
-import { remark } from 'remark'
-import remarkHtml from 'remark-html'
-import { convert as htmlToText } from 'html-to-text'
 import { createMarkdownParser } from 'comark/parse'
 import shiki from 'comark/plugins/shiki'
 import palenight from 'shiki/themes/material-theme-palenight.mjs'
 
+import { createBuildCache, hashKey } from './shared/build-cache'
 import { headingIds } from './shared/comark-heading-ids'
 import { serialize } from './shared/serialisers'
 import { mdCleanHtml, mdInternalLinks, mdStripContainers } from './shared/md-transforms'
 import { tidFromDate } from './shared/tid'
 
+/**
+ * Bumped whenever the shape of a cached syntax-highlighted tree changes; the
+ * resolved `comark`/`shiki` versions are folded in so a dependency bump
+ * invalidates the cache without needing to remember to touch this.
+ */
+const TREE_CACHE_VERSION = [
+  '1',
+  ...['comark', 'shiki'].map(name => {
+    try {
+      return createRequire(import.meta.url)(`${name}/package.json`).version as string
+    }
+    catch {
+      return name
+    }
+  }),
+].join('-')
+
 interface BlogFrontmatter {
   title: string
   date: string
@@ -27,6 +43,7 @@ interface BlogFrontmatter {
 
 interface ParsedBlogPost {
   slug: string
+  file: string
   title: string
   date: string
   tid: string
@@ -63,6 +80,7 @@ export default defineNuxtModule({
 
       blogPosts.push({
         slug,
+        file: filePath,
         title: fm.title,
         date,
         tid: tidFromDate(date),
@@ -87,14 +105,14 @@ export default defineNuxtModule({
     nuxt.hook('modules:done', async () => {
       await Promise.all([
         nuxt.callHook('markdown:blog-entries', blogPosts),
-        nuxt.callHook('markdown:sync-articles', syncArticles),
+        nuxt.callHook('markdown:sync-articles', getSyncArticles),
       ])
     })
 
     addTemplate({
       filename: 'markdown/blog-entries.mjs',
       getContents: () => {
-        const entries = blogPosts.map(({ slug: _, body: __, ...entry }) => entry)
+        const entries = blogPosts.map(({ slug: _, file: __, body: ___, ...entry }) => entry)
         return `export const blogEntries = ${JSON.stringify(entries)}`
       },
       write: true,
@@ -110,23 +128,19 @@ export default defineNuxtModule({
       ],
     })
 
-    for (const post of blogPosts) {
-      const tree = await parse(post.body)
-      addTemplate({
-        filename: `markdown/blog/${post.slug}.mjs`,
-        getContents: () => `const tree = ${JSON.stringify(tree)}
-export async function getBody () {
-  return tree
-}
-`,
-        write: true,
-      })
+    const treeCache = createBuildCache('markdown-trees')
+    async function parseCached (body: string) {
+      const key = hashKey(TREE_CACHE_VERSION, body)
+      const cached = await treeCache.get<unknown>(key)
+      if (cached) return cached.value
+      const tree = await parse(body)
+      await treeCache.set(key, tree)
+      return tree
     }
 
-    for (const slug of Object.keys(pageBodies)) {
-      const tree = await parse(pageBodies[slug]!)
+    function addBodyTemplate (filename: string, tree: unknown) {
       addTemplate({
-        filename: `markdown/page/${slug}.mjs`,
+        filename,
         getContents: () => `const tree = ${JSON.stringify(tree)}
 export async function getBody () {
   return tree
@@ -136,6 +150,15 @@ export async function getBody () {
       })
     }
 
+    await Promise.all([
+      ...blogPosts.map(async post => {
+        addBodyTemplate(`markdown/blog/${post.slug}.mjs`, await parseCached(post.body))
+      }),
+      ...Object.entries(pageBodies).map(async ([slug, body]) => {
+        addBodyTemplate(`markdown/page/${slug}.mjs`, await parseCached(body))
+      }),
+    ])
+
     addTemplate({
       filename: 'markdown/blog/index.mjs',
       getContents: () => {
@@ -165,42 +188,56 @@ export async function getBody () {
       write: true,
     })
 
-    const md = remark().use(remarkHtml)
-    const rssMetadata: Record<string, any> = {}
-
-    for (const post of blogPosts) {
-      const contents = serialize(post.body)
-      const date = new Date(post.date)
-      rssMetadata[post.slug] = {
-        title: post.title,
-        description: post.description,
-        tags: post.tags,
-        html: await md.process(contents).then(r => r.value),
-        date: `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`,
+    // `remark`/`html-to-text` are only needed to render the feed and to feed
+    // the (production-only) sync providers, so both are loaded on demand
+    let markdownToHtml: ((markdown: string) => Promise<string>) | undefined
+    async function toHtml (markdown: string) {
+      if (!markdownToHtml) {
+        const [{ remark }, { default: remarkHtml }] = await Promise.all([
+          import('remark'),
+          import('remark-html'),
+        ])
+        const md = remark().use(remarkHtml)
+        markdownToHtml = async source => String(await md.process(source))
       }
+      return markdownToHtml(markdown)
     }
 
     nuxt.options.nitro.virtual ||= {}
-    nuxt.options.nitro.virtual['#metadata.json'] = () =>
-      `export const metadata = ${JSON.stringify(rssMetadata)}`
-
-    const syncArticles = await Promise.all(blogPosts
-      .filter(p => !p.skip_dev)
-      .map(async post => {
-        const body = serialize(post.body)
-        const html = String(await md.process(body))
-        const textContent = htmlToText(html, { wordwrap: false })
-        return {
-          type: 'blog' as const,
+    nuxt.options.nitro.virtual['#metadata.json'] = async () => {
+      const rssMetadata: Record<string, unknown> = {}
+      for (const post of blogPosts) {
+        const date = new Date(post.date)
+        rssMetadata[post.slug] = {
           title: post.title,
-          date: post.date,
-          description: post.description || '',
-          body_markdown: body,
-          text_content: textContent,
-          canonical_url: `https://roe.dev/blog/${post.slug}/`,
-          tags: post.tags.length ? post.tags : undefined,
+          description: post.description,
+          tags: post.tags,
+          html: await toHtml(serialize(post.body)),
+          date: `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`,
         }
-      }))
+      }
+      return `export const metadata = ${JSON.stringify(rssMetadata)}`
+    }
+
+    async function getSyncArticles () {
+      const { convert: htmlToText } = await import('html-to-text')
+      return Promise.all(blogPosts
+        .filter(p => !p.skip_dev)
+        .map(async post => {
+          const body = serialize(post.body)
+          const html = await toHtml(body)
+          return {
+            type: 'blog' as const,
+            title: post.title,
+            date: post.date,
+            description: post.description || '',
+            body_markdown: body,
+            text_content: htmlToText(html, { wordwrap: false }),
+            canonical_url: `https://roe.dev/blog/${post.slug}/`,
+            tags: post.tags.length ? post.tags : undefined,
+          }
+        }))
+    }
 
     const rawBlogData = blogPosts.map(post => ({
       slug: post.slug,
@@ -288,8 +325,13 @@ declare module '#md-pages.json' {
 
 declare module '@nuxt/schema' {
   interface NuxtHooks {
-    'markdown:blog-entries': (entries: Array<{ path: string, slug: string, date: string, bluesky?: string }>) => void
-    'markdown:sync-articles': (articles: Array<{
+    'markdown:blog-entries': (entries: Array<{ path: string, slug: string, file: string, date: string, bluesky?: string }>) => void
+    /**
+     * Receives a lazy getter rather than the articles themselves: rendering
+     * them costs markdown -> HTML -> text for every post, and only the
+     * (production-only) sync module ever asks for them.
+     */
+    'markdown:sync-articles': (getArticles: () => Promise<Array<{
       type: 'blog'
       title: string
       date: string
@@ -298,6 +340,6 @@ declare module '@nuxt/schema' {
       text_content: string
       canonical_url: string
       tags?: string[]
-    }>) => void
+    }>>) => void
   }
 }
diff --git a/modules/runtime/server/discover-bluesky-post.get.ts b/modules/runtime/server/discover-bluesky-post.get.ts
index 9b752ea6..1de6d21a 100644
--- a/modules/runtime/server/discover-bluesky-post.get.ts
+++ b/modules/runtime/server/discover-bluesky-post.get.ts
@@ -1,14 +1,18 @@
 // @ts-expect-error virtual file generated by bsky-comments module
-import { newestPostUrl, newestPostDate } from 'bsky-runtime-discovery-server.mjs'
+import { pendingPosts } from 'bsky-runtime-discovery-server.mjs'
 import { BLUESKY_API, postLinksToUrl, type BlueskyFeedResponse } from '#shared/utils/bluesky'
 
-export default defineEventHandler(async event => {
-  if (!newestPostUrl) {
+const posts = pendingPosts as Record<string, { url: string, date: string }>
+
+export default defineCachedEventHandler(async event => {
+  const path = getQuery(event).path
+  const post = typeof path === 'string' ? posts[path] : undefined
+  if (!post) {
     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
+  const searchCutoff = new Date(new Date(post.date).getTime() - 24 * 60 * 60 * 1000)
 
   let cursor: string | undefined
 
@@ -27,14 +31,11 @@ export default defineEventHandler(async event => {
       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 (new Date(item.post.record.createdAt) < searchCutoff) {
+        return { uri: null }
       }
 
-      if (postLinksToUrl(item.post, newestPostUrl)) {
+      if (postLinksToUrl(item.post, post.url)) {
         return { uri: item.post.uri }
       }
     }
@@ -43,4 +44,8 @@ export default defineEventHandler(async event => {
   } while (cursor)
 
   return { uri: null }
+}, {
+  maxAge: 60 * 60,
+  swr: true,
+  getKey: event => String(getQuery(event).path || ''),
 })
diff --git a/modules/shared/build-cache.ts b/modules/shared/build-cache.ts
new file mode 100644
index 00000000..b36bfc65
--- /dev/null
+++ b/modules/shared/build-cache.ts
@@ -0,0 +1,78 @@
+/**
+ * Tiny on-disk cache for build-time work (markdown highlighting, atproto
+ * identity resolution, Bluesky post discovery). Everything lives under
+ * `node_modules/.cache/roe.dev/<namespace>` so it is disposable: a miss only
+ * ever costs the work it was caching.
+ */
+import { createHash } from 'node:crypto'
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+
+import { join } from 'pathe'
+import { useNuxt } from 'nuxt/kit'
+
+export function hashKey (...parts: Array<string | number | undefined>): string {
+  return createHash('sha256').update(parts.join('\0')).digest('hex').slice(0, 16)
+}
+
+export function createBuildCache (namespace: string) {
+  const dir = join(useNuxt().options.rootDir, 'node_modules', '.cache', 'roe.dev', namespace)
+  let ready: Promise<unknown> | undefined
+
+  function ensureDir () {
+    return (ready ||= mkdir(dir, { recursive: true }))
+  }
+
+  return {
+    async get<T> (key: string): Promise<{ value: T, mtime: number } | null> {
+      try {
+        const raw = await readFile(join(dir, `${key}.json`), 'utf8')
+        return JSON.parse(raw) as { value: T, mtime: number }
+      }
+      catch {
+        return null
+      }
+    },
+    async set<T> (key: string, value: T): Promise<void> {
+      try {
+        await ensureDir()
+        const file = join(dir, `${key}.json`)
+        const tmp = `${file}.${process.pid}.tmp`
+        await writeFile(tmp, JSON.stringify({ value, mtime: Date.now() }))
+        await rename(tmp, file)
+      }
+      catch {
+        // a cache that cannot be written is still a working cache
+      }
+    },
+  }
+}
+
+/**
+ * Read `key` from `namespace`, falling back to `fetch`. Entries older than
+ * `maxAge` are returned anyway when `stale` is set, with a refresh kicked off
+ * in the background so the next build gets a fresh value without this one
+ * paying for it.
+ */
+export async function withCache<T> (options: {
+  namespace: string
+  key: string
+  maxAge: number
+  stale?: boolean
+  fetch: () => Promise<T>
+}): Promise<T | null> {
+  const cache = createBuildCache(options.namespace)
+  const entry = await cache.get<T>(options.key)
+
+  if (entry && Date.now() - entry.mtime < options.maxAge) {
+    return entry.value
+  }
+
+  if (entry && options.stale) {
+    options.fetch().then(value => cache.set(options.key, value)).catch(() => {})
+    return entry.value
+  }
+
+  const value = await options.fetch()
+  await cache.set(options.key, value)
+  return value
+}
diff --git a/modules/sync/index.ts b/modules/sync/index.ts
index 4c75257e..f646e8e0 100644
--- a/modules/sync/index.ts
+++ b/modules/sync/index.ts
@@ -31,8 +31,8 @@ export default defineNuxtModule({
       return
     }
 
-    nuxt.hook('markdown:sync-articles', async articles => {
-      const talks = await fetchTalks()
+    nuxt.hook('markdown:sync-articles', async getArticles => {
+      const [articles, talks] = await Promise.all([getArticles(), fetchTalks()])
       const items: SyncItem[] = [...articles, ...talks]
 
       console.info(`[sync] ${dryRun ? 'Dry run' : 'Syncing'}: ${items.length} items (${articles.length} articles, ${talks.length} talks)`)
-- 
2.51.2