Homepage.dev Technical Architecture

interface ArchitectureStack {
  frontend: "Next.js 15 + TypeScript + Real-time UI"
  backend: "3-Project Convex Architecture"
  authentication: "Standalone Clerk Instance"
  realtime: "WebSocket + Optimistic Updates"
  modules: "Sandboxed Execution + Module Registry"
  deployment: "Vercel + Multi-region CDN"
}

// Dedicated Clerk instance for homepage.dev
interface HomepageClerkConfig {
  instance: {
    development: "homepage-dev"
    production: "homepage-production"
    domain: "homepage.dev"
  }
  
  // Custom organization structure
  organizations: {
    maxMembers: {
      team: 50        // Small teams
      enterprise: -1  // Unlimited
    }
    
    permissions: {
      team: ["homepage:read", "homepage:write", "homepage:collaborate"]
      enterprise: ["homepage:admin", "homepage:audit", "homepage:sso"]
    }
    
    billing: {
      team: "$9.99/user/month"
      enterprise: "custom pricing"
    }
  }
  
  // Homepage-specific user roles
  roles: {
    viewer: ["read", "comment"]
    editor: ["read", "write", "collaborate"] 
    admin: ["read", "write", "admin", "billing"]
    developer: ["read", "write", "publish-modules"]
  }
}

// Enhanced user profile beyond basic Clerk data
interface HomepageUserProfile {
  // Clerk basics
  clerkId: string
  email: string
  name: string
  avatar?: string
  
  // Homepage-specific profile
  preferences: {
    defaultLayout: "grid" | "flex" | "masonry"
    theme: "light" | "dark" | "auto"
    notifications: boolean
    collaborationMode: "active" | "passive" | "focus"
    language: string
    timezone: string
  }
  
  // Subscription and billing
  subscription: {
    tier: "free" | "pro" | "team" | "enterprise"
    billingId?: string
    usage: {
      homepages: number
      modules: number
      storage: number // in MB
      collaborators: number
    }
  }
  
  // Platform engagement
  stats: {
    totalHomepages: number
    modulesInstalled: number
    lastActiveAt: number
    createdAt: number
    onboardingCompleted: boolean
  }
}

// Convex project: homepage-auth
export const authSchema = defineSchema({
  // Synced from Clerk via webhooks
  users: defineTable({
    clerkId: v.string(),
    email: v.string(),
    name: v.string(),
    avatar: v.optional(v.string()),
    
    // Homepage-specific profile
    profile: v.object({
      preferences: v.object({
        defaultLayout: v.string(),
        theme: v.string(),
        notifications: v.boolean(),
        collaborationMode: v.string(),
      }),
      subscription: v.object({
        tier: v.string(),
        billingId: v.optional(v.string()),
      }),
    }),
    
    // Usage tracking
    usage: v.object({
      homepages: v.number(),
      modules: v.number(),
      storage: v.number(),
      collaborators: v.number(),
    }),
    
    createdAt: v.number(),
    lastActiveAt: v.number(),
  })
    .index("by_clerk_id", ["clerkId"])
    .index("by_email", ["email"]),

  // Organization management
  organizations: defineTable({
    clerkOrgId: v.string(),
    name: v.string(),
    slug: v.string(),
    
    // Enterprise settings
    settings: v.object({
      allowedModules: v.array(v.string()),
      enforceTemplates: v.boolean(),
      collaborationRules: v.object({
        allowPublicSharing: v.boolean(),
        requireApprovalForModules: v.boolean(),
        maxHomepagesPerUser: v.number(),
      }),
    }),
    
    // Enterprise features
    enterprise: v.object({
      ssoEnabled: v.boolean(),
      auditLogsRetention: v.number(),
      customBranding: v.optional(v.object({
        logo: v.string(),
        primaryColor: v.string(),
        secondaryColor: v.string(),
      })),
    }),
    
    createdAt: v.number(),
    memberCount: v.number(),
  })
    .index("by_clerk_org_id", ["clerkOrgId"])
    .index("by_slug", ["slug"]),
    
  // Role and permission management
  userRoles: defineTable({
    userId: v.id("users"),
    organizationId: v.optional(v.id("organizations")),
    role: v.string(),
    permissions: v.array(v.string()),
    grantedBy: v.id("users"),
    grantedAt: v.number(),
  })
    .index("by_user", ["userId"])
    .index("by_org", ["organizationId"]),
})

