Deploy EDGE Processing

# Step 1: Create EDGE processor project
wave edge:init my-frame-processor

# Step 2: Navigate to project
cd my-frame-processor

# Step 3: Deploy to staging (100% safe to test)
wave edge:deploy --stage=staging

# Step 4: Get deployment details
wave edge:status

# Step 5: Deploy to production (replicate to 200+ POPs)
wave edge:deploy --stage=production

# View real-time logs from edge locations
wave edge:logs --follow --stage=production

// Subscribe to frame processing events in real-time
const wave = require('@wave/sdk');

const client = new wave.Client({ apiKey: process.env.WAVE_API_KEY });

// Listen for frame analysis events
client.edge.onFrameAnalyzed(async (event) => {
  const {
    streamId,
    timestamp,
    metadata,
    processingMs,
    region,
  } = event;

  console.log(`
    ✓ Frame processed in ${processingMs}ms at ${region}
    ├─ Scene change: ${metadata.sceneChange}
    ├─ Dominant colors: RGB(${metadata.dominantColors.r}, ${metadata.dominantColors.g}, ${metadata.dominantColors.b})
    └─ Histogram distance: ${metadata.histogram}`);

  // Real-time metrics dashboard
  await client.metrics.record('edge.frame.processed', {
    value: 1,
    tags: {
      'stream_id': streamId,
      'region': region,
      'processing_ms': processingMs,
    },
  });
});

// Monitor processing errors across all regions
client.edge.onProcessingError(async (error) => {
  console.error(`⚠️  Error in ${error.region}: ${error.message}`);

  await client.metrics.record('edge.processing.error', {
    region: error.region,
    errorType: error.type,
    timestamp: Date.now(),
  });
});

// Fetch aggregated metrics
setInterval(async () => {
  const metrics = await client.edge.getMetrics({
    period: '5m',
    rollup: 'avg',
  });

  console.log(`
    📊 EDGE Metrics (Last 5 minutes):
    ├─ Frames processed: ${metrics.framesProcessed}
    ├─ Avg latency: ${metrics.avgLatencyMs}ms (target: <15ms)
    ├─ Error rate: ${metrics.errorRate}%
    ├─ Throughput: ${metrics.framesPerSecond} fps
    └─ Geographic coverage: ${metrics.activeRegions} regions
  `);
}, 30000);

{
  "name": "ai-moderation-processor",
  "runtime": "python3.11",
  "resources": {
    "cpu": "4-core",
    "memory": "8GB",
    "gpu": "nvidia-t4",
    "gpuMemory": "16GB"
  },
  "models": [
    {
      "name": "moderation-model-v2",
      "path": "s3://wave-models/moderation-v2.tflite",
      "accelerator": "gpu",
      "cacheFrames": 300
    }
  ],
  "regions": {
    "primary": ["us-east", "us-west", "eu-west"],
    "secondary": ["apac-ne", "apac-se"],
    "tertiary": "*"
  },
  "timeouts": {
    "frameSoftLimit": 12,
    "frameHardLimit": 14
  }
}

// Apply real-time effects to video stream
export default async function applyEffects(frame, ctx) {
  const canvas = ctx.createCanvas(frame.width, frame.height);
  const imageData = canvas.createImageData(frame.data);

  // 1. Apply brand watermark (bottom-right corner)
  applyWatermark(imageData, {
    text: 'LIVE',
    x: frame.width - 150,
    y: frame.height - 50,
    color: '#FF6B35',
  });

  // 2. Add engagement overlay (viewer count, live badge)
  applyOverlay(imageData, {
    type: 'engagement',
    viewerCount: ctx.stream.viewerCount,
    isLive: true,
  });

  // 3. Apply cinematic letterbox effect during highlights
  if (ctx.metadata.isHighlight) {
    applyLetterbox(imageData, {
      height: 60,
      color: '#000000',
    });
  }

  // 4. Apply color correction (brightness, saturation)
  applyColorCorrection(imageData, {
    brightness: 1.1,
    saturation: 1.2,
    contrast: 1.0,
  });

  // 5. Render frame back to video
  return canvas.toBuffer('video/h264');
}

function applyWatermark(imageData, options) {
  // Watermark implementation
}

function applyOverlay(imageData, options) {
  // Engagement overlay with live badge
}

function applyLetterbox(imageData, options) {
  // Black bars for cinematic effect
}

function applyColorCorrection(imageData, options) {
  // Color grade the entire frame
}

// Subscribe to frame analysis events in real-time
import { WaveClient } from '@wave/sdk';

const wave = new WaveClient();

// Listen for scene changes detected in EDGE
wave.on('edge:scene-change', (event) => {
  console.log(`🎬 Scene change detected at ${event.timestamp}ms`);

  // Emit to PULSE for analytics
  wave.emit('viewer:scene-change', {
    streamId: event.streamId,
    timestamp: event.timestamp,
    duration: event.duration,
    sceneIndex: event.sceneIndex,
  });
});

// Monitor moderation violations in real-time
wave.on('edge:moderation-violation', (event) => {
  console.warn(`⚠️  Violation detected: ${event.label} (confidence: ${event.confidence})`);

  // Trigger RUNTIME function to blur frame or notify moderator
  wave.runtime.execute('handle-violation', {
    streamId: event.streamId,
    violation: event.label,
    action: 'blur',
  });
});

// Track processing latency per region
const latencyByRegion = {};
wave.on('edge:frame-processed', (event) => {
  const region = event.region;
  if (!latencyByRegion[region]) {
    latencyByRegion[region] = [];
  }
  latencyByRegion[region].push(event.latencyMs);

  // Alert if latency exceeds 15ms SLA
  if (event.latencyMs > 15) {
    console.error(`❌ SLA violation in ${region}: ${event.latencyMs}ms`);
    wave.metrics.increment('edge.sla_violations', { region });
  }
});