A forward-only JSON writer, the shape of .NET's Utf8JsonWriter: no tree, no allocation. The bytes go straight into the reply - or a raw pipe, or a buffer - escaped as they are written, and stream out as the slab fills. Nesting and commas are tracked, so a handler just says what it means:

ioxd_json j = ioxd_json_reply(ctx);                  // content-type: application/json
ioxd_json_object(&j);
    ioxd_json_key(&j, "id");    ioxd_json_int(&j, id);
    ioxd_json_key(&j, "name");  ioxd_json_string(&j, name);
    ioxd_json_key(&j, "tags");  ioxd_json_array(&j);
        ioxd_json_cstr(&j, "new");
    ioxd_json_end(&j);
ioxd_json_end(&j);
if (!ioxd_json_done(&j)) { ... }                     // whole: nothing failed, nothing open

Strings are emitted byte for byte, with only '"', '\' and the control characters escaped: invalid UTF-8 goes out exactly as it came in, so untrusted input has to be validated first. Every call returns false once the sink is gone (the peer left; the buffer is full), the nesting passed IOXD_JSON_DEPTH, or the call had no place in the document - a key outside an object, a value where a key was due, an end with nothing open. The rest is then dropped, so checking the last call is enough; check done() after it to catch an end that was never written.

A value by its C type, and a key with one: the _Generic picks ioxd_json_int for the integer types, _uint for the unsigned ones, _float and _double for those two, _bool, _cstr for a char pointer, _string for a slice.

A key and its value in one line. The answer goes through a function so that a field written for its effect - `IOXD_JSON_FIELD(j, "n", n);` - is a plain statement and not a value the compiler sees discarded, while `if (IOXD_JSON_FIELD(j, "n", n))` still reads it.

A struct described once, serialized with one call. The description is a list of fields, each line its kind, its C type (or, for a nested struct, that struct's name) and its name:

#define USER_FIELDS(X)                       \
    X(VALUE,    int64_t,      id)            \
    X(VALUE,    const char *, name)          \
    X(OBJECT,   address,      address)       \
    X(OPTIONAL, address,      billing)       \
    X(ARRAY,    const char *, tags,   n_tags)    \
    X(OBJECTS,  order,        orders, n_orders)
IOXD_JSON_STRUCT(user, USER_FIELDS)

VALUE is a scalar, written by its C type; OBJECT a nested struct held by value; OPTIONAL a pointer to one, null where the pointer is NULL; ARRAY scalars and the field holding their count; OBJECTS the same for nested structs. IOXD_JSON_STRUCT defines the struct and the function - struct user, and user_to_json(ioxd_json *, const struct user *); IOXD_JSON_WRITER only the function, for a struct declared elsewhere with the same fields. A nested struct's own IOXD_JSON_STRUCT comes first. Counts are size_t; arrays are pointers to their first element. A note beside a field is written as a block comment, the way playground/hello/main.c writes them: a // one would run on through the backslash and swallow the lines after it.