yeptris 0.6.5.4 → 0.6.7.2

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

@@ -0,0 +1,100 @@
+/* plan.h — the compiled plan walk (TODO.restructure/87 slice one,
+ * yeptris#293): a Descriptor-shaped plan compiled from a JSON spec,
+ * applied to a parsed JSON tape in ONE C pass producing typed
+ * COLUMNAR output — no Ruby/Python tree, no per-node host dispatch.
+ *
+ * Slice one covers the lutaml-model shape: a root collection (seq or
+ * map-of-rows) whose rows are mappings of scalar leaves (int, float,
+ * str, bool). Nested paths, the YAML leg, and partial descriptors
+ * compose later per the board item.
+ *
+ * The plan borrows nothing; the result borrows the tape's source
+ * buffer for string spans (free the result before the tape/source).
+ */
+#ifndef YEPTRIS_PLAN_H
+#define YEPTRIS_PLAN_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/tape.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Column kinds (mirrors the spec's leaf "kind"). */
+enum {
+    YEP_PLAN_INT = 0,
+    YEP_PLAN_FLOAT,
+    YEP_PLAN_STR,
+    YEP_PLAN_BOOL,
+};
+
+typedef struct yeptris_plan yeptris_plan;
+typedef struct yeptris_plan_result yeptris_plan_result;
+
+/* Compiles a plan from a strict-JSON spec document:
+ *
+ *   {"kind":"seq","path":"items","children":[
+ *      {"name":"id","kind":"int"}, {"name":"ok","kind":"bool"}, ...]}
+ *
+ * kind: "seq" or "map" — the ROWS container's shape at the root.
+ * path: the root mapping's key holding the rows — a string, or an
+ *       ARRAY of strings for a segmented (nested) path walked
+ *       mapping by mapping. Empty/absent: the seq root itself.
+ *       Leaf kinds: int, float, str, bool. Returns NULL with *st on
+ *       a malformed spec (ARG/PARSE) or allocation failure. */
+YEPTRIS_API yeptris_plan* yeptris_plan_compile(const char* spec, size_t len, YeptrisStatus* st);
+
+YEPTRIS_API void yeptris_plan_free(yeptris_plan* plan);
+
+YEPTRIS_API size_t yeptris_plan_column_count(const yeptris_plan* plan);
+
+/* Applies the plan to a tape (from yeptris_parse_json_tape; the
+ * LENIENT tape also works — NUM records convert at extraction).
+ * Every row of the collection fills one slot per column; missing or
+ * null leaves mark the slot null. Returns NULL with *st on
+ * PARSE (document shape disagreement) or MEMORY. */
+YEPTRIS_API yeptris_plan_result*
+yeptris_tape_plan_walk(const yeptris_json_tape* tape, const yeptris_plan* plan, YeptrisStatus* st);
+
+/* The YAML/DOM leg: the same compiled plan applied to a parsed
+ * yeptris document (yeptris_parse — any schema). Typed extraction
+ * rides the parse-time tag ids; string columns expose (ptr,len)
+ * views into the document's regions (input or string arena), so the
+ * RESULT BORROWS the document — free the result first. Same status
+ * contract as the tape walk. */
+YEPTRIS_API yeptris_plan_result*
+yeptris_document_plan_walk(YeptrisDocument doc, const yeptris_plan* plan, YeptrisStatus* st);
+
+YEPTRIS_API void yeptris_plan_result_free(yeptris_plan_result* r);
+
+/* Result accessors: rows, and per-column kind + typed arrays. The
+ * arrays hold `rows` entries; NULL markers are the per-column u8
+ * bitmap (1 = null/missing). String columns expose spans into the
+ * tape's source. */
+YEPTRIS_API size_t yeptris_plan_result_rows(const yeptris_plan_result* r);
+YEPTRIS_API int yeptris_plan_result_kind(const yeptris_plan_result* r, size_t col);
+YEPTRIS_API const int64_t* yeptris_plan_result_ints(const yeptris_plan_result* r, size_t col);
+YEPTRIS_API const double* yeptris_plan_result_floats(const yeptris_plan_result* r, size_t col);
+YEPTRIS_API const uint32_t* yeptris_plan_result_str_offs(const yeptris_plan_result* r, size_t col);
+YEPTRIS_API const uint32_t* yeptris_plan_result_str_lens(const yeptris_plan_result* r, size_t col);
+/* The DOM leg's string column: rows (ptr,len) views into the
+ * document (NULL on the tape leg — use the offs/lens pair there). */
+typedef struct yeptris_plan_str {
+    const char* p;
+    size_t len;
+} yeptris_plan_str;
+
+YEPTRIS_API const yeptris_plan_str* yeptris_plan_result_strs(const yeptris_plan_result* r,
+                                                             size_t col);
+YEPTRIS_API const uint8_t* yeptris_plan_result_nulls(const yeptris_plan_result* r, size_t col);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_PLAN_H */

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