// Convex project: homepage-core
export const coreSchema = defineSchema({
  // Real-time homepage configurations
  homepageConfigs: defineTable({
    userId: v.id("users"), // Reference to auth project
    organizationId: v.optional(v.id("organizations")),
    name: v.string(),
    description: v.optional(v.string()),
    isDefault: v.boolean(),
    isActive: v.boolean(),
    
    // Real-time collaboration state
    collaboration: v.object({
      // Currently active editors
      activeEditors: v.array(v.object({
        userId: v.id("users"),
        userName: v.string(),
        userAvatar: v.optional(v.string()),
        cursorPosition: v.optional(v.object({ x: v.number(), y: v.number() })),
        lastActiveAt: v.number(),
        editingModule: v.optional(v.string()),
      })),
      
      // Lock state for conflict resolution
      locked: v.boolean(),
      lockedBy: v.optional(v.id("users")),
      lockedAt: v.optional(v.number()),
    }),
    
    // Layout configuration
    layout: v.object({
      type: v.union(v.literal("grid"), v.literal("flex"), v.literal("masonry")),
      columns: v.number(),
      gap: v.number(),
      padding: v.object({
        top: v.number(),
        right: v.number(), 
        bottom: v.number(),
        left: v.number(),
      }),
      responsive: v.object({
        mobile: v.object({ columns: v.number() }),
        tablet: v.object({ columns: v.number() }),
        desktop: v.object({ columns: v.number() }),
      }),
    }),
    
    // Theme and styling
    theme: v.object({
      mode: v.union(v.literal("light"), v.literal("dark"), v.literal("auto")),
      primaryColor: v.string(),
      accentColor: v.string(),
      customCSS: v.optional(v.string()),
      backgroundImage: v.optional(v.string()),
    }),
    
    // Module instances
    modules: v.array(v.object({
      instanceId: v.string(),
      moduleId: v.string(), // Reference to marketplace
      
      // Position and sizing
      position: v.object({
        x: v.number(),
        y: v.number(),
        w: v.number(),
        h: v.number(),
      }),
      
      // Module configuration
      config: v.any(), // Module-specific settings
      
      // Real-time state
      state: v.any(), // Current module state
      lastUpdated: v.number(),
      updatedBy: v.optional(v.id("users")),
      
      // Permissions
      visibility: v.union(
        v.literal("private"),
        v.literal("team"),
        v.literal("public")
      ),
      editPermissions: v.array(v.id("users")),
    })),
    
    // Sharing and permissions
    sharing: v.object({
      isPublic: v.boolean(),
      publicSlug: v.optional(v.string()),
      allowComments: v.boolean(),
      allowCloning: v.boolean(),
      
      sharedWith: v.array(v.object({
        type: v.union(v.literal("user"), v.literal("team"), v.literal("organization")),
        id: v.string(),
        permissions: v.array(v.string()),
        sharedAt: v.number(),
        sharedBy: v.id("users"),
      })),
    }),
    
    // Version control
    version: v.number(),
    lastSyncedAt: v.number(),
    syncStatus: v.union(
      v.literal("synced"),
      v.literal("syncing"), 
      v.literal("conflict"),
      v.literal("error")
    ),
    
    // Metadata
    createdAt: v.number(),
    updatedAt: v.number(),
    lastAccessedAt: v.number(),
  })
    .index("by_user", ["userId"])
    .index("by_user_active", ["userId", "isActive"])
    .index("by_organization", ["organizationId"])
    .index("by_public_slug", ["sharing.publicSlug"])
    .searchIndex("search_homepages", {
      searchField: "name",
      filterFields: ["userId", "organizationId", "sharing.isPublic"],
    }),

  // Real-time module state management
  moduleStates: defineTable({
    configId: v.id("homepageConfigs"),
    instanceId: v.string(),
    moduleId: v.string(),
    
    // Real-time data streams
    liveData: v.object({
      // Stock ticker data
      stocks: v.optional(v.array(v.object({
        symbol: v.string(),
        price: v.number(),
        change: v.number(),
        changePercent: v.number(),
        timestamp: v.number(),
      }))),
      
      // Chat messages
      messages: v.optional(v.array(v.object({
        id: v.string(),
        userId: v.id("users"),
        userName: v.string(),
        text: v.string(),
        timestamp: v.number(),
        reactions: v.optional(v.array(v.object({
          emoji: v.string(),
          userId: v.id("users"),
          timestamp: v.number(),
        }))),
      }))),
      
      // Weather data
      weather: v.optional(v.object({
        location: v.string(),
        temperature: v.number(),
        condition: v.string(),
        humidity: v.number(),
        windSpeed: v.number(),
        timestamp: v.number(),
      })),
      
      // Custom module data
      customData: v.optional(v.any()),
    }),
    
    // Performance tracking
    performance: v.object({
      loadTime: v.number(),
      renderTime: v.number(),
      memoryUsage: v.number(),
      apiCalls: v.number(),
      lastMeasured: v.number(),
    }),
    
    // Update tracking
    lastUpdated: v.number(),
    updateFrequency: v.number(), // ms between updates
    errorCount: v.number(),
    lastError: v.optional(v.string()),
  })
    .index("by_config_instance", ["configId", "instanceId"])
    .index("by_module", ["moduleId"]),

  // Real-time activity feed
  activityFeed: defineTable({
    configId: v.id("homepageConfigs"),
    userId: v.id("users"),
    userName: v.string(),
    
    action: v.string(), // "module_added", "layout_changed", etc.
    target: v.object({
      type: v.string(),
      id: v.string(),
      name: v.optional(v.string()),
    }),
    
    details: v.optional(v.object({
      before: v.optional(v.any()),
      after: v.optional(v.any()),
      metadata: v.optional(v.any()),
    })),
    
    timestamp: v.number(),
  })
    .index("by_config_time", ["configId", "timestamp"])
    .index("by_user", ["userId"])
    .index("by_action", ["action"]),

  // Inter-module communication
  moduleMessages: defineTable({
    fromConfigId: v.id("homepageConfigs"),
    fromInstanceId: v.string(),
    toInstanceId: v.string(),
    
    messageType: v.string(),
    payload: v.any(),
    
    // Delivery tracking
    sent: v.boolean(),
    acknowledged: v.boolean(),
    failed: v.boolean(),
    
    timestamp: v.number(),
    expiresAt: v.optional(v.number()),
  })
    .index("by_recipient", ["toInstanceId", "timestamp"])
    .index("by_sender", ["fromInstanceId", "timestamp"])
    .index("by_delivery_status", ["sent", "acknowledged"]),

  // Shared state between modules
  sharedModuleState: defineTable({
    configId: v.id("homepageConfigs"),
    key: v.string(),
    value: v.any(),
    
    // Ownership and access
    ownerInstanceId: v.string(),
    subscribers: v.array(v.string()), // Instance IDs
    
    // Version control
    version: v.number(),
    lastUpdated: v.number(),
    updatedBy: v.id("users"),
    
    // Expiration
    ttl: v.optional(v.number()), // Time to live in seconds
    expiresAt: v.optional(v.number()),
  })
    .index("by_config_key", ["configId", "key"])
    .index("by_owner", ["ownerInstanceId"]),
})

