yeptris 0.6.5.4 → 0.6.7.2

data/vendor/libyeptris/src/include/yeptris/yajl_compat.h

@@ -0,0 +1,135 @@
+/* yajl_compat.h — the yajl generator migration layer (TODO.impl/21).
+ *
+ * REAL yajl_gen symbol names over the yeptris core: users link
+ * -lyeptris-yajl instead of -lyajl and change nothing else. The
+ * generator validates call order (yajl's own state machine) and
+ * builds a Yeptris document; get_buf serializes JSON (beautify
+ * selects the pretty writer, default compact).
+ *
+ * v2 scope: the generator (yajl_gen_*) and the SAX parser
+ * (yajl_alloc/yajl_parse/...). The parser accumulates yajl_parse
+ * feeds and delivers all callbacks at yajl_complete_parse (the core
+ * parses whole documents; timing is batched, order and content are
+ * yajl's). Strict RFC 8259 always; yajl_allow_comments masks
+ * JavaScript comments (block star-slash, line double-slash) outside
+ * strings before the strict parse — offsets preserved, yajl's exact
+ * semantics. Unsupported options (trailing garbage / multiple
+ * values / partial values) are rejected at yajl_config time: zero,
+ * per yajl's own error contract.
+ */
+#ifndef YEPTRIS_YAJL_COMPAT_H
+#define YEPTRIS_YAJL_COMPAT_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    yajl_gen_status_ok = 0,
+    yajl_gen_keys_must_be_strings, /* 1 */
+    yajl_max_depth_exceeded,       /* unused: depth-guarded builder */
+    yajl_gen_in_error_state = 3,
+    yajl_gen_generation_complete, /* 4: gen after get_buf without clear */
+    yajl_gen_invalid_string = 5   /* NULL bytes with len 0 handled; reserved */
+} yajl_gen_status;
+
+typedef enum {
+    yajl_gen_beautify = 1,      /* int: pretty output */
+    yajl_gen_indent_string = 2, /* const char*: reserved (fixed 2-space) */
+    yajl_gen_validate_utf8 = 3  /* int: always on (the front-end validates) */
+} yajl_gen_option;
+
+typedef struct yajl_gen_t* yajl_gen;
+typedef struct yajl_alloc_funcs_t yajl_alloc_funcs;
+
+/* NULL alloc (the yajl default) uses the system allocator. */
+yajl_gen yajl_gen_alloc(const yajl_alloc_funcs* afs);
+void yajl_gen_free(yajl_gen g);
+void yajl_gen_reset(yajl_gen g, const char* sep_ignored);
+
+/* var-args: (yajl_gen_beautify, int). Returns 1 on success. */
+int yajl_gen_config(yajl_gen g, yajl_gen_option opt, ...);
+
+yajl_gen_status yajl_gen_map_open(yajl_gen g);
+yajl_gen_status yajl_gen_map_close(yajl_gen g);
+yajl_gen_status yajl_gen_array_open(yajl_gen g);
+yajl_gen_status yajl_gen_array_close(yajl_gen g);
+
+/* In a map, the first call per entry is the KEY: it must be a
+ * string (yajl accepts raw bytes; keys serialize JSON-quoted). */
+yajl_gen_status yajl_gen_string(yajl_gen g, const unsigned char* str, size_t len);
+yajl_gen_status yajl_gen_integer(yajl_gen g, long long n);
+yajl_gen_status yajl_gen_double(yajl_gen g, double d);
+yajl_gen_status yajl_gen_number(yajl_gen g, const char* s, size_t len);
+yajl_gen_status yajl_gen_null(yajl_gen g);
+yajl_gen_status yajl_gen_bool(yajl_gen g, int b);
+
+/* The serialized document (owned by the generator; valid until the
+ * next generating call or reset). Empty until the ROOT closes. */
+const unsigned char* yajl_gen_get_buf(yajl_gen g, size_t* len);
+void yajl_gen_clear(yajl_gen g);
+
+/* ---- SAX parser ------------------------------------------------------- */
+
+typedef enum { yajl_status_ok = 0, yajl_status_client_canceled, yajl_status_error } yajl_status;
+
+const char* yajl_status_to_string(yajl_status code);
+
+/* Zero return from a callback cancels the parse
+ * (yajl_status_client_canceled). When yajl_number is set it carries
+ * EVERY number in string form; yajl_integer/yajl_double are then
+ * ignored (yajl's own precedence). */
+typedef struct {
+    int (*yajl_null)(void* ctx);
+    int (*yajl_boolean)(void* ctx, int boolVal);
+    int (*yajl_integer)(void* ctx, long long integerVal);
+    int (*yajl_double)(void* ctx, double doubleVal);
+    int (*yajl_number)(void* ctx, const char* numberVal, size_t numberLen);
+    int (*yajl_string)(void* ctx, const unsigned char* stringVal, size_t stringLen);
+    int (*yajl_start_map)(void* ctx);
+    int (*yajl_map_key)(void* ctx, const unsigned char* key, size_t stringLen);
+    int (*yajl_end_map)(void* ctx);
+    int (*yajl_start_array)(void* ctx);
+    int (*yajl_end_array)(void* ctx);
+} yajl_callbacks;
+
+typedef enum {
+    yajl_allow_comments = 0x01,        /* JS comments masked, offsets kept */
+    yajl_dont_validate_strings = 0x02, /* accepted no-op: always on */
+    yajl_allow_trailing_garbage = 0x04,
+    yajl_allow_multiple_values = 0x08,
+    yajl_allow_partial_values = 0x10
+} yajl_option;
+
+typedef struct yajl_handle_t* yajl_handle;
+
+/* callbacks may be NULL (pure validation). afs accepted, ignored. */
+yajl_handle yajl_alloc(const yajl_callbacks* callbacks, yajl_alloc_funcs* afs, void* ctx);
+void yajl_free(yajl_handle handle);
+
+/* var-args int option: 1 on, 0 off. Returns 0 on unknown/unsupported
+ * options (trailing garbage / multiple values / partial values). */
+int yajl_config(yajl_handle h, yajl_option opt, ...);
+
+/* Accumulates feeds; callbacks fire at complete_parse. After an
+ * error or cancel the handle stays in that state. */
+yajl_status yajl_parse(yajl_handle hand, const unsigned char* jsonText, size_t jsonTextLength);
+yajl_status yajl_complete_parse(yajl_handle hand);
+
+/* Malloc'd message (free with yajl_free_error); NULL when no error.
+ * verbose adds the offending line and a caret. */
+unsigned char* yajl_get_error(yajl_handle hand, int verbose, const unsigned char* jsonText,
+                              size_t jsonTextLength);
+void yajl_free_error(yajl_handle hand, unsigned char* str);
+
+/* Bytes consumed: the whole input once complete; on error, the
+ * offset of the violation. */
+size_t yajl_get_bytes_consumed(yajl_handle hand);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_YAJL_COMPAT_H */