@@ -0,0 +1,71 @@
+/* resolve.h — schema resolvers and typed scalar access (TODO.impl/10).
+ *
+ * Typing is pluggable and outside the grammar: a resolver decides,
+ * per plain scalar, which implicit tag it carries. YAML 1.2 core
+ * correctness and Psych/libyaml 1.1 parity are two resolvers over one
+ * interface; the parse options select one per document.
+ *
+ * Resolution assigns a dense tag id at parse time (stored on DOM
+ * nodes); typed VALUE conversion happens on accessor demand — parse
+ * speed never pays for typing the caller never reads.
+ */
+#ifndef YEPTRIS_RESOLVE_H
+#define YEPTRIS_RESOLVE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Tag ids. The core set is preallocated and stable (ABI-pinned);
+ * custom tags resolve to YEPTRIS_TAG_CUSTOM and keep their string. */
+typedef enum {
+    YEPTRIS_TAG_STR = 0,
+    YEPTRIS_TAG_INT = 1,
+    YEPTRIS_TAG_FLOAT = 2,
+    YEPTRIS_TAG_BOOL = 3,
+    YEPTRIS_TAG_NULL = 4,
+    YEPTRIS_TAG_TIMESTAMP = 5,
+    YEPTRIS_TAG_SEQ = 6,
+    YEPTRIS_TAG_MAP = 7,
+    YEPTRIS_TAG_BINARY = 8,
+    YEPTRIS_TAG_MERGE = 9,
+    YEPTRIS_TAG_VALUE = 10,
+    YEPTRIS_TAG_CUSTOM = 11,
+} YeptrisTagId;
+
+/* Schemas. */
+typedef enum {
+    YEPTRIS_SCHEMA_12_CORE = 0, /* default: the yaml-test-suite target */
+    YEPTRIS_SCHEMA_11_COMPAT,   /* libyaml/Psych implicit typing */
+} YeptrisSchema;
+
+/* Canonical tag URI for a core id ("tag:yaml.org,2002:str"); NULL for
+ * YEPTRIS_TAG_CUSTOM. */
+YEPTRIS_API const char* yeptris_tag_uri(YeptrisTagId id);
+
+/* The tag a scalar resolved to (PLAIN scalars carry their implicit
+ * tag; quoted/other styles are always STR; explicit tags map to their
+ * core id when they match one, else CUSTOM). Non-scalars: SEQ/MAP.
+ * YEPTRIS_ERROR_ARG on a bad handle. */
+YEPTRIS_API YeptrisTagId yeptris_node_tag_id(YeptrisNode node);
+
+/* Typed access (lazy conversion from the raw view; resolution's tag
+ * id decides eligibility, the conversion revalidates the bytes):
+ * YEPTRIS_ERROR_PARSE when the scalar's tag does not match the
+ * accessor (e.g. an INT accessor on a STR). */
+YEPTRIS_API YeptrisStatus yeptris_node_int(YeptrisNode node, int64_t* out);
+YEPTRIS_API YeptrisStatus yeptris_node_float(YeptrisNode node, double* out);
+YEPTRIS_API YeptrisStatus yeptris_node_bool(YeptrisNode node, int* out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_RESOLVE_H */

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

@@ -0,0 +1,119 @@
+/* schema.h — the fused schema-descriptor materialization API
+ * (issue #238, TODO.restructure/83).
+ *
+ * The descriptor is the ABI, NOT a schema language: XSD/JSON-Schema
+ * cannot express consumer semantics (two-names-one-slot merges, value
+ * maps, key renames, raw capture) — the CONSUMER compiles those into
+ * this flat positional plan, the same way lutaml-model compiles its
+ * rule plans. The engine materializes against it in ONE native pass;
+ * the intermediate generic document (the Hash/Array the bindings used
+ * to build) never exists.
+ *
+ * Design contract (from the committed consumer, co-designed):
+ *  - kind CALLBACK is the escape hatch: the raw value span plus the
+ *    node's byte position come back as records; the host finishes
+ *    just those fields (custom procs, polymorphism, delegates).
+ *  - Results are WHOLE DOCUMENTS: this call never crosses the FFI
+ *    boundary per value — the caller passes output buffers sized by
+ *    expectation and receives per-node counts.
+ *  - The descriptor ABI is versioned in lockstep with the bindings
+ *    ({c-semver}.{binding-patch}); desc_abi changes only with a C
+ *    minor bump.
+ *  - Sequences of a plan run the SAME node plan for every element
+ *    (flags ELEMENT); nested mappings run their child plan slice.
+ */
+#ifndef YEPTRIS_SCHEMA_H
+#define YEPTRIS_SCHEMA_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/parse.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The descriptor ABI version of this header. */
+#define YEPTRIS_DESC_ABI 1u
+
+/* node kinds */
+enum {
+    YEP_SK_SCALAR = 0, /* typed leaf: type_tag decides the column */
+    YEP_SK_SEQUENCE,   /* sequence: children[0] is the ELEMENT plan */
+    YEP_SK_MAPPING,    /* mapping: children are the key plans */
+    YEP_SK_CALLBACK,   /* escape hatch: raw span + position records */
+};
+
+/* scalar type tags (the columns' element types) */
+enum {
+    YEP_ST_STR = 0, /* off/len into the input */
+    YEP_ST_INT,     /* int64_t */
+    YEP_ST_FLOAT,   /* double */
+    YEP_ST_BOOL,    /* uint8_t */
+    YEP_ST_NULL,    /* no payload (count only) */
+    YEP_ST_ANY,     /* SCALAR: keep the resolver's verdict — the
+                       column is a YeptrisValue-like record */
+};
+
+/* node flags */
+enum {
+    YEP_SF_REQUIRED = 1u << 0,   /* missing at its mapping -> error */
+    YEP_SF_FIRST_WINS = 1u << 1, /* duplicates: first match kept
+                                    (default: last, as at parse) */
+};
+
+/* One plan node. 32 bytes, ABI-pinned. */
+typedef struct yeptris_desc_node {
+    const char* wire_name; /* mapping key to match (NULL: the root) */
+    uint8_t kind;          /* YEP_SK_* */
+    uint8_t type_tag;      /* YEP_ST_* (SCALAR) */
+    uint16_t flags;        /* YEP_SF_* */
+    uint32_t child_index;  /* SEQUENCE: the element plan; MAPPING: the
+                              first child. Unused otherwise (0). */
+    uint32_t child_count;  /* MAPPING: children from child_index. */
+    uint32_t reserved;     /* must be 0 (ABI headroom) */
+} yeptris_desc_node;
+
+YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == 24);
+
+/* One column's output. Caller allocates the payload array (sized by
+ * expectation); the call fills it and sets count. No per-value FFI:
+ * hosts drain whole columns after the call. */
+typedef struct yeptris_schema_column {
+    void* data;        /* element type from the plan's type_tag */
+    uint32_t capacity; /* elements the buffer holds */
+    uint32_t count;    /* elements materialized (out) */
+} yeptris_schema_column;
+
+/* STR/CALLBACK payload: off/len into the INPUT buffer (zero-copy to
+ * the host). CALLBACK also carries the node's byte position. */
+typedef struct yeptris_span2 {
+    uint32_t off;
+    uint32_t len;
+    uint32_t node_off; /* the node's first byte (callbacks) */
+    uint32_t pad;
+} yeptris_span2;
+
+YEPTRIS_CT_ASSERT(sizeof(yeptris_span2) == 16);
+
+/* Parses `source` (YAML or strict JSON — the same front door as
+ * yeptris_parse_ex) and materializes against the descriptor in one
+ * pass: node i's matches land in cols[i]. The input buffer must
+ * outlive the string/callback spans (they borrow it).
+ *
+ * Status: YEPTRIS_OK; YEPTRIS_ERROR_PARSE (yeptris_last_error);
+ * YEPTRIS_ERROR_SCHEMA (a REQUIRED node missing — the error carries
+ * the node index; detail via yeptris_last_error); YEPTRIS_ERROR_MEMORY
+ * / ARG (NULL descriptor, desc_len 0, desc_abi mismatch). */
+YEPTRIS_API YeptrisStatus yeptris_schema_load(const char* source, size_t len, YeptrisSchema schema,
+                                              const yeptris_desc_node* desc, uint32_t desc_len,
+                                              uint32_t desc_abi, yeptris_schema_column* cols);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_SCHEMA_H */

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

