misc changes

src/lexicons/social.grain.photo.exif.json

···
+{
+    "lexicon": 1,
+    "id": "social.grain.photo.exif",
+    "defs": {
+      "main": {
+        "type": "record",
+        "description": "Basic EXIF metadata for a photo. Integers are scaled by 1000000 to accommodate decimal values and potentially other tags in the future.",
+        "key": "tid",
+        "record": {
+          "type": "object",
+          "required": [
+            "photo",
+            "createdAt"
+          ],
+          "properties": {
+            "photo": { "type": "string", "format": "at-uri" },
+            "createdAt": { "type": "string", "format": "datetime" },
+            "dateTimeOriginal": { "type": "string", "format": "datetime" },
+            "exposureTime": { "type": "integer" },
+            "fNumber": { "type": "integer" },
+            "flash": { "type": "string" },
+            "focalLengthIn35mmFormat": { "type": "integer" },
+            "iSO": { "type": "integer" },
+            "lensMake": { "type": "string" },
+            "lensModel": { "type": "string" },
+            "make": { "type": "string" },
+            "model": { "type": "string" }
+          }
+        }
+      }
+    }
+  }

src/lib/atproto/blob-url.ts

···
+import { loadConfig } from '../config/site'
+
+export type BlobVariant = 'full' | 'avatar' | 'feed'
+
+export function blobCdnUrl(did: string, cid: string, _variant: BlobVariant = 'full'): string {
+  const base = 'https://bsky.social/xrpc/com.atproto.sync.getBlob'
+  const params = new URLSearchParams({ did, cid })
+  return `${base}?${params.toString()}`
+}
+
+export function extractCidFromBlobRef(ref: unknown): string | null {
+  if (typeof ref === 'string') return ref
+  if (ref && typeof ref === 'object') {
+    const anyRef = ref as any
+    if (typeof anyRef.$link === 'string') return anyRef.$link
+    if (typeof anyRef.toString === 'function') {
+      const s = anyRef.toString()
+      if (s && typeof s === 'string') return s
+    }
+  }
+  return null
+}
+
+export function didFromConfig(): string {
+  const cfg = loadConfig()
+  return cfg.atproto.did
+}
+
+

src/lib/atproto/blob.ts

···
+import { AtpAgent } from '@atproto/api'
+import { loadConfig } from '../config/site'
+
+export type BlobVariant = 'full' | 'avatar' | 'feed'
+
+export function blobCdnUrl(did: string, cid: string, variant: BlobVariant = 'full'): string {
+  // Default to PDS sync getBlob endpoint; AppView/CDN variants can be swapped in later
+  const base = 'https://bsky.social/xrpc/com.atproto.sync.getBlob'
+  const params = new URLSearchParams({ did, cid })
+  return `${base}?${params.toString()}`
+}
+
+export async function fetchBlob(did: string, cid: string, agent?: AtpAgent): Promise<Blob> {
+  const cfg = loadConfig()
+  const atp = agent ?? new AtpAgent({ service: cfg.atproto.pdsUrl || 'https://bsky.social' })
+  const res = await atp.com.atproto.sync.getBlob({ did, cid })
+  // @atproto/api returns a Response-like object with data as ArrayBuffer
+  const arrayBuf = await res.data.blob()
+  return new Blob([arrayBuf])
+}
+
+// Extract CID string from common embed image blob refs
+export function extractCidFromBlobRef(ref: unknown): string | null {
+  // Formats we might encounter:
+  // - string (cid)
+  // - { $link: string }
+  // - BlobRef object with toString()
+  if (typeof ref === 'string') return ref
+  if (ref && typeof ref === 'object') {
+    const anyRef = ref as any
+    if (typeof anyRef.$link === 'string') return anyRef.$link
+    if (typeof anyRef.toString === 'function') {
+      const s = anyRef.toString()
+      if (s && typeof s === 'string') return s
+    }
+  }
+  return null
+}
+
+

src/lib/generated/com-whtwnd-blog-entry.ts

···
+// Generated from lexicon schema: com.whtwnd.blog.entry
+// Do not edit manually - regenerate with: npm run gen:types
+
+export interface ComWhtwndBlogEntryRecord {
+  content: string;
+  createdAt?: string;
+  title?: string;
+  subtitle?: string;
+  ogp?: any;
+  theme?: 'github-light';
+  blobs?: any[];
+  isDraft?: boolean;
+  visibility?: 'public' | 'url' | 'author';
+}
+
+export interface ComWhtwndBlogEntry {
+  $type: 'com.whtwnd.blog.entry';
+  value: ComWhtwndBlogEntryRecord;
+}
+
+// Helper type for discriminated unions
+export type ComWhtwndBlogEntryUnion = ComWhtwndBlogEntry;

src/lib/generated/discovered-types.ts

