Client Request
                              |
                              v
                    +-------------------+
                    |   Anycast DNS     |
                    |   (Cloudflare)    |
                    +--------+----------+
                             |
              +--------------+--------------+
              |              |              |
              v              v              v
       +------------+  +------------+  +------------+
       | Edge PoP   |  | Edge PoP   |  | Edge PoP   |
       | US-East    |  | EU-West    |  | AP-Tokyo   |
       |            |  |            |  |            |
       | +--------+ |  | +--------+ |  | +--------+ |
       | |V8 Iso- | |  | |V8 Iso- | |  | |V8 Iso- | |
       | |lates   | |  | |lates   | |  | |lates   | |
       | +--------+ |  | +--------+ |  | +--------+ |
       | +--------+ |  | +--------+ |  | +--------+ |
       | |Edge KV | |  | |Edge KV | |  | |Edge KV | |
       | |Cache   | |  | |Cache   | |  | |Cache   | |
       | +--------+ |  | +--------+ |  | +--------+ |
       | +--------+ |  | +--------+ |  | +--------+ |
       | |Rate    | |  | |Rate    | |  | |Rate    | |
       | |Limiter | |  | |Limiter | |  | |Limiter | |
       | +--------+ |  | +--------+ |  | +--------+ |
       +-----+------+  +-----+------+  +-----+------+
             |              |              |
             +--------------+--------------+
                            |
                            v
                  +-------------------+
                  |  Hanzo Gateway    |
                  |  api.hanzo.ai    |
                  |  (Origin)        |
                  +--------+----------+
                           |
              +------------+------------+
              |            |            |
              v            v            v
          cloud-api   commerce     agents
           :8000       :8001       :8080

# Install the Hanzo CLI
npm install -g @hanzo/cli

# Authenticate
hanzo auth login

# Create a new edge function project
hanzo edge init my-function
cd my-function

my-function/
  src/
    index.ts        # Entry point
  hanzo.edge.toml   # Configuration
  package.json
  tsconfig.json

// src/index.ts
export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const url = new URL(request.url)

    // Cache AI responses at the edge
    if (url.pathname.startsWith('/api/inference')) {
      const cacheKey = new Request(url.toString(), request)
      const cache = caches.default

      let response = await cache.match(cacheKey)
      if (response) {
        return new Response(response.body, {
          ...response,
          headers: { ...response.headers, 'X-Edge-Cache': 'HIT' },
        })
      }

      // Forward to Hanzo Gateway origin
      response = await fetch(`https://api.hanzo.ai/v1/chat/completions`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${env.HANZO_API_KEY}`,
          'Content-Type': 'application/json',
        },
        body: request.body,
      })

      // Cache for 60 seconds
      const cached = new Response(response.body, response)
      cached.headers.set('Cache-Control', 'public, max-age=60')
      ctx.waitUntil(cache.put(cacheKey, cached.clone()))

      return cached
    }

    return new Response('Hanzo Edge', { status: 200 })
  },
}

# Deploy to all edge PoPs
hanzo edge deploy

# Deploy to specific regions only
hanzo edge deploy --regions us-east,eu-west,ap-northeast

# View deployment status
hanzo edge status my-function

curl https://my-function.edge.hanzo.ai/api/inference \
  -H "Content-Type: application/json" \
  -d '{"model": "alibaba-qwen3-32b", "messages": [{"role": "user", "content": "Hello"}]}'

const cacheKey = `${model}:${hashBody(request.body)}`
const cached = await env.EDGE_KV.get(cacheKey, 'json')

if (cached) {
  return Response.json(cached, {
    headers: { 'X-Edge-Cache': 'HIT', 'X-Cache-TTL': cached._ttl },
  })
}

const result = await forwardToOrigin(request)
await env.EDGE_KV.put(cacheKey, JSON.stringify(result), {
  expirationTtl: 3600, // 1 hour
})

import { cosineSimilarity, embed } from '@hanzo/edge/semantic'

const queryEmbedding = await embed(request.body.messages)
const neighbors = await env.EDGE_VECTOR.query(queryEmbedding, { topK: 1 })

if (neighbors[0] && neighbors[0].score > 0.95) {
  const cached = await env.EDGE_KV.get(neighbors[0].id, 'json')
  return Response.json(cached, {
    headers: { 'X-Edge-Cache': 'SEMANTIC_HIT', 'X-Similarity': neighbors[0].score },
  })
}

[cache]
default_ttl = 3600          # 1 hour default
max_ttl = 86400              # 24 hour maximum
bypass_cookie = "nocache"    # Bypass cache on cookie
bypass_header = "X-No-Cache" # Bypass cache on header

[[cache.rules]]
path = "/api/embeddings/*"
ttl = 86400                  # Embeddings rarely change

[[cache.rules]]
path = "/api/chat/*"
ttl = 0                      # Never cache chat by default

[[cache.rules]]
path = "/api/classify/*"
ttl = 3600
semantic = true              # Enable semantic matching
similarity_threshold = 0.95

# Purge all cached content for a function
hanzo edge cache purge my-function

# Purge specific paths
hanzo edge cache purge my-function --path "/api/embeddings/*"

# View cache analytics
hanzo edge cache stats my-function

# hanzo.edge.toml

[bindings]
# Key-value storage (globally replicated, eventually consistent)
EDGE_KV = { type = "kv", namespace = "my-app-cache" }

# Durable Objects (strongly consistent, single-instance coordination)
SESSIONS = { type = "durable-object", class = "SessionManager" }

# Hanzo S3 bucket (S3-compatible object storage)
MODELS = { type = "s3", bucket = "my-models" }

# Environment secrets
HANZO_API_KEY = { type = "secret" }
DATABASE_URL = { type = "secret" }

import { Router, withAuth, withRateLimit, withCors } from '@hanzo/edge'

const router = new Router()

router.use(withCors({ origin: '*' }))
router.use(withRateLimit({ limit: 100, window: 60 }))
router.use(withAuth({ issuer: 'https://hanzo.id' }))

router.post('/api/inference', async (req, env) => {
  const response = await fetch('https://api.hanzo.ai/v1/chat/completions', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${env.HANZO_API_KEY}` },
    body: req.body,
  })
  return response
})