@@ -0,0 +1,99 @@
+/* tape.h — the compact JSON tape (issue #238's consumer shape,
+ * TODO.restructure/85: the simdjson-class materialization).
+ *
+ * One fused strict walk appends ONE record per token — no DOM nodes,
+ * no links, no views. Records are THREE parallel columns (kind byte,
+ * off, len) carved from one block: bools encode in the kind, container
+ * links ride the off column, and NUMBERS RECORD SPANS ONLY — parse
+ * validates the grammar (the lean shape scan) and materialize converts
+ * (yeptris_tape_convert; the C-API materializer converts inline).
+ * Strings stay zero-copy spans into the caller's buffer.
+ *
+ * The tape is a document-level result (never per value across FFI);
+ * the buffer the spans borrow must outlive it.
+ */
+#ifndef YEPTRIS_TAPE_H
+#define YEPTRIS_TAPE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Record kinds (the kinds column). */
+enum {
+    YEP_T_DOC = 0, /* document boundary (records start after it) */
+    YEP_T_NULL,
+    YEP_T_TRUE,     /* the kind IS the value */
+    YEP_T_FALSE,    /* the kind IS the value */
+    YEP_T_INT,      /* off/len: signed digit span; convert at materialize */
+    YEP_T_FLOAT,    /* off/len: float text span; convert at materialize */
+    YEP_T_STR,      /* off/len: raw span (escapes untouched; the
+                        qbc kernel found them) */
+    YEP_T_SEQ_OPEN, /* off: index of the matching CLOSE */
+    YEP_T_MAP_OPEN, /* off: index of the matching CLOSE; keys are
+                        the STR records at even positions inside */
+    YEP_T_CLOSE,    /* off: index of the matching OPEN */
+    YEP_T_NUM,      /* lenient route only: off/len number span with
+                        the grammar UNVALIDATED at parse —
+                        yeptris_tape_convert is the authority (it
+                        classifies int/float and rejects malformed
+                        spans; simdjson's deferred contract) */
+};
+
+typedef struct yeptris_json_tape {
+    size_t count;
+    uint8_t* kinds;   /* yeptris tape kind per record */
+    uint32_t* offs;   /* span starts (STR/INT/FLOAT); container links */
+    uint32_t* lens;   /* span lengths (STR/INT/FLOAT) */
+    int64_t int_min;  /* set by yeptris_tape_convert when an INT span
+                         exceeds int64 (materialize-time discovery) */
+    const void* _src; /* the parsed buffer (spans borrow it; it must
+                         outlive the tape — same contract as the spans) */
+    size_t _srclen;
+    void* _block; /* the carved allocation base */
+} yeptris_json_tape;
+
+/* Parses strict JSON into the tape. Accepts scalar roots (a single
+ * record). Returns YEPTRIS_OK, YEPTRIS_ERROR_PARSE (details via
+ * yeptris_last_error), YEPTRIS_ERROR_MEMORY, YEPTRIS_ERROR_ARG. */
+YEPTRIS_API YeptrisStatus yeptris_parse_json_tape(const char* source, size_t len,
+                                                  yeptris_json_tape* tape);
+
+/* The lenient route (simdjson's deferred contract, opt-in): every
+ * STRUCTURAL check stays at parse (bracket matching, alternation,
+ * comma/colon placement, literals, string closes/escapes) while
+ * NUMBER grammar defers to yeptris_tape_convert — a number records
+ * as a YEP_T_NUM charset run (so "1.2.3" is accepted here and
+ * rejected at convert, exactly where simdjson's number parse would
+ * fail; a run with non-number bytes like "12ab" still rejects
+ * structurally at parse). Accepts a superset of the strict route's
+ * inputs (tab whitespace becomes legal, RFC 8259); on everything
+ * the strict route accepts, the tapes are structurally identical
+ * (spans and containers equal; NUM records carry the same bytes the
+ * strict INT/FLOAT records carry). Non-ASCII inputs take the strict
+ * route unchanged. */
+YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, size_t len,
+                                                          yeptris_json_tape* tape);
+
+YEPTRIS_API void yeptris_tape_free(yeptris_json_tape* tape);
+
+/* Converts the INT/FLOAT records in [from, to): ivals/dvals are
+ * parallel to the RECORD indices (slots for other kinds are left
+ * untouched; either pointer may be NULL). Returns the number of
+ * number records converted, or SIZE_MAX if a span does not re-scan
+ * as a number (impossible for a tape this library produced).
+ * Sets t->int_min when an INT span exceeds int64. */
+YEPTRIS_API size_t yeptris_tape_convert(yeptris_json_tape* t, size_t from, size_t to,
+                                        int64_t* ivals, double* dvals);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_TAPE_H */

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