···
+// Auto-generated types from collection discovery
+// Generated at: 2025-08-06T17:33:43.119Z
+// Repository: tynanpurdy.com (did:plc:6ayddqghxhciedbaofoxkcbs)
+// Collections: 64, Records: 124
+
+// Collection: app.bsky.actor.profile
+// Service: bsky.app
+// Types: app.bsky.actor.profile
+export interface AppBskyActorProfile {
+  $type: 'app.bsky.actor.profile';
+  avatar?: Record<string, any>;
+  banner?: Record<string, any>;
+  description?: string;
+  displayName?: string;
+}
+
+
+// Collection: app.bsky.feed.like
+// Service: bsky.app
+// Types: app.bsky.feed.like
+export interface AppBskyFeedLike {
+  $type: 'app.bsky.feed.like';
+  subject?: Record<string, any>;
+  createdAt?: string;
+}
+
+
+// Collection: app.bsky.feed.post
+// Service: bsky.app
+// Types: app.bsky.feed.post
+export interface AppBskyFeedPost {
+  $type: 'app.bsky.feed.post';
+  text?: string;
+  langs?: string[];
+  createdAt?: string;
+}
+
+
+// Collection: app.bsky.feed.postgate
+// Service: bsky.app
+// Types: app.bsky.feed.postgate
+export interface AppBskyFeedPostgate {
+  $type: 'app.bsky.feed.postgate';
+  post?: string;
+  createdAt?: string;
+  embeddingRules?: Record<string, any>[];
+  detachedEmbeddingUris?: any[];
+}
+
+
+// Collection: app.bsky.feed.repost
+// Service: bsky.app
+// Types: app.bsky.feed.repost
+export interface AppBskyFeedRepost {
+  $type: 'app.bsky.feed.repost';
+  subject?: Record<string, any>;
+  createdAt?: string;
+}
+
+
+// Collection: app.bsky.feed.threadgate
+// Service: bsky.app
+// Types: app.bsky.feed.threadgate
+export interface AppBskyFeedThreadgate {
+  $type: 'app.bsky.feed.threadgate';
+  post?: string;
+  allow?: Record<string, any>[];
+  createdAt?: string;
+  hiddenReplies?: any[];
+}
+
+
+// Collection: app.bsky.graph.block
+// Service: bsky.app
+// Types: app.bsky.graph.block
+export interface AppBskyGraphBlock {
+  $type: 'app.bsky.graph.block';
+  subject?: string;
+  createdAt?: string;
+}
+
+
+// Collection: app.bsky.graph.follow
+// Service: bsky.app
+// Types: app.bsky.graph.follow
+export interface AppBskyGraphFollow {
+  $type: 'app.bsky.graph.follow';
+  subject?: string;
+  createdAt?: string;
+}
+
+
+// Collection: app.bsky.graph.list
+// Service: bsky.app
+// Types: app.bsky.graph.list
+export interface AppBskyGraphList {
+  $type: 'app.bsky.graph.list';
+  name?: string;
+  purpose?: string;
+  createdAt?: string;
+  description?: string;
+}
+
+
+// Collection: app.bsky.graph.listitem
+// Service: bsky.app
+// Types: app.bsky.graph.listitem
+export interface AppBskyGraphListitem {
+  $type: 'app.bsky.graph.listitem';
+  list?: string;
+  subject?: string;
+  createdAt?: string;
+}
+
+
+// Collection: app.bsky.graph.starterpack
+// Service: bsky.app
+// Types: app.bsky.graph.starterpack
+export interface AppBskyGraphStarterpack {
+  $type: 'app.bsky.graph.starterpack';
+  list?: string;
+  name?: string;
+  feeds?: Record<string, any>[];
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+
+// Collection: app.bsky.graph.verification
+// Service: bsky.app
+// Types: app.bsky.graph.verification
+export interface AppBskyGraphVerification {
+  $type: 'app.bsky.graph.verification';
+  handle?: string;
+  subject?: string;
+  createdAt?: string;
+  displayName?: string;
+}
+
+
+// Collection: app.popsky.list
+// Service: unknown
+// Types: app.popsky.list
+export interface AppPopskyList {
+  $type: 'app.popsky.list';
+  name?: string;
+  authorDid?: string;
+  createdAt?: string;
+  indexedAt?: string;
+  description?: string;
+}
+
+
+// Collection: app.popsky.listItem
+// Service: unknown
+// Types: app.popsky.listItem
+export interface AppPopskyListItem {
+  $type: 'app.popsky.listItem';
+  addedAt?: string;
+  listUri?: string;
+  identifiers?: Record<string, any>;
+  creativeWorkType?: string;
+}
+
+
+// Collection: app.popsky.profile
+// Service: unknown
+// Types: app.popsky.profile
+export interface AppPopskyProfile {
+  $type: 'app.popsky.profile';
+  createdAt?: string;
+  description?: string;
+  displayName?: string;
+}
+
+
+// Collection: app.popsky.review
+// Service: unknown
+// Types: app.popsky.review
+export interface AppPopskyReview {
+  $type: 'app.popsky.review';
+  tags?: any[];
+  facets?: any[];
+  rating?: number;
+  createdAt?: string;
+  isRevisit?: boolean;
+  reviewText?: string;
+  identifiers?: Record<string, any>;
+  containsSpoilers?: boolean;
+  creativeWorkType?: string;
+}
+
+
+// Collection: app.rocksky.album
+// Service: unknown
+// Types: app.rocksky.album
+export interface AppRockskyAlbum {
+  $type: 'app.rocksky.album';
+  year?: number;
+  title?: string;
+  artist?: string;
+  albumArt?: Record<string, any>;
+  createdAt?: string;
+  releaseDate?: string;
+}
+
+
+// Collection: app.rocksky.artist
+// Service: unknown
+// Types: app.rocksky.artist
+export interface AppRockskyArtist {
+  $type: 'app.rocksky.artist';
+  name?: string;
+  picture?: Record<string, any>;
+  createdAt?: string;
+}
+
+
+// Collection: app.rocksky.like
+// Service: unknown
+// Types: app.rocksky.like
+export interface AppRockskyLike {
+  $type: 'app.rocksky.like';
+  subject?: Record<string, any>;
+  createdAt?: string;
+}
+
+
+// Collection: app.rocksky.scrobble
+// Service: unknown
+// Types: app.rocksky.scrobble
+export interface AppRockskyScrobble {
+  $type: 'app.rocksky.scrobble';
+  year?: number;
+  album?: string;
+  title?: string;
+  artist?: string;
+  albumArt?: Record<string, any>;
+  duration?: number;
+  createdAt?: string;
+  discNumber?: number;
+  albumArtist?: string;
+  releaseDate?: string;
+  spotifyLink?: string;
+  trackNumber?: number;
+}
+
+
+// Collection: app.rocksky.song
+// Service: unknown
+// Types: app.rocksky.song
+export interface AppRockskySong {
+  $type: 'app.rocksky.song';
+  year?: number;
+  album?: string;
+  title?: string;
+  artist?: string;
+  albumArt?: Record<string, any>;
+  duration?: number;
+  createdAt?: string;
+  discNumber?: number;
+  albumArtist?: string;
+  releaseDate?: string;
+  spotifyLink?: string;
+  trackNumber?: number;
+}
+
+
+// Collection: blue.flashes.actor.profile
+// Service: unknown
+// Types: blue.flashes.actor.profile
+export interface BlueFlashesActorProfile {
+  $type: 'blue.flashes.actor.profile';
+  createdAt?: string;
+  showFeeds?: boolean;
+  showLikes?: boolean;
+  showLists?: boolean;
+  showMedia?: boolean;
+  enablePortfolio?: boolean;
+  portfolioLayout?: string;
+  allowRawDownload?: boolean;
+}
+
+
+// Collection: blue.linkat.board
+// Service: unknown
+// Types: blue.linkat.board
+export interface BlueLinkatBoard {
+  $type: 'blue.linkat.board';
+  cards?: Record<string, any>[];
+}
+
+
+// Collection: buzz.bookhive.book
+// Service: unknown
+// Types: buzz.bookhive.book
+export interface BuzzBookhiveBook {
+  $type: 'buzz.bookhive.book';
+  cover?: Record<string, any>;
+  title?: string;
+  hiveId?: string;
+  status?: string;
+  authors?: string;
+  createdAt?: string;
+}
+
+
+// Collection: chat.bsky.actor.declaration
+// Service: unknown
+// Types: chat.bsky.actor.declaration
+export interface ChatBskyActorDeclaration {
+  $type: 'chat.bsky.actor.declaration';
+  allowIncoming?: string;
+}
+
+
+// Collection: chat.roomy.01JPNX7AA9BSM6TY2GWW1TR5V7.catalog
+// Service: unknown
+// Types: chat.roomy.01JPNX7AA9BSM6TY2GWW1TR5V7.catalog
+export interface ChatRoomy01JPNX7AA9BSM6TY2GWW1TR5V7Catalog {
+  $type: 'chat.roomy.01JPNX7AA9BSM6TY2GWW1TR5V7.catalog';
+  id?: string;
+}
+
+
+// Collection: chat.roomy.profile
+// Service: unknown
+// Types: chat.roomy.profile
+export interface ChatRoomyProfile {
+  $type: 'chat.roomy.profile';
+  accountId?: string;
+  profileId?: string;
+}
+
+
+// Collection: com.germnetwork.keypackage
+// Service: unknown
+// Types: com.germnetwork.keypackage
+export interface ComGermnetworkKeypackage {
+  $type: 'com.germnetwork.keypackage';
+  anchorHello?: string;
+}
+
+
+// Collection: com.whtwnd.blog.entry
+// Service: unknown
+// Types: com.whtwnd.blog.entry
+export interface ComWhtwndBlogEntry {
+  $type: 'com.whtwnd.blog.entry';
+  theme?: string;
+  title?: string;
+  content?: string;
+  createdAt?: string;
+  visibility?: string;
+}
+
+
+// Collection: community.lexicon.calendar.rsvp
+// Service: unknown
+// Types: community.lexicon.calendar.rsvp
+export interface CommunityLexiconCalendarRsvp {
+  $type: 'community.lexicon.calendar.rsvp';
+  status?: string;
+  subject?: Record<string, any>;
+  createdAt?: string;
+}
+
+
+// Collection: events.smokesignal.app.profile
+// Service: unknown
+// Types: events.smokesignal.app.profile
+export interface EventsSmokesignalAppProfile {
+  $type: 'events.smokesignal.app.profile';
+  tz?: string;
+}
+
+
+// Collection: events.smokesignal.calendar.event
+// Service: unknown
+// Types: events.smokesignal.calendar.event
+export interface EventsSmokesignalCalendarEvent {
+  $type: 'events.smokesignal.calendar.event';
+  mode?: string;
+  name?: string;
+  text?: string;
+  endsAt?: string;
+  status?: string;
+  location?: Record<string, any>;
+  startsAt?: string;
+  createdAt?: string;
+}
+
+
+// Collection: farm.smol.games.skyrdle.score
+// Service: unknown
+// Types: farm.smol.games.skyrdle.score
+export interface FarmSmolGamesSkyrdleScore {
+  $type: 'farm.smol.games.skyrdle.score';
+  hash?: string;
+  isWin?: boolean;
+  score?: number;
+  guesses?: Record<string, any>[];
+  timestamp?: string;
+  gameNumber?: number;
+}
+
+
+// Collection: fyi.bluelinks.links
+// Service: unknown
+// Types: fyi.bluelinks.links
+export interface FyiBluelinksLinks {
+  $type: 'fyi.bluelinks.links';
+  links?: Record<string, any>[];
+}
+
+
+// Collection: fyi.unravel.frontpage.comment
+// Service: unknown
+// Types: fyi.unravel.frontpage.comment
+export interface FyiUnravelFrontpageComment {
+  $type: 'fyi.unravel.frontpage.comment';
+  post?: Record<string, any>;
+  content?: string;
+  createdAt?: string;
+}
+
+
+// Collection: fyi.unravel.frontpage.post
+// Service: unknown
+// Types: fyi.unravel.frontpage.post
+export interface FyiUnravelFrontpagePost {
+  $type: 'fyi.unravel.frontpage.post';
+  url?: string;
+  title?: string;
+  createdAt?: string;
+}
+
+
+// Collection: fyi.unravel.frontpage.vote
+// Service: unknown
+// Types: fyi.unravel.frontpage.vote
+export interface FyiUnravelFrontpageVote {
+  $type: 'fyi.unravel.frontpage.vote';
+  subject?: Record<string, any>;
+  createdAt?: string;
+}
+
+
+// Collection: im.flushing.right.now
+// Service: unknown
+// Types: im.flushing.right.now
+export interface ImFlushingRightNow {
+  $type: 'im.flushing.right.now';
+  text?: string;
+  emoji?: string;
+  createdAt?: string;
+}
+
+
+// Collection: link.woosh.linkPage
+// Service: unknown
+// Types: link.woosh.linkPage
+export interface LinkWooshLinkPage {
+  $type: 'link.woosh.linkPage';
+  collections?: Record<string, any>[];
+}
+
+
+// Collection: my.skylights.rel
+// Service: unknown
+// Types: my.skylights.rel
+export interface MySkylightsRel {
+  $type: 'my.skylights.rel';
+  item?: Record<string, any>;
+  note?: Record<string, any>;
+  rating?: Record<string, any>;
+}
+
+
+// Collection: org.owdproject.application.windows
+// Service: unknown
+// Types: org.owdproject.application.windows
+export interface OrgOwdprojectApplicationWindows {
+  $type: 'org.owdproject.application.windows';
+}
+
+
+// Collection: org.owdproject.desktop
+// Service: unknown
+// Types: org.owdproject.desktop
+export interface OrgOwdprojectDesktop {
+  $type: 'org.owdproject.desktop';
+  state?: Record<string, any>;
+}
+
+
+// Collection: org.scrapboard.list
+// Service: unknown
+// Types: org.scrapboard.list
+export interface OrgScrapboardList {
+  $type: 'org.scrapboard.list';
+  name?: string;
+  createdAt?: string;
+  description?: string;
+}
+
+
+// Collection: org.scrapboard.listitem
+// Service: unknown
+// Types: org.scrapboard.listitem
+export interface OrgScrapboardListitem {
+  $type: 'org.scrapboard.listitem';
+  url?: string;
+  list?: string;
+  createdAt?: string;
+}
+
+
+// Collection: place.stream.chat.message
+// Service: unknown
+// Types: place.stream.chat.message
+export interface PlaceStreamChatMessage {
+  $type: 'place.stream.chat.message';
+  text?: string;
+  streamer?: string;
+  createdAt?: string;
+}
+
+
+// Collection: place.stream.chat.profile
+// Service: unknown
+// Types: place.stream.chat.profile
+export interface PlaceStreamChatProfile {
+  $type: 'place.stream.chat.profile';
+  color?: Record<string, any>;
+}
+
+
+// Collection: pub.leaflet.document
+// Service: unknown
+// Types: pub.leaflet.document
+export interface PubLeafletDocument {
+  $type: 'pub.leaflet.document';
+  pages?: Record<string, any>[];
+  title?: string;
+  author?: string;
+  postRef?: Record<string, any>;
+  description?: string;
+  publication?: string;
+  publishedAt?: string;
+}
+
+
+// Collection: pub.leaflet.graph.subscription
+// Service: unknown
+// Types: pub.leaflet.graph.subscription
+export interface PubLeafletGraphSubscription {
+  $type: 'pub.leaflet.graph.subscription';
+  publication?: string;
+}
+
+
+// Collection: pub.leaflet.publication
+// Service: unknown
+// Types: pub.leaflet.publication
+export interface PubLeafletPublication {
+  $type: 'pub.leaflet.publication';
+  icon?: Record<string, any>;
+  name?: string;
+  base_path?: string;
+  description?: string;
+}
+
+
+// Collection: sh.tangled.actor.profile
+// Service: sh.tangled
+// Types: sh.tangled.actor.profile
+export interface ShTangledActorProfile {
+  $type: 'sh.tangled.actor.profile';
+  links?: string[];
+  stats?: string[];
+  bluesky?: boolean;
+  location?: string;
+  description?: string;
+  pinnedRepositories?: string[];
+}
+
+
+// Collection: sh.tangled.feed.star
+// Service: sh.tangled
+// Types: sh.tangled.feed.star
+export interface ShTangledFeedStar {
+  $type: 'sh.tangled.feed.star';
+  subject?: string;
+  createdAt?: string;
+}
+
+
+// Collection: sh.tangled.publicKey
+// Service: sh.tangled
+// Types: sh.tangled.publicKey
+export interface ShTangledPublicKey {
+  $type: 'sh.tangled.publicKey';
+  key?: string;
+  name?: string;
+  createdAt?: string;
+}
+
+
+// Collection: sh.tangled.repo
+// Service: sh.tangled
+// Types: sh.tangled.repo
+export interface ShTangledRepo {
+  $type: 'sh.tangled.repo';
+  knot?: string;
+  name?: string;
+  owner?: string;
+  createdAt?: string;
+}
+
+
+// Collection: so.sprk.actor.profile
+// Service: unknown
+// Types: so.sprk.actor.profile
+export interface SoSprkActorProfile {
+  $type: 'so.sprk.actor.profile';
+  avatar?: Record<string, any>;
+  description?: string;
+  displayName?: string;
+}
+
+
+// Collection: so.sprk.feed.like
+// Service: unknown
+// Types: so.sprk.feed.like
+export interface SoSprkFeedLike {
+  $type: 'so.sprk.feed.like';
+  subject?: Record<string, any>;
+  createdAt?: string;
+}
+
+
+// Collection: so.sprk.feed.story
+// Service: unknown
+// Types: so.sprk.feed.story
+export interface SoSprkFeedStory {
+  $type: 'so.sprk.feed.story';
+  tags?: any[];
+  media?: Record<string, any>;
+  createdAt?: string;
+  selfLabels?: any[];
+}
+
+
+// Collection: social.grain.actor.profile
+// Service: grain.social
+// Types: social.grain.actor.profile
+export interface SocialGrainActorProfile {
+  $type: 'social.grain.actor.profile';
+  avatar?: Record<string, any>;
+  description?: string;
+  displayName?: string;
+}
+
+
+// Collection: social.grain.favorite
+// Service: grain.social
+// Types: social.grain.favorite
+export interface SocialGrainFavorite {
+  $type: 'social.grain.favorite';
+  subject?: string;
+  createdAt?: string;
+}
+
+
+// Collection: social.grain.gallery
+// Service: grain.social
+// Types: social.grain.gallery
+export interface SocialGrainGallery {
+  $type: 'social.grain.gallery';
+  title?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  description?: string;
+}
+
+
+// Collection: social.grain.gallery.item
+// Service: grain.social
+// Types: social.grain.gallery.item
+export interface SocialGrainGalleryItem {
+  $type: 'social.grain.gallery.item';
+  item?: string;
+  gallery?: string;
+  position?: number;
+  createdAt?: string;
+}
+
+
+// Collection: social.grain.graph.follow
+// Service: grain.social
+// Types: social.grain.graph.follow
+export interface SocialGrainGraphFollow {
+  $type: 'social.grain.graph.follow';
+  subject?: string;
+  createdAt?: string;
+}
+
+
+// Collection: social.grain.photo
+// Service: grain.social
+// Types: social.grain.photo
+export interface SocialGrainPhoto {
+  $type: 'social.grain.photo';
+  alt?: string;
+  cid?: string;
+  did?: string;
+  uri?: string;
+  photo?: Record<string, any>;
+  createdAt?: string;
+  indexedAt?: string;
+  aspectRatio?: Record<string, any>;
+}
+
+
+// Collection: social.grain.photo.exif
+// Service: grain.social
+// Types: social.grain.photo.exif
+export interface SocialGrainPhotoExif {
+  $type: 'social.grain.photo.exif';
+  iSO?: number;
+  make?: string;
+  flash?: string;
+  model?: string;
+  photo?: string;
+  fNumber?: number;
+  lensMake?: string;
+  createdAt?: string;
+  lensModel?: string;
+  exposureTime?: number;
+  dateTimeOriginal?: string;
+  focalLengthIn35mmFormat?: number;
+}
+
+
+// Collection: social.pinksky.app.preference
+// Service: unknown
+// Types: social.pinksky.app.preference
+export interface SocialPinkskyAppPreference {
+  $type: 'social.pinksky.app.preference';
+  slug?: string;
+  value?: string;
+  createdAt?: string;
+}
+
+
+// Union type for all discovered types
+export type DiscoveredTypes = 'app.bsky.actor.profile' | 'app.bsky.feed.like' | 'app.bsky.feed.post' | 'app.bsky.feed.postgate' | 'app.bsky.feed.repost' | 'app.bsky.feed.threadgate' | 'app.bsky.graph.block' | 'app.bsky.graph.follow' | 'app.bsky.graph.list' | 'app.bsky.graph.listitem' | 'app.bsky.graph.starterpack' | 'app.bsky.graph.verification' | 'app.popsky.list' | 'app.popsky.listItem' | 'app.popsky.profile' | 'app.popsky.review' | 'app.rocksky.album' | 'app.rocksky.artist' | 'app.rocksky.like' | 'app.rocksky.scrobble' | 'app.rocksky.song' | 'blue.flashes.actor.profile' | 'blue.linkat.board' | 'buzz.bookhive.book' | 'chat.bsky.actor.declaration' | 'chat.roomy.01JPNX7AA9BSM6TY2GWW1TR5V7.catalog' | 'chat.roomy.profile' | 'com.germnetwork.keypackage' | 'com.whtwnd.blog.entry' | 'community.lexicon.calendar.rsvp' | 'events.smokesignal.app.profile' | 'events.smokesignal.calendar.event' | 'farm.smol.games.skyrdle.score' | 'fyi.bluelinks.links' | 'fyi.unravel.frontpage.comment' | 'fyi.unravel.frontpage.post' | 'fyi.unravel.frontpage.vote' | 'im.flushing.right.now' | 'link.woosh.linkPage' | 'my.skylights.rel' | 'org.owdproject.application.windows' | 'org.owdproject.desktop' | 'org.scrapboard.list' | 'org.scrapboard.listitem' | 'place.stream.chat.message' | 'place.stream.chat.profile' | 'pub.leaflet.document' | 'pub.leaflet.graph.subscription' | 'pub.leaflet.publication' | 'sh.tangled.actor.profile' | 'sh.tangled.feed.star' | 'sh.tangled.publicKey' | 'sh.tangled.repo' | 'so.sprk.actor.profile' | 'so.sprk.feed.like' | 'so.sprk.feed.story' | 'social.grain.actor.profile' | 'social.grain.favorite' | 'social.grain.gallery' | 'social.grain.gallery.item' | 'social.grain.graph.follow' | 'social.grain.photo' | 'social.grain.photo.exif' | 'social.pinksky.app.preference';
+

src/lib/generated/lexicon-types.ts

···
+// Generated index of all lexicon types
+// Do not edit manually - regenerate with: npm run gen:types
+
+import type { AStatusUpdate } from './a-status-update';
+import type { ComWhtwndBlogEntry } from './com-whtwnd-blog-entry';
+import type { SocialGrainGalleryItem } from './social-grain-gallery-item';
+import type { SocialGrainGallery } from './social-grain-gallery';
+import type { SocialGrainPhotoExif } from './social-grain-photo-exif';
+import type { SocialGrainPhoto } from './social-grain-photo';
+
+// Union type for all generated lexicon records
+export type GeneratedLexiconUnion = AStatusUpdate | ComWhtwndBlogEntry | SocialGrainGalleryItem | SocialGrainGallery | SocialGrainPhotoExif | SocialGrainPhoto;
+
+// Type map for component registry
+export type GeneratedLexiconTypeMap = {
+  'AStatusUpdate': AStatusUpdate;
+  'ComWhtwndBlogEntry': ComWhtwndBlogEntry;
+  'SocialGrainGalleryItem': SocialGrainGalleryItem;
+  'SocialGrainGallery': SocialGrainGallery;
+  'SocialGrainPhotoExif': SocialGrainPhotoExif;
+  'SocialGrainPhoto': SocialGrainPhoto;
+};

src/lib/generated/social-grain-gallery-item.ts

···
+// Generated from lexicon schema: social.grain.gallery.item
+// Do not edit manually - regenerate with: npm run gen:types
+
+export interface SocialGrainGalleryItemRecord {
+  createdAt: string;
+  gallery: string;
+  item: string;
+  position?: number;
+}
+
+export interface SocialGrainGalleryItem {
+  $type: 'social.grain.gallery.item';
+  value: SocialGrainGalleryItemRecord;
+}
+
+// Helper type for discriminated unions
+export type SocialGrainGalleryItemUnion = SocialGrainGalleryItem;

src/lib/generated/social-grain-gallery.ts

···
+// Generated from lexicon schema: social.grain.gallery
+// Do not edit manually - regenerate with: npm run gen:types
+
+export interface SocialGrainGalleryRecord {
+  title: string;
+  description?: string;
+  facets?: any[];
+  labels?: any;
+  updatedAt?: string;
+  createdAt: string;
+}
+
+export interface SocialGrainGallery {
+  $type: 'social.grain.gallery';
+  value: SocialGrainGalleryRecord;
+}
+
+// Helper type for discriminated unions
+export type SocialGrainGalleryUnion = SocialGrainGallery;

src/lib/generated/social-grain-photo-exif.ts

···
+// Generated from lexicon schema: social.grain.photo.exif
+// Do not edit manually - regenerate with: npm run gen:types
+
+export interface SocialGrainPhotoExifRecord {
+  photo: string;
+  createdAt: string;
+  dateTimeOriginal?: string;
+  exposureTime?: number;
+  fNumber?: number;
+  flash?: string;
+  focalLengthIn35mmFormat?: number;
+  iSO?: number;
+  lensMake?: string;
+  lensModel?: string;
+  make?: string;
+  model?: string;
+}
+
+export interface SocialGrainPhotoExif {
+  $type: 'social.grain.photo.exif';
+  value: SocialGrainPhotoExifRecord;
+}
+
+// Helper type for discriminated unions
+export type SocialGrainPhotoExifUnion = SocialGrainPhotoExif;

src/lib/generated/social-grain-photo.ts

···
+// Generated from lexicon schema: social.grain.photo
+// Do not edit manually - regenerate with: npm run gen:types
+
+export interface SocialGrainPhotoRecord {
+  photo: any;
+  alt?: string;
+  aspectRatio: any;
+  createdAt: string;
+}
+
+export interface SocialGrainPhoto {
+  $type: 'social.grain.photo';
+  value: SocialGrainPhotoRecord;
+}
+
+// Helper type for discriminated unions
+export type SocialGrainPhotoUnion = SocialGrainPhoto;

src/lib/services/content-service.ts

···
+import { AtprotoBrowser } from '../atproto/atproto-browser';
+import { loadConfig } from '../config/site';
+
+export interface ContentRecord {
+  uri: string;
+  cid: string;
+  value: any;
+  indexedAt: string;
+  collection: string;
+}
+
+export interface ProcessedContent {
+  $type: string;
+  collection: string;
+  uri: string;
+  data: any;
+  createdAt: Date;
+}
+
+export class ContentService {
+  private browser: AtprotoBrowser;
+  private config: any;
+  private cache: Map<string, ProcessedContent[]> = new Map();
+
+  constructor() {
+    this.config = loadConfig();
+    this.browser = new AtprotoBrowser();
+  }
+
+  async getContentFromCollection(identifier: string, collection: string): Promise<ProcessedContent[]> {
+    const cacheKey = `${identifier}:${collection}`;
+    
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey)!;
+    }
+
+    try {
+      console.log(`Fetching ${collection} for ${identifier}...`);
+      const collectionInfo = await this.browser.getCollectionRecords(identifier, collection);
+      console.log(`Collection info for ${collection}:`, collectionInfo);
+      
+      if (!collectionInfo || !collectionInfo.records) {
+        console.log(`No records found for ${collection}`);
+        return [];
+      }
+      
+      console.log(`Found ${collectionInfo.records.length} records for ${collection}`);
+      
+      // Debug: Show first few records
+      if (collectionInfo.records.length > 0) {
+        console.log(`First record in ${collection}:`, JSON.stringify(collectionInfo.records[0], null, 2));
+      }
+      
+      const processed = collectionInfo.records.map(record => this.processRecord(record));
+      
+      this.cache.set(cacheKey, processed);
+      return processed;
+    } catch (error) {
+      console.error(`Error fetching ${collection}:`, error);
+      return [];
+    }
+  }
+
+  private processRecord(record: ContentRecord): ProcessedContent {
+    return {
+      $type: record.value.$type || 'unknown',
+      collection: record.collection,
+      uri: record.uri,
+      data: record.value,
+      createdAt: new Date(record.value.createdAt || record.indexedAt)
+    };
+  }
+
+  // Get galleries specifically
+  async getGalleries(identifier: string): Promise<ProcessedContent[]> {
+    return this.getContentFromCollection(identifier, 'social.grain.gallery');
+  }
+
+  // Get gallery items specifically with linked photos
+  async getGalleryItems(identifier: string): Promise<ProcessedContent[]> {
+    console.log(`Fetching gallery items for ${identifier}...`);
+    const galleryItems = await this.getContentFromCollection(identifier, 'social.grain.gallery.item');
+    console.log(`Found ${galleryItems.length} gallery items`);
+    
+    if (galleryItems.length === 0) {
+      console.log('No gallery items found - this might be the issue');
+      // Let's also try to fetch galleries to see if they exist
+      const galleries = await this.getContentFromCollection(identifier, 'social.grain.gallery');
+      console.log(`Found ${galleries.length} galleries`);
+      return [];
+    }
+    
+    // For each gallery item, try to fetch the linked photo
+    const enrichedItems = await Promise.all(
+      galleryItems.map(async (item) => {
+        console.log(`Processing gallery item: ${item.uri}`);
+        console.log(`Item data:`, JSON.stringify(item.data, null, 2));
+        
+        if (item.data.item && typeof item.data.item === 'string') {
+          try {
+            // Extract the photo URI from the item field
+            const photoUri = item.data.item;
+            console.log(`Fetching linked photo: ${photoUri}`);
+            
+            // Make sure we have a complete URI with record ID
+            if (!photoUri.includes('/social.grain.photo/')) {
+              console.log(`Invalid photo URI format: ${photoUri}`);
+              return item;
+            }
+            
+            const photoRecord = await this.browser.getRecord(photoUri);
+            
+            if (photoRecord && photoRecord.value) {
+              console.log(`Found photo record:`, JSON.stringify(photoRecord.value, null, 2));
+              // Merge the photo data into the gallery item
+              return {
+                ...item,
+                data: {
+                  ...item.data,
+                  linkedPhoto: photoRecord.value,
+                  photoUri: photoUri
+                }
+              };
+            } else {
+              console.log(`No photo record found for: ${photoUri}`);
+              console.log(`Photo record was:`, photoRecord);
+              
+              // Let's try to fetch the photo record directly to see what's happening
+              try {
+                console.log(`Attempting to fetch photo record directly...`);
+                const directResponse = await this.browser.agent.api.com.atproto.repo.getRecord({
+                  uri: photoUri
+                });
+                console.log(`Direct API response:`, directResponse);
+              } catch (directError) {
+                console.log(`Direct API error:`, directError);
+              }
+            }
+          } catch (error) {
+            console.log(`Could not fetch linked photo for ${item.uri}:`, error);
+          }
+        } else {
+          console.log(`No item field found in gallery item:`, item.data);
+        }
+        return item;
+      })
+    );
+    
+    console.log(`Returning ${enrichedItems.length} enriched gallery items`);
+    return enrichedItems;
+  }
+
+  // Get posts
+  async getPosts(identifier: string): Promise<ProcessedContent[]> {
+    return this.getContentFromCollection(identifier, 'app.bsky.feed.post');
+  }
+
+  // Get profile
+  async getProfile(identifier: string): Promise<ProcessedContent[]> {
+    return this.getContentFromCollection(identifier, 'app.bsky.actor.profile');
+  }
+
+  // Get all content from multiple collections
+  async getAllContent(identifier: string, collections: string[]): Promise<ProcessedContent[]> {
+    const allContent: ProcessedContent[] = [];
+    
+    for (const collection of collections) {
+      const content = await this.getContentFromCollection(identifier, collection);
+      allContent.push(...content);
+    }
+    
+    return allContent;
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+} 

