Multiple endpoint fixes

docker-compose.yml

···
       - OAUTH_KEYSET_PATH=/app/oauth-keyset.json
       - ADMIN_DIDS=did:plc:abc123xyz,admin.bsky.social,did:plc:def456uvw
       - OSPREY_ENABLED=${OSPREY_ENABLED:-false}
+      - ENHANCED_HYDRATION_ENABLED=true
     depends_on:
       redis:
         condition: service_healthy

package.json

···
   "type": "module",
   "license": "MIT",
   "scripts": {
-    "dev": "NODE_ENV=development tsx server/index.ts",
+    "dev": "./start-with-redis.sh",
     "build": "vite build && esbuild server/index.ts --platform=node --packages=external --bundle --format=esm --outdir=dist",
     "start": "npm run build && NODE_ENV=production node dist/index.js",
     "check": "tsc",

scripts/setup-oauth-keys.sh

···
+#!/bin/bash
+
+set -e
+
+echo "🔐 OAuth Keyset Generator for AT Protocol AppView"
+echo "=================================================="
+echo ""
+echo "This script generates OAuth signing keys for production use."
+echo "Keys will be stored in oauth-keyset.json"
+echo ""
+
+# Check for required dependencies
+MISSING_DEPS=()
+for cmd in openssl xxd jq; do
+  if ! command -v $cmd &> /dev/null; then
+    MISSING_DEPS+=($cmd)
+  fi
+done
+
+if [ ${#MISSING_DEPS[@]} -ne 0 ]; then
+  echo "❌ Missing required dependencies: ${MISSING_DEPS[*]}"
+  echo ""
+  echo "Please install them:"
+  echo "  Ubuntu/Debian: sudo apt-get install openssl xxd jq"
+  echo "  RHEL/CentOS:   sudo yum install openssl vim-common jq"
+  echo "  macOS:         brew install jq"
+  echo ""
+  exit 1
+fi
+
+
+if [ -f oauth-keyset.json ]; then
+  echo "⚠️  oauth-keyset.json already exists!"
+  read -p "Overwrite existing keys? (yes/no): " -r
+  if [[ ! $REPLY =~ ^[Yy][Ee][Ss]$ ]]; then
+    echo "❌ Cancelled. Existing keys preserved."
+    exit 1
+  fi
+fi
+
+# Generate a unique Key ID (kid) - e.g., timestamp + random hex
+KID="$(date +%s)-$(openssl rand -hex 4)"
+echo "🔐 Generated Key ID (kid): ${KID}"
+echo ""
+
+echo "🔑 Generating ES256 key pair for OAuth..."
+
+# Generate ES256 (P-256) private key
+openssl ecparam -name prime256v1 -genkey -noout -out oauth-private.pem 2>/dev/null
+
+# Extract public key
+openssl ec -in oauth-private.pem -pubout -out oauth-public.pem 2>/dev/null
+
+# Convert private key to PKCS8 format for easier handling
+openssl pkcs8 -topk8 -nocrypt -in oauth-private.pem -out oauth-private-pkcs8.pem 2>/dev/null
+
+# Read the keys (use PKCS8 format for private key)
+PRIVATE_KEY=$(cat oauth-private-pkcs8.pem)
+PUBLIC_KEY=$(cat oauth-public.pem)
+
+# Extract private key components for JWK format
+PRIVATE_D=$(openssl ec -in oauth-private.pem -text -noout 2>/dev/null | grep -A 3 'priv:' | tail -n +2 | tr -d ' \n:' | xxd -r -p | base64 | tr '+/' '-_' | tr -d '=')
+
+# Extract public key coordinates (x, y) from the public key
+PUBLIC_KEY_HEX=$(openssl ec -in oauth-private.pem -pubout -text -noout 2>/dev/null | grep -A 5 'pub:' | tail -n +2 | tr -d ' \n:')
+
+# Extract X and Y coordinates (each 32 bytes / 64 hex chars after the 04 prefix)
+X_HEX=$(echo $PUBLIC_KEY_HEX | cut -c 3-66)
+Y_HEX=$(echo $PUBLIC_KEY_HEX | cut -c 67-130)
+
+# Convert to base64url
+X_B64=$(echo $X_HEX | xxd -r -p | base64 | tr '+/' '-_' | tr -d '=')
+Y_B64=$(echo $Y_HEX | xxd -r -p | base64 | tr '+/' '-_' | tr -d '=')
+
+# Create OAuth keyset JSON file with both PEM and JWK formats
+cat > oauth-keyset.json << EOF
+{
+  "kid": "${KID}",
+  "privateKeyPem": $(echo "$PRIVATE_KEY" | jq -Rs .),
+  "publicKeyPem": $(echo "$PUBLIC_KEY" | jq -Rs .),
+  "jwk": {
+    "kid": "${KID}",
+    "kty": "EC",
+    "crv": "P-256",
+    "x": "${X_B64}",
+    "y": "${Y_B64}",
+    "d": "${PRIVATE_D}",
+    "alg": "ES256",
+    "use": "sig"
+  }
+}
+EOF
+
+echo ""
+echo "✅ OAuth keys generated successfully!"
+echo ""
+echo "📁 Files created:"
+echo "  - oauth-keyset.json (KEEP SECRET! Add to .gitignore)"
+echo "  - oauth-private.pem (KEEP SECRET! Add to .gitignore)"
+echo "  - oauth-public.pem (public key - safe to share)"
+echo ""
+echo "🔒 Security checklist:"
+echo ""
+echo "1. Add to .gitignore (if not already added):"
+echo "   echo 'oauth-keyset.json' >> .gitignore"
+echo "   echo 'oauth-private.pem' >> .gitignore"
+echo ""
+echo "2. Set environment variable for production:"
+echo "   export OAUTH_KEYSET_PATH=/path/to/oauth-keyset.json"
+echo "   Or add to your .env file:"
+echo "   OAUTH_KEYSET_PATH=/app/oauth-keyset.json"
+echo ""
+echo "3. Secure file permissions (on VPS):"
+echo "   chmod 600 oauth-keyset.json oauth-private.pem"
+echo "   chown appuser:appuser oauth-keyset.json oauth-private.pem"
+echo ""
+echo "4. For Docker deployment, mount as a volume:"
+echo "   volumes:"
+echo "     - ./oauth-keyset.json:/app/oauth-keyset.json:ro"
+echo ""
+echo "⚠️  NEVER commit these files to git!"
+echo "⚠️  Store backups securely - losing these keys will invalidate all OAuth sessions!"
+echo ""

server/routes.ts

···
   app.get("/xrpc/app.bsky.unspecced.getPostThreadOtherV2", xrpcApi.getPostThreadOtherV2.bind(xrpcApi));
   app.get("/xrpc/app.bsky.unspecced.getSuggestedUsers", xrpcApi.getSuggestedUsersUnspecced.bind(xrpcApi));
   app.get("/xrpc/app.bsky.unspecced.getSuggestedFeeds", xrpcApi.getSuggestedFeedsUnspecced.bind(xrpcApi));
+  app.get("/xrpc/app.bsky.unspecced.getPopularFeedGenerators", xrpcApi.getPopularFeedGenerators.bind(xrpcApi));
   app.get("/xrpc/app.bsky.unspecced.getOnboardingSuggestedStarterPacks", xrpcApi.getOnboardingSuggestedStarterPacks.bind(xrpcApi));
   app.get("/xrpc/app.bsky.unspecced.getTaggedSuggestions", xrpcApi.getTaggedSuggestions.bind(xrpcApi));
   app.get("/xrpc/app.bsky.unspecced.getTrendingTopics", xrpcApi.getTrendingTopics.bind(xrpcApi));

server/services/event-processor.ts

···
 import { pdsDataFetcher } from "./pds-data-fetcher";
 import { smartConsole } from "./console-wrapper";
 import { logAggregator } from "./log-aggregator";
-import type { InsertUser, InsertPost, InsertLike, InsertRepost, InsertFollow, InsertBlock, InsertList, InsertListItem, InsertFeedGenerator, InsertStarterPack, InsertLabelerService, InsertFeedItem } from "@shared/schema";
+import type { InsertUser, InsertPost, InsertLike, InsertRepost, InsertFollow, InsertBlock, InsertList, InsertListItem, InsertFeedGenerator, InsertStarterPack, InsertLabelerService, InsertFeedItem, InsertQuote, InsertVerification } from "@shared/schema";
 
 function sanitizeText(text: string | undefined | null): string | undefined {
   if (!text) return undefined;
···
             case "com.atproto.label.label":
               await this.processLabel(uri, repo, record);
               break;
+            case "app.bsky.graph.verification":
+              await this.processVerification(uri, cid, repo, record);
+              break;
           }
         } else if (action === "delete") {
           await this.processDelete(uri, collection);
···
       }
     } catch (error) {
         smartConsole.error(`[NOTIFICATION] Error creating mention notifications:`, error);
+    }
+    
+    // Handle quote posts (embed.record or embed.recordWithMedia)
+    try {
+      let quotedUri: string | null = null;
+      let quotedCid: string | null = null;
+      
+      if (record.embed?.$type === 'app.bsky.embed.record') {
+        quotedUri = record.embed.record.uri;
+        quotedCid = record.embed.record.cid;
+      } else if (record.embed?.$type === 'app.bsky.embed.recordWithMedia') {
+        quotedUri = record.embed.record.record.uri;
+        quotedCid = record.embed.record.record.cid;
+      }
+      
+      if (quotedUri) {
+        await this.storage.createQuote({
+          uri: `${uri}#quote`,
+          cid,
+          postUri: uri,
+          quotedUri,
+          quotedCid: quotedCid || undefined,
+          createdAt: this.safeDate(record.createdAt),
+        });
+        
+        // Increment quoted post's quote count
+        await this.storage.incrementPostAggregation(quotedUri, 'quoteCount', 1);
+        
+        // Create notification for quote
+        const quotedPost = await this.storage.getPost(quotedUri);
+        if (quotedPost && quotedPost.authorDid !== authorDid) {
+          await this.storage.createNotification({
+            uri: `at://${uri.replace('at://', '')}#notification/quote`,
+            recipientDid: quotedPost.authorDid,
+            authorDid,
+            reason: 'quote',
+            reasonSubject: uri,
+            cid: cid,
+            isRead: false,
+            createdAt: new Date(record.createdAt),
+          });
+        }
+      }
+    } catch (error) {
+      smartConsole.error(`[QUOTE] Error processing quote:`, error);
     }
     
     // Flush any pending operations for this post
···
 
     await this.storage.createLabelerService(labelerService);
     smartConsole.log(`[LABELER_SERVICE] Processed labeler service ${uri} for ${creatorDid}`);
+  }
+
+  private async processVerification(uri: string, cid: string, creatorDid: string, record: any) {
+    const creatorReady = await this.ensureUser(creatorDid);
+    if (!creatorReady) {
+      smartConsole.warn(`[EVENT_PROCESSOR] Skipping verification ${uri} - creator not ready`);
+      return;
+    }
+    
+    // Check if data collection is forbidden for this user
+    if (await this.isDataCollectionForbidden(creatorDid)) {
+      return;
+    }
+
+    const verification: InsertVerification = {
+      uri,
+      cid,
+      subjectDid: record.subject || creatorDid,
+      handle: record.handle || '',
+      verifiedAt: this.safeDate(record.verifiedAt),
+      createdAt: this.safeDate(record.createdAt),
+    };
+
+    await this.storage.createVerification(verification);
+    smartConsole.log(`[VERIFICATION] Processed verification ${uri} for ${verification.subjectDid}`);
   }
 
   // Guard against invalid or missing dates in upstream records