// Convex project: homepage-marketplace
export const marketplaceSchema = defineSchema({
  // Module registry
  modules: defineTable({
    // Identity
    id: v.string(),
    slug: v.string(),
    publisherId: v.string(), // User or organization ID
    
    // Metadata
    name: v.string(),
    description: v.string(),
    longDescription: v.optional(v.string()),
    category: v.string(),
    tags: v.array(v.string()),
    
    // Visual assets
    icon: v.string(),
    screenshots: v.array(v.string()),
    bannerImage: v.optional(v.string()),
    
    // Version information
    version: v.string(),
    changelog: v.string(),
    previousVersions: v.array(v.object({
      version: v.string(),
      releaseDate: v.number(),
      deprecated: v.boolean(),
    })),
    
    // Source and distribution
    source: v.object({
      type: v.union(
        v.literal("built-in"),     // First-party modules
        v.literal("verified"),     // Verified third-party
        v.literal("community")     // Community modules
      ),
      bundleUrl: v.string(),
      integrity: v.string(), // SHA-256 hash
      repositoryUrl: v.optional(v.string()),
      licenseUrl: v.optional(v.string()),
    }),
    
    // Module configuration
    configSchema: v.any(), // JSON Schema for module config
    defaultConfig: v.any(),
    
    // Requirements and permissions
    permissions: v.array(v.string()),
    dependencies: v.array(v.string()),
    minHomepageVersion: v.string(),
    maxHomepageVersion: v.optional(v.string()),
    
    // Display and behavior
    displayOptions: v.object({
      defaultSize: v.object({ width: v.number(), height: v.number() }),
      minSize: v.object({ width: v.number(), height: v.number() }),
      maxSize: v.object({ width: v.number(), height: v.number() }),
      resizable: v.boolean(),
      refreshInterval: v.optional(v.number()),
      singleton: v.boolean(), // Only one instance allowed
    }),
    
    // Marketplace and pricing
    pricing: v.object({
      model: v.union(v.literal("free"), v.literal("paid"), v.literal("freemium")),
      price: v.optional(v.number()), // in cents
      currency: v.optional(v.string()),
      trialDays: v.optional(v.number()),
      subscriptionType: v.optional(v.union(v.literal("monthly"), v.literal("yearly"))),
    }),
    
    // Analytics and engagement
    stats: v.object({
      totalInstalls: v.number(),
      activeInstalls: v.number(),
      weeklyInstalls: v.number(),
      rating: v.number(), // 0-5 stars
      reviewCount: v.number(),
      lastWeekViews: v.number(),
      conversionRate: v.number(), // installs / views
    }),
    
    // Moderation and quality
    status: v.union(
      v.literal("draft"),
      v.literal("review"),
      v.literal("approved"),
      v.literal("rejected"),
      v.literal("suspended"),
      v.literal("deprecated")
    ),
    
    moderation: v.object({
      reviewedBy: v.optional(v.string()),
      reviewedAt: v.optional(v.number()),
      reviewNotes: v.optional(v.string()),
      securityScanPassed: v.boolean(),
      performanceTestPassed: v.boolean(),
    }),
    
    // Timestamps
    createdAt: v.number(),
    updatedAt: v.number(),
    publishedAt: v.optional(v.number()),
    lastInstallAt: v.optional(v.number()),
  })
    .index("by_slug", ["slug"])
    .index("by_publisher", ["publisherId"])
    .index("by_category", ["category"])
    .index("by_status", ["status"])
    .index("by_rating", ["stats.rating"])
    .searchIndex("search_modules", {
      searchField: "name",
      filterFields: ["category", "status", "tags", "pricing.model"],
    }),

  // Module installations tracking
  installations: defineTable({
    userId: v.string(),
    moduleId: v.string(),
    configId: v.optional(v.string()), // Which homepage it's installed on
    instanceId: v.string(),
    
    // Installation details
    version: v.string(),
    installedAt: v.number(),
    lastUsed: v.number(),
    timesUsed: v.number(),
    
    // Configuration
    config: v.any(),
    customizations: v.optional(v.any()),
    
    // Status
    status: v.union(
      v.literal("active"),
      v.literal("disabled"),
      v.literal("uninstalled")
    ),
    
    // Analytics
    usage: v.object({
      sessionsCount: v.number(),
      totalTimeUsed: v.number(), // in seconds
      actionsPerformed: v.number(),
      errorsEncountered: v.number(),
    }),
  })
    .index("by_user", ["userId"])
    .index("by_module", ["moduleId"])
    .index("by_config", ["configId"])
    .index("by_user_module", ["userId", "moduleId"]),

  // Module reviews and ratings
  reviews: defineTable({
    moduleId: v.string(),
    userId: v.string(),
    userName: v.string(),
    userAvatar: v.optional(v.string()),
    
    // Review content
    rating: v.number(), // 1-5 stars
    title: v.string(),
    content: v.string(),
    version: v.string(), // Module version reviewed
    
    // Moderation
    status: v.union(
      v.literal("published"),
      v.literal("pending"),
      v.literal("rejected"),
      v.literal("hidden")
    ),
    
    // Engagement
    helpfulVotes: v.number(),
    reportCount: v.number(),
    
    // Developer response
    developerResponse: v.optional(v.object({
      content: v.string(),
      respondedAt: v.number(),
      respondedBy: v.string(),
    })),
    
    createdAt: v.number(),
    updatedAt: v.number(),
  })
    .index("by_module", ["moduleId"])
    .index("by_user", ["userId"])
    .index("by_rating", ["rating"])
    .index("by_status", ["status"]),

  // Developer analytics and revenue
  developerAnalytics: defineTable({
    publisherId: v.string(),
    moduleId: v.string(),
    
    // Time-based metrics
    period: v.string(), // "daily", "weekly", "monthly"
    date: v.string(), // ISO date string
    
    // Usage metrics
    metrics: v.object({
      views: v.number(),
      installs: v.number(),
      uninstalls: v.number(),
      activeUsers: v.number(),
      revenue: v.number(), // in cents
      errors: v.number(),
      supportRequests: v.number(),
    }),
    
    // Performance data
    performance: v.object({
      avgLoadTime: v.number(),
      avgMemoryUsage: v.number(),
      crashRate: v.number(),
      apiLatency: v.number(),
    }),
    
    timestamp: v.number(),
  })
    .index("by_publisher", ["publisherId"])
    .index("by_module_date", ["moduleId", "date"])
    .index("by_period", ["period", "timestamp"]),
})

