[ Cloudflare Edge Mesh ]
            (Workers + Durable Objects + SQLite Storage)
                Global Presence, Matchmaking & Signaling
                           ▲              ▲
                 WebSocket │              │ WebSocket
                (Signaling)│              │ (Signaling)
                           │              │
     ┌─────────────────────┴──────────────┴─────────────────────┐
     │                                                          │
[ Host Player ] <════════════════════════════════════════> [ Client Peer ]
• Authoritative Physics               WebRTC DataChannel   • Local Input Capture
• 60Hz Binary State Broadcast           (Sub-15ms UDP)     • Client Prediction
• Damage & Collision Check                                 • Hermite Interpolation
• Fallback Bot Simulation (if solo)                        • RTT Ping & Jitter Probe

import { MerebClient, MerebLobby, SnapshotInterpolator } from 'mereb-netcode';

// 1. Initialize Multiplayer Client
const net = new MerebClient({
  host: 'mereb-signaling.dawitbaslyos.workers.dev',
  botTimeoutMs: 8000,
  autoJoinFromUrl: true
});

// 2. Attach Drop-in Arcade Lobby UI
const lobby = new MerebLobby(net, { title: '⚔️ ARENA WARRIORS' });

// 3. Set up Interpolation Buffer for Smooth Opponent Movement
const interpolator = new SnapshotInterpolator({ bufferTime: 80 });

// 4. Handle Match Lifecycle
net.on('match-start', ({ role, isHost, localId, peerId, isBot }) => {
  console.log(`Match Active! Role: ${role}, Opponent: ${peerId}`);

  if (isHost) {
    // Host: Run Authoritative Simulation Loop (20-60Hz)
    setInterval(() => {
      net.sendState({
        t: Date.now(),
        x: player.x,
        y: player.y,
        health: player.health
      });
    }, 50);
  } else {
    // Client: Stream Inputs to Host
    window.addEventListener('keydown', (e) => {
      net.sendInput({ key: e.key, down: true });
    });
  }
});

// 5. Client receives World State & feeds Interpolator
net.on('state', (serverState) => {
  interpolator.pushSnapshot(serverState.t, { opponent: serverState });
});

// 6. Render Loop (60/120 FPS)
function render() {
  requestAnimationFrame(render);
  if (!net.isHost) {
    const smooth = interpolator.getInterpolated();
    if (smooth.opponent) {
      opponentSprite.x = smooth.opponent.x;
      opponentSprite.y = smooth.opponent.y;
    }
  }
}
requestAnimationFrame(render);

name = "mereb-signaling"
main = "worker.js"
compatibility_date = "2024-09-23"

[durable_objects]
bindings = [
  { name = "GAME_ROOM", class_name = "GameRoom" }
]

[[migrations]]
tag = "v1"
new_sqlite_classes = ["GameRoom"]

const res = await fetch('https://mereb-signaling.workers.dev/api/turn-credentials');
const { iceServers } = await res.json();

const net = new MerebClient({
  host: 'mereb-signaling.workers.dev',
  turnServers: iceServers
});

mergeInto(LibraryManager.library, {
  Mereb_Init: function(hostStr, botTimeoutMs) {
    var host = UTF8ToString(hostStr);
    window.merebClient = new window.Mereb.MerebClient({
      host: host,
      botTimeoutMs: botTimeoutMs,
      autoJoinFromUrl: true
    });
    window.merebClient.on('match-start', function(data) {
      SendMessage('MerebNetworkManager', 'OnNativeMatchStarted', JSON.stringify(data));
    });
    window.merebClient.on('state', function(state) {
      SendMessage('MerebNetworkManager', 'OnNativeStateReceived', JSON.stringify(state));
    });
    window.merebClient.on('input', function(input) {
      SendMessage('MerebNetworkManager', 'OnNativeInputReceived', JSON.stringify(input));
    });
  },
  Mereb_QuickPlay: function() {
    if (window.merebClient) window.merebClient.quickPlay();
  },
  Mereb_SendState: function(stateJsonStr) {
    if (window.merebClient) window.merebClient.sendState(JSON.parse(UTF8ToString(stateJsonStr)));
  },
  Mereb_SendInput: function(inputJsonStr) {
    if (window.merebClient) window.merebClient.sendInput(JSON.parse(UTF8ToString(inputJsonStr)));
  }
});

using System.Runtime.InteropServices;
using UnityEngine;

public class MerebNetworkManager : MonoBehaviour
{
    [SerializeField] private string signalingHost = "mereb-signaling.dawitbaslyos.workers.dev";
    public bool isHost = false;

#if UNITY_WEBGL && !UNITY_EDITOR
    [DllImport("__Internal")] private static extern void Mereb_Init(string host, int timeout);
    [DllImport("__Internal")] private static extern void Mereb_QuickPlay();
    [DllImport("__Internal")] private static extern void Mereb_SendState(string json);
    [DllImport("__Internal")] private static extern void Mereb_SendInput(string json);
#else
    private static void Mereb_Init(string h, int t) => Debug.Log("Editor Mock Init");
    private static void Mereb_QuickPlay() => Debug.Log("Editor Mock QuickPlay");
    private static void Mereb_SendState(string j) {}
    private static void Mereb_SendInput(string j) {}
#endif

    void Start() {
        Mereb_Init(signalingHost, 8000);
        Mereb_QuickPlay();
    }

    public void OnNativeMatchStarted(string json) {
        Debug.Log("[Unity] Match Started: " + json);
    }

    public void OnNativeStateReceived(string json) {
        // Apply remote entity state
    }
}

extends Node2D

@onready var net: MerebMultiplayer = $MerebMultiplayer

func _ready() -> void:
    net.match_started.connect(_on_match_started)
    net.state_received.connect(_on_state_received)
    net.connect_to_server("mereb-signaling.dawitbaslyos.workers.dev")
    net.quick_play()

func _physics_process(delta: float) -> void:
    if net.is_host():
        net.send_state({ "x": $Player.position.x, "y": $Player.position.y })
    else:
        net.send_input({ "up": Input.is_action_pressed("ui_up") })

func _on_state_received(data: Dictionary) -> void:
    $Enemy.position = Vector2(data["x"], data["y"])

import React from 'react';
import { useMereb } from 'mereb-netcode/react';

export function GameLobby() {
  const { status, roomCode, quickPlay, quality } = useMereb({
    host: 'mereb-signaling.dawitbaslyos.workers.dev'
  });

  return (
    <div>
      <h3>Status: {status} ({quality.ping}ms)</h3>
      {roomCode && <p>Room Code: {roomCode}</p>}
      <button onClick={quickPlay}>⚡ Quick Play</button>
    </div>
  );
}

import { defineSchema } from 'mereb-netcode';

export const PlayerSchema = defineSchema({
  x: 'fixed16',        // 2 bytes: precision 100
  z: 'fixed16',        // 2 bytes
  angle: 'fixed16',    // 2 bytes: precision 1000
  health: 'uint8',     // 1 byte
  isFiring: 'boolean'  // 1 bit
});

// Host transmits packed binary ArrayBuffer:
net.sendBinary(PlayerSchema.encode({ x: 12.5, z: -8.4, angle: 1.57, health: 100, isFiring: true }));

// Client decodes in <0.02ms with zero allocations:
net.on('binary', (buffer) => {
  const state = PlayerSchema.decode(buffer);
});

// Auto-hooks official portal SDK
net.usePortal('poki', window.PokiSDK);

// Commercial break pause
async function showAd() {
  await net.portal.commercialBreak(); // Pauses netcode safely
  gameEngine.resume();
}