@@ -0,0 +1,38 @@
+/* types.h — opaque public handles.
+ *
+ * The single canonical source of public types (TODO.impl/02 extends this
+ * file; internal types never appear here). Callers never see struct
+ * definitions: every handle is opaque and pointer-sized, asserted by the
+ * ABI pinning test (test/unit/test_abi.cpp).
+ */
+#ifndef YEPTRIS_TYPES_H
+#define YEPTRIS_TYPES_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* A parsed document; the sole owner of all memory reachable from it.
+ * Memory: freed exactly once with yeptris_document_free (TODO.impl/11). */
+typedef struct yeptris_document* YeptrisDocument;
+
+/* A node (document, mapping, sequence, scalar, alias) inside a document.
+ * Memory: borrowed from its document — valid until the document is freed. */
+typedef struct yeptris_node* YeptrisNode;
+
+/* Streaming/streaming-adjacent handles, introduced with their items:
+ * parser engine (TODO.impl/07), pull/recorder/iterparse (TODO.impl/12),
+ * emitter (TODO.impl/13). Declared now so the handle vocabulary is stable. */
+typedef struct yeptris_parser* YeptrisParser;
+typedef struct yeptris_pull* YeptrisPullParser;
+typedef struct yeptris_recorder* YeptrisRecorder;
+typedef struct yeptris_iterparse* YeptrisIterparse;
+typedef struct yeptris_emitter* YeptrisEmitter;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_TYPES_H */

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