interface RealtimeConnectionManager {
  // Connection lifecycle
  connection: {
    establish: () => Promise<WebSocket>
    heartbeat: () => void // 30-second intervals
    reconnect: () => Promise<void> // Exponential backoff
    cleanup: () => void
  }
  
  // State synchronization
  sync: {
    optimisticUpdate: (operation: Operation) => void
    conflictResolution: (conflicts: Conflict[]) => Resolution
    broadcastChange: (change: Change) => void
    subscribeToChanges: (callback: ChangeHandler) => Unsubscribe
  }
  
  // Performance optimization
  optimization: {
    batchUpdates: (updates: Update[]) => void
    throttleUpdates: (interval: number) => void
    compressPayload: (data: any) => CompressedData
    deltaSync: (state: State) => Delta
  }
}

interface OperationalTransform {
  // Operation types
  operations: {
    insert: (position: Position, content: any) => Operation
    delete: (position: Position, length: number) => Operation
    modify: (position: Position, changes: Changes) => Operation
    move: (from: Position, to: Position) => Operation
  }
  
  // Transform operations for concurrent editing
  transform: (op1: Operation, op2: Operation) => [Operation, Operation]
  
  // Apply operations to state
  apply: (state: State, operation: Operation) => State
  
  // Version vector for causality tracking
  versionVector: {
    increment: (siteId: string) => VectorClock
    compare: (v1: VectorClock, v2: VectorClock) => Ordering
    merge: (vectors: VectorClock[]) => VectorClock
  }
}