src/lib/services/grain-gallery-service.ts

···
 import { AtprotoBrowser } from '../atproto/atproto-browser';
 import { loadConfig } from '../config/site';
-import type { AtprotoRecord } from '../types/atproto';
 import { extractCidFromBlobRef, blobCdnUrl } from '../atproto/blob-url';
-
-export interface GrainGalleryItem {
-  uri: string;
-  cid: string;
-  value: {
-    $type: string;
-    galleryId?: string;
-    gallery_id?: string;
-    id?: string;
-    title?: string;
-    description?: string;
-    caption?: string;
-    image?: {
-      url?: string;
-      src?: string;
-      alt?: string;
-      caption?: string;
-    };
-    photo?: {
-      url?: string;
-      src?: string;
-      alt?: string;
-      caption?: string;
-    };
-    media?: {
-      url?: string;
-      src?: string;
-      alt?: string;
-      caption?: string;
-    };
-    createdAt: string;
-  };
-  indexedAt: string;
-  collection: string;
-}
-
-export interface GrainGallery {
-  id: string;
-  title: string;
-  description?: string;
-  createdAt: string;
-  items: GrainGalleryItem[];
-  imageCount: number;
-  collections: string[];
-}
+import type { SocialGrainGalleryRecord } from '../generated/social-grain-gallery';
+import type { SocialGrainGalleryItemRecord } from '../generated/social-grain-gallery-item';
+import type { SocialGrainPhotoRecord } from '../generated/social-grain-photo';
+import type { SocialGrainPhotoExifRecord } from '../generated/social-grain-photo-exif';
 
 export interface ProcessedGrainGallery {
   id: string;
···
   }
 
   // Resolve gallery URI directly from the item record if present