data/vendor/libyeptris/src/include/yeptris.h

@@ -0,0 +1,23 @@
+/* yeptris.h — umbrella header for libyeptris.
+ *
+ * Ultra-fast YAML 1.2 parser, emitter and streamer in C; the YAML
+ * counterpart of libleptris. Subsystem headers grow with their items
+ * (TODO.impl/01-20); this file only includes the public surface.
+ */
+#ifndef YEPTRIS_H
+#define YEPTRIS_H
+
+#include <yeptris/api.h>
+#include <yeptris/dom.h>
+#include <yeptris/emit.h>
+#include <yeptris/error.h>
+#ifdef YEPTRIS_WITH_CBOR
+#include <yeptris/cbor.h>
+#endif
+#include <yeptris/events.h>
+#include <yeptris/parse.h>
+#include <yeptris/resolve.h>
+#include <yeptris/types.h>
+#include <yeptris/version.h>
+
+#endif /* YEPTRIS_H */

data/vendor/libyeptris/src/yeptris/build.c

@@ -0,0 +1,371 @@
+/* build.c — the public from-scratch construction API (TODO.impl/11
+ * phase 3). Thin: argument checking + handle wrapping over the dom
+ * mutation primitives. The emitter and every query API work on
+ * synthesized documents unchanged — same nodes, same invariants. */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <yeptris.h>
+
+#include "doc.h"
+#include "dom/dom.h"
+#include "memory/allocator.h"
+
+static yeptris_document* doc_of(YeptrisDocument handle) {
+    return (yeptris_document*)handle;
+}
+
+static yeptris_node* node_of(YeptrisNode handle) {
+    return (yeptris_node*)handle;
+}
+
+YEPTRIS_API YeptrisDocument yeptris_document_new(void) {
+    const yep_allocator* sys = yep_system_allocator();
+    yep_dom* dom = yep_dom_create(sys);
+    if (dom == NULL) {
+        return NULL;
+    }
+    yeptris_document* doc = yep_alloc(sys, sizeof(yeptris_document));
+    if (doc == NULL) {
+        yep_dom_destroy(dom);
+        return NULL;
+    }
+    memset(doc, 0, sizeof(*doc));
+    doc->dom = dom;
+    doc->sys = sys;
+    return (YeptrisDocument)doc;
+}
+
+YEPTRIS_API int yeptris_document_set_root(YeptrisDocument handle, YeptrisNode root) {
+    yeptris_document* doc = doc_of(handle);
+    yeptris_node* n = node_of(root);
+    if (doc == NULL || n == NULL || n->doc != doc) {
+        return YEPTRIS_ERROR_PARSE;
+    }
+    int rc = yep_mut_add_root(doc->dom, n->id);
+    return rc == 0 ? YEPTRIS_OK
+                   : (rc == -1 ? YEPTRIS_ERROR_MEMORY
+                               : (rc == -3 ? YEPTRIS_ERROR_DEPTH : YEPTRIS_ERROR_ARG));
+}
+
+YEPTRIS_API YeptrisNode yeptris_node_new_mapping(YeptrisDocument handle) {
+    yeptris_document* doc = doc_of(handle);
+    if (doc == NULL) {
+        return NULL;
+    }
+    uint32_t id = yep_mut_map(doc->dom, 0);
+    return id == UINT32_MAX ? NULL : (YeptrisNode)yep_handle_new(doc, id);
+}
+
+YEPTRIS_API YeptrisNode yeptris_node_new_sequence(YeptrisDocument handle) {
+    yeptris_document* doc = doc_of(handle);
+    if (doc == NULL) {
+        return NULL;
+    }
+    uint32_t id = yep_mut_seq(doc->dom, 0);
+    return id == UINT32_MAX ? NULL : (YeptrisNode)yep_handle_new(doc, id);
+}
+
+/* Memory: the value is copied into the document (nothing is borrowed
+ * from the caller). Plain style types the copy through the resolver,
+ * quoted styles force string — identical to parse-time typing. */
+YEPTRIS_API YeptrisNode yeptris_node_new_scalar(YeptrisDocument handle, const char* value,
+                                                size_t len, YeptrisScalarStyle style) {
+    yeptris_document* doc = doc_of(handle);
+    if (doc == NULL || (value == NULL && len > 0) || style < YEPTRIS_STYLE_PLAIN ||
+        style > YEPTRIS_STYLE_FOLDED) {
+        return NULL;
+    }
+    uint32_t id = yep_mut_scalar(doc->dom, value, len, (uint8_t)style);
+    return id == UINT32_MAX ? NULL : (YeptrisNode)yep_handle_new(doc, id);
+}
+
+static int mut_status(int rc) {
+    switch (rc) {
+    case 0:
+    case 1: /* map_set replaced — success for the caller */
+        return YEPTRIS_OK;
+    case -1:
+        return YEPTRIS_ERROR_MEMORY;
+    case -3:
+        return YEPTRIS_ERROR_DEPTH;
+    default: /* -2 duplicate key, -4 double-attach */
+        return YEPTRIS_ERROR_PARSE;
+    }
+}
+
+static int same_doc(YeptrisNode parent, YeptrisNode child) {
+    yeptris_node* p = node_of(parent);
+    yeptris_node* c = node_of(child);
+    return p != NULL && c != NULL && p->doc == c->doc;
+}
+
+YEPTRIS_API int yeptris_node_map_add(YeptrisNode handle, const char* key, size_t key_len,
+                                     YeptrisNode value) {
+    yeptris_node* m = node_of(handle);
+    if (m == NULL || key == NULL || !same_doc(handle, value)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return mut_status(yep_mut_map_add(m->doc->dom, m->id, key, key_len, node_of(value)->id));
+}
+
+/* Replace-or-add (json-c semantics): an existing key keeps its
+ * position and swaps the value; a new key appends. */
+YEPTRIS_API int yeptris_node_map_set(YeptrisNode handle, const char* key, size_t key_len,
+                                     YeptrisNode value) {
+    yeptris_node* m = node_of(handle);
+    if (m == NULL || key == NULL || !same_doc(handle, value)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return mut_status(yep_mut_map_set(m->doc->dom, m->id, key, key_len, node_of(value)->id));
+}
+
+YEPTRIS_API int yeptris_node_seq_add(YeptrisNode handle, YeptrisNode value) {
+    yeptris_node* s = node_of(handle);
+    if (s == NULL || !same_doc(handle, value)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return mut_status(yep_mut_seq_add(s->doc->dom, s->id, node_of(value)->id));
+}
+
+YEPTRIS_API int yeptris_node_seq_set(YeptrisNode handle, size_t index, YeptrisNode value) {
+    yeptris_node* s = node_of(handle);
+    if (s == NULL || !same_doc(handle, value)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return mut_status(yep_mut_seq_set(s->doc->dom, s->id, (uint32_t)index, node_of(value)->id));
+}
+
+YEPTRIS_API int yeptris_node_seq_del(YeptrisNode handle, size_t index) {
+    yeptris_node* s = node_of(handle);
+    if (s == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return yep_mut_seq_del(s->doc->dom, s->id, (uint32_t)index) == 0 ? YEPTRIS_OK
+                                                                     : YEPTRIS_ERROR_PARSE;
+}
+
+/* The removed subtree stays document-owned (arena lifetime); its
+ * handle remains valid but unreachable from the root. */
+YEPTRIS_API int yeptris_node_set_anchor(YeptrisNode handle, const char* name, size_t len) {
+    yeptris_node* n = node_of(handle);
+    if (n == NULL || name == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return yep_mut_set_anchor(n->doc->dom, n->id, name, len) == 0 ? YEPTRIS_OK : YEPTRIS_ERROR_ARG;
+}
+
+YEPTRIS_API int yeptris_node_set_tag(YeptrisNode handle, const char* tag, size_t len) {
+    yeptris_node* n = node_of(handle);
+    if (n == NULL || tag == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return yep_mut_set_tag(n->doc->dom, n->id, tag, len) == 0 ? YEPTRIS_OK : YEPTRIS_ERROR_ARG;
+}
+
+YEPTRIS_API YeptrisNode yeptris_node_new_alias(YeptrisDocument handle, YeptrisNode target,
+                                               const char* name, size_t len) {
+    yeptris_document* doc = doc_of(handle);
+    yeptris_node* t = node_of(target);
+    if (doc == NULL || t == NULL || t->doc != doc || name == NULL) {
+        return NULL;
+    }
+    uint32_t id = yep_mut_new_alias(doc->dom, t->id, name, len);
+    return id == UINT32_MAX ? NULL : (YeptrisNode)yep_handle_new(doc, id);
+}
+
+YEPTRIS_API int yeptris_node_map_add_node(YeptrisNode handle, YeptrisNode key, YeptrisNode value) {
+    yeptris_node* m = node_of(handle);
+    if (m == NULL || !same_doc(handle, key) || !same_doc(handle, value)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return mut_status(
+        yep_mut_map_add_node(m->doc->dom, m->id, node_of(key)->id, node_of(value)->id));
+}
+
+YEPTRIS_API int yeptris_node_map_del(YeptrisNode handle, const char* key, size_t key_len) {
+    yeptris_node* m = node_of(handle);
+    if (m == NULL || key == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return yep_mut_map_del(m->doc->dom, m->id, key, key_len) == 0 ? YEPTRIS_OK
+                                                                  : YEPTRIS_ERROR_PARSE;
+}
+
+/* ---- bulk build --------------------------------------------------------
+ *
+ * One call, one tree: entries walk in document order (the same shape
+ * as the event stream), pairing and linking ride the mutation
+ * primitives unchanged — dup checks, depth caps, and per-link depth
+ * fixups all come along for free (DRY with the public builder). */
+YEPTRIS_API YeptrisStatus yeptris_document_build(YeptrisDocument handle,
+                                                 const YeptrisBuildEntry* entries, size_t count,
+                                                 const char* blob, size_t blob_len) {
+    yeptris_document* doc = doc_of(handle);
+    if (doc == NULL || (entries == NULL && count != 0) || (blob == NULL && blob_len != 0)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    struct frame {
+        uint32_t id;
+        uint8_t is_map;
+        uint8_t key_pending;
+    };
+    if (count > (SIZE_MAX / 2) / sizeof(struct frame)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    struct frame* st = yep_alloc(doc->dom->sys, (count + 1) * sizeof(*st));
+    if (st == NULL) {
+        return YEPTRIS_ERROR_MEMORY;
+    }
+    int depth = 0;
+    uint32_t root = UINT32_MAX;
+    uint32_t root_closed = 0;
+    uint32_t pending_key = UINT32_MAX; /* map frame's buffered key */
+    uint32_t last_id = UINT32_MAX;     /* TAG applies here (#300) */
+    YeptrisStatus rc = YEPTRIS_OK;
+    for (size_t i = 0; i < count && rc == YEPTRIS_OK; i++) {
+        const YeptrisBuildEntry* e = &entries[i];
+        if (root_closed) {
+            rc = YEPTRIS_ERROR_PARSE; /* the document ended; more entries */
+            break;
+        }
+        if (e->off > blob_len || e->len > blob_len - e->off) {
+            rc = YEPTRIS_ERROR_PARSE; /* slice out of range */
+            break;
+        }
+        uint32_t id = UINT32_MAX; /* set by every arm that reaches the place; MSVC wants the init */
+        switch (e->op) {
+        case YEPTRIS_BUILD_SCALAR: {
+            id = yep_mut_scalar(doc->dom, blob + e->off, e->len, e->style);
+            if (id == UINT32_MAX) {
+                rc = YEPTRIS_ERROR_MEMORY;
+                break;
+            }
+            break;
+        }
+        case YEPTRIS_BUILD_SEQ:
+            id = yep_mut_seq(doc->dom, 0);
+            if (id == UINT32_MAX) {
+                rc = YEPTRIS_ERROR_MEMORY;
+                break;
+            }
+            break;
+        case YEPTRIS_BUILD_MAP:
+            id = yep_mut_map(doc->dom, 0);
+            if (id == UINT32_MAX) {
+                rc = YEPTRIS_ERROR_MEMORY;
+                break;
+            }
+            break;
+        case YEPTRIS_BUILD_END:
+            if (depth == 0) {
+                rc = YEPTRIS_ERROR_PARSE; /* END with nothing open */
+                break;
+            }
+            depth--;
+            if (depth == 0) {
+                root_closed = 1; /* the root just completed */
+            }
+            if (st[depth].is_map && st[depth].key_pending) {
+                st[depth].key_pending = 0; /* a closed container was the value */
+            }
+            continue;
+        case YEPTRIS_BUILD_TAG:
+            /* #300: apply an explicit tag to the last-placed node —
+             * the bulk ABI otherwise cannot express tags. Placed
+             * immediately after the entry it tags. */
+            if (last_id == UINT32_MAX) {
+                rc = YEPTRIS_ERROR_PARSE; /* TAG with nothing placed */
+                break;
+            }
+            if (yep_mut_set_tag(doc->dom, last_id, blob + e->off, e->len) != 0) {
+                rc = YEPTRIS_ERROR_MEMORY;
+                break;
+            }
+            continue;
+        default:
+            rc = YEPTRIS_ERROR_PARSE; /* unknown op */
+            break;
+        }
+        if (rc != YEPTRIS_OK) {
+            break;
+        }
+        last_id = id; /* TAG entries target this (#300) */
+        /* place the fresh node */
+        if (depth == 0) {
+            if (root != UINT32_MAX) {
+                rc = YEPTRIS_ERROR_PARSE; /* two roots */
+                break;
+            }
+            root = id; /* a single scalar root needs no END */
+            root_closed = (e->op != YEPTRIS_BUILD_SEQ && e->op != YEPTRIS_BUILD_MAP) ? 1 : 0;
+            if (!root_closed) {
+                st[depth].id = id;
+                st[depth].is_map = (e->op == YEPTRIS_BUILD_MAP);
+                st[depth].key_pending = 0;
+                depth = 1;
+            }
+            continue;
+        }
+        struct frame* top = &st[depth - 1];
+        if (top->is_map) {
+            if (!top->key_pending) {
+                top->key_pending = 1;
+                pending_key = id;
+                continue;
+            }
+            /* the check-free pairing twin: document-order entries
+             * from a host mapping cannot duplicate, and map_add's
+             * linear dup scan is O(n^2) on wide maps */
+            int mrc = yep_mut_map_append(doc->dom, top->id, pending_key, id);
+            if (mrc == 0) {
+                top->key_pending = 0;
+                pending_key = UINT32_MAX;
+            } else {
+                rc = (mrc == -3) ? YEPTRIS_ERROR_DEPTH
+                                 : (mrc == -1 ? YEPTRIS_ERROR_ARG : YEPTRIS_ERROR_MEMORY);
+            }
+        } else {
+            int src_ = yep_mut_seq_add(doc->dom, top->id, id);
+            if (src_ != 0) {
+                rc = (src_ == -3) ? YEPTRIS_ERROR_DEPTH
+                                  : (src_ == -1 ? YEPTRIS_ERROR_ARG : YEPTRIS_ERROR_MEMORY);
+            }
+        }
+        if (rc == YEPTRIS_OK && (e->op == YEPTRIS_BUILD_SEQ || e->op == YEPTRIS_BUILD_MAP)) {
+            if ((size_t)depth >= (size_t)YEP_DOM_MAX_DEPTH) {
+                rc = YEPTRIS_ERROR_DEPTH;
+                break;
+            }
+            st[depth].id = id;
+            st[depth].is_map = (e->op == YEPTRIS_BUILD_MAP);
+            st[depth].key_pending = 0;
+            depth++;
+        }
+    }
+    if (rc == YEPTRIS_OK) {
+        if (depth > 1 || (depth == 1)) {
+            rc = YEPTRIS_ERROR_PARSE; /* an unclosed container */
+        } else if (root == UINT32_MAX) {
+            rc = YEPTRIS_ERROR_PARSE; /* no root */
+        } else if (pending_key != UINT32_MAX) {
+            rc = YEPTRIS_ERROR_PARSE; /* a key without its value */
+        } else {
+            int arc = yep_mut_add_root(doc->dom, root);
+            if (arc == 0) {
+                rc = YEPTRIS_OK;
+            } else if (arc == -4) {
+                rc = YEPTRIS_ERROR_PARSE;
+            } else if (arc == -3) {
+                rc = YEPTRIS_ERROR_DEPTH;
+            } else if (arc == -1) {
+                rc = YEPTRIS_ERROR_MEMORY;
+            } else {
+                rc = YEPTRIS_ERROR_ARG;
+            }
+        }
+    }
+    yep_free(doc->dom->sys, st);
+    return rc;
+}

data/vendor/libyeptris/src/yeptris/cbor/cbor.h

@@ -0,0 +1,25 @@
+/* cbor.h — the CBOR (RFC 8949) codec's internal interface
+ * (TODO.cbor/01). The public surface is <yeptris/cbor.h>. */
+#ifndef YEP_CBOR_H
+#define YEP_CBOR_H
+
+#include <stdint.h>
+
+#include "../dom/dom.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* one data item: bytes -> the shared DOM (the plan's item 01) */
+/* One data item. consumed (may be NULL): when given, returns the
+ * item's byte extent and TRAILING BYTES ARE NOT an error (the
+ * sequence loop steps on them); NULL keeps the one-item contract. */
+int yep_cbor_decode_dom(yep_dom* d, const unsigned char* p, size_t len, int strict,
+                        size_t* consumed);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_CBOR_H */