interface ModuleSandbox {
  // Execution environment
  environment: {
    iframe: boolean          // Isolate in iframe
    csp: ContentSecurityPolicy
    permissions: ModulePermissions
    resourceLimits: ResourceLimits
  }
  
  // API access
  api: {
    homepage: HomepageAPI     // Access to homepage context
    storage: StorageAPI       // Scoped data storage
    network: NetworkAPI       // Controlled external access
    ui: UIComponentAPI        // Render components
  }
  
  // Communication
  messaging: {
    sendMessage: (target: ModuleId, message: Message) => void
    onMessage: (handler: MessageHandler) => Unsubscribe
    broadcastEvent: (event: Event) => void
    subscribeEvent: (eventType: string, handler: EventHandler) => void
  }
}

interface ModuleLifecycle {
  // Loading phases
  loading: {
    fetch: () => Promise<ModuleBundle>
    validate: (bundle: ModuleBundle) => ValidationResult
    instantiate: (bundle: ModuleBundle) => ModuleInstance
    mount: (instance: ModuleInstance, container: Element) => void
  }
  
  // Runtime management
  runtime: {
    onMount: (callback: LifecycleCallback) => void
    onUnmount: (callback: LifecycleCallback) => void
    onStateChange: (callback: StateChangeCallback) => void
    onMessage: (callback: MessageCallback) => void
    onError: (callback: ErrorCallback) => void
  }
  
  // Cleanup and disposal
  cleanup: {
    unmount: () => void
    dispose: () => void
    removeListeners: () => void
    clearStorage: () => void
  }
}

interface PerformanceTargets {
  // Page loading
  pageLoad: {
    lcp: 1000,        // Largest Contentful Paint < 1s
    fid: 100,         // First Input Delay < 100ms
    cls: 0.1,         // Cumulative Layout Shift < 0.1
    ttfb: 200,        // Time to First Byte < 200ms
  }
  
  // Real-time sync
  realtime: {
    syncLatency: 100,     // Global sync < 100ms
    conflictResolution: 50, // Resolve conflicts < 50ms
    presenceUpdate: 16,    // Cursor updates at 60fps
    reconnection: 1000,    // Reconnect < 1s
  }
  
  // Module performance
  modules: {
    loadTime: 500,        // Module load < 500ms
    memoryUsage: 50,      // < 50MB per module
    apiLatency: 200,      // API calls < 200ms
    renderTime: 16,       // 60fps rendering
  }
  