@@ -0,0 +1,102 @@
+/* values.h — the typed value stream (TODO.impl/15 phase F).
+ *
+ * The materialization fast path for FFI bindings: one parse, one
+ * drain of PRE-CONVERTED typed values. The C side runs the same
+ * engine the recorder drives, then converts every scalar by its
+ * resolver tag — the host walks a flat array and builds containers,
+ * never re-parsing text.
+ *
+ * The `is_key` bit carries the key/value alternation, so hosts need
+ * no pending-key bookkeeping; `tag_id` rides along so hosts with
+ * schema quirks (Psych's single-char y/n, PyYAML's dot-required
+ * floats) can re-decide a scalar's type from its raw bytes without
+ * re-running a conversion grammar.
+ */
+#ifndef YEPTRIS_VALUES_H
+#define YEPTRIS_VALUES_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/resolve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEP_V_DOC = 0, /* document boundary */
+    YEP_V_NULL,
+    YEP_V_BOOL,      /* b carries 0/1 */
+    YEP_V_INT,       /* i */
+    YEP_V_FLOAT,     /* d */
+    YEP_V_STR,       /* off/len bytes */
+    YEP_V_TIMESTAMP, /* off/len bytes (host constructs the date) */
+    YEP_V_SEQ_OPEN,
+    YEP_V_MAP_OPEN,
+    YEP_V_CLOSE, /* closes the innermost open container */
+    YEP_V_ALIAS, /* off/len: the alias name */
+    /* decorates the entry that FOLLOWS it: the anchor name binds to
+     * that value (identity for aliases). Emitted only when anchored. */
+    YEP_V_ANCHOR, /* off/len: the name */
+} YeptrisValueKind;
+
+/* 24 bytes, ABI-pinned. Every scalar carries its raw bytes (off/len)
+ * next to a typed payload; `p` holds the INT bits or the FLOAT bits
+ * (reinterpreted by kind — hosts unpack it as ONE 64-bit field, so
+ * the record costs 7 values, not 8). */
+typedef struct {
+    uint8_t kind;   /* YeptrisValueKind */
+    uint8_t tag_id; /* the resolver's verdict for this scalar */
+    uint8_t is_key; /* the entry lands in the inner map's key slot */
+    uint8_t b;      /* BOOL payload; implicit-plain flag otherwise */
+    uint32_t off;   /* STR/TIMESTAMP/ALIAS/anchor bytes */
+    uint32_t len;
+    uint64_t p; /* INT or FLOAT payload, by kind */
+} YeptrisValue;
+YEPTRIS_CT_ASSERT(sizeof(YeptrisValue) == 24);
+
+/* Parses `yaml` and drains the typed value stream. On success sets
+ * *vals / *count / *arena / *arena_len (both malloc'd; free with
+ * yeptris_value_free exactly once). Returns YEPTRIS_OK,
+ * YEPTRIS_ERROR_PARSE (details via yeptris_last_error), or
+ * YEPTRIS_ERROR_MEMORY / YEPTRIS_ERROR_ARG. */
+YEPTRIS_API YeptrisStatus yeptris_value_drain(const char* yaml, size_t len, YeptrisSchema schema,
+                                              YeptrisValue** vals, size_t* count, char** arena,
+                                              size_t* arena_len);
+
+YEPTRIS_API void yeptris_value_free(YeptrisValue* vals, char* arena);
+
+/* Columnar projection of the same stream (task #42: the materializer
+ * wall is per-record struct decoding in FFI hosts — parallel typed
+ * buffers let bindings iterate C-speed arrays and unpack whole
+ * columns in one call). Same walk, same semantics, same arena; one
+ * carved allocation holds payloads/offs/lens/kinds/tags/is_keys/bools
+ * (payloads is the block base — yeptris_value_free_columns frees it
+ * and the arena; both are safe on a zero-entry drain). */
+typedef struct {
+    size_t count;
+    size_t arena_len;
+    int64_t* payloads; /* INT or FLOAT bits, by kind */
+    uint32_t* offs;    /* STR/TIMESTAMP/ALIAS/ANCHOR bytes */
+    uint32_t* lens;
+    uint8_t* kinds; /* YeptrisValueKind */
+    uint8_t* tags;  /* resolver verdict per scalar */
+    uint8_t* is_keys;
+    uint8_t* bools; /* BOOL payload; implicit-plain flag otherwise */
+    char* arena;
+} YeptrisValueColumns;
+
+YEPTRIS_API YeptrisStatus yeptris_value_drain_columns(const char* yaml, size_t len,
+                                                      YeptrisSchema schema,
+                                                      YeptrisValueColumns* cols);
+
+YEPTRIS_API void yeptris_value_free_columns(YeptrisValueColumns* cols);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VALUES_H */

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