-  private extractGalleryUriFromItem(item: any): string | null {
-    const value = item?.value ?? item;
+  private extractGalleryUriFromItem(item: { value: SocialGrainGalleryItemRecord } | SocialGrainGalleryItemRecord): string | null {
+    const value: SocialGrainGalleryItemRecord = (item as any)?.value ?? (item as SocialGrainGalleryItemRecord);
     if (typeof value?.gallery === 'string') return value.gallery;
-    // Some variants might use a nested key
-    if (typeof value?.galleryUri === 'string') return value.galleryUri;
-    return null;
-  }
-
-  // Extract image from gallery item
-  private extractImageFromItem(item: GrainGalleryItem): { alt?: string; url: string; caption?: string } | null {
-    const value = item.value;
-    
-    // Try different image fields
-    const imageFields = ['image', 'photo', 'media'];
-    
-    for (const field of imageFields) {
-      const imageData = value[field];
-      if (imageData && (imageData.url || imageData.src)) {
-        return {
-          alt: imageData.alt || imageData.caption || value.caption,
-          url: imageData.url || imageData.src,
-          caption: imageData.caption || value.caption
-        };
-      }
-    }
-    
     return null;
   }
 
   // Build processed galleries using the authoritative gallery records and item mappings
   private buildProcessedGalleries(
-    galleries: AtprotoRecord[],
-    items: AtprotoRecord[],
-    photosByUri: Map<string, AtprotoRecord>,
-    exifByPhotoUri: Map<string, any>
+    galleries: Array<{ uri: string; value: SocialGrainGalleryRecord; indexedAt: string; collection: string }>,
+    items: Array<{ uri: string; value: SocialGrainGalleryItemRecord }>,
+    photosByUri: Map<string, { uri: string; value: SocialGrainPhotoRecord }>,
+    exifByPhotoUri: Map<string, SocialGrainPhotoExifRecord>
   ): ProcessedGrainGallery[] {
     // Index items by gallery URI
-    const itemsByGallery = new Map<string, AtprotoRecord[]>();
+    const itemsByGallery = new Map<string, Array<{ uri: string; value: SocialGrainGalleryItemRecord }>>();
     for (const item of items) {
       const galleryUri = this.extractGalleryUriFromItem(item);
       if (!galleryUri) continue;
···
       const galleryItems = itemsByGallery.get(galleryUri) ?? [];
       // Sort by position if available
       galleryItems.sort((a, b) => {
-        const pa = Number(a.value?.position ?? 0);
-        const pb = Number(b.value?.position ?? 0);
+        const pa = Number(a.value.position ?? 0);
+        const pb = Number(b.value.position ?? 0);
         return pa - pb;
       });
 
       const images: Array<{ alt?: string; url: string; caption?: string; exif?: any }> = [];
       for (const item of galleryItems) {
-        const photoUri = typeof item.value?.item === 'string' ? item.value.item : null;
+        const photoUri = item.value.item;
         if (!photoUri) continue;
         const photo = photosByUri.get(photoUri);
         if (!photo) continue;
 
         // Extract blob CID
-        const cid = extractCidFromBlobRef(photo.value?.photo?.ref ?? photo.value?.photo);
+        const cid = extractCidFromBlobRef((photo.value as any)?.photo?.ref ?? (photo.value as any)?.photo);
         if (!cid || !did) continue;
         const url = blobCdnUrl(did, cid);
 
         const exif = exifByPhotoUri.get(photoUri);
         images.push({
           url,
-          alt: photo.value?.alt,
-          caption: photo.value?.caption,
-          exif: exif ? {
-            make: exif.make,
-            model: exif.model,
-            lensMake: exif.lensMake,
-            lensModel: exif.lensModel,
-            iSO: exif.iSO,
-            fNumber: exif.fNumber,
-            exposureTime: exif.exposureTime,
-            focalLengthIn35mmFormat: exif.focalLengthIn35mmFormat,
-            dateTimeOriginal: exif.dateTimeOriginal,
-          } : undefined,
+          alt: photo.value.alt,
+          caption: (photo.value as any).caption,
+          exif: exif
+            ? {
+                make: exif.make,
+                model: exif.model,
+                lensMake: exif.lensMake,
+                lensModel: exif.lensModel,
+                iSO: exif.iSO,
+                fNumber: exif.fNumber,
+                exposureTime: exif.exposureTime,
+                focalLengthIn35mmFormat: exif.focalLengthIn35mmFormat,
+                dateTimeOriginal: exif.dateTimeOriginal,
+              }
+            : undefined,
         });
       }
 
       processed.push({
         id: galleryUri,
-        title: gallery.value?.title || 'Untitled Gallery',
-        description: gallery.value?.description,
-        createdAt: gallery.value?.createdAt || gallery.indexedAt,
+        title: gallery.value.title || 'Untitled Gallery',
+        description: gallery.value.description,
+        createdAt: gallery.value.createdAt || gallery.indexedAt,
         images,
         itemCount: galleryItems.length,
         collections: [gallery.collection],
···
     return processed;
   }
 
-  // Process gallery into display format
-  private processGalleryForDisplay(gallery: GrainGallery): ProcessedGrainGallery {
-    const images: Array<{ alt?: string; url: string; caption?: string }> = [];
-    
-    // Extract images from all items
-    for (const item of gallery.items) {
-      const image = this.extractImageFromItem(item);
-      if (image) {
-        images.push(image);
-      }
-    }
-    
-    return {
-      id: gallery.id,
-      title: gallery.title,
-      description: gallery.description,
-      createdAt: gallery.createdAt,
-      images,
-      itemCount: gallery.items.length,
-      collections: gallery.collections
-    };
-  }
-
   // Fetch galleries with items, photos, and exif metadata
   async getGalleries(identifier: string): Promise<ProcessedGrainGallery[]> {
     try {
···
         this.browser.getAllCollectionRecords(identifier, 'social.grain.photo.exif', 5000),
       ]);
 
-      // Build maps for fast lookup
-      const photosByUri = new Map<string, AtprotoRecord>();
+      // Type and build maps for fast lookup
+      const typedGalleries = galleryRecords.map(r => ({
+        uri: r.uri,
+        value: r.value as SocialGrainGalleryRecord,
+        indexedAt: r.indexedAt,
+        collection: r.collection,
+      }));
+
+      const typedItems = itemRecords.map(r => ({
+        uri: r.uri,
+        value: r.value as SocialGrainGalleryItemRecord,
+      }));
+
+      const photosByUri = new Map<string, { uri: string; value: SocialGrainPhotoRecord }>();
       for (const p of photoRecords) {
-        photosByUri.set(p.uri, p);
+        photosByUri.set(p.uri, { uri: p.uri, value: p.value as SocialGrainPhotoRecord });
       }
-      const exifByPhotoUri = new Map<string, any>();
+
+      const exifByPhotoUri = new Map<string, SocialGrainPhotoExifRecord>();
       for (const e of exifRecords) {
-        const photoUri = typeof e.value?.photo === 'string' ? e.value.photo : undefined;
-        if (photoUri) exifByPhotoUri.set(photoUri, e.value);
+        const ev = e.value as SocialGrainPhotoExifRecord;
+        const photoUri = ev.photo;
+        if (photoUri) exifByPhotoUri.set(photoUri, ev);
       }
 
       const processed = this.buildProcessedGalleries(
-        galleryRecords,
-        itemRecords,
+        typedGalleries,
+        typedItems,
         photosByUri,
         exifByPhotoUri,
       );
···
     }
   }
 
-  // Get gallery items for a specific gallery
-  async getGalleryItemsForGallery(identifier: string, galleryId: string): Promise<GrainGalleryItem[]> {
-    try {
-      const items = await this.getGalleryItems(identifier);
-      return items.filter(item => this.extractGalleryId(item) === galleryId);
-    } catch (error) {
-      console.error('Error getting gallery items:', error);
-      return [];
-    }
-  }
 } 

src/pages/blog.astro

···
+---
+import Layout from '../layouts/Layout.astro';
+import { AtprotoBrowser } from '../lib/atproto/atproto-browser';
+import { loadConfig } from '../lib/config/site';
+import type { ComWhtwndBlogEntryRecord } from '../lib/generated/com-whtwnd-blog-entry';
+
+const config = loadConfig();
+const browser = new AtprotoBrowser();
+
+// Fetch Whitewind blog posts from the repo using generated types
+let posts: Array<{
+  uri: string;
+  record: ComWhtwndBlogEntryRecord;
+  createdAt: string;
+}> = [];
+
+try {
+  const records = await browser.getAllCollectionRecords(config.atproto.handle, 'com.whtwnd.blog.entry', 2000);
+  posts = records
+    .filter((r: any) => r.value?.$type === 'com.whtwnd.blog.entry')
+    .map((r: any) => {
+      const record = r.value as ComWhtwndBlogEntryRecord;
+      const createdAt = (record as any).createdAt || r.indexedAt;
+      return {
+        uri: r.uri,
+        record,
+        createdAt,
+      };
+    });
+  posts.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+} catch (e) {
+  console.error('Error loading whitewind posts', e);
+}
+
+function excerpt(text: string, maxChars = 240) {
+  let t = text
+    .replace(/!\[[^\]]*\]\([^\)]+\)/g, ' ')
+    .replace(/\[[^\]]+\]\(([^\)]+)\)/g, '$1')
+    .replace(/`{3}[\s\S]*?`{3}/g, ' ')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/[*_]{1,3}([^*_]+)[*_]{1,3}/g, '$1');
+  t = t.replace(/\s+/g, ' ').trim();
+  if (t.length <= maxChars) return t;
+  return t.slice(0, maxChars).trimEnd() + '…';
+}
+
+function postPathFromUri(uri: string) {
+  // at://did/.../<collection>/<rkey>
+  const parts = uri.split('/');
+  const rkey = parts[parts.length - 1];
+  return `/blog/${rkey}`;
+}
+---
+
+<Layout title="Blog">
+  <div class="container mx-auto px-4 py-8">
+    <header class="text-center mb-12">
+      <h1 class="text-4xl font-bold text-gray-900 dark:text-white mb-4">Blog</h1>
+      <p class="text-xl text-gray-600 dark:text-gray-400 max-w-2xl mx-auto">Writing powered by the Whitewind lexicon</p>
+    </header>
+
+    <main class="max-w-3xl mx-auto">
+      {posts.length === 0 ? (
+        <div class="text-center text-gray-500 dark:text-gray-400 py-16">No posts yet.</div>
+      ) : (
+        <div class="space-y-8">
+          {posts.map((p) => (
+            <article class="bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-200 dark:border-gray-700 p-6">
+              <h2 class="text-2xl font-bold text-gray-900 dark:text-white mb-2">
+                <a href={postPathFromUri(p.uri)} class="hover:underline">
+                  {p.record.title || 'Untitled'}
+                </a>
+              </h2>
+              <div class="text-sm text-gray-500 dark:text-gray-400 mb-3">
+                {(() => {
+                  const d = new Date(p.createdAt);
+                  return isNaN(d.getTime()) ? '' : d.toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+                })()}
+              </div>
+              <p class="text-gray-700 dark:text-gray-300">{excerpt(p.record.content || '')}</p>
+            </article>
+          ))}
+        </div>
+      )}
+    </main>
+  </div>
+</Layout>
+

