pbwire 0.1.7__tar.gz

pbwire-0.1.7/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: pbwire
+Version: 0.1.7
+Summary: Dynamic protobuf over the pbwire C ABI, schema at runtime, no generated code
+Home-page: https://github.com/jinganix/pbwire
+Author: jinganix
+License: Apache-2.0
+Requires-Python: >=3.9
+Dynamic: author
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary

pbwire-0.1.7/README.md

@@ -0,0 +1,170 @@
+# pbwire Python binding
+
+`bindings/python/runtime/pbwire.c` is a CPython extension and the Python
+binding: a `FileDescriptorSet` (`protoc --descriptor_set_out`) becomes a schema
+at runtime, and messages go between wire bytes and plain Python data with no
+generated code and no intermediate message tree.
+
+```python
+import pbwire
+
+schema = pbwire.Schema.from_file("examples/addressbook.desc")
+person = schema.message("tutorial.Person")
+
+wire = person.encode({"name": "alice", "id": 1,
+                      "phones": [{"number": "555", "type": 1}]})
+message = person.decode(wire)         # parsed once, fields read on demand
+assert message.name == "alice"
+assert message.phones[0].number == "555"
+assert message.to_dict() == {"name": "alice", "id": 1,
+                             "phones": [{"number": "555", "type": 1}]}
+assert person.encode(message) == wire  # byte-exact round trip
+```
+
+## Two representations
+
+| | path | cost |
+|---|---|---|
+| `dict` | `encode(dict)` / `Message.to_dict()` | one pass, plain CPython objects |
+| wire | `decode(bytes)` → `Message` | one tag scan, a slice per wire field |
+| `Message` | `encode(message)` | the bytes it was parsed from |
+
+`decode()` returns a lazily read message rather than a dict tree, because a
+dict tree has to build every dict, string and int before the caller can look at
+any of them. On a 75 KB message that is ~400 µs of `malloc`-bound object
+creation; `decode()` instead walks the wire once (58 µs) and records where each
+field lives. Field values materialize when they are read, `to_dict()` builds
+the whole tree when it is actually wanted.
+
+`decode()` validates everything it walks: every tag, field number, wire type,
+length, nesting depth, sub-message and packed run. A message you get back is
+well-formed; field values (and proto2 `required` presence) are checked when
+they are materialized or written.
+
+## `Message`
+
+A `Message` is immutable and keeps the buffer it was parsed from, so sub
+messages share the bytes and `encode(message)` is a copy of them. That makes a
+`decode`/`encode` round trip exact: unknown fields, field order and
+non-canonical encodings survive, which a `to_dict()`/`encode(dict)` round trip
+cannot do. Use `Message` to inspect or pass through payloads, and
+`to_dict()`/`encode()` to work with plain data.
+
+| member | meaning |
+|---|---|
+| `msg.name` / `msg["name"]` | field value; attribute access gives `None` for an absent field, item access raises `KeyError` |
+| `msg.nums` | list for a repeated field, built when read |
+| `msg.inner` | sub `Message`; repeated sub-messages come back as a list of `Message` |
+| `msg.get(name, default=None)` | value, or `default` when the field is absent |
+| `msg.keys()` / `values()` / `items()` | fields present on the wire, in wire order |
+| `"nums" in msg`, `len(msg)` | presence and field count |
+| `msg.to_dict()` | the eager form: plain dicts and lists all the way down |
+| `msg.type` | message full name |
+| `encode(msg)` | the message's wire bytes |
+
+A singular message field that appears more than once on the wire merges (the
+payloads concatenate), and a oneof member set later clears the earlier ones, in
+both representations.
+
+## Value mapping
+
+| protobuf | Python |
+|---|---|
+| int32/int64/sint*/sfixed* | int (signed, range-checked) |
+| uint32/uint64/fixed* | int (range-checked) |
+| bool | bool |
+| float/double | float |
+| string | str (utf-8; undecodable bytes come back as `bytes`) |
+| bytes | bytes |
+| enum | int |
+| message | dict / `Message` |
+| repeated | list (any sequence is accepted on encode) |
+
+A field missing from the dict is absent from the message and vice versa, which
+matches proto2 presence and proto3 implicit presence. Values written into the
+dict are emitted as given, including zeros — that is a valid but not the
+shortest encoding of a proto3 message. Unknown fields in the wire are kept by a
+`Message` and skipped by `to_dict()`; an unknown *key* on encode raises
+`KeyError` instead of being dropped silently. Encoding a proto2 message whose
+`required` field is missing raises `ValueError`, and so does materializing one.
+
+## Layout
+
+| Piece | Path | Role |
+|---|---|---|
+| runtime | [`runtime/pbwire.c`](runtime/pbwire.c) | the CPython extension: schema, message types, dict <-> wire, parsed messages |
+| examples | [`examples/addressbook.py`](examples/addressbook.py) | schema at runtime, dict round trip + parsed message |
+| tests | [`tests/test_pbwire.py`](tests/test_pbwire.py) | byte parity with the `protoc` reference, oneof/merge/required failure paths |
+| benchmarks | [`benchmarks/bench.py`](benchmarks/bench.py) | vs `google.protobuf` on four tiers |
+| conformance | [`conformance/`](conformance/) | official runner testee, `make conformance-python` |
+
+## Build
+
+```shell
+make python-bind    # builds the extension next to the sources
+make python-test    # self-check (no dependencies beyond Python)
+make python-bench   # benchmark vs google.protobuf (needs protoc + protobuf)
+```
+
+The extension statically links the core (`build/libpbwire.a`), so it needs a C
+compiler and the Python headers (`python3 -c "import sysconfig; ..."`), but no
+setuptools, no wheel, no generated Python. `make python-bind` writes
+`bindings/python/pbwire<EXT_SUFFIX>`; add that directory to `PYTHONPATH` (the
+tests and the benchmark do it themselves).
+
+## Benchmark
+
+[`benchmarks/bench.py`](benchmarks/bench.py) compares against `google.protobuf`
+(the upb C extension) on the same `matrix3.proto` message at the four standard
+tiers from [`../../BENCHMARKS.md`](../../BENCHMARKS.md) (small / medium / large /
+xlarge scale the repeated fields x0 / x1 / x100 / x3000), printing the same
+`impl op ns/op MB/s` table as every other harness. Copied from that file, which
+is the single source for all performance numbers; higher is better, MB/s over
+wire bytes.
+
+```shell
+make python-bench
+```
+
+It verifies byte-for-byte parity with `protobuf`'s own encoding and
+both dict representations before timing.
+
+| payload | op | pbwire-py (MB/s, x upb) | upb (MB/s) |
+|---|---|---|---|
+| 136 B | encode(data) | 298.9 (5.7x) | 52.3 |
+| 136 B | decode(bytes) | 689.3 (1.20x) | 575.5 |
+| 136 B | to_dict(bytes) | 162.0 (4.9x) | 33.3 |
+| 136 B | encode(parsed) | 3099.8 (4.1x) | 747.6 |
+| 174 B | encode(data) | 342.2 (5.6x) | 60.6 |
+| 174 B | decode(bytes) | 724.9 (1.25x) | 580.8 |
+| 174 B | to_dict(bytes) | 156.7 (5.7x) | 27.6 |
+| 174 B | encode(parsed) | 4005.2 (4.7x) | 860.8 |
+| 2469 B | encode(data) | 495.3 (6.5x) | 76.5 |
+| 2469 B | decode(bytes) | 1167.1 (1.60x) | 730.5 |
+| 2469 B | to_dict(bytes) | 195.9 (4.8x) | 40.4 |
+| 2469 B | encode(parsed) | 30710.1 (22x) | 1400.5 |
+| 74913 B | encode(data) | 564.4 (6.5x) | 86.6 |
+| 74913 B | decode(bytes) | 1366.0 (1.69x) | 810.0 |
+| 74913 B | to_dict(bytes) | 170.6 (3.8x) | 44.6 |
+| 74913 B | encode(parsed) | 97683.0 (63x) | 1540.4 |
+
+Rows are the same user-visible task on both sides: `encode(data)` starts from
+the same dict, `decode(bytes)` ends with an in-memory message, `to_dict(bytes)`
+ends with plain Python data, and `encode(parsed)` starts from an already parsed
+message (a `Message` hands back the bytes it was parsed from, so the round trip
+is byte-exact).
+
+upb wins nothing: it spends 890 µs filling a message field by field from the
+dict, it parses into its arena and materializes a proxy per field access, and
+its serialization re-encodes every field from its own structs where a parsed
+`Message` just hands back the bytes. The `to_dict()` row is the one where both
+sides pay for every dict, string and int; that cost is `malloc`-bound and
+nobody can avoid it.
+
+## Typed models
+
+`protoc-gen-pbwire-typed` (in `../typed`) generates dataclasses with type
+annotations plus `to_dict()`/`from_dict()`, and `encode(msg_type)` /
+`decode(msg_type, wire)` on top of the dict API. The committed output is
+`tests/gen/` and `examples/gen/`; `examples/addressbook.py` uses the dataclasses
+only. See `../typed/README.md`.