  // System scalability
  scale: {
    concurrentUsers: 10000,    // 10K concurrent users
    modulesPerHomepage: 100,   // 100 modules max
    collaboratorsPerPage: 50,  // 50 simultaneous editors
    messagesPerSecond: 1000,   // 1K messages/sec
  }
}

interface CachingStrategy {
  // CDN caching
  cdn: {
    staticAssets: "1 year",      // Images, fonts, etc.
    moduleBundle: "1 month",     // Module code bundles
    apiResponse: "5 minutes",    // Non-realtime API data
    userAvatar: "1 day",         // Profile images
  }
  
  // Browser caching
  browser: {
    moduleState: "session",      // Module state cache
    userPrefs: "localStorage",   // User preferences
    offlineData: "indexedDB",    // Offline support
    recentPages: "sessionStorage", // Recent homepages
  }
  
  // Server caching
  server: {
    convexQueries: "30 seconds", // Query result cache
    userSessions: "24 hours",    // Session data
    moduleMetadata: "1 hour",    // Module registry
    analytics: "15 minutes",     // Analytics data
  }
}

interface DeploymentStrategy {
  // Primary regions
  regions: {
    primary: "us-east-1"     // North America
    europe: "eu-west-1"      // Europe
    asia: "ap-southeast-1"   // Asia Pacific
  }
  
  // Service distribution
  services: {
    frontend: "Vercel Edge Network"
    convex: "Multi-region with automatic failover"
    cdn: "CloudFlare global network"
    monitoring: "DataDog global monitoring"
  }
  
  // Failover strategy
  failover: {
    healthChecks: "Every 30 seconds"
    automaticFailover: "< 60 seconds"
    gracefulDegradation: "Read-only mode if needed"
    rollback: "Automatic on errors"
  }
}

interface SecurityArchitecture {
  // Data protection
  dataProtection: {
    encryption: {
      atRest: "AES-256 with AWS KMS"
      inTransit: "TLS 1.3 minimum"
      database: "Convex built-in encryption"
    }
    
    privacy: {
      gdpr: "Full compliance with data portability"
      ccpa: "California privacy rights support"
      dataRetention: "Automatic cleanup after 2 years"
    }
  }
  
  // Application security
  applicationSecurity: {
    authentication: "Clerk with MFA support"
    authorization: "Role-based access control"
    apiSecurity: "Rate limiting and request validation"
    moduleSecurity: "Sandboxed execution environment"
  }
  
  // Monitoring and auditing
  monitoring: {
    securityEvents: "Real-time SIEM monitoring"
    auditLogging: "Comprehensive activity tracking"
    vulnerabilityScanning: "Automated security scanning"
    penetrationTesting: "Quarterly security audits"
  }
}

interface ExternalIntegrations {
  // Authentication and user management
  clerk: {
    webhooks: "User and organization sync"
    api: "Profile and session management"
    organizations: "Team workspace mapping"
  }
  
  // Real-time data sources
  dataSources: {
    stocks: "Financial data APIs"
    weather: "Weather service APIs"
    news: "RSS and news APIs"
    calendar: "Google Calendar, Outlook"
    chat: "Slack, Discord, Teams"
  }
  
  // Platform services
  platform: {
    analytics: "PostHog for user analytics"
    monitoring: "DataDog for system monitoring"
    cdn: "CloudFlare for asset delivery"
    storage: "AWS S3 for file storage"
  }
}

interface MonitoringStack {
  // Application monitoring
  apm: {
    tool: "DataDog APM"
    metrics: ["response_time", "error_rate", "throughput"]
    traces: "Distributed tracing across Convex projects"
    alerts: "Real-time incident alerting"
  }
  
  // User experience monitoring
  rum: {
    tool: "PostHog + Custom metrics"
    metrics: ["page_load", "module_load", "interaction_delay"]
    heatmaps: "User interaction heatmaps"
    funnels: "Conversion funnel analysis"
  }
  
  // Real-time system monitoring
  realtime: {
    syncLatency: "P50, P95, P99 latency tracking"
    connectionHealth: "WebSocket connection monitoring"
    conflictResolution: "Operational transform performance"
    presenceAccuracy: "Cursor and presence tracking"
  }
  
  // Business metrics
  business: {
    userEngagement: "DAU, MAU, session duration"
    moduleUsage: "Installation and usage analytics"
    platformHealth: "System reliability metrics"
    revenueTracking: "Subscription and marketplace revenue"
  }
}