One executable,
the entire C server world

/* route.h — URI × method slot-based registration (real source excerpt) */
static void RouteHTTP_Init(void)
{
	G_StaticRouteTableHTTP = xrtMapCreate(sizeof(RouteInfoHTTP));

	/* Static routes: exact URIs */
	AddStaticRouteHTTP("/api/v1/items", XHTTP_METHOD_GET,  Handle_API_List);
	AddStaticRouteHTTP("/api/v1/items", XHTTP_METHOD_POST, Handle_API_Add);

	/* Dynamic routes: {id} segment capture, method masks combine freely */
	AddDynamicRouteHTTP("/api/v1/items/{id}",
		XHTTP_METHOD_GET,                    Handle_API_Item);
	AddDynamicRouteHTTP("/api/v1/items/{id}",
		XHTTP_METHOD_PUT | XHTTP_METHOD_PATCH, Handle_API_Item_Update);
	AddDynamicRouteHTTP("/api/v1/items/{id}",
		XHTTP_METHOD_DELETE,                 Handle_API_Item_Delete);

	/* After registration, compile once into immutable patterns —
	   matching cost is independent of the route count */
	(void)RouteHTTP_Compile();
}

/* route_http/basic.h — building JSON with xvalue (real source excerpt) */
static void Handle_JSON(XS_HttpReq* pReq,
	const RouteParamHTTP* arrParam, uint32 iParamCount)
{
	const XS_HostInfo* pHost = pReq->host;
	xvalue* pObject = xrtValueObject();

	(void)arrParam; (void)iParamCount;
	xrtValueObjectSetNew(pObject, XRT_STR_LITERAL("server"),
		xrtValueString(XRT_STR_LITERAL("xs3 demo")));
	xrtValueObjectSetNew(pObject, XRT_STR_LITERAL("ok"),
		xrtValueBool(true));
	xrtValueObjectSetNew(pObject, XRT_STR_LITERAL("host"),
		xrtValueString(xrtStrView((pHost->Name ? pHost->Name : "?"))));

	(void)ReplyJSON(pReq, 200, pObject);
	xrtValueRelease(pObject);
}

/* ws / wss contract callbacks: XServer does handshake and framing,
   you write only business logic */
static void WsOpen(XS_HostInfo* pHost, xwsstream* pWs)
{
	xrtWsStreamText(pWs, xrtStrView("connected"));
}

static void WsText(XS_HostInfo* pHost, xwsstream* pWs, xstrview tText)
{
	/* Masking, fragment reassembly, control frames and message
	   limits are all handled by the xrt layer */
	(void)xrtWsStreamText(pWs, tText);          /* echo */
}

static void WsBinary(XS_HostInfo* pHost, xwsstream* pWs, xbytesview tData)
{
	xvalue* pMsg = xrtValueObject();
	xrtValueObjectSetNew(pMsg, XRT_STR_LITERAL("size"),
		xrtValueInt64((int64)tData.Size));
	(void)xrtWsStreamBinary(pWs, tData);
	xrtValueRelease(pMsg);
}

/* Hot-reload state handover: the old generation exports a snapshot,
   the new one takes it and carries on (contract API) */
static bool ServiceSwap(XS_HostInfo* pHost, xvalue** ppShared)
{
	xvalue* pState = xrtValueObject();

	xrtValueObjectSetNew(pState, XRT_STR_LITERAL("counter"),
		xrtValueInt64(G_iCounter));
	*ppShared = pState;               /* non-destructive: the old
	                                      generation can still serve */
	return true;
}

static void ServiceInit(XS_HostInfo* pHost)
{
	xvalue* pState = xsSwapTake(pHost);   /* valid only inside the
	                                      new generation's Init */

	if ( pState != NULL ) {
		G_iCounter = xrtValueInt64(
			xrtValueObjectGet(pState, "counter"));
		xrtValueRelease(pState);
	}
}

/* Trigger a reload: desired-state coordination; the returned
   stable ID can query the final state */
XS_ReloadId iId = xsReloadHostSubmit(pHost);