@@ -0,0 +1,29 @@
+/* version.h — generated from the CMake project VERSION.
+ *
+ * CMakeLists.txt project(yeptris VERSION ...) is the single source of truth;
+ * scripts/bump-version.sh syncs vcpkg.json and CHANGELOG.md from it. Never
+ * hand-edit the generated file (it lives in the build tree).
+ */
+#ifndef YEPTRIS_VERSION_H
+#define YEPTRIS_VERSION_H
+
+#include <yeptris/api.h>
+
+#define YEPTRIS_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
+#define YEPTRIS_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define YEPTRIS_VERSION_PATCH @PROJECT_VERSION_PATCH@
+#define YEPTRIS_VERSION_STRING "@PROJECT_VERSION@"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Returns the library version string ("major.minor.patch").
+ * Memory: static storage; valid for the lifetime of the process. */
+YEPTRIS_API const char* yeptris_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VERSION_H */

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

@@ -0,0 +1,77 @@
+/* visit.h — language-agnostic value visitor (TODO.restructure/22/24).
+ *
+ * A push-style sink over the parsed value stream. Hosts that build
+ * native objects (Ruby C-API, CPython, etc.) implement the vtable and
+ * receive one callback per scalar/container — no intermediate records,
+ * no DOM, no host-side walk. The JSON entry is a fused RFC 8259 scan
+ * that never allocates a tree; the YAML entry rides the engine; the
+ * node entry walks an existing DOM subtree.
+ *
+ * OCP: a new host is a new vtable, never a core edit. MECE: scanning
+ * stays in scan/; this header is only the sink contract. */
+#ifndef YEPTRIS_VISIT_H
+#define YEPTRIS_VISIT_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/dom.h>
+#include <yeptris/error.h>
+#include <yeptris/resolve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Return 0 to continue, nonzero to abort (propagated as the status
+ * detail when non-zero; YEPTRIS_ERROR_INTERNAL is the library-side
+ * stand-in when the visitor doesn't set a more specific code). */
+typedef struct YeptrisVisitVTable {
+    int (*on_null)(void* ctx);
+    int (*on_bool)(void* ctx, int truthy);
+    int (*on_int)(void* ctx, int64_t v);
+    int (*on_float)(void* ctx, double v);
+    /* bytes are borrowed from the input (or a short-lived decode
+     * scratch for escaped JSON strings — valid only for the duration
+     * of the callback). */
+    int (*on_string)(void* ctx, const char* p, size_t len);
+    int (*on_seq_start)(void* ctx);
+    int (*on_seq_end)(void* ctx);
+    int (*on_map_start)(void* ctx);
+    /* A map key is always a string callback immediately followed by
+     * the value; hosts that need the key/value pairing push the key
+     * on on_string when is_key is set. */
+    int (*on_map_end)(void* ctx);
+    /* Optional: 1 when the next scalar/container is a map key. NULL
+     * means the visitor does not distinguish (JSON keys are always
+     * strings fired via on_string before their value). */
+    int (*on_key)(void* ctx, const char* p, size_t len);
+    /* Optional document boundary (YAML multi-doc). NULL = ignore. */
+    int (*on_doc)(void* ctx);
+    /* Optional anchor/alias. NULL = materializer does not support
+     * identity (JSON never fires these). */
+    int (*on_anchor)(void* ctx, const char* name, size_t len);
+    int (*on_alias)(void* ctx, const char* name, size_t len);
+} YeptrisVisitVTable;
+
+/* Fused strict-JSON scan → visit. No DOM, no records. On success the
+ * visitor saw exactly one value (plus optional ws). */
+YEPTRIS_API YeptrisStatus yeptris_visit_json(const char* data, size_t len,
+                                             const YeptrisVisitVTable* vt, void* ctx);
+
+/* YAML parse → visit through the engine (schema selects the resolver).
+ * Multi-doc streams fire on_doc before each document's root value. */
+YEPTRIS_API YeptrisStatus yeptris_visit(const char* data, size_t len, YeptrisSchema schema,
+                                        const YeptrisVisitVTable* vt, void* ctx);
+
+/* Existing DOM subtree → visit (Node#to_ruby bulk path without
+ * records/Marshal). */
+YEPTRIS_API YeptrisStatus yeptris_visit_node(YeptrisNode node, const YeptrisVisitVTable* vt,
+                                             void* ctx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VISIT_H */