router.get('/health', () => Response.json({ status: 'ok' }))

export default router

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.headers.get('Upgrade') === 'websocket') {
      const [client, server] = Object.values(new WebSocketPair())

      server.accept()
      server.addEventListener('message', async (event) => {
        const payload = JSON.parse(event.data as string)

        // Stream from Hanzo Gateway
        const response = await fetch('https://api.hanzo.ai/v1/chat/completions', {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${env.HANZO_API_KEY}`,
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ ...payload, stream: true }),
        })

        const reader = response.body!.getReader()
        const decoder = new TextDecoder()

        while (true) {
          const { done, value } = await reader.read()
          if (done) {
            server.send(JSON.stringify({ type: 'done' }))
            break
          }
          server.send(decoder.decode(value))
        }
      })

      return new Response(null, { status: 101, webSocket: client })
    }

    return new Response('WebSocket endpoint', { status: 426 })
  },
}

# Add a custom domain
hanzo edge domain add my-function api.example.com

# Verify DNS (add a CNAME pointing to edge.hanzo.ai)
hanzo edge domain verify api.example.com

# List domains
hanzo edge domain list my-function

hanzo edge domain add my-function "*.example.com"

# hanzo.edge.toml

[[rate_limit]]
path = "/api/*"
limit = 100            # requests
window = 60            # seconds
key = "ip"             # per IP address
response_code = 429

[[rate_limit]]
path = "/api/inference"
limit = 20
window = 60
key = "header:Authorization"  # per API key
response_code = 429

[[rate_limit]]
path = "/api/public/*"
limit = 1000
window = 60
key = "ip"

import { RateLimiter } from '@hanzo/edge'

const limiter = new RateLimiter({
  namespace: env.RATE_LIMITER,
  limit: 60,
  window: 60,
})

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const clientIP = request.headers.get('CF-Connecting-IP') || 'unknown'
    const { success, remaining, reset } = await limiter.check(clientIP)

    if (!success) {
      return new Response('Rate limit exceeded', {
        status: 429,
        headers: {
          'X-RateLimit-Remaining': '0',
          'X-RateLimit-Reset': String(reset),
          'Retry-After': String(Math.ceil((reset - Date.now()) / 1000)),
        },
      })
    }

    const response = await handleRequest(request, env)
    response.headers.set('X-RateLimit-Remaining', String(remaining))
    return response
  },
}

import { withSecurity } from '@hanzo/edge'

// Adds CSP, HSTS, X-Frame-Options, X-Content-Type-Options
router.use(withSecurity({
  hsts: { maxAge: 31536000, includeSubDomains: true },
  contentSecurityPolicy: "default-src 'self'; script-src 'self'",
  frameOptions: 'DENY',
}))

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const country = request.cf?.country || 'US'
    const continent = request.cf?.continent || 'NA'

    // Route to nearest regional origin
    const origins: Record<string, string> = {
      'NA': 'https://us.api.hanzo.ai',
      'EU': 'https://eu.api.hanzo.ai',
      'AS': 'https://ap.api.hanzo.ai',
    }

    const origin = origins[continent] || origins['NA']

    return fetch(new Request(origin + new URL(request.url).pathname, request))
  },
}

# Stream live logs from all PoPs
hanzo edge logs my-function --follow

# Filter by status code
hanzo edge logs my-function --status 500

# Filter by region
hanzo edge logs my-function --region eu-west

# View metrics summary
hanzo edge metrics my-function --period 24h

name = "my-function"
main = "src/index.ts"
compatibility_date = "2026-02-22"

[account]
id = "your-account-id"

# Build settings
[build]
command = "npm run build"
watch_dir = "src"

# Environment variables (non-secret)
[vars]
ENVIRONMENT = "production"
LOG_LEVEL = "info"

# Bindings
[bindings]
EDGE_KV = { type = "kv", namespace = "my-cache" }
HANZO_API_KEY = { type = "secret" }

# Routes
[[routes]]
pattern = "api.example.com/*"
zone_name = "example.com"

# Cache rules
[cache]
default_ttl = 3600

# Rate limiting
[[rate_limit]]
path = "/api/*"
limit = 100
window = 60
key = "ip"

# Cron triggers (scheduled invocations)
[[triggers.crons]]
cron = "0 * * * *"    # Every hour

hanzo edge init <name>              # Scaffold a new edge function
hanzo edge dev                      # Run locally with hot reload
hanzo edge deploy                   # Deploy to all PoPs
hanzo edge deploy --regions <list>  # Deploy to specific regions
hanzo edge delete <name>            # Remove an edge function
hanzo edge list                     # List all edge functions
hanzo edge status <name>            # View deployment status
hanzo edge logs <name> --follow     # Stream live logs
hanzo edge metrics <name>           # View performance metrics
hanzo edge cache purge <name>       # Purge edge cache
hanzo edge domain add <name> <dom>  # Add custom domain
hanzo edge domain list <name>       # List custom domains
hanzo edge secret put <key>         # Set a secret binding
hanzo edge secret list              # List secret bindings