server/services/hydration/README.md

···
+# Enhanced Hydration Service
+
+A lightweight, production-ready hydration service for the AT Protocol AppView, implementing Bluesky's hydration patterns with Redis caching.
+
+## Architecture
+
+The hydration service consists of four main components:
+
+### 1. ViewerContext Builder (`viewer-context.ts`)
+Builds comprehensive viewer context including all relationships and preferences:
+- Following/followers relationships
+- Blocking/blocked relationships
+- Muting relationships
+- Thread mutes
+- User preferences
+- Actor viewer states (with URIs for follows, blocks)
+- Post viewer states (likes, reposts, bookmarks)
+
+### 2. Embed Resolver (`embed-resolver.ts`)
+Resolves embeds recursively with circular reference protection:
+- Maximum depth: 3 levels
+- Supports: images, videos, external links, quote posts, record embeds
+- Circular reference detection using visited URIs
+- In-memory caching for performance
+
+### 3. Label Propagator (`label-propagator.ts`)
+Centralized moderation and label handling:
+- Fetches labels for posts and actors
+- Propagates actor labels to their content
+- Takedown detection
+- Content filtering based on labels and viewer preferences
+- Handles: spam, NSFW, adult content, takedowns
+
+### 4. Redis Caching Layer (`cache.ts`)
+Lightweight caching wrapper around existing CacheService:
+- 5-minute TTL by default
+- Post, actor, and viewer context caching
+- Batch operations (mget, mset)
+- Cache invalidation
+
+## Main Hydration Service (`index.ts`)
+
+### Core Methods
+
+#### `hydratePosts(postUris: string[], viewerDid?: string)`
+Hydrates posts with full context:
+- Post data (text, embed, reply structure)
+- Author profiles
+- Aggregations (like, repost, quote counts)
+- Viewer states (liked, reposted, bookmarked)
+- Actor viewer states (following, blocking, muting)
+- Resolved embeds (recursive, 3 levels deep)
+- Labels (propagated from actors)
+
+**Returns:** `HydrationState` with all maps populated
+
+#### `hydrateActors(actorDids: string[], viewerDid?: string)`
+Hydrates actors with viewer relationships:
+- Actor profiles
+- Viewer states (following, blocked, muted)
+- Labels
+
+**Returns:** `HydrationState` with actor data
+
+#### `hydratePostsCached(postUris: string[], viewerDid?: string)`
+Cached version of `hydratePosts`:
+- Checks Redis cache first
+- Only fetches uncached posts
+- Merges cached and fresh data
+- Caches new data (5 min TTL)
+
+## Usage Examples
+
+### Basic Post Hydration
+
+```typescript
+import { enhancedHydrator } from './services/hydration';
+
+// In an XRPC handler
+async getTimeline(req: Request, res: Response) {
+  const userDid = await this.getAuthenticatedDid(req);
+  const postUris = [...]; // Get post URIs from feed
+
+  // Hydrate posts with viewer context
+  const state = await enhancedHydrator.hydratePosts(postUris, userDid);
+
+  // Build response using hydrated data
+  const posts = postUris.map(uri => {
+    const post = state.posts.get(uri);
+    const actor = state.actors.get(post.authorDid);
+    const agg = state.aggregations.get(uri);
+    const viewerState = state.viewerStates.get(uri);
+    const actorViewerState = state.actorViewerStates.get(post.authorDid);
+    const embed = state.embeds.get(uri);
+    const labels = state.labels.get(uri) || [];
+
+    return {
+      uri: post.uri,
+      cid: post.cid,
+      author: {
+        did: actor.did,
+        handle: actor.handle,
+        displayName: actor.displayName,
+        viewer: actorViewerState
+      },
+      record: {
+        text: post.text,
+        embed: post.embed
+      },
+      embed: embed, // Resolved embed
+      likeCount: agg?.likeCount || 0,
+      repostCount: agg?.repostCount || 0,
+      quoteCount: agg?.quoteCount || 0,
+      viewer: {
+        like: viewerState?.likeUri,
+        repost: viewerState?.repostUri,
+        bookmarked: viewerState?.bookmarked
+      },
+      labels: labels
+    };
+  });
+
+  res.json({ feed: posts });
+}
+```
+
+### Cached Post Hydration
+
+```typescript
+// Currently performs full hydration to ensure complete state
+// Future optimization: implement full HydrationState caching
+const state = await enhancedHydrator.hydratePostsCached(postUris, userDid);
+```
+
+**Note**: The cached version currently performs full hydration to ensure all maps (actors, aggregations, viewer states, etc.) are properly populated. Future optimization will cache the complete HydrationState.
+
+### Actor Hydration
+
+```typescript
+async getProfiles(req: Request, res: Response) {
+  const viewerDid = await this.getAuthenticatedDid(req);
+  const actorDids = req.query.actors as string[];
+
+  const state = await enhancedHydrator.hydrateActors(actorDids, viewerDid);
+
+  const profiles = actorDids.map(did => {
+    const actor = state.actors.get(did);
+    const viewerState = state.actorViewerStates.get(did);
+    const labels = state.labels.get(did) || [];
+
+    return {
+      did: actor.did,
+      handle: actor.handle,
+      displayName: actor.displayName,
+      description: actor.description,
+      avatar: actor.avatarUrl,
+      viewer: viewerState,
+      labels: labels
+    };
+  });
+
+  res.json({ profiles });
+}
+```
+
+### Content Filtering
+
+```typescript
+import { LabelPropagator } from './services/hydration';
+
+const labelPropagator = new LabelPropagator();
+
+// Filter content based on labels
+const allowedUris = await labelPropagator.filterContent(
+  postUris,
+  viewerContext?.preferences
+);
+
+// Only return allowed content
+const filteredPosts = posts.filter(p => allowedUris.has(p.uri));
+```
+
+## HydrationState Interface
+
+```typescript
+interface HydrationState {
+  posts: Map<string, any>;              // Post data by URI
+  actors: Map<string, any>;             // Actor data by DID
+  aggregations: Map<string, any>;       // Post aggregations by URI
+  viewerStates: Map<string, any>;       // Post viewer states by URI
+  actorViewerStates: Map<string, any>;  // Actor viewer states by DID
+  embeds: Map<string, any>;             // Resolved embeds by URI
+  labels: Map<string, Label[]>;         // Labels by subject URI/DID
+  viewerContext?: ViewerContext;        // Full viewer context
+}
+```
+
+## Performance Characteristics
+
+- **Batched Queries**: Single query per data type (posts, actors, aggregations)
+- **Parallel Fetching**: All data types fetched concurrently
+- **Redis Caching**: 5-minute TTL reduces database load
+- **Embed Caching**: In-memory cache for embed resolution
+- **Circular Protection**: Prevents infinite loops in embed resolution
+- **Label Propagation**: Efficient actor-to-content label inheritance
+
+## Migration Guide
+
+### From Old Hydrator
+
+```typescript
+// Old way (basic)
+const hydrator = new Hydrator();
+const state = await hydrator.hydrateFeedItems(items, viewerDid);
+
+// New way (enhanced)
+import { enhancedHydrator } from './services/hydration';
+const postUris = items.map(i => i.post.uri);
+const state = await enhancedHydrator.hydratePosts(postUris, viewerDid);
+```
+
+### Benefits of Enhanced Hydrator
+
+1. **Richer Viewer Context**: Full relationship data, not just blocks/mutes
+2. **Recursive Embeds**: 3-level deep embed resolution
+3. **Label Propagation**: Centralized moderation logic
+4. **Redis Caching**: Significant performance improvement
+5. **Actor Hydration**: Dedicated method for profile hydration
+6. **Standardized**: Follows Bluesky's hydration patterns
+
+## Implementation Status
+
+✅ **Completed:**
+- ViewerContext builder with relationships
+- Embed resolver with circular protection
+- Label propagator with takedown logic
+- Main hydration service
+- Actor hydration
+- Post hydration
+
+⚠️ **Limitations:**
+- **Caching Disabled**: The `hydratePostsCached` method currently performs full hydration on every call. While a Redis caching layer exists, proper HydrationState snapshot caching is not yet implemented to avoid incomplete state bugs.
+- **Embed Resolution**: Basic embed structure is resolved, but full record views for quotes/embeds matching the Bluesky spec require additional work.
+
+📋 **Next Steps (Optional):**
+- Implement proper HydrationState caching (cache complete state snapshots)
+- Enhance embed resolver to build full record views for quotes
+- Integrate into all XRPC handlers
+- Add metrics/monitoring
+- Performance benchmarking
+- Cache invalidation on mutations

server/services/hydration/cache.ts