pbwire-0.1.7/VERSION

@@ -0,0 +1 @@
+0.1.7

pbwire-0.1.7/core/arena.c

@@ -0,0 +1,239 @@
+/* Bump allocator backing pbw_ctx: allocation is a pointer add, releasing is a
+ * pointer reset. Chunks double in size so a steady decode workload stops
+ * calling malloc entirely after the first few messages. */
+
+#include "internal.h"
+
+#define PBW_ARENA_MIN_CHUNK 4096u
+
+static size_t
+align_up(size_t size)
+{
+    /* 8 bytes keeps every struct in this library naturally aligned. */
+    return (size + 7u) & ~(size_t)7u;
+}
+
+static int
+chunk_add(pbw_arena *arena, size_t need)
+{
+    size_t cap = arena->chunk_size;
+    pbw_arena_chunk *chunk;
+
+    if (arena == NULL) {
+        return 0;
+    }
+    if (cap < need) {
+        cap = need;
+    }
+    if (cap > SIZE_MAX - sizeof(*chunk)) {
+        return 0;
+    }
+    chunk = (pbw_arena_chunk *)malloc(sizeof(*chunk) + cap);
+    if (chunk == NULL) {
+        return 0;
+    }
+    chunk->next = arena->head;
+    chunk->used = 0;
+    chunk->cap = cap;
+    arena->head = chunk;
+    /* Grow the next chunk so a workload that needs more keeps its balance: the
+     * chunk count stays small while per-call allocation stays O(1). */
+    arena->chunk_size = cap < (size_t)1 << 20 ? cap * 2 : cap;
+    return 1;
+}
+
+void *
+pbw_arena_alloc_slow(pbw_arena *arena, size_t size)
+{
+    pbw_arena_chunk *chunk;
+    void *ptr;
+
+    size_t large_at;
+
+    if (arena == NULL) {
+        return NULL;
+    }
+    large_at = arena->retain_cap > PBW_ARENA_LARGE_THRESHOLD
+                   ? arena->retain_cap
+                   : PBW_ARENA_LARGE_THRESHOLD;
+
+    if (size > SIZE_MAX - 7u) {
+        return NULL;
+    }
+    size = align_up(size == 0 ? 1 : size);
+    if (size > large_at) {
+        /* Oversized single allocation: one malloc on the large list, freed on
+         * reset/free instead of pinning the reusable head chunk. */
+        pbw_arena_chunk *big;
+
+        /* new_packed guards the same addition; sizes here can approach
+         * SIZE_MAX - 7 through the public bytes constructors. */
+        if (size > SIZE_MAX - sizeof(*big)) {
+            return NULL;
+        }
+        big = (pbw_arena_chunk *)malloc(sizeof(*big) + size);
+
+        if (big == NULL) {
+            return NULL;
+        }
+        big->next = arena->large;
+        big->used = size;
+        big->cap = size;
+        arena->large = big;
+        return (char *)(big + 1);
+    }
+    chunk = arena->head;
+    if (chunk == NULL || !pbw_cap_holds(chunk->cap, chunk->used) ||
+        chunk->cap - chunk->used < size) {
+        if (!chunk_add(arena, size)) {
+            return NULL;
+        }
+        chunk = arena->head;
+    }
+    ptr = (char *)(chunk + 1) + chunk->used;
+    chunk->used += size;
+    return ptr;
+}
+
+void
+pbw_arena_reset(pbw_arena *arena)
+{
+    /* Chunks are pushed at the head and grow, so the head is the largest one:
+     * keep it and drop the rest. A workload that needs the same amount of space
+     * every time then stops calling malloc entirely. */
+    pbw_arena_chunk *head;
+    pbw_arena_chunk *chunk;
+
+    if (arena == NULL) {
+        return;
+    }
+    head = arena->head;
+
+    if (head == NULL || arena->block != NULL) {
+        /* A packed arena belongs to one decoded tree and is never reset.
+         * A fresh context has no chunks yet: still return it to the blank
+         * (mutable) slate. */
+        arena->readonly = 0;
+        return;
+    }
+    /* A reset context is a blank slate: trees built into it afterwards are
+     * mutable until a decode seals it read-only again. */
+    arena->readonly = 0;
+    /* Large single allocations never become resident. */
+    for (chunk = arena->large; chunk != NULL;) {
+        pbw_arena_chunk *next = chunk->next;
+
+        free(chunk);
+        chunk = next;
+    }
+    arena->large = NULL;
+    /* An outlier that grew the head past the budget is dropped as well:
+     * steady workloads under budget stay malloc-free, anything above pays
+     * one malloc per reset instead of pinning the peak forever. */
+    if (head->cap > arena->retain_cap) {
+        free(head);
+        arena->head = NULL;
+        arena->chunk_size = PBW_ARENA_MIN_CHUNK;
+        return;
+    }
+    for (chunk = head->next; chunk != NULL;) {
+        pbw_arena_chunk *next = chunk->next;
+        free(chunk);
+        chunk = next;
+    }
+    head->next = NULL;
+    head->used = 0;
+}
+
+pbw_arena *
+pbw_arena_new_packed(size_t first_chunk)
+{
+    size_t total;
+    uint8_t *block;
+    pbw_arena *arena;
+    pbw_arena_chunk *chunk;
+
+    if (first_chunk > SIZE_MAX - sizeof(pbw_arena) - sizeof(pbw_arena_chunk)) {
+        return NULL;
+    }
+    total = sizeof(pbw_arena) + sizeof(pbw_arena_chunk) + first_chunk;
+    block = (uint8_t *)malloc(total);
+    if (block == NULL) {
+        return NULL;
+    }
+    arena = (pbw_arena *)(void *)block;
+    chunk = (pbw_arena_chunk *)(void *)(block + sizeof(pbw_arena));
+    chunk->next = NULL;
+    chunk->used = 0;
+    chunk->cap = first_chunk;
+    arena->head = chunk;
+    arena->large = NULL;
+    arena->retain_cap = PBW_ARENA_LARGE_THRESHOLD;
+    arena->chunk_size = first_chunk < PBW_ARENA_MIN_CHUNK ? PBW_ARENA_MIN_CHUNK
+                                                          : first_chunk;
+    arena->readonly = 0;
+    arena->block = block;
+    return arena;
+}
+
+void
+pbw_arena_free(pbw_arena *arena)
+{
+    pbw_arena_chunk *chunk;
+    pbw_arena_chunk *big;
+
+    if (arena == NULL) {
+        return;
+    }
+    chunk = arena->head;
+    big = arena->large;
+
+    while (big != NULL) {
+        pbw_arena_chunk *next = big->next;
+
+        free(big);
+        big = next;
+    }
+    arena->large = NULL;
+    if (arena->block != NULL) {
+        /* The arena struct and its first chunk live in the block itself. */
+        uint8_t *base = (uint8_t *)arena->block;
+        pbw_arena_chunk *first =
+            (pbw_arena_chunk *)(void *)(base + sizeof(pbw_arena));
+
+        for (chunk = arena->head; chunk != NULL && chunk != first;) {
+            pbw_arena_chunk *next = chunk->next;
+
+            free(chunk);
+            chunk = next;
+        }
+        free(base);
+        return;
+    }
+    while (chunk != NULL) {
+        pbw_arena_chunk *next = chunk->next;
+        free(chunk);
+        chunk = next;
+    }
+    arena->head = NULL;
+    arena->chunk_size = PBW_ARENA_MIN_CHUNK;
+}
+
+size_t
+pbw_arena_used(const pbw_arena *arena)
+{
+    const pbw_arena_chunk *chunk;
+    size_t used = 0;
+
+    if (arena == NULL) {
+        return 0;
+    }
+
+    for (chunk = arena->head; chunk != NULL; chunk = chunk->next) {
+        used += chunk->used;
+    }
+    for (chunk = arena->large; chunk != NULL; chunk = chunk->next) {
+        used += chunk->used;
+    }
+    return used;
+}

