graph TD
    A[User Frontend] --> B[Next.js App]
    B --> C[Cloudflare Pages]
    B --> D[Cloudflare Workers]
    D --> E[D1 Database]
    D --> F[R2 Storage]
    B --> G[WebRTC P2P]
    D --> H[KV Store]
    
    subgraph "User Infrastructure"
    B
    C
    D
    E
    F
    G
    H
    end

// pages/index.tsx
import { useEffect } from 'react'
import { useWebRTC } from '@/hooks/useWebRTC'
import { useFriends } from '@/hooks/useFriends'

export default function Home() {
  const { initializeWebRTC, peers } = useWebRTC()
  const { friends } = useFriends()
  
  useEffect(() => {
    // Initialize WebRTC connections with online friends
    friends.forEach(friend => {
      if (friend.status === 'online') {
        initializeWebRTC(friend.globalId)
      }
    })
  }, [friends])
  
  return (
    <div>
      <FriendsList friends={friends} />
      <P2PChat peers={peers} />
    </div>
  )
}

// worker/index.ts
import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { jwt } from 'hono/jwt'

const app = new Hono()

app.use('/*', cors())
app.use('/api/*', jwt({ secret: env.JWT_SECRET }))

// API routes
app.route('/api/auth', authRouter)
app.route('/api/friends', friendsRouter)
app.route('/api/posts', postsRouter)
app.route('/api/rtc', rtcRouter)

export default app

// schema/index.ts
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'

export const users = sqliteTable('users', {
  id: integer('id').primaryKey(),
  globalId: text('global_id').notNull().unique(),
  apiUrl: text('api_url').notNull(),
  publicKey: text('public_key').notNull(),
  createdAt: integer('created_at').notNull(),
})

export const posts = sqliteTable('posts', {
  id: integer('id').primaryKey(),
  userId: integer('user_id').references(() => users.id),
  content: text('content').notNull(),
  mediaUrl: text('media_url'),
  createdAt: integer('created_at').notNull(),
})

export const friends = sqliteTable('friends', {
  id: integer('id').primaryKey(),
  userId: integer('user_id').references(() => users.id),
  friendGlobalId: text('friend_global_id').notNull(),
  friendApiUrl: text('friend_api_url').notNull(),
  status: text('status').notNull(), // pending, accepted, blocked
})

// AT Protocol PDS example
interface ATProtocolPDS {
  did: string;  // did:plc:xxxxx
  handle: string;
  posts: Post[];
  follows: Follow[];
}

// Our distributed approach
interface DistributedNode {
  globalId: string;  // UUID v4
  apiUrl: string;
  publicKey: string;
  localData: D1Database;
}

// ActivityPub outbox implementation
app.get('/api/activitypub/outbox', async (c) => {
  const db = initDrizzle(c.env)
  const userId = c.get('jwtPayload').userId
  
  const posts = await db.query.posts.findMany({
    where: eq(posts.userId, userId),
    orderBy: desc(posts.createdAt),
  })
  
  return c.json({
    '@context': 'https://www.w3.org/ns/activitystreams',
    type: 'OrderedCollection',
    totalItems: posts.length,
    orderedItems: posts.map(formatActivityPubPost),
  })
})

// hooks/useWebRTC.ts
export function useWebRTC() {
  const [peers, setPeers] = useState<Map<string, RTCPeerConnection>>()
  
  const initializePeer = async (targetId: string) => {
    const pc = new RTCPeerConnection({
      iceServers: [
        { urls: 'stun:stun.l.google.com:19302' },
        {
          urls: env.TURN_URL,
          username: env.TURN_USERNAME,
          credential: env.TURN_PASSWORD,
        }
      ]
    })
    
    // Handle connection lifecycle
    pc.onicecandidate = ({ candidate }) => {
      if (candidate) {
        sendSignal(targetId, { type: 'candidate', candidate })
      }
    }
    
    pc.onconnectionstatechange = () => {
      if (pc.connectionState === 'failed') {
        // Implement ICE restart logic
        pc.restartIce()
      }
    }
    
    return pc
  }
  
  // ... rest of the implementation
}

// Content moderation schema and API
export const contentTags = sqliteTable('content_tags', {
  id: integer('id').primaryKey(),
  postId: integer('post_id').references(() => posts.id),
  tag: text('tag').notNull(), // spam, adult, harassment, etc.
  createdBy: text('created_by').notNull(),
  confidence: real('confidence').notNull(),
  createdAt: integer('created_at').notNull(),
})

app.post('/api/moderation/report', async (c) => {
  const { postId, tag, evidence } = await c.req.json()
  const userId = c.get('jwtPayload').userId
  
  // Add to personal blocklist
  await db.insert(contentTags).values({
    postId,
    tag,
    createdBy: userId,
    confidence: 1.0,
    createdAt: Date.now(),
  })
  
  // Update community blocklist if threshold met
  const tags = await db.query.contentTags.findMany({
    where: eq(contentTags.postId, postId),
  })
  
  if (tags.length >= 5) { // Configurable threshold
    const kv = c.env.KV
    await kv.put(`blocklist:${postId}`, JSON.stringify({
      postId,
      tags: aggregateTags(tags),
      updatedAt: Date.now(),
    }))
  }
  
  return c.json({ success: true })
})

# Clone and setup
git clone https://github.com/JoeJoeyMa/distributed-social
cd distributed-social
pnpm install

# Configure environment
cp .env.example .env
# Edit .env with your Cloudflare credentials

# Initialize D1 database
npx wrangler d1 create my-social-db
npx wrangler d1 execute my-social-db --file=./schema.sql

# Deploy
npx wrangler deploy

// wrangler.toml
name = "distributed-social"
main = "src/worker/index.ts"

[[ d1_databases ]]
binding = "DB"
database_name = "my-social-db"
database_id = "your-database-id"

[[ r2_buckets ]]
binding = "MEDIA"
bucket_name = "media-storage"

[[ kv_namespaces ]]
binding = "KV"
id = "your-kv-id"