src/pages/blog/[rkey].astro

···
+---
+import Layout from '../../layouts/Layout.astro';
+import { AtprotoBrowser } from '../../lib/atproto/atproto-browser';
+import { loadConfig } from '../../lib/config/site';
+import WhitewindBlogPost from '../../components/content/WhitewindBlogPost.astro';
+
+export async function getStaticPaths() {
+  const config = loadConfig();
+  const browser = new AtprotoBrowser();
+  const paths: Array<{ params: { rkey: string } }> = [];
+  try {
+    const records = await browser.getAllCollectionRecords(config.atproto.handle, 'com.whtwnd.blog.entry', 2000);
+    for (const rec of records) {
+      if (rec.value?.$type === 'com.whtwnd.blog.entry') {
+        const rkey = rec.uri.split('/').pop();
+        if (rkey) paths.push({ params: { rkey } });
+      }
+    }
+  } catch (e) {
+    console.error('getStaticPaths whitewind', e);
+  }
+  return paths;
+}
+
+const { rkey } = Astro.params as Record<string, string>;
+
+const config = loadConfig();
+const browser = new AtprotoBrowser();
+
+let record: any = null;
+let title = 'Post';
+
+try {
+  const did = config.atproto.did || (await browser.resolveHandle(config.atproto.handle));
+  if (did) {
+    const uri = `at://${did}/com.whtwnd.blog.entry/${rkey}`;
+    const rec = await browser.getRecord(uri);
+    if (rec && rec.value?.$type === 'com.whtwnd.blog.entry') {
+      record = rec.value;
+      title = record.title || title;
+    }
+  }
+} catch (e) {
+  console.error('Error loading whitewind post', e);
+}
+---
+
+<Layout title={title}>
+  <div class="container mx-auto px-4 py-8">
+    {record ? (
+      <div class="max-w-3xl mx-auto">
+        <WhitewindBlogPost record={record} showTags={true} showTimestamp={true} />
+      </div>
+    ) : (
+      <div class="text-center text-gray-500 dark:text-gray-400 py-16">Post not found.</div>
+    )}
+  </div>
+</Layout>
+

src/pages/index.astro

···
 ---
 import Layout from '../layouts/Layout.astro';
 import ContentFeed from '../components/content/ContentFeed.astro';
+import StatusUpdate from '../components/content/StatusUpdate.astro';
 import { loadConfig } from '../lib/config/site';
 
 const config = loadConfig();
···
     </header>
 
     <main>
+      <section class="mb-8">
+        <h2 class="text-2xl font-semibold text-gray-900 dark:text-white mb-4">
+          Current Status
+        </h2>
+        <StatusUpdate />
+      </section>
+      
       <section class="mb-8">
         <h2 class="text-2xl font-semibold text-gray-900 dark:text-white mb-4">
           Latest Posts

src/pages/now.astro

···
+---
+import Layout from '../layouts/Layout.astro';
+---
+
+<Layout title="Now">
+    <div class="flex flex-col items-center h-screen">
+        <h1 class="text-2xl font-bold">Now</h1>
+        <p>This is the now page.</p>
+    </div>
+</Layout>