yeptris 0.6.5.4 → 0.6.7.2

data/vendor/libyeptris/src/CMakeLists.txt

@@ -0,0 +1,167 @@
+# libyeptris — core library sources.
+#
+# Subsystems land with their TODO.impl items (common/ 02, memory/ 03,
+# simd/ 04, encoding/ 05, scan/ 06, parse/ 07+). The SIMD per-ISA TUs get
+# their own -m flags here when item 04 lands.
+
+set(YEPTRIS_SOURCES
+    yeptris/version.c
+    yeptris/common/cpu.c
+    yeptris/common/chartype.c
+    yeptris/common/string_view.c
+    yeptris/common/error.c
+    yeptris/common/nametab.c
+    yeptris/common/simd_text.c
+    yeptris/common/simd_text_scalar.c
+    yeptris/memory/allocator.c
+    yeptris/memory/pool.c
+    yeptris/memory/arena.c
+    yeptris/encoding/bom.c
+    yeptris/encoding/transcode.c
+    yeptris/encoding/utf8_validate.c
+    yeptris/scan/json.c
+    yeptris/scan/scan.c
+    yeptris/parse/scalars.c
+    yeptris/parse/engine.c
+    yeptris/dom/dom.c
+    yeptris/dom/hpool.c
+    yeptris/dom/mapindex.c
+    yeptris/dom/mutate.c
+    yeptris/parse.c
+    yeptris/build.c
+    yeptris/events/capture.c
+    yeptris/events/push.c
+    yeptris/events/pull.c
+    yeptris/events/recorder.c
+    yeptris/events/iterparse.c
+    yeptris/events/yaml_compat.c
+    yeptris/resolve/tags.c
+    yeptris/resolve/core12.c
+    yeptris/resolve/compat11.c
+    yeptris/parse/numbers.c
+    yeptris/events/values.c
+    yeptris/schema.c
+    yeptris/tape.c
+    yeptris/plan.c
+
+    yeptris/marshal.c
+    yeptris/visit/json_visit.c
+    yeptris/visit/yaml_visit.c
+    yeptris/visit/dom_visit.c
+    yeptris/emit/style.c
+    yeptris/emit/writer.c
+    yeptris/emit/emit.c
+    yeptris/emit/float/print.c
+    yeptris/emit/float/dragon.c
+)
+
+if(YEPTRIS_WITH_CBOR)
+    list(APPEND YEPTRIS_SOURCES yeptris/cbor/decode.c yeptris/cbor/encode.c)
+endif()
+
+# AOT SIMD TUs (TODO.impl/04): per-ISA compile flags; the TUs and the
+# dispatch share architecture guards, so links resolve on every platform.
+# CMAKE_OSX_ARCHITECTURES participates: an -arch x86_64 cross-build on
+# an arm Mac compiles the dispatch for x86 — the source pick must
+# follow the TARGET arch, not the host (the all-platform wheels ride
+# this; host-processor-only selection linked NEON objects into an
+# x86_64 image).
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|i[3-6]86)$" OR
+    CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
+    list(APPEND YEPTRIS_SOURCES yeptris/common/simd_text_avx2.c)
+    if(MSVC)
+        set_source_files_properties(yeptris/common/simd_text_avx2.c
+            PROPERTIES COMPILE_OPTIONS "/arch:AVX2")
+    else()
+        set_source_files_properties(yeptris/common/simd_text_avx2.c
+            PROPERTIES COMPILE_OPTIONS "-mavx2;-mpopcnt")
+    endif()
+elseif((CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$" OR
+    CMAKE_OSX_ARCHITECTURES MATCHES "arm64") AND NOT CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
+    list(APPEND YEPTRIS_SOURCES yeptris/common/simd_text_neon.c)
+endif()
+
+set(YEPTRIS_PUBLIC_HEADERS
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/api.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/dom.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/error.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/events.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/emit.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/resolve.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/parse.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/values.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/schema.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/tape.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/plan.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/marshal.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/visit.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/json.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/types.h
+)
+
+set(YEPTRIS_INCLUDE_DIRS
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated>
+)
+
+# json-c drop-in (TODO.impl/21): REAL json-c symbol names in its own
+# library — users link -lyeptris-jsonc instead of -ljson-c.
+option(YEPTRIS_BUILD_YAJL_COMPAT
+    "Build libyeptris-yajl: the yajl generator drop-in (TODO.impl/21)" ON)
+if(YEPTRIS_BUILD_YAJL_COMPAT AND YEPTRIS_BUILD_STATIC)
+    add_library(yeptris_yajl STATIC yeptris/jsonapi/yajl_compat.c)
+    set_target_properties(yeptris_yajl PROPERTIES OUTPUT_NAME yeptris-yajl)
+    target_link_libraries(yeptris_yajl PUBLIC yeptris_static)
+    target_include_directories(yeptris_yajl PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+    target_include_directories(yeptris_yajl PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris)
+    yeptris_set_warnings(yeptris_yajl)
+    add_library(yeptris::yajl ALIAS yeptris_yajl)
+endif()
+
+if(YEPTRIS_BUILD_JSONC_COMPAT AND YEPTRIS_BUILD_STATIC)
+    add_library(yeptris_jsonc STATIC yeptris/jsonapi/jsonc_compat.c)
+    set_target_properties(yeptris_jsonc PROPERTIES OUTPUT_NAME yeptris-jsonc)
+    target_link_libraries(yeptris_jsonc PUBLIC yeptris_static)
+    target_include_directories(yeptris_jsonc PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+    # internal headers (emit/writer.h, float/api.h): PRIVATE — they
+    # never leak into the compat library's public interface
+    target_include_directories(yeptris_jsonc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris)
+    yeptris_set_warnings(yeptris_jsonc)
+    add_library(yeptris::jsonc ALIAS yeptris_jsonc)
+endif()
+
+if(YEPTRIS_BUILD_STATIC)
+    find_package(Threads REQUIRED)
+
+add_library(yeptris_static STATIC ${YEPTRIS_SOURCES})
+    add_library(yeptris::yeptris ALIAS yeptris_static)
+    set_target_properties(yeptris_static PROPERTIES OUTPUT_NAME yeptris)
+    target_include_directories(yeptris_static
+        PUBLIC ${YEPTRIS_INCLUDE_DIRS}
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris) # internal root-relative includes
+    target_compile_definitions(yeptris_static PRIVATE YEPTRIS_BUILDING)
+    if(YEPTRIS_WITH_CBOR)
+        target_compile_definitions(yeptris_static PUBLIC YEPTRIS_WITH_CBOR)
+    endif()
+    target_link_libraries(yeptris_static PRIVATE Threads::Threads)
+    yeptris_set_warnings(yeptris_static)
+endif()
+
+if(YEPTRIS_BUILD_SHARED)
+    add_library(yeptris_shared SHARED ${YEPTRIS_SOURCES})
+    set_target_properties(yeptris_shared
+        PROPERTIES OUTPUT_NAME yeptris
+                    SOVERSION ${PROJECT_VERSION_MAJOR})
+    target_include_directories(yeptris_shared
+        PUBLIC ${YEPTRIS_INCLUDE_DIRS}
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris/emit/float)
+    target_compile_definitions(yeptris_shared PRIVATE YEPTRIS_BUILDING)
+    if(YEPTRIS_WITH_CBOR)
+        target_compile_definitions(yeptris_shared PUBLIC YEPTRIS_WITH_CBOR)
+    endif()
+    yeptris_set_warnings(yeptris_shared)
+endif()

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

@@ -0,0 +1,32 @@
+/* api.h — export control for libyeptris.
+ *
+ * The library is built with hidden visibility; exactly the YEPTRIS_API-marked
+ * surface is exported. Define YEPTRIS_BUILDING when compiling libyeptris
+ * itself; define YEPTRIS_SHARED when consuming the shared library on Windows.
+ */
+#ifndef YEPTRIS_API_H
+/* YEPTRIS_CT_ASSERT — the compile-time layout gate, C99/MSVC-C-mode/
+ * C++ portable (typedef-array; libleptris's same migration): the old
+ * C11 _Static_assert was the ONE C11 feature pinning the standard. */
+#define YEPTRIS_CT_ASSERT_(cond, line) typedef char yeptris_ct_assert_##line[(cond) ? 1 : -1]
+#define YEPTRIS_CT_ASSERT(cond) YEPTRIS_CT_ASSERT_(cond, __LINE__)
+
+#define YEPTRIS_API_H
+
+#if defined(YEPTRIS_BUILDING) && defined(YEPTRIS_SHARED)
+#error "define YEPTRIS_BUILDING (building) or YEPTRIS_SHARED (consuming), not both"
+#endif
+
+#if defined(YEPTRIS_BUILDING)
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define YEPTRIS_API __declspec(dllexport)
+#else
+#define YEPTRIS_API __attribute__((visibility("default")))
+#endif
+#elif defined(YEPTRIS_SHARED) && (defined(_WIN32) || defined(__CYGWIN__))
+#define YEPTRIS_API __declspec(dllimport)
+#else
+#define YEPTRIS_API
+#endif
+
+#endif /* YEPTRIS_API_H */

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

@@ -0,0 +1,101 @@
+/* cbor.h — the CBOR (RFC 8949) public surface (TODO.cbor).
+ *
+ * CBOR is the JSON data model in binary: decode builds the same DOM
+ * yeptris_parse_json builds, so every query, emit, and binding API
+ * applies unchanged. The surface compiles only when the library was
+ * built with YEPTRIS_WITH_CBOR (the default). */
+#ifndef YEPTRIS_CBOR_H
+#define YEPTRIS_CBOR_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Flags. */
+#define YEPTRIS_CBOR_STRICT                                                                        \
+    0x1u /* decode: reject non-minimal length                                                      \
+           arguments and non-text-string map keys                                                  \
+           (the deterministic profile's input side) */
+#define YEPTRIS_CBOR_CANONICAL                                                                     \
+    0x2u /* encode: RFC 8949 s4.2.1 core                                                           \
+           deterministic profile — minimal lengths,                                              \
+           definite lengths, preferred floats, map                                                 \
+           keys sorted bytewise on their encoded                                                   \
+           forms (the length-first variant of                                                      \
+           s4.2.3 is NOT selected) */
+
+/* Decodes ONE CBOR data item (RFC 8949). buf must remain valid for the
+ * lifetime of the returned document (string values are borrowed
+ * zero-copy views; indefinite-length chunks concatenate in the
+ * document's arena). Trailing bytes after the item are an error —
+ * CBOR Sequences (RFC 8742) get their own entry point.
+ *
+ * Representation notes (full ledger in src/yeptris/cbor/decode.c):
+ * integers beyond int64 materialize as shortest-double text; bignums
+ * (tags 2/3) stay tag+bytes; byte and text strings are tag-str
+ * scalars; undefined and unassigned simple values are diagnostic text
+ * ("undefined", "simple(N)"); tag chains ride the node's tag field as
+ * a space-separated decimal chain, outermost first.
+ *
+ * On failure returns NULL; *status (may be NULL) receives the code
+ * (YEPTRIS_ERROR_PARSE well-formedness, YEPTRIS_ERROR_ENCODING UTF-8,
+ * YEPTRIS_ERROR_DEPTH nesting, YEPTRIS_ERROR_MEMORY) and
+ * yeptris_last_error() carries the message with the byte offset.
+ *
+ * Memory: the caller owns the document; yeptris_document_free releases
+ * everything in one call. */
+YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uint32_t opts,
+                                                YeptrisStatus* status);
+
+/* CBOR Sequences (RFC 8742): top-level data items, concatenated —
+ * no framing bytes. Iterates the buffer, one document per item; the
+ * callback OWNS each item (free it with yeptris_document_free) and
+ * its nonzero return aborts the iteration. Returns the item count
+ * delivered so far. An empty sequence is valid (0 items). A truncated
+ * or malformed trailing item fails YEPTRIS_ERROR_PARSE with the item
+ * index and byte offset on the error channel. opts: decode flags. */
+typedef int (*yeptris_cbor_item_cb)(void* ctx, YeptrisDocument item, size_t index);
+YEPTRIS_API size_t yeptris_cbor_decode_sequence(const void* buf, size_t len, uint32_t opts,
+                                                yeptris_cbor_item_cb cb, void* ctx,
+                                                YeptrisStatus* status);
+
+/* Encodes n documents as a CBOR Sequence: the concatenation of the
+ * items (opts as yeptris_cbor_encode_into). buf == NULL: the exact
+ * byte count. Otherwise writes at most cap and returns the count; a
+ * too-small cap writes nothing and returns the need. Returns 0 on a
+ * NULL items entry or an unencodable document. */
+YEPTRIS_API size_t yeptris_cbor_encode_sequence_into(YeptrisDocument* items, size_t n,
+                                                     uint32_t opts, void* buf, size_t cap);
+
+/* Convenience: the sequence in a malloc'd buffer — caller frees. */
+YEPTRIS_API void* yeptris_cbor_encode_sequence(YeptrisDocument* items, size_t n, uint32_t opts,
+                                               size_t* len);
+
+/* Encodes the document's first root as ONE data item (sequences are a
+ * separate surface). buf == NULL: returns the exact byte count needed.
+ * Otherwise writes at most cap bytes and returns the count written; a
+ * too-small cap writes nothing and returns the needed size. Returns 0
+ * on a NULL document or an unencodable one (aliases, non-decimal tag
+ * text, non-numeric INT/FLOAT text) — yeptris_last_error() says why.
+ *
+ * Canonical opts sort map keys (s4.2.1); without it, insertion order.
+ * encode(decode(x)) is byte-stable across repeated calls. */
+YEPTRIS_API size_t yeptris_cbor_encode_into(YeptrisDocument doc, uint32_t opts, void* buf,
+                                            size_t cap);
+
+/* Convenience: encodes into a malloc'd buffer — caller frees with
+ * free(). Returns NULL on failure; *len (may be NULL) receives the
+ * byte count. */
+YEPTRIS_API void* yeptris_cbor_encode(YeptrisDocument doc, uint32_t opts, size_t* len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_CBOR_H */

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

@@ -0,0 +1,181 @@
+/* document.h / node.h surface — DOM accessors (TODO.impl/11).
+ * Pinned enums: bindings hard-code these values (test_abi). */
+
+#ifndef YEPTRIS_DOM_PUBLIC_H
+#define YEPTRIS_DOM_PUBLIC_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEPTRIS_NODE_SCALAR = 0,
+    YEPTRIS_NODE_SEQUENCE = 1,
+    YEPTRIS_NODE_MAPPING = 2,
+    YEPTRIS_NODE_ALIAS = 3,
+} YeptrisNodeKind;
+
+typedef enum {
+    YEPTRIS_STYLE_ANY = 0,
+    YEPTRIS_STYLE_PLAIN = 1,
+    YEPTRIS_STYLE_SINGLE_QUOTED = 2,
+    YEPTRIS_STYLE_DOUBLE_QUOTED = 3,
+    YEPTRIS_STYLE_LITERAL = 4,
+    YEPTRIS_STYLE_FOLDED = 5,
+} YeptrisScalarStyle;
+
+/* Releases the document and everything reachable from it (one call).
+ * Handles are invalid afterwards. NULL is accepted. */
+YEPTRIS_API void yeptris_document_free(YeptrisDocument doc);
+
+/* Number of documents in the parsed stream. */
+YEPTRIS_API size_t yeptris_document_count(YeptrisDocument doc);
+
+/* Root node of document i (0-based); NULL when out of range. */
+YEPTRIS_API YeptrisNode yeptris_document_root(YeptrisDocument doc, size_t index);
+
+YEPTRIS_API YeptrisNodeKind yeptris_node_kind(YeptrisNode node);
+
+/* Stable identity of the node within its document (bindings key
+ * wrapper caches on it; query handles are transient, ids are not).
+ * Only for equality — not an index into any public structure. */
+YEPTRIS_API uint32_t yeptris_node_id(YeptrisNode node);
+
+/* Scalar content / alias name. Returns NULL for collections.
+ * Memory: borrowed from the input (or document-owned when the value was
+ * folded/escaped) — valid until yeptris_document_free. */
+YEPTRIS_API const char* yeptris_node_value(YeptrisNode node, size_t* len);
+
+YEPTRIS_API YeptrisScalarStyle yeptris_node_style(YeptrisNode node);
+
+/* Node properties; empty (NULL, 0) when absent. */
+YEPTRIS_API const char* yeptris_node_tag(YeptrisNode node, size_t* len);
+YEPTRIS_API const char* yeptris_node_anchor(YeptrisNode node, size_t* len);
+
+/* Alias target node; NULL for non-aliases. */
+YEPTRIS_API YeptrisNode yeptris_node_alias_target(YeptrisNode node);
+
+/* Sequence entry count / entry i. */
+YEPTRIS_API size_t yeptris_node_seq_count(YeptrisNode node);
+YEPTRIS_API YeptrisNode yeptris_node_seq_at(YeptrisNode node, size_t index);
+
+/* Mapping pair count / value for a key (linear; interning lands with the
+ * full DOM item). The first matching key wins. */
+YEPTRIS_API size_t yeptris_node_map_count(YeptrisNode node);
+YEPTRIS_API YeptrisNode yeptris_node_map_get(YeptrisNode node, const char* key, size_t key_len);
+
+/* Ordered pair access: key and value of pair i (0-based). Returns 0
+ * and sets the out-params when the index is in range, -1 otherwise. */
+YEPTRIS_API int yeptris_node_map_at(YeptrisNode node, size_t index, YeptrisNode* key,
+                                    YeptrisNode* value);
+
+/* ---- Construction (TODO.impl/11 phase 3) ----
+ *
+ * Build documents from scratch and mutate them; the emitter and every
+ * query API above work on synthesized documents unchanged. All values
+ * are COPIED into the document — nothing is borrowed from the caller.
+ * Nodes belong to exactly one parent (or one document root); a node
+ * already attached, a duplicate map key (add), cross-document links,
+ * and trees deeper than the nesting cap (YEPTRIS_ERROR_DEPTH) are
+ * rejected. Deletion unlinks but keeps arena lifetime: handles stay
+ * valid until yeptris_document_free. */
+
+/* An empty document with no input; build nodes and set the root. */
+YEPTRIS_API YeptrisDocument yeptris_document_new(void);
+
+/* Records a detached node as document i's root. */
+YEPTRIS_API int yeptris_document_set_root(YeptrisDocument doc, YeptrisNode root);
+
+YEPTRIS_API YeptrisNode yeptris_node_new_mapping(YeptrisDocument doc);
+YEPTRIS_API YeptrisNode yeptris_node_new_sequence(YeptrisDocument doc);
+
+/* Memory: value copied (document lifetime). Plain style types the copy
+ * through the schema resolver exactly like parse; quoted/block styles
+ * force string. */
+YEPTRIS_API YeptrisNode yeptris_node_new_scalar(YeptrisDocument doc, const char* value, size_t len,
+                                                YeptrisScalarStyle style);
+
+/* YEPTRIS_OK, or ERROR_ARG (cross-document/detached misuse),
+ * ERROR_MEMORY, ERROR_DEPTH, ERROR_PARSE (duplicate key). */
+YEPTRIS_API int yeptris_node_map_add(YeptrisNode map, const char* key, size_t key_len,
+                                     YeptrisNode value);
+
+/* Replace-or-add: an existing key keeps its position and swaps the
+ * value; a new key appends. */
+YEPTRIS_API int yeptris_node_map_set(YeptrisNode map, const char* key, size_t key_len,
+                                     YeptrisNode value);
+
+YEPTRIS_API int yeptris_node_seq_add(YeptrisNode seq, YeptrisNode value);
+YEPTRIS_API int yeptris_node_seq_del(YeptrisNode seq, size_t index);
+
+/* Replace the entry at index (same position kept). */
+YEPTRIS_API int yeptris_node_seq_set(YeptrisNode seq, size_t index, YeptrisNode value);
+YEPTRIS_API int yeptris_node_map_del(YeptrisNode map, const char* key, size_t key_len);
+
+/* ---- bulk build (TODO.impl/15 phase D: the dump-side mirror of the
+ * recorder's bulk drain — ONE call builds a whole document, so
+ * bindings never pay per-node FFI) ------------------------------------- */
+
+typedef enum {
+    YEPTRIS_BUILD_SCALAR = 1, /* push a scalar (value bytes in the blob) */
+    YEPTRIS_BUILD_SEQ = 2,    /* open a sequence */
+    YEPTRIS_BUILD_MAP = 3,    /* open a mapping */
+    YEPTRIS_BUILD_END = 4,    /* close the innermost open container */
+    YEPTRIS_BUILD_TAG = 5,    /* tag the last-placed node (tag bytes in
+                               * the blob) — #300: nil mapping keys need
+                               * Psych's explicit `!` tag */
+} YeptrisBuildOp;
+
+/* 12 bytes, ABI-pinned: op, style (scalar: YeptrisScalarStyle;
+ * ignored for containers), reserved, then the value slice. */
+typedef struct {
+    uint8_t op;
+    uint8_t style;
+    uint16_t reserved;
+    uint32_t off;
+    uint32_t len;
+} YeptrisBuildEntry;
+#if defined(__cplusplus)
+static_assert(sizeof(YeptrisBuildEntry) == 12, "build entry layout pinned");
+#else
+_Static_assert(sizeof(YeptrisBuildEntry) == 12, "build entry layout pinned");
+#endif
+
+/* Walks the entries in order — the same document-order grammar as the
+ * event stream: scalars link into the innermost open container (in a
+ * mapping, entries alternate key/value), SEQ/MAP open a child
+ * container, END closes it; after the last entry exactly one root
+ * must remain open-free and becomes the document root. Scalars copy
+ * their bytes from the blob (nothing is borrowed). Duplicate keys
+ * keep the LAST value, exactly as the parser accepts them (host
+ * mappings cannot produce one; the check would cost O(n^2) on wide
+ * maps). Returns YEPTRIS_OK, ERROR_ARG (NULL inputs),
+ * ERROR_PARSE (imbalanced walk: END on an empty stack, entries after
+ * the root closed, an unclosed container, a dangling key, a bad op
+ * or out-of-range slice), ERROR_DEPTH, or ERROR_MEMORY. */
+YEPTRIS_API YeptrisStatus yeptris_document_build(YeptrisDocument doc,
+                                                 const YeptrisBuildEntry* entries, size_t count,
+                                                 const char* blob, size_t blob_len);
+
+/* Appends a pre-built key node (duplicate rejected). */
+YEPTRIS_API int yeptris_node_map_add_node(YeptrisNode map, YeptrisNode key, YeptrisNode value);
+
+/* Props on synthesized nodes (copied in). An alias node carries its
+ * display name and resolves to `target` for queries/serialization. */
+YEPTRIS_API int yeptris_node_set_anchor(YeptrisNode node, const char* name, size_t len);
+YEPTRIS_API int yeptris_node_set_tag(YeptrisNode node, const char* tag, size_t len);
+YEPTRIS_API YeptrisNode yeptris_node_new_alias(YeptrisDocument doc, YeptrisNode target,
+                                               const char* name, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_DOM_PUBLIC_H */

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

@@ -0,0 +1,81 @@
+/* emit.h — serialization (TODO.impl/13).
+ *
+ * One writer engine serves DOM walks and (with 13C) event streams;
+ * sizing runs the SAME engine dry, so the size query and the write
+ * agree by construction — zero reallocations after the reserve.
+ *
+ * Roundtrip fidelity: re-serializing a parsed document re-emits its
+ * recorded scalar styles (a plain stays plain where safe, quoted stays
+ * quoted, block scalars stay block). Byte stability:
+ * serialize(parse(serialize(x))) == serialize(x) — gated by the
+ * corpus roundtrip test.
+ */
+#ifndef YEPTRIS_EMIT_H
+#define YEPTRIS_EMIT_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Emission options (13B). Versioned by size: initialize with
+ * {sizeof(yeptris_emit_options)} so future fields stay optional. */
+typedef struct yeptris_emit_options {
+    uint32_t size;          /* sizeof(yeptris_emit_options) */
+    int canonical;          /* fixed form: flow collections, quoted strings,
+                             * typed words, shortest floats; a parse of the
+                             * output re-serializes byte-identically */
+    int best_width;         /* 0 = library default (80): flow collections
+                             * wrap after a value when the current line
+                             * exceeds the width (13B) */
+    int explicit_doc_start; /* nonzero: every document carries the
+                             * leading --- marker (Psych/libyaml's
+                             * implicit=false parity). Default 0: a
+                             * single document is emitted bare. Only
+                             * read when the caller's struct is large
+                             * enough (size-versioned). */
+} yeptris_emit_options;
+
+/* Options-aware entries; opts == NULL selects the fidelity mode
+ * (recorded styles re-emitted). Same contracts as below. */
+YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument doc, const yeptris_emit_options* opts,
+                                             char* buf, size_t cap);
+YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument doc, const yeptris_emit_options* opts,
+                                       size_t* len);
+
+/* Serializes the document set. buf == NULL: returns the exact byte
+ * count needed and writes nothing. Otherwise writes at most cap bytes
+ * (NUL-terminated when cap allows) and returns the count written;
+ * when cap is too small nothing is written and the needed size is
+ * returned. Returns 0 on a NULL document. */
+YEPTRIS_API size_t yeptris_serialize_into(YeptrisDocument doc, char* buf, size_t cap);
+
+/* Streaming emission (13C): bytes are delivered in chunks to sink as
+ * the walk proceeds — memory bounded by the largest scalar, never the
+ * document. Returns the total byte count, or 0 on a NULL argument or
+ * when the sink aborts (nonzero return aborts the walk). */
+typedef int (*yeptris_emit_sink)(void* ctx, const char* bytes, size_t len);
+YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument doc, const yeptris_emit_options* opts,
+                                            yeptris_emit_sink sink, void* ctx);
+
+/* Convenience: serializes into a malloc'd buffer (caller frees).
+ * Returns NULL on allocation failure or a NULL document; *len (may be
+ * NULL) receives the byte count. The buffer is NUL-terminated. */
+YEPTRIS_API char* yeptris_serialize(YeptrisDocument doc, size_t* len);
+
+/* Frees a buffer the library returned (the serialize* family's
+ * "caller frees" contract). The buffer was allocated by THIS
+ * library's allocator — freeing it with the host's free is
+ * wrong-CRT on Windows (the #318 mingw lesson). NULL is a no-op. */
+YEPTRIS_API void yeptris_free(void* p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_EMIT_H */

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

@@ -0,0 +1,41 @@
+/* error.h — public status codes.
+ *
+ * Public entry points write only these codes (the internal error channel —
+ * thread-local + per-document messages with line/column — lands with
+ * TODO.impl/02). Enum values are ABI: bindings hard-code them and the ABI
+ * pinning test (test/unit/test_abi.cpp) fails if one shifts without a major
+ * version bump.
+ */
+#include <stdint.h>
+
+#ifndef YEPTRIS_ERROR_H
+#define YEPTRIS_ERROR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEPTRIS_OK = 0,                /* success */
+    YEPTRIS_ERROR_PARSE = 1,       /* malformed YAML (details + line/col via the error channel) */
+    YEPTRIS_ERROR_MEMORY = 2,      /* allocation failure; document remains freeable */
+    YEPTRIS_ERROR_DEPTH = 3,       /* nesting exceeds max_depth (default 1000) */
+    YEPTRIS_ERROR_ENCODING = 4,    /* invalid input encoding / ill-formed UTF-8 */
+    YEPTRIS_ERROR_IO = 5,          /* caller-supplied I/O failure */
+    YEPTRIS_ERROR_ARG = 6,         /* invalid argument (NULL handle, bad option) */
+    YEPTRIS_ERROR_UNSUPPORTED = 7, /* requested feature not built in */
+    YEPTRIS_ERROR_INTERNAL = 8,    /* invariant violation — a bug, please report */
+    YEPTRIS_ERROR_SCHEMA = 9, /* descriptor materialization: a REQUIRED node missing (issue #238) */
+} YeptrisStatus;
+
+/* Message of the most recent failure on the calling thread, with its
+ * 1-based line/column (0 = unknown). Returns "" when the last operation
+ * succeeded. Memory: thread-local static storage; valid until the next
+ * library call on this thread. */
+YEPTRIS_API const char* yeptris_last_error(uint32_t* line, uint32_t* col);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_ERROR_H */