···
+import { CacheService } from '../cache';
+
+export class HydrationCache {
+  private readonly TTL = 300; // 5 minutes
+  private cache: CacheService;
+
+  constructor() {
+    this.cache = new CacheService({ ttl: this.TTL, keyPrefix: 'hydration:' });
+  }
+
+  /**
+   * Get cached hydration data
+   */
+  async get<T>(key: string): Promise<T | null> {
+    return await this.cache.get<T>(key);
+  }
+
+  /**
+   * Set cached hydration data
+   */
+  async set(key: string, value: any, ttl: number = this.TTL): Promise<void> {
+    await this.cache.set(key, value, ttl);
+  }
+
+  /**
+   * Get multiple cached values (not supported by current cache, fetch individually)
+   */
+  async mget<T>(keys: string[]): Promise<Map<string, T>> {
+    const result = new Map<string, T>();
+    
+    for (const key of keys) {
+      const value = await this.get<T>(key);
+      if (value) {
+        result.set(key, value);
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Set multiple cached values
+   */
+  async mset(entries: Map<string, any>, ttl: number = this.TTL): Promise<void> {
+    for (const [key, value] of Array.from(entries.entries())) {
+      await this.set(key, value, ttl);
+    }
+  }
+
+  /**
+   * Invalidate cached data
+   */
+  async invalidate(key: string): Promise<void> {
+    await this.cache.del(key);
+  }
+
+  /**
+   * Invalidate multiple keys
+   */
+  async invalidateMany(keys: string[]): Promise<void> {
+    for (const key of keys) {
+      await this.invalidate(key);
+    }
+  }
+
+  /**
+   * Build cache key for posts
+   */
+  postKey(uri: string): string {
+    return `post:${uri}`;
+  }
+
+  /**
+   * Build cache key for actor
+   */
+  actorKey(did: string): string {
+    return `actor:${did}`;
+  }
+
+  /**
+   * Build cache key for viewer context
+   */
+  viewerContextKey(did: string): string {
+    return `viewer:${did}`;
+  }
+
+  /**
+   * Build cache key for labels
+   */
+  labelsKey(uri: string): string {
+    return `labels:${uri}`;
+  }
+}

server/services/hydration/embed-resolver.ts

···
+import { db } from '../../db';
+import { posts, users } from '../../../shared/schema';
+import { eq, inArray } from 'drizzle-orm';
+
+export interface ResolvedEmbed {
+  $type: string;
+  [key: string]: any;
+}
+
+export class EmbedResolver {
+  private readonly MAX_DEPTH = 3;
+  private cache = new Map<string, ResolvedEmbed | null>();
+
+  /**
+   * Resolve embeds recursively up to MAX_DEPTH levels
+   * Handles circular reference detection
+   */
+  async resolveEmbeds(
+    postUris: string[],
+    depth = 0,
+    visited = new Set<string>()
+  ): Promise<Map<string, ResolvedEmbed | null>> {
+    if (depth >= this.MAX_DEPTH || postUris.length === 0) {
+      return new Map();
+    }
+
+    // Filter out already visited URIs (circular reference protection)
+    const newUris = postUris.filter(uri => !visited.has(uri));
+    if (newUris.length === 0) {
+      return new Map();
+    }
+
+    // Mark all URIs as visited
+    newUris.forEach(uri => visited.add(uri));
+
+    // Check cache first
+    const uncachedUris = newUris.filter(uri => !this.cache.has(uri));
+    
+    if (uncachedUris.length === 0) {
+      const result = new Map();
+      newUris.forEach(uri => {
+        result.set(uri, this.cache.get(uri) || null);
+      });
+      return result;
+    }
+
+    // Fetch posts with embeds
+    const postsData = await db
+      .select()
+      .from(posts)
+      .where(inArray(posts.uri, uncachedUris));
+
+    const result = new Map<string, ResolvedEmbed | null>();
+    const childUris: string[] = [];
+
+    for (const post of postsData) {
+      if (!post.embed) {
+        result.set(post.uri, null);
+        this.cache.set(post.uri, null);
+        continue;
+      }
+
+      const embed = post.embed as any;
+      let resolved: ResolvedEmbed | null = null;
+
+      // Handle different embed types
+      if (embed.$type === 'app.bsky.embed.record') {
+        // Quote post or record embed
+        const recordUri = embed.record?.uri;
+        if (recordUri) {
+          childUris.push(recordUri);
+          resolved = {
+            $type: 'app.bsky.embed.record#view',
+            record: { uri: recordUri } // Will be hydrated recursively
+          };
+        }
+      } else if (embed.$type === 'app.bsky.embed.recordWithMedia') {
+        // Quote with media
+        const recordUri = embed.record?.record?.uri;
+        if (recordUri) {
+          childUris.push(recordUri);
+        }
+        resolved = {
+          $type: 'app.bsky.embed.recordWithMedia#view',
+          record: recordUri ? { uri: recordUri } : undefined,
+          media: this.resolveMediaEmbed(embed.media)
+        };
+      } else if (embed.$type === 'app.bsky.embed.images') {
+        // Images
+        resolved = this.resolveImagesEmbed(embed);
+      } else if (embed.$type === 'app.bsky.embed.external') {
+        // External link
+        resolved = this.resolveExternalEmbed(embed);
+      } else if (embed.$type === 'app.bsky.embed.video') {
+        // Video
+        resolved = this.resolveVideoEmbed(embed);
+      }
+
+      result.set(post.uri, resolved);
+      this.cache.set(post.uri, resolved);
+    }
+
+    // Recursively resolve child embeds
+    if (childUris.length > 0 && depth < this.MAX_DEPTH - 1) {
+      const childEmbeds = await this.resolveEmbeds(childUris, depth + 1, visited);
+      
+      // Update parent embeds with resolved children
+      for (const [uri, embed] of Array.from(result.entries())) {
+        if (embed && embed.$type === 'app.bsky.embed.record#view') {
+          const recordUri = embed.record?.uri;
+          if (recordUri && childEmbeds.has(recordUri)) {
+            embed.record = childEmbeds.get(recordUri);
+          }
+        } else if (embed && embed.$type === 'app.bsky.embed.recordWithMedia#view') {
+          const recordUri = embed.record?.uri;
+          if (recordUri && childEmbeds.has(recordUri)) {
+            embed.record = childEmbeds.get(recordUri);
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  private resolveImagesEmbed(embed: any): ResolvedEmbed {
+    return {
+      $type: 'app.bsky.embed.images#view',
+      images: (embed.images || []).map((img: any) => ({
+        thumb: this.blobToCdnUrl(img.image),
+        fullsize: this.blobToCdnUrl(img.image),
+        alt: img.alt || '',
+        aspectRatio: img.aspectRatio
+      }))
+    };
+  }
+
+  private resolveExternalEmbed(embed: any): ResolvedEmbed {
+    return {
+      $type: 'app.bsky.embed.external#view',
+      external: {
+        uri: embed.external?.uri || '',
+        title: embed.external?.title || '',
+        description: embed.external?.description || '',
+        thumb: embed.external?.thumb ? this.blobToCdnUrl(embed.external.thumb) : undefined
+      }
+    };
+  }
+
+  private resolveVideoEmbed(embed: any): ResolvedEmbed {
+    return {
+      $type: 'app.bsky.embed.video#view',
+      cid: embed.video?.ref?.$link || '',
+      playlist: '', // TODO: generate video playlist URL
+      thumbnail: embed.thumbnail ? this.blobToCdnUrl(embed.thumbnail) : undefined,
+      alt: embed.alt || '',
+      aspectRatio: embed.aspectRatio
+    };
+  }
+
+  private resolveMediaEmbed(media: any): any {
+    if (!media) return undefined;
+
+    if (media.$type === 'app.bsky.embed.images') {
+      return this.resolveImagesEmbed(media);
+    } else if (media.$type === 'app.bsky.embed.external') {
+      return this.resolveExternalEmbed(media);
+    } else if (media.$type === 'app.bsky.embed.video') {
+      return this.resolveVideoEmbed(media);
+    }
+
+    return undefined;
+  }
+
+  private blobToCdnUrl(blob: any): string {
+    if (!blob || !blob.ref) return '';
+    const cid = typeof blob.ref === 'string' ? blob.ref : blob.ref.$link;
+    // TODO: Use actual CDN URL from environment
+    return `https://cdn.bsky.app/img/feed_thumbnail/plain/${cid}@jpeg`;
+  }
+
+  /**
+   * Clear the embed cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}

server/services/hydration/index.ts

···
+import { db } from '../../db';
+import { 
+  posts, 
+  users, 
+  postAggregations, 
+  postViewerStates 
+} from '../../../shared/schema';
+import { eq, inArray, sql } from 'drizzle-orm';
+import { ViewerContextBuilder, ViewerContext } from './viewer-context';
+import { EmbedResolver } from './embed-resolver';
+import { LabelPropagator, Label } from './label-propagator';
+import { HydrationCache } from './cache';
+
+export interface HydrationState {
+  posts: Map<string, any>;
+  actors: Map<string, any>;
+  aggregations: Map<string, any>;
+  viewerStates: Map<string, any>;
+  actorViewerStates: Map<string, any>;
+  embeds: Map<string, any>;
+  labels: Map<string, Label[]>;
+  viewerContext?: ViewerContext;
+}
+
+export class EnhancedHydrator {
+  private viewerBuilder = new ViewerContextBuilder();
+  private embedResolver = new EmbedResolver();
+  private labelPropagator = new LabelPropagator();
+  private cache = new HydrationCache();
+
+  /**
+   * Hydrate posts with full context including viewer states, embeds, and labels
+   */
+  async hydratePosts(
+    postUris: string[],
+    viewerDid?: string
+  ): Promise<HydrationState> {
+    if (postUris.length === 0) {
+      return this.emptyState();
+    }
+
+    // Build viewer context if authenticated
+    const viewerContext = viewerDid 
+      ? await this.viewerBuilder.build(viewerDid)
+      : undefined;
+
+    // Fetch posts
+    const postsData = await db
+      .select()
+      .from(posts)
+      .where(inArray(posts.uri, postUris));
+
+    const postsMap = new Map<string, any>();
+    const actorDids = new Set<string>();
+
+    for (const post of postsData) {
+      postsMap.set(post.uri, {
+        uri: post.uri,
+        cid: post.cid,
+        authorDid: post.authorDid,
+        text: post.text,
+        createdAt: post.createdAt.toISOString(),
+        indexedAt: post.indexedAt.toISOString(),
+        embed: post.embed,
+        reply: post.parentUri ? {
+          parent: { uri: post.parentUri },
+          root: { uri: post.rootUri || post.parentUri }
+        } : undefined,
+        tags: post.tags
+      });
+      actorDids.add(post.authorDid);
+    }
+
+    // Fetch aggregations
+    const aggregationsData = await db
+      .select()
+      .from(postAggregations)
+      .where(inArray(postAggregations.postUri, postUris));
+
+    const aggregationsMap = new Map<string, any>();
+    for (const agg of aggregationsData) {
+      aggregationsMap.set(agg.postUri, {
+        likeCount: agg.likeCount,
+        repostCount: agg.repostCount,
+        replyCount: agg.replyCount,
+        quoteCount: agg.quoteCount,
+        bookmarkCount: agg.bookmarkCount
+      });
+    }
+
+    // Fetch viewer states for posts
+    let viewerStatesMap = new Map<string, any>();
+    if (viewerDid) {
+      viewerStatesMap = await this.viewerBuilder.buildPostStates(viewerDid, postUris);
+    }
+
+    // Fetch actors
+    const actorsData = await db
+      .select()
+      .from(users)
+      .where(inArray(users.did, Array.from(actorDids)));
+
+    const actorsMap = new Map<string, any>();
+    for (const actor of actorsData) {
+      actorsMap.set(actor.did, {
+        did: actor.did,
+        handle: actor.handle,
+        displayName: actor.displayName,
+        description: actor.description,
+        avatarUrl: actor.avatarUrl,
+        indexedAt: actor.indexedAt?.toISOString()
+      });
+    }
+
+    // Fetch viewer states for actors
+    let actorViewerStatesMap = new Map<string, any>();
+    if (viewerDid) {
+      actorViewerStatesMap = await this.viewerBuilder.buildActorStates(
+        viewerDid, 
+        Array.from(actorDids)
+      );
+    }
+
+    // Resolve embeds
+    const embedsMap = await this.embedResolver.resolveEmbeds(postUris);
+
+    // Fetch labels
+    const allSubjects = [...postUris, ...Array.from(actorDids)];
+    const labelsMap = await this.labelPropagator.propagateActorLabels(
+      Array.from(actorDids),
+      postUris
+    );
+
+    return {
+      posts: postsMap,
+      actors: actorsMap,
+      aggregations: aggregationsMap,
+      viewerStates: viewerStatesMap,
+      actorViewerStates: actorViewerStatesMap,
+      embeds: embedsMap,
+      labels: labelsMap,
+      viewerContext
+    };
+  }
+
+  /**
+   * Hydrate actors with viewer states
+   */
+  async hydrateActors(
+    actorDids: string[],
+    viewerDid?: string
+  ): Promise<HydrationState> {
+    if (actorDids.length === 0) {
+      return this.emptyState();
+    }
+
+    const viewerContext = viewerDid 
+      ? await this.viewerBuilder.build(viewerDid)
+      : undefined;
+
+    // Fetch actors
+    const actorsData = await db
+      .select()
+      .from(users)
+      .where(inArray(users.did, actorDids));
+
+    const actorsMap = new Map<string, any>();
+    for (const actor of actorsData) {
+      actorsMap.set(actor.did, {
+        did: actor.did,
+        handle: actor.handle,
+        displayName: actor.displayName,
+        description: actor.description,
+        avatarUrl: actor.avatarUrl,
+        bannerUrl: actor.bannerUrl,
+        indexedAt: actor.indexedAt?.toISOString()
+      });
+    }
+
+    // Fetch viewer states for actors
+    let actorViewerStatesMap = new Map<string, any>();
+    if (viewerDid) {
+      actorViewerStatesMap = await this.viewerBuilder.buildActorStates(
+        viewerDid,
+        actorDids
+      );
+    }
+
+    // Fetch labels
+    const labelsMap = await this.labelPropagator.getLabels(actorDids);
+
+    return {
+      posts: new Map(),
+      actors: actorsMap,
+      aggregations: new Map(),
+      viewerStates: new Map(),
+      actorViewerStates: actorViewerStatesMap,
+      embeds: new Map(),
+      labels: labelsMap,
+      viewerContext
+    };
+  }
+
+  /**
+   * Hydrate with caching
+   * Note: Simplified implementation - always performs full hydration for complete state
+   * TODO: Implement proper state caching that includes all hydrated data (actors, aggregations, etc.)
+   */
+  async hydratePostsCached(
+    postUris: string[],
+    viewerDid?: string
+  ): Promise<HydrationState> {
+    // For now, always do full hydration to ensure complete state with all maps populated
+    // Future optimization: Cache full HydrationState snapshots including actors, aggregations, etc.
+    return await this.hydratePosts(postUris, viewerDid);
+  }
+
+  /**
+   * Clear hydration cache
+   */
+  async clearCache() {
+    this.embedResolver.clearCache();
+  }
+
+  private emptyState(): HydrationState {
+    return {
+      posts: new Map(),
+      actors: new Map(),
+      aggregations: new Map(),
+      viewerStates: new Map(),
+      actorViewerStates: new Map(),
+      embeds: new Map(),
+      labels: new Map()
+    };
+  }
+}
+
+// Export singleton instance
+export const enhancedHydrator = new EnhancedHydrator();
+
+// Re-export classes
+export { ViewerContextBuilder } from './viewer-context';
+export { EmbedResolver } from './embed-resolver';
+export { LabelPropagator } from './label-propagator';
+export { HydrationCache } from './cache';
+
+// Re-export types
+export type { ViewerContext } from './viewer-context';
+export type { ResolvedEmbed } from './embed-resolver';
+export type { Label } from './label-propagator';

server/services/hydration/label-propagator.ts

···
+import { db } from '../../db';
+import { labels, users } from '../../../shared/schema';
+import { inArray, eq, or, and } from 'drizzle-orm';
+
+export interface Label {
+  $type: 'com.atproto.label.defs#label';
+  src: string;
+  uri: string;
+  cid?: string;
+  val: string;
+  neg?: boolean;
+  cts: string;
+  exp?: string;
+}
+
+export interface Takedown {
+  isTakendown: boolean;
+  reason?: string;
+}
+
+export class LabelPropagator {
+  /**
+   * Fetch labels for a set of subjects (posts, actors, etc.)
+   */
+  async getLabels(subjects: string[]): Promise<Map<string, Label[]>> {
+    if (subjects.length === 0) return new Map();
+
+    const labelsData = await db
+      .select()
+      .from(labels)
+      .where(inArray(labels.subject, subjects));
+
+    const result = new Map<string, Label[]>();
+
+    for (const label of labelsData) {
+      const existing = result.get(label.subject) || [];
+      existing.push({
+        $type: 'com.atproto.label.defs#label',
+        src: label.src,
+        uri: label.subject,
+        cid: undefined, // CID not stored in current schema
+        val: label.val,
+        neg: label.neg || undefined,
+        cts: label.createdAt.toISOString(),
+        exp: undefined // Expiration not in current schema
+      });
+      result.set(label.subject, existing);
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if content is taken down based on labels
+   */
+  checkTakedown(labels: Label[]): Takedown {
+    if (!labels || labels.length === 0) {
+      return { isTakendown: false };
+    }
+
+    // Check for takedown labels
+    const takedownLabel = labels.find(l => 
+      l.val === '!takedown' || 
+      l.val === '!suspend' ||
+      l.val === 'dmca-violation'
+    );
+
+    if (takedownLabel) {
+      return {
+        isTakendown: true,
+        reason: takedownLabel.val
+      };
+    }
+
+    return { isTakendown: false };
+  }
+
+  /**
+   * Filter content based on moderation labels and viewer preferences
+   */
+  shouldFilter(
+    labels: Label[],
+    viewerPreferences?: any
+  ): { shouldHide: boolean; reason?: string } {
+    if (!labels || labels.length === 0) {
+      return { shouldHide: false };
+    }
+
+    // Always filter takedowns
+    const takedown = this.checkTakedown(labels);
+    if (takedown.isTakendown) {
+      return { shouldHide: true, reason: 'takedown' };
+    }
+
+    // Check for NSFW/adult content labels
+    const nsfwLabels = labels.filter(l => 
+      l.val === 'porn' || 
+      l.val === 'sexual' || 
+      l.val === 'nudity' ||
+      l.val === 'graphic-media'
+    );
+
+    if (nsfwLabels.length > 0) {
+      // Check viewer preferences
+      const hideNsfw = viewerPreferences?.adultContentEnabled === false;
+      if (hideNsfw) {
+        return { shouldHide: true, reason: 'nsfw' };
+      }
+    }
+
+    // Check for spam
+    const spamLabels = labels.filter(l => l.val === 'spam');
+    if (spamLabels.length > 0) {
+      return { shouldHide: true, reason: 'spam' };
+    }
+
+    return { shouldHide: false };
+  }
+
+  /**
+   * Propagate labels from actors to their content
+   * If an actor is labeled, their content inherits those labels
+   */
+  async propagateActorLabels(
+    actorDids: string[],
+    contentUris: string[]
+  ): Promise<Map<string, Label[]>> {
+    if (actorDids.length === 0 || contentUris.length === 0) {
+      return new Map();
+    }
+
+    // Get actor labels
+    const actorLabels = await this.getLabels(actorDids);
+    
+    // Get content labels
+    const contentLabels = await this.getLabels(contentUris);
+
+    // Build content URI to actor DID mapping
+    const contentToActor = new Map<string, string>();
+    
+    // Extract actor DID from content URI (at://did/collection/rkey)
+    for (const uri of contentUris) {
+      const match = uri.match(/^at:\/\/([^/]+)\//);
+      if (match) {
+        contentToActor.set(uri, match[1]);
+      }
+    }
+
+    // Propagate actor labels to content
+    const result = new Map<string, Label[]>();
+    
+    for (const uri of contentUris) {
+      const actorDid = contentToActor.get(uri);
+      const contentLabelsList = contentLabels.get(uri) || [];
+      const actorLabelsList = actorDid ? (actorLabels.get(actorDid) || []) : [];
+      
+      // Combine content and actor labels (content labels take precedence)
+      const combined = [...contentLabelsList, ...actorLabelsList];
+      
+      // Remove duplicates
+      const unique = Array.from(
+        new Map(combined.map(l => [`${l.src}:${l.val}`, l])).values()
+      );
+      
+      result.set(uri, unique);
+    }
+
+    return result;
+  }
+
+  /**
+   * Filter a list of content URIs based on moderation rules
+   * Returns only URIs that should be shown
+   */
+  async filterContent(
+    contentUris: string[],
+    viewerPreferences?: any
+  ): Promise<Set<string>> {
+    const actorDids = contentUris
+      .map(uri => {
+        const match = uri.match(/^at:\/\/([^/]+)\//);
+        return match ? match[1] : null;
+      })
+      .filter(Boolean) as string[];
+
+    const allLabels = await this.propagateActorLabels(actorDids, contentUris);
+    const allowed = new Set<string>();
+
+    for (const uri of contentUris) {
+      const labels = allLabels.get(uri) || [];
+      const filter = this.shouldFilter(labels, viewerPreferences);
+      
+      if (!filter.shouldHide) {
+        allowed.add(uri);
+      }
+    }
+
+    return allowed;
+  }
+}

server/services/hydration/viewer-context.ts

···
+import { db } from '../../db';
+import { 
+  users, 
+  blocks, 
+  mutes, 
+  follows, 
+  userPreferences,
+  listMutes,
+  threadMutes
+} from '../../../shared/schema';
+import { eq, and, inArray, sql } from 'drizzle-orm';
+
+export interface ViewerContext {
+  did: string;
+  following: Set<string>;
+  followers: Set<string>;
+  blocking: Set<string>;
+  blockedBy: Set<string>;
+  muting: Set<string>;
+  mutedByLists: Map<string, string>; // did -> list URI
+  threadMutes: Set<string>; // thread URIs
+  preferences?: any;
+}
+
+export class ViewerContextBuilder {
+  /**
+   * Build comprehensive viewer context for a given DID
+   * This includes all relationships and preferences needed for view construction
+   */
+  async build(viewerDid: string): Promise<ViewerContext> {
+    const [
+      followingData,
+      followersData,
+      blockingData,
+      blockedByData,
+      mutingData,
+      threadMutesData,
+      preferencesData
+    ] = await Promise.all([
+      // Following
+      db.select({ followingDid: follows.followingDid })
+        .from(follows)
+        .where(eq(follows.followerDid, viewerDid)),
+      
+      // Followers  
+      db.select({ followerDid: follows.followerDid })
+        .from(follows)
+        .where(eq(follows.followingDid, viewerDid)),
+      
+      // Blocking
+      db.select({ blockedDid: blocks.blockedDid })
+        .from(blocks)
+        .where(eq(blocks.blockerDid, viewerDid)),
+      
+      // Blocked by
+      db.select({ blockerDid: blocks.blockerDid })
+        .from(blocks)
+        .where(eq(blocks.blockedDid, viewerDid)),
+      
+      // Muting
+      db.select({ mutedDid: mutes.mutedDid })
+        .from(mutes)
+        .where(eq(mutes.muterDid, viewerDid)),
+      
+      // Thread mutes
+      db.select({ threadRootUri: threadMutes.threadRootUri })
+        .from(threadMutes)
+        .where(eq(threadMutes.muterDid, viewerDid)),
+      
+      // Preferences
+      db.select()
+        .from(userPreferences)
+        .where(eq(userPreferences.userDid, viewerDid))
+        .limit(1)
+    ]);
+
+    return {
+      did: viewerDid,
+      following: new Set(followingData.map(f => f.followingDid)),
+      followers: new Set(followersData.map(f => f.followerDid)),
+      blocking: new Set(blockingData.map(b => b.blockedDid)),
+      blockedBy: new Set(blockedByData.map(b => b.blockerDid)),
+      muting: new Set(mutingData.map(m => m.mutedDid)),
+      mutedByLists: new Map(), // TODO: implement list-based muting
+      threadMutes: new Set(threadMutesData.map(t => t.threadRootUri)),
+      preferences: preferencesData[0]
+    };
+  }
+
+  /**
+   * Build viewer states for a set of actors
+   * Returns a map of DID -> viewer relationship state
+   */
+  async buildActorStates(
+    viewerDid: string,
+    actorDids: string[]
+  ): Promise<Map<string, any>> {
+    if (actorDids.length === 0) return new Map();
+
+    const ctx = await this.build(viewerDid);
+    const result = new Map();
+
+    // Get follow URIs for actors
+    const followingUris = await db
+      .select({ 
+        followingDid: follows.followingDid, 
+        uri: follows.uri 
+      })
+      .from(follows)
+      .where(
+        and(
+          eq(follows.followerDid, viewerDid),
+          inArray(follows.followingDid, actorDids)
+        )
+      );
+
+    const followedByUris = await db
+      .select({ 
+        followerDid: follows.followerDid, 
+        uri: follows.uri 
+      })
+      .from(follows)
+      .where(
+        and(
+          eq(follows.followingDid, viewerDid),
+          inArray(follows.followerDid, actorDids)
+        )
+      );
+
+    const blockingUris = await db
+      .select({ 
+        blockedDid: blocks.blockedDid, 
+        uri: blocks.uri 
+      })
+      .from(blocks)
+      .where(
+        and(
+          eq(blocks.blockerDid, viewerDid),
+          inArray(blocks.blockedDid, actorDids)
+        )
+      );
+
+    for (const did of actorDids) {
+      const state: any = {};
+
+      // Following
+      const followingUri = followingUris.find(f => f.followingDid === did)?.uri;
+      if (followingUri) {
+        state.following = followingUri;
+      }
+
+      // Followed by
+      const followedByUri = followedByUris.find(f => f.followerDid === did)?.uri;
+      if (followedByUri) {
+        state.followedBy = followedByUri;
+      }
+
+      // Blocking
+      const blockingUri = blockingUris.find(b => b.blockedDid === did)?.uri;
+      if (blockingUri) {
+        state.blocking = blockingUri;
+      }
+
+      // Blocked by
+      if (ctx.blockedBy.has(did)) {
+        state.blockedBy = true;
+      }
+
+      // Muting
+      if (ctx.muting.has(did)) {
+        state.muted = true;
+      }
+
+      result.set(did, state);
+    }
+
+    return result;
+  }
+
+  /**
+   * Build viewer states for a set of posts
+   * Returns a map of post URI -> viewer state
+   */
+  async buildPostStates(
+    viewerDid: string,
+    postUris: string[]
+  ): Promise<Map<string, any>> {
+    if (postUris.length === 0) return new Map();
+
+    const [likesData, repostsData, bookmarksData] = await Promise.all([
+      db.select({ postUri: sql<string>`post_uri`, uri: sql<string>`uri` })
+        .from(sql`likes`)
+        .where(
+          and(
+            eq(sql`user_did`, viewerDid),
+            inArray(sql`post_uri`, postUris)
+          )
+        ),
+      
+      db.select({ postUri: sql<string>`post_uri`, uri: sql<string>`uri` })
+        .from(sql`reposts`)
+        .where(
+          and(
+            eq(sql`user_did`, viewerDid),
+            inArray(sql`post_uri`, postUris)
+          )
+        ),
+      
+      db.select({ postUri: sql<string>`post_uri` })
+        .from(sql`bookmarks`)
+        .where(
+          and(
+            eq(sql`user_did`, viewerDid),
+            inArray(sql`post_uri`, postUris)
+          )
+        )
+    ]);
+
+    const result = new Map();
+
+    for (const uri of postUris) {
+      const state: any = {};
+
+      const like = likesData.find(l => l.postUri === uri);
+      if (like) {
+        state.likeUri = like.uri;
+      }
+
+      const repost = repostsData.find(r => r.postUri === uri);
+      if (repost) {
+        state.repostUri = repost.uri;
+      }
+
+      const bookmark = bookmarksData.find(b => b.postUri === uri);
+      if (bookmark) {
+        state.bookmarked = true;
+      }
+
+      result.set(uri, state);
+    }
+
+    return result;
+  }
+}

server/services/xrpc-api.ts

···
 import type { UserSettings } from "@shared/schema";
 import { Hydrator } from "./hydration";
 import { Views } from "./views";
+import { enhancedHydrator } from "./hydration/index";
 
 // Query schemas
 const getTimelineSchema = z.object({
···
 const getSuggestedFeedsSchema = z.object({
   limit: z.coerce.number().min(1).max(100).default(50),
   cursor: z.string().optional(),
+});
+
+const getPopularFeedGeneratorsSchema = z.object({
+  limit: z.coerce.number().min(1).max(100).default(50),
+  cursor: z.string().optional(),
+  query: z.string().optional(),
 });
 
 const describeFeedGeneratorSchema = z.object({
···
     };
   }
 
+  private async serializePostsEnhanced(posts: any[], viewerDid?: string) {
+    const startTime = performance.now();
+    
+    if (posts.length === 0) {
+      return [];
+    }
+
+    const postUris = posts.map((p) => p.uri);
+    
+    const state = await enhancedHydrator.hydratePosts(postUris, viewerDid);
+    
+    const hydrationTime = performance.now() - startTime;
+    console.log(`[ENHANCED_HYDRATION] Hydrated ${postUris.length} posts in ${hydrationTime.toFixed(2)}ms`);
+
+    const serializedPosts = posts.map((post) => {
+      const hydratedPost = state.posts.get(post.uri);
+      const author = state.actors.get(post.authorDid);
+      const aggregation = state.aggregations.get(post.uri);
+      const viewerState = state.viewerStates.get(post.uri);
+      const actorViewerState = state.actorViewerStates.get(post.authorDid);
+      const labels = state.labels.get(post.uri) || [];
+      const authorLabels = state.labels.get(post.authorDid) || [];
+      const hydratedEmbed = state.embeds.get(post.uri);
+
+      const authorHandle = (author?.handle && typeof author.handle === 'string' && author.handle.trim() !== '') 
+        ? author.handle 
+        : 'handle.invalid';
+
+      const record: any = {
+        $type: 'app.bsky.feed.post',
+        text: hydratedPost?.text || post.text,
+        createdAt: hydratedPost?.createdAt || post.createdAt.toISOString(),
+      };
+
+      if (hydratedPost?.embed || post.embed) {
+        const embedData = hydratedPost?.embed || post.embed;
+        if (embedData && typeof embedData === 'object' && embedData.$type) {
+          let transformedEmbed = { ...embedData };
+          
+          if (embedData.$type === 'app.bsky.embed.images') {
+            transformedEmbed.images = embedData.images?.map((img: any) => ({
+              ...img,
+              image: {
+                ...img.image,
+                ref: {
+                  ...img.image.ref,
+                  link: this.transformBlobToCdnUrl(img.image.ref.$link, post.authorDid, 'feed_fullsize')
+                }
+              }
+            }));
+          } else if (embedData.$type === 'app.bsky.embed.external' && embedData.external?.thumb?.ref?.$link) {
+            transformedEmbed.external = {
+              ...embedData.external,
+              thumb: {
+                ...embedData.external.thumb,
+                ref: {
+                  ...embedData.external.thumb.ref,
+                  link: this.transformBlobToCdnUrl(embedData.external.thumb.ref.$link, post.authorDid, 'feed_thumbnail')
+                }
+              }
+            };
+          }
+          
+          record.embed = transformedEmbed;
+        }
+      }
+      if (hydratedPost?.facets || post.facets) record.facets = hydratedPost?.facets || post.facets;
+      if (hydratedPost?.reply) record.reply = hydratedPost.reply;
+
+      const avatarUrl = author?.avatarUrl;
+      const avatarCdn = avatarUrl 
+        ? (avatarUrl.startsWith('http') ? avatarUrl : this.transformBlobToCdnUrl(avatarUrl, author.did, 'avatar'))
+        : undefined;
+
+      const postView: any = {
+        $type: 'app.bsky.feed.defs#postView',
+        uri: post.uri,
+        cid: post.cid,
+        author: {
+          $type: 'app.bsky.actor.defs#profileViewBasic',
+          did: post.authorDid,
+          handle: authorHandle,
+          displayName: author?.displayName ?? authorHandle,
+          pronouns: author?.pronouns,
+          avatar: avatarCdn,
+          viewer: actorViewerState || {},
+          labels: authorLabels,
+          createdAt: author?.createdAt?.toISOString(),
+        },
+        record,
+        replyCount: aggregation?.replyCount || 0,
+        repostCount: aggregation?.repostCount || 0,
+        likeCount: aggregation?.likeCount || 0,
+        bookmarkCount: aggregation?.bookmarkCount || 0,
+        quoteCount: aggregation?.quoteCount || 0,
+        indexedAt: hydratedPost?.indexedAt || post.indexedAt.toISOString(),
+        labels: labels,
+        viewer: viewerState ? { 
+          $type: 'app.bsky.feed.defs#viewerState',
+          like: viewerState.likeUri || undefined, 
+          repost: viewerState.repostUri || undefined,
+          bookmarked: viewerState.bookmarked || false,
+          threadMuted: viewerState.threadMuted || false,
+          replyDisabled: viewerState.replyDisabled || false,
+          embeddingDisabled: viewerState.embeddingDisabled || false,
+          pinned: viewerState.pinned || false,
+        } : {},
+      };
+
+      if (hydratedEmbed) {
+        postView.embed = hydratedEmbed;
+      }
+
+      return postView;
+    });
+
+    return serializedPosts;
+  }
+
   private async serializePosts(posts: any[], viewerDid?: string) {
+    const useEnhancedHydration = process.env.ENHANCED_HYDRATION_ENABLED === 'true';
+    
+    if (useEnhancedHydration) {
+      return this.serializePostsEnhanced(posts, viewerDid);
+    }
+
     if (posts.length === 0) {
       return [];
     }
···
         items.unshift(pinnedItem);
       }
 
-      // Hydrate the feed items
-      const hydrator = new Hydrator();
-      const views = new Views();
+      // Extract post URIs for hydration
+      const postUris = items.map(item => item.post.uri);
+
+      // Fetch posts from storage for serialization
+      const posts = await storage.getPosts(postUris);
       
-      const hydrationState = await hydrator.hydrateFeedItems(items, viewerDid);
+      // Fetch reposts and reposter profiles for reason construction
+      const repostUris = items
+        .filter(item => item.repost)
+        .map(item => item.repost!.uri);
+      
+      const reposts = await Promise.all(
+        repostUris.map(uri => storage.getRepost(uri))
+      );
+      const repostsByUri = new Map(
+        reposts.filter(Boolean).map(r => [r!.uri, r!])
+      );
 
-      // Filter out blocked/muted content
-      const filteredItems = items.filter((item) => {
-        const bam = views.feedItemBlocksAndMutes(item, hydrationState);
-        return (
-          !bam.authorBlocked &&
-          !bam.originatorBlocked &&
-          (!bam.authorMuted || bam.originatorMuted) // repost of muted content
-        );
-      });
+      // Get all reposter DIDs for profile fetching
+      const reposterDids = Array.from(repostsByUri.values()).map(r => r.repostedByDid);
+      const reposters = await Promise.all(
+        reposterDids.map(did => storage.getUser(did))
+      );
+      const repostersByDid = new Map(
+        reposters.filter(Boolean).map(u => [u!.did, u!])
+      );
 
-      // Handle posts_and_author_threads filter
-      if (params.filter === 'posts_and_author_threads') {
-        const { SelfThreadTracker } = await import('../types/feed');
-        const selfThread = new SelfThreadTracker(filteredItems, hydrationState);
-        items = filteredItems.filter((item) => {
-          return (
-            item.repost || 
-            item.authorPinned || 
-            selfThread.ok(item.post.uri)
-          );
-        });
-      } else {
-        items = filteredItems;
+      // Apply content filtering if viewer is authenticated
+      let filteredPosts = posts;
+      if (viewerDid) {
+        const settings = await storage.getUserSettings(viewerDid);
+        if (settings) {
+          filteredPosts = contentFilter.filterPosts(posts, settings);
+        }
       }
 
-      // Convert to feed view posts
+      // Serialize posts with enhanced hydration (when flag is enabled)
+      const serializedPosts = await this.serializePosts(filteredPosts, viewerDid);
+      const postsByUri = new Map(serializedPosts.map(p => [p.uri, p]));
+
+      // Build feed with reposts and pinned posts
       const feed = items
-        .map((item) => views.feedViewPost(item, hydrationState))
+        .map(item => {
+          const post = postsByUri.get(item.post.uri);
+          if (!post) return null;
+
+          let reason: any = undefined;
+
+          // Handle pinned post reason
+          if (item.authorPinned) {
+            reason = {
+              $type: 'app.bsky.feed.defs#reasonPin',
+            };
+          }
+          // Handle repost reason
+          else if (item.repost) {
+            const repost = repostsByUri.get(item.repost.uri);
+            const reposter = repost ? repostersByDid.get(repost.repostedByDid) : null;
+            
+            if (repost && reposter) {
+              reason = {
+                $type: 'app.bsky.feed.defs#reasonRepost',
+                by: {
+                  $type: 'app.bsky.actor.defs#profileViewBasic',
+                  did: reposter.did,
+                  handle: reposter.handle,
+                  displayName: reposter.displayName,
+                  avatar: reposter.avatarUrl ? this.transformBlobToCdnUrl(reposter.avatarUrl, reposter.did, 'avatar') : undefined,
+                },
+                indexedAt: repost.indexedAt.toISOString(),
+              };
+            }
+          }
+
+          return {
+            post,
+            ...(reason && { reason }),
+          };
+        })
         .filter(Boolean);
 
       res.json({
···
       const relationships = await storage.getRelationships(actorDid, targetDids);
 
       res.json({
-        actor: params.actor,
+        actor: actorDid,
         relationships: Array.from(relationships.entries()).map(([did, rel]) => ({
+          $type: 'app.bsky.graph.defs#relationship',
           did,
-          following: rel.following
-            ? `at://${actorDid}/app.bsky.graph.follow/${did}`
-            : undefined,
-          followedBy: rel.followedBy
-            ? `at://${did}/app.bsky.graph.follow/${actorDid}`
-            : undefined,
+          following: rel.following || undefined,
+          followedBy: rel.followedBy || undefined,
+          blocking: rel.blocking || undefined,
+          blockedBy: rel.blockedBy || undefined,
+          muted: rel.muting || undefined,
         })),
       });
     } catch (error) {
···
     }
   }
 
+  async getPopularFeedGenerators(req: Request, res: Response) {
+    try {
+      const params = getPopularFeedGeneratorsSchema.parse(req.query);
+
+      let generators: any[];
+      let cursor: string | undefined;
+
+      // If query is provided, search for feed generators by name/description
+      // Otherwise, return suggested feeds (popular by default)
+      if (params.query && params.query.trim()) {
+        const searchResults = await storage.searchFeedGeneratorsByName(
+          params.query.trim(),
+          params.limit,
+          params.cursor
+        );
+        generators = searchResults.feedGenerators;
+        cursor = searchResults.cursor;
+      } else {
+        const suggestedResults = await storage.getSuggestedFeeds(
+          params.limit,
+          params.cursor,
+        );
+        generators = suggestedResults.generators;
+        cursor = suggestedResults.cursor;
+      }
+
+      const feeds = await Promise.all(
+        generators.map(async (generator) => {
+          const creator = await storage.getUser(generator.creatorDid);
+
+          const creatorView: any = {
+            did: generator.creatorDid,
+            handle:
+              creator?.handle ||
+              `${generator.creatorDid.replace(/:/g, '-')}.invalid`,
+          };
+          if (creator?.displayName)
+            creatorView.displayName = creator.displayName;
+          if (creator?.avatarUrl) creatorView.avatar = this.transformBlobToCdnUrl(creator.avatarUrl, creator.did, 'avatar');
+
+          const view: any = {
+            uri: generator.uri,
+            cid: generator.cid,
+            did: generator.did,
+            creator: creatorView,
+            displayName: generator.displayName,
+            likeCount: generator.likeCount,
+            indexedAt: generator.indexedAt.toISOString(),
+          };
+          if (generator.description) view.description = generator.description;
+          if (generator.avatarUrl) view.avatar = this.transformBlobToCdnUrl(generator.avatarUrl, generator.creatorDid, 'avatar');
+
+          return view;
+        }),
+      );
+
+      res.json({ cursor, feeds });
+    } catch (error) {
+      this._handleError(res, error, 'getPopularFeedGenerators');
+    }
+  }
+
   // Starter Pack endpoints
   async getStarterPack(req: Request, res: Response) {
     try {
···
 
   async getUnspeccedConfig(req: Request, res: Response) {
     try {
-      res.json({ liveNowConfig: { enabled: false } });
+      // Get country code from request headers or IP
+      // Default to US for self-hosted instances
+      const countryCode = req.headers['cf-ipcountry'] || 
+                          req.headers['x-country-code'] || 
+                          process.env.DEFAULT_COUNTRY_CODE || 
+                          'US';
+      
+      const regionCode = req.headers['cf-region-code'] || 
+                         req.headers['x-region-code'] || 
+                         process.env.DEFAULT_REGION_CODE || 
+                         '';
+
+      // For self-hosted instances, disable age restrictions unless explicitly configured
+      const isAgeBlockedGeo = process.env.AGE_BLOCKED_GEOS?.split(',')?.includes(countryCode.toString()) || false;
+      const isAgeRestrictedGeo = process.env.AGE_RESTRICTED_GEOS?.split(',')?.includes(countryCode.toString()) || false;
+
+      res.json({ 
+        liveNowConfig: { enabled: false },
+        countryCode: countryCode.toString().substring(0, 2),
+        regionCode: regionCode ? regionCode.toString() : undefined,
+        isAgeBlockedGeo,
+        isAgeRestrictedGeo,
+      });
     } catch (error) {
       this._handleError(res, error, 'getUnspeccedConfig');
     }

server/storage.ts

···
-import { users, posts, likes, reposts, bookmarks, follows, blocks, mutes, listMutes, listBlocks, threadMutes, userPreferences, sessions, userSettings, labels, labelDefinitions, labelEvents, moderationReports, moderationActions, moderatorAssignments, notifications, lists, listItems, feedGenerators, starterPacks, labelerServices, pushSubscriptions, videoJobs, firehoseCursor, feedItems, postAggregations, postViewerStates, threadContexts, type User, type InsertUser, type Post, type InsertPost, type Like, type InsertLike, type Repost, type InsertRepost, type Follow, type InsertFollow, type Block, type InsertBlock, type Mute, type InsertMute, type ListMute, type InsertListMute, type ListBlock, type InsertListBlock, type ThreadMute, type InsertThreadMute, type UserPreferences, type InsertUserPreferences, type Session, type InsertSession, type UserSettings, type InsertUserSettings, type Label, type InsertLabel, type LabelDefinition, type InsertLabelDefinition, type LabelEvent, type InsertLabelEvent, type ModerationReport, type InsertModerationReport, type ModerationAction, type InsertModerationAction, type ModeratorAssignment, type InsertModeratorAssignment, type Notification, type InsertNotification, type List, type InsertList, type ListItem, type InsertListItem, type FeedGenerator, type InsertFeedGenerator, type StarterPack, type InsertStarterPack, type LabelerService, type InsertLabelerService, type PushSubscription, type InsertPushSubscription, type VideoJob, type InsertVideoJob, type FirehoseCursor, type InsertFirehoseCursor, type Bookmark, insertBookmarkSchema, type FeedItem, type InsertFeedItem, type PostAggregation, type InsertPostAggregation, type PostViewerState, type InsertPostViewerState, type ThreadContext, type InsertThreadContext } from "@shared/schema";
+import { users, posts, likes, reposts, bookmarks, quotes, verifications, activitySubscriptions, follows, blocks, mutes, listMutes, listBlocks, threadMutes, userPreferences, sessions, userSettings, labels, labelDefinitions, labelEvents, moderationReports, moderationActions, moderatorAssignments, notifications, lists, listItems, feedGenerators, starterPacks, labelerServices, pushSubscriptions, videoJobs, firehoseCursor, feedItems, postAggregations, postViewerStates, threadContexts, type User, type InsertUser, type Post, type InsertPost, type Like, type InsertLike, type Repost, type InsertRepost, type Follow, type InsertFollow, type Block, type InsertBlock, type Mute, type InsertMute, type ListMute, type InsertListMute, type ListBlock, type InsertListBlock, type ThreadMute, type InsertThreadMute, type UserPreferences, type InsertUserPreferences, type Session, type InsertSession, type UserSettings, type InsertUserSettings, type Label, type InsertLabel, type LabelDefinition, type InsertLabelDefinition, type LabelEvent, type InsertLabelEvent, type ModerationReport, type InsertModerationReport, type ModerationAction, type InsertModerationAction, type ModeratorAssignment, type InsertModeratorAssignment, type Notification, type InsertNotification, type List, type InsertList, type ListItem, type InsertListItem, type FeedGenerator, type InsertFeedGenerator, type StarterPack, type InsertStarterPack, type LabelerService, type InsertLabelerService, type PushSubscription, type InsertPushSubscription, type VideoJob, type InsertVideoJob, type FirehoseCursor, type InsertFirehoseCursor, type Bookmark, insertBookmarkSchema, type Quote, type InsertQuote, type Verification, type InsertVerification, type ActivitySubscription, type InsertActivitySubscription, type FeedItem, type InsertFeedItem, type PostAggregation, type InsertPostAggregation, type PostViewerState, type InsertPostViewerState, type ThreadContext, type InsertThreadContext } from "@shared/schema";
 import { db, pool, type DbConnection } from "./db";
-import { eq, desc, and, sql, inArray, isNull } from "drizzle-orm";
+import { eq, desc, and, or, sql, inArray, isNull } from "drizzle-orm";
 import { encryptionService } from "./services/encryption";
 import { sanitizeObject } from "./utils/sanitize";
 import { cacheService } from "./services/cache";
···
   getBookmark(uri: string): Promise<Bookmark | undefined>;
   getBookmarks(userDid: string, limit?: number, cursor?: string): Promise<{ bookmarks: Bookmark[], cursor?: string }>;
   getBookmarkUri(userDid: string, postUri: string): Promise<string | undefined>;
+
+  // Quote operations
+  createQuote(quote: InsertQuote): Promise<Quote>;
+  deleteQuote(uri: string): Promise<void>;
+  getQuote(uri: string): Promise<Quote | undefined>;
+  getQuotes(postUri: string, limit?: number, cursor?: string): Promise<{ quotes: Quote[], cursor?: string }>;
+
+  // Verification operations
+  createVerification(verification: InsertVerification): Promise<Verification>;
+  deleteVerification(uri: string): Promise<void>;
+  getVerification(uri: string): Promise<Verification | undefined>;
+  getVerificationBySubject(subjectDid: string): Promise<Verification | undefined>;
+
+  // Activity subscription operations
+  createActivitySubscription(subscription: InsertActivitySubscription): Promise<ActivitySubscription>;
+  deleteActivitySubscription(uri: string): Promise<void>;
+  getActivitySubscription(uri: string): Promise<ActivitySubscription | undefined>;
+  getActivitySubscriptions(subscriberDid: string, limit?: number, cursor?: string): Promise<{ subscriptions: ActivitySubscription[], cursor?: string }>;
 
   // Follow operations
   createFollow(follow: InsertFollow): Promise<Follow>;
···
   getFeedGenerators(uris: string[]): Promise<FeedGenerator[]>;
   getActorFeeds(actorDid: string, limit?: number, cursor?: string): Promise<{ generators: FeedGenerator[], cursor?: string }>;
   getSuggestedFeeds(limit?: number, cursor?: string): Promise<{ generators: FeedGenerator[], cursor?: string }>;
+  searchFeedGeneratorsByName(q: string, limit?: number, cursor?: string): Promise<{ feedGenerators: FeedGenerator[], cursor?: string }>;
   updateFeedGenerator(uri: string, data: Partial<InsertFeedGenerator>): Promise<FeedGenerator | undefined>;
   
   // Starter pack operations
···
       .where(and(eq(bookmarks.userDid, userDid), eq(bookmarks.postUri, postUri)))
       .limit(1);
     return row?.uri;
+  }
+
+  // Quote operations
+  async createQuote(quote: InsertQuote): Promise<Quote> {
+    const [row] = await this.db
+      .insert(quotes)
+      .values(quote)
+      .onConflictDoNothing()
+      .returning();
+    return row as Quote;
+  }
+
+  async deleteQuote(uri: string): Promise<void> {
+    await this.db.delete(quotes).where(eq(quotes.uri, uri));
+  }
+
+  async getQuote(uri: string): Promise<Quote | undefined> {
+    const [row] = await this.db
+      .select()
+      .from(quotes)
+      .where(eq(quotes.uri, uri))
+      .limit(1);
+    return row as Quote | undefined;
+  }
+
+  async getQuotes(postUri: string, limit = 50, cursor?: string): Promise<{ quotes: Quote[]; cursor?: string }> {
+    const conditions = [eq(quotes.quotedUri, postUri)];
+    if (cursor) {
+      conditions.push(sql`${quotes.indexedAt} < ${new Date(cursor)}`);
+    }
+    const results = await this.db
+      .select()
+      .from(quotes)
+      .where(and(...conditions))
+      .orderBy(desc(quotes.indexedAt))
+      .limit(limit + 1);
+    const hasMore = results.length > limit;
+    const items = hasMore ? results.slice(0, limit) : results;
+    const nextCursor = hasMore ? items[items.length - 1].indexedAt.toISOString() : undefined;
+    return { quotes: items as Quote[], cursor: nextCursor };
+  }
+
+  // Verification operations
+  async createVerification(verification: InsertVerification): Promise<Verification> {
+    const [row] = await this.db
+      .insert(verifications)
+      .values(verification)
+      .onConflictDoNothing()
+      .returning();
+    return row as Verification;
+  }
+
+  async deleteVerification(uri: string): Promise<void> {
+    await this.db.delete(verifications).where(eq(verifications.uri, uri));
+  }
+
+  async getVerification(uri: string): Promise<Verification | undefined> {
+    const [row] = await this.db
+      .select()
+      .from(verifications)
+      .where(eq(verifications.uri, uri))
+      .limit(1);
+    return row as Verification | undefined;
+  }
+
+  async getVerificationBySubject(subjectDid: string): Promise<Verification | undefined> {
+    const [row] = await this.db
+      .select()
+      .from(verifications)
+      .where(eq(verifications.subjectDid, subjectDid))
+      .limit(1);
+    return row as Verification | undefined;
+  }
+
+  // Activity subscription operations
+  async createActivitySubscription(subscription: InsertActivitySubscription): Promise<ActivitySubscription> {
+    const [row] = await this.db
+      .insert(activitySubscriptions)
+      .values(subscription)
+      .onConflictDoNothing()
+      .returning();
+    return row as ActivitySubscription;
+  }
+
+  async deleteActivitySubscription(uri: string): Promise<void> {
+    await this.db.delete(activitySubscriptions).where(eq(activitySubscriptions.uri, uri));
+  }
+
+  async getActivitySubscription(uri: string): Promise<ActivitySubscription | undefined> {
+    const [row] = await this.db
+      .select()
+      .from(activitySubscriptions)
+      .where(eq(activitySubscriptions.uri, uri))
+      .limit(1);
+    return row as ActivitySubscription | undefined;
+  }
+
+  async getActivitySubscriptions(subscriberDid: string, limit = 50, cursor?: string): Promise<{ subscriptions: ActivitySubscription[]; cursor?: string }> {
+    const conditions = [eq(activitySubscriptions.subscriberDid, subscriberDid)];
+    if (cursor) {
+      conditions.push(sql`${activitySubscriptions.indexedAt} < ${new Date(cursor)}`);
+    }
+    const results = await this.db
+      .select()
+      .from(activitySubscriptions)
+      .where(and(...conditions))
+      .orderBy(desc(activitySubscriptions.indexedAt))
+      .limit(limit + 1);
+    const hasMore = results.length > limit;
+    const items = hasMore ? results.slice(0, limit) : results;
+    const nextCursor = hasMore ? items[items.length - 1].indexedAt.toISOString() : undefined;
+    return { subscriptions: items as ActivitySubscription[], cursor: nextCursor };
   }
 
   async createFollow(follow: InsertFollow): Promise<Follow> {
···
       : undefined;
 
     return { generators: results, cursor: nextCursor };
+  }
+
+  async searchFeedGeneratorsByName(q: string, limit = 25, cursor?: string): Promise<{ feedGenerators: FeedGenerator[], cursor?: string }> {
+    const searchPattern = `%${q.toLowerCase()}%`;
+    const conditions = [
+      or(
+        sql`LOWER(${feedGenerators.displayName}) LIKE ${searchPattern}`,
+        sql`LOWER(${feedGenerators.description}) LIKE ${searchPattern}`
+      )
+    ];
+
+    // Use composite cursor matching the ordering: likeCount DESC, indexedAt DESC
+    if (cursor) {
+      const [likeCount, indexedAt] = cursor.split('::');
+      conditions.push(
+        sql`(${feedGenerators.likeCount}, ${feedGenerators.indexedAt}) < (${parseInt(likeCount)}, ${new Date(indexedAt)})`
+      );
+    }
+
+    const results = await db
+      .select()
+      .from(feedGenerators)
+      .where(and(...conditions))
+      .orderBy(desc(feedGenerators.likeCount), desc(feedGenerators.indexedAt))
+      .limit(limit + 1);
+
+    const hasMore = results.length > limit;
+    const feedGeneratorList = hasMore ? results.slice(0, limit) : results;
+    const nextCursor = hasMore 
+      ? `${feedGeneratorList[feedGeneratorList.length - 1].likeCount}::${feedGeneratorList[feedGeneratorList.length - 1].indexedAt.toISOString()}`
+      : undefined;
+
+    return { feedGenerators: feedGeneratorList, cursor: nextCursor };
   }
 
   async updateFeedGenerator(uri: string, data: Partial<InsertFeedGenerator>): Promise<FeedGenerator | undefined> {

shared/schema.ts

···
   uniqueBookmark: uniqueIndex("unique_bookmark_user_post").on(table.userDid, table.postUri),
 }));
 
+// Quotes table - tracks quote posts
+export const quotes = pgTable("quotes", {
+  uri: varchar("uri", { length: 512 }).primaryKey(),
+  cid: varchar("cid", { length: 255 }).notNull(),
+  postUri: varchar("post_uri", { length: 512 }).notNull(), // The quote post URI
+  quotedUri: varchar("quoted_uri", { length: 512 }).notNull(), // The URI of the quoted post
+  quotedCid: varchar("quoted_cid", { length: 255 }),
+  createdAt: timestamp("created_at").notNull(),
+  indexedAt: timestamp("indexed_at").defaultNow().notNull(),
+}, (table) => ({
+  postIdx: index("idx_quotes_post").on(table.postUri),
+  quotedIdx: index("idx_quotes_quoted").on(table.quotedUri),
+  uniqueQuote: uniqueIndex("unique_quote_post_quoted").on(table.postUri, table.quotedUri),
+}));
+
 // Follows table
 export const follows = pgTable("follows", {
   uri: varchar("uri", { length: 512 }).primaryKey(),
···
   indexedAtIdx: index("idx_notifications_indexed_at").on(table.indexedAt),
 }));
 
+// Activity subscriptions table - per-actor notification preferences
+export const activitySubscriptions = pgTable("activity_subscriptions", {
+  uri: varchar("uri", { length: 512 }).primaryKey(),
+  cid: varchar("cid", { length: 255 }).notNull(),
+  subscriberDid: varchar("subscriber_did", { length: 255 }).notNull(), // No FK - user subscribing
+  subjectDid: varchar("subject_did", { length: 255 }).notNull(), // No FK - user being subscribed to
+  priority: boolean("priority").default(false).notNull(), // Priority notifications flag
+  createdAt: timestamp("created_at").notNull(),
+  indexedAt: timestamp("indexed_at").defaultNow().notNull(),
+}, (table) => ({
+  subscriberIdx: index("idx_activity_subscriptions_subscriber").on(table.subscriberDid),
+  subjectIdx: index("idx_activity_subscriptions_subject").on(table.subjectDid),
+  uniqueSubscription: uniqueIndex("unique_activity_subscription").on(table.subscriberDid, table.subjectDid),
+}));
+
 // Lists table - curated user lists
 export const lists = pgTable("lists", {
   uri: varchar("uri", { length: 512 }).primaryKey(),
···
   creatorIdx: index("idx_labeler_services_creator").on(table.creatorDid),
   likeCountIdx: index("idx_labeler_services_like_count").on(table.likeCount),
   indexedAtIdx: index("idx_labeler_services_indexed_at").on(table.indexedAt),
+}));
+
+// Verifications table - handle verification records
+export const verifications = pgTable("verifications", {
+  uri: varchar("uri", { length: 512 }).primaryKey(),
+  cid: varchar("cid", { length: 255 }).notNull(),
+  subjectDid: varchar("subject_did", { length: 255 }).notNull(), // No FK - can reference external users
+  handle: varchar("handle", { length: 255 }).notNull(),
+  verifiedAt: timestamp("verified_at").notNull(),
+  createdAt: timestamp("created_at").notNull(),
+  indexedAt: timestamp("indexed_at").defaultNow().notNull(),
+}, (table) => ({
+  subjectIdx: index("idx_verifications_subject").on(table.subjectDid),
+  handleIdx: index("idx_verifications_handle").on(table.handle),
+  uniqueVerification: uniqueIndex("unique_verification_subject").on(table.subjectDid),
 }));
 
 // Push subscriptions table - device push notification registrations
···
 export const insertVideoJobSchema = createInsertSchema(videoJobs).omit({ id: true, createdAt: true, updatedAt: true });
 // Bookmark insert schema/types
 export const insertBookmarkSchema = createInsertSchema(bookmarks).omit({ indexedAt: true });
+export const insertQuoteSchema = createInsertSchema(quotes).omit({ indexedAt: true });
+export const insertVerificationSchema = createInsertSchema(verifications).omit({ indexedAt: true });
+export const insertActivitySubscriptionSchema = createInsertSchema(activitySubscriptions).omit({ indexedAt: true });
 export const insertFirehoseCursorSchema = createInsertSchema(firehoseCursor).omit({ id: true, updatedAt: true });
 
 // Types
···
 export type VideoJob = typeof videoJobs.$inferSelect;
 export type Bookmark = typeof bookmarks.$inferSelect;
 export type InsertVideoJob = z.infer<typeof insertVideoJobSchema>;
+export type InsertBookmark = z.infer<typeof insertBookmarkSchema>;
+export type Quote = typeof quotes.$inferSelect;
+export type InsertQuote = z.infer<typeof insertQuoteSchema>;
+export type Verification = typeof verifications.$inferSelect;
+export type InsertVerification = z.infer<typeof insertVerificationSchema>;
+export type ActivitySubscription = typeof activitySubscriptions.$inferSelect;
+export type InsertActivitySubscription = z.infer<typeof insertActivitySubscriptionSchema>;
 export type FirehoseCursor = typeof firehoseCursor.$inferSelect;
 export type InsertFirehoseCursor = z.infer<typeof insertFirehoseCursorSchema>;

start-with-redis.sh

···
+#!/bin/bash
+
+# Start Redis in the background
+echo "[STARTUP] Starting Redis server..."
+redis-server --daemonize yes --port 6379 --dir /tmp --save "" --appendonly no
+
+# Wait for Redis to be ready
+for i in {1..10}; do
+  if redis-cli ping > /dev/null 2>&1; then
+    echo "[STARTUP] Redis is ready!"
+    break
+  fi
+  echo "[STARTUP] Waiting for Redis to start... ($i/10)"
+  sleep 1
+done
+
+# Check if Redis is running
+if ! redis-cli ping > /dev/null 2>&1; then
+  echo "[STARTUP] ERROR: Redis failed to start!"
+  exit 1
+fi
+
+# Start the application
+echo "[STARTUP] Starting Node.js application..."
+NODE_ENV=development tsx server/index.ts