pbwire-0.1.7/core/ctx.c

@@ -0,0 +1,286 @@
+/* Reusable per-caller workspace: one bump allocator for decoded messages and one
+ * growable buffer for encoded output. This is the explicit, thread-safe-by-
+ * construction version of pbwire's per-scheduler thread data. */
+
+#include "internal.h"
+
+struct pbw_ctx {
+    pbw_arena arena;
+    pbw_buf out;
+    /* Opaque binding slot (Erlang NIF thread data, Go state, ...). Set once
+     * by the binding; the core never reads it, and reset/pool keep it. */
+    void *user;
+};
+
+/* Bounded freelist of contexts. Unsynchronized by design (the core stays
+ * C99 with no dependencies): one pool per worker thread, never shared
+ * concurrently. Preallocation is lazy: the first acquire allocates, steady
+ * use then stops calling malloc. */
+struct pbw_pool {
+    pbw_ctx **idle;
+    size_t count;
+    size_t cap;        /* max_idle: how many a release keeps */
+    size_t idle_cap;   /* allocated slots in idle[] */
+    size_t retain_cap; /* budget stamped on contexts this pool creates */
+};
+
+int
+pbw_abi_version(void)
+{
+    return PBW_ABI_VERSION;
+}
+
+pbw_ctx *
+pbw_ctx_new(void)
+{
+    pbw_ctx *ctx = (pbw_ctx *)calloc(1, sizeof(*ctx));
+
+    if (ctx == NULL) {
+        return NULL;
+    }
+    ctx->arena.chunk_size = 4096;
+    /* Writable: an empty context holds nothing to protect. Decoding seals
+     * it read-only; resetting returns it to this state. */
+    ctx->arena.readonly = 0;
+    ctx->arena.retain_cap = PBW_ARENA_LARGE_THRESHOLD;
+    pbw_buf_init(&ctx->out);
+    return ctx;
+}
+
+void
+pbw_ctx_free(pbw_ctx *ctx)
+{
+    if (ctx == NULL) {
+        return;
+    }
+    pbw_arena_free(&ctx->arena);
+    pbw_buf_free(&ctx->out);
+    free(ctx);
+}
+
+void
+pbw_ctx_set_user(pbw_ctx *ctx, void *user)
+{
+    if (ctx != NULL) {
+        ctx->user = user;
+    }
+}
+
+void *
+pbw_ctx_user(const pbw_ctx *ctx)
+{
+    return ctx != NULL ? ctx->user : NULL;
+}
+
+void
+pbw_ctx_set_retain_cap(pbw_ctx *ctx, size_t cap)
+{
+    if (ctx == NULL) {
+        return;
+    }
+    ctx->arena.retain_cap = cap;
+}
+
+void
+pbw_ctx_reset(pbw_ctx *ctx)
+{
+    if (ctx == NULL) {
+        return;
+    }
+    pbw_arena_reset(&ctx->arena);
+    if (ctx->out.cap > ctx->arena.retain_cap) {
+        /* Same rule as the arena head: an oversized encode buffer is freed
+         * instead of staying resident. A steady workload under budget keeps
+         * reusing it with no malloc. */
+        pbw_buf_free(&ctx->out);
+    }
+    ctx->out.len = 0;
+    ctx->out.oom = 0;
+}
+
+size_t
+pbw_ctx_used(const pbw_ctx *ctx)
+{
+    return ctx == NULL ? 0 : pbw_arena_used(&ctx->arena);
+}
+
+pbw_pool *
+pbw_pool_new(size_t max_idle, size_t retain_cap)
+{
+    pbw_pool *pool = (pbw_pool *)calloc(1, sizeof(*pool));
+
+    if (pool == NULL) {
+        return NULL;
+    }
+    pool->retain_cap = retain_cap > 0 ? retain_cap
+                                      : PBW_ARENA_LARGE_THRESHOLD;
+    pool->cap = max_idle;
+    return pool;
+}
+
+void
+pbw_pool_free(pbw_pool *pool)
+{
+    size_t i;
+
+    if (pool == NULL) {
+        return;
+    }
+    for (i = 0; i < pool->count; i++) {
+        pbw_ctx_free(pool->idle[i]);
+    }
+    free(pool->idle);
+    free(pool);
+}
+
+pbw_ctx *
+pbw_pool_acquire(pbw_pool *pool)
+{
+    pbw_ctx *ctx;
+
+    if (pool == NULL) {
+        return NULL;
+    }
+    if (pool->count > 0) {
+        return pool->idle[--pool->count];
+    }
+    ctx = pbw_ctx_new();
+    if (ctx == NULL) {
+        return NULL;
+    }
+    pbw_ctx_set_retain_cap(ctx, pool->retain_cap);
+    return ctx;
+}
+
+void
+pbw_pool_release(pbw_pool *pool, pbw_ctx *ctx)
+{
+    pbw_ctx **slot;
+
+    if (pool == NULL || ctx == NULL) {
+        return;
+    }
+    /* A released context is always clean: the next acquire can use it
+     * without resetting. The retain cap bounds what the reset keeps, so
+     * an outlier never pins the pool. */
+    pbw_ctx_reset(ctx);
+    if (pool->count >= pool->cap) {
+        pbw_ctx_free(ctx);
+        return;
+    }
+    /* Grow the slot array by doubling: one realloc per doubling instead of
+     * one per release, which matters for a pool that fills up. */
+    if (pool->count == pool->idle_cap) {
+        size_t want;
+
+        if (pool->idle_cap > SIZE_MAX / 2 / sizeof(*slot)) {
+            pbw_ctx_free(ctx);
+            return;
+        }
+        want = pool->idle_cap != 0 ? pool->idle_cap * 2 : 8;
+        if (want > pool->cap) {
+            want = pool->cap;
+        }
+        if (want <= pool->idle_cap || want > SIZE_MAX / sizeof(*slot)) {
+            pbw_ctx_free(ctx);
+            return;
+        }
+        slot = (pbw_ctx **)realloc(pool->idle, want * sizeof(*slot));
+        if (slot == NULL) {
+            pbw_ctx_free(ctx);
+            return;
+        }
+        pool->idle = slot;
+        pool->idle_cap = want;
+    }
+    pool->idle[pool->count++] = ctx;
+}
+
+size_t
+pbw_pool_idle(const pbw_pool *pool)
+{
+    return pool == NULL ? 0 : pool->count;
+}
+
+pbw_status
+pbw_decode_ctx(pbw_ctx *ctx, const pbw_descriptor *desc, const void *buf,
+               size_t len, pbw_message **out)
+{
+    return pbw_decode_ctx_limits(ctx, desc, buf, len, NULL, out);
+}
+
+pbw_status
+pbw_decode_ctx_limits(pbw_ctx *ctx, const pbw_descriptor *desc,
+                      const void *buf, size_t len, const pbw_limits *limits,
+                      pbw_message **out)
+{
+    if (out != NULL) {
+        *out = NULL;
+    }
+    if (ctx == NULL || out == NULL || (buf == NULL && len > 0)) {
+        return PBW_ERR_INVALID;
+    }
+    /* Every failure below leaves NULL: callers can rely on *out alone. */
+    if (limits != NULL && limits->max_bytes > 0 && len > limits->max_bytes) {
+        return PBW_ERR_LIMIT;
+    }
+    {
+        pbw_status status =
+            pbw_decode_arena_lim(&ctx->arena, desc, buf, len, pbw_effective_depth(limits), out);
+        if (status == PBW_OK) {
+            /* Seal the arena: decoded trees are read-only, later builds
+             * need a reset first. */
+            ctx->arena.readonly = 1;
+        }
+        return status;
+    }
+}
+
+pbw_status
+pbw_encode_ctx(pbw_ctx *ctx, const pbw_message *msg, const uint8_t **out,
+               size_t *len)
+{
+    pbw_status status;
+
+    if (ctx == NULL || out == NULL || len == NULL) {
+        return PBW_ERR_INVALID;
+    }
+    *out = NULL;
+    *len = 0;
+    status = pbw_encode_buf(&ctx->out, msg);
+    if (status != PBW_OK) {
+        *out = NULL;
+        *len = 0;
+        return status;
+    }
+    *out = ctx->out.data != NULL ? ctx->out.data : (const uint8_t *)"";
+    *len = ctx->out.len;
+    return PBW_OK;
+}
+
+pbw_message *
+pbw_message_new_ctx(pbw_ctx *ctx, const pbw_descriptor *desc)
+{
+    if (ctx == NULL) {
+        return NULL;
+    }
+    return pbw_message_new_a(&ctx->arena, desc);
+}
+
+pbw_value *
+pbw_value_new_uint_ctx(pbw_ctx *ctx, uint64_t bits)
+{
+    if (ctx == NULL) {
+        return NULL;
+    }
+    return pbw_value_new_uint_a(&ctx->arena, bits);
+}
+
+pbw_value *
+pbw_value_new_bytes_ctx(pbw_ctx *ctx, const void *data, size_t len)
+{
+    if (ctx == NULL) {
+        return NULL;
+    }
+    return pbw_value_new_bytes_a(&ctx->arena, data, len);
+}