yeptris 0.6.18.2-arm-linux-eabihf

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

@@ -0,0 +1,76 @@
+/* writer.h — internal emitter engine (TODO.impl/13). */
+#ifndef YEP_EMIT_WRITER_H
+#define YEP_EMIT_WRITER_H
+
+#include <stdint.h>
+
+#include "../common/nametab.h"
+#include "../doc.h"
+#include "../dom/dom.h"
+
+/* Streaming high-water mark: the writer flushes when len crosses it
+ * (append-only output makes any point safe; 13C). */
+#define YEP_EMIT_WATERMARK (1u << 16)
+
+typedef int (*yep_emit_flush)(void* ctx, const char* bytes, size_t len);
+
+typedef struct yep_writer {
+    char* p;             /* output (wet) */
+    size_t len;          /* bytes written (or counted, dry) */
+    int dry;             /* 1: size only */
+    char last;           /* last byte written ('\0' at start) — dry-safe */
+    int force_flow;      /* complex-key emission: collections render flow */
+    yep_emit_flush sink; /* 13C: streaming flush (NULL = buffered) */
+    void* sink_ctx;
+    size_t watermark;
+    size_t flushed;   /* total bytes handed to the sink */
+    int sink_aborted; /* a sink returned nonzero: stop, report 0 */
+    int canonical;
+    int explicit_doc_start;
+    /* every document carries the --- marker */ /* 13B: fixed canonical form — flow collections,
+                                                 * quoted strings, typed words, shortest floats
+                                                 */
+    int json;                                   /* 21: JSON output — canonical minus YAML words:
+                                                 * null (not ~), no document markers, JSON escapes */
+    int json_compact;                           /* json-c to_json_string: no padding spaces */
+    int json_pretty;                            /* json-c PRETTY: 2-space indent, per-entry lines */
+    int pretty_depth;                           /* json_pretty nesting level (indent = 2*depth) */
+    int best_width;                             /* 13B: 0 = default 80; flow lines wrap after a
+                                                 * value past this width */
+    int col;                                    /* current output column (wr_* maintains) */
+    const char* sv_input;                       /* compact-view decode bases (dom regions) */
+    const char* sv_arena;
+    /* #352: per-scalar route decisions, derived once in the dry
+     * sizing pass and consumed by the wet write pass (one byte per
+     * scalar, indexed by consumption order; NULL = derive per pass) */
+    uint8_t* sc_dec;
+    uint32_t sc_i;
+    /* #352 slice 2: the growable single-pass route — the exact-sizing
+     * dry pass measured 0.54-0.73x of the one-pass stream route on
+     * CI-fresh runners, so serialize_ex writes wet into a buffer that
+     * doubles on demand (cap/grow), like the streaming window. The
+     * fixed-buffer routes keep grow=0 and today's trust-the-count
+     * behavior. oom marks a failed growth: writes stop touching memory
+     * but the byte count keeps running so callers can fail cleanly. */
+    size_t cap;
+    int grow;
+    int oom;
+} yep_writer;
+
+typedef struct yep_emitter {
+    const yeptris_document* doc;
+    yep_writer w;
+    yep_nametab canon_names; /* canonical anchor renaming: view -> index */
+} yep_emitter;
+
+/* One pass over the document set. dry=1 counts exactly. */
+size_t yep_emit_run(yep_emitter* em, int dry);
+
+/* Compact single-line JSON (internal entries for the json-c compat
+ * layer's to_json_string forms). pretty selects json-c's
+ * JSON_C_TO_STRING_PRETTY layout: newline + 2-space indent per
+ * nesting level, one entry per line. */
+char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len);
+char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len);
+
+#endif /* YEP_EMIT_WRITER_H */

data/vendor/libyeptris/src/yeptris/encoding/bom.c

@@ -0,0 +1,31 @@
+/* bom.c — byte-order-mark sniffing (TODO.impl/05). */
+
+#include "encoding.h"
+
+size_t yep_bom_sniff(const unsigned char* p, size_t len, yep_encoding* out) {
+    yep_encoding enc = YEP_ENC_UNKNOWN;
+    size_t consumed = 0;
+
+    /* UTF-32LE (FF FE 00 00) must be tested before UTF-16LE (FF FE). */
+    if (len >= 4 && p[0] == 0xFF && p[1] == 0xFE && p[2] == 0x00 && p[3] == 0x00) {
+        enc = YEP_ENC_UTF32LE;
+        consumed = 4;
+    } else if (len >= 3 && p[0] == 0xEF && p[1] == 0xBB && p[2] == 0xBF) {
+        enc = YEP_ENC_UTF8;
+        consumed = 3;
+    } else if (len >= 4 && p[0] == 0x00 && p[1] == 0x00 && p[2] == 0xFE && p[3] == 0xFF) {
+        enc = YEP_ENC_UTF32BE;
+        consumed = 4;
+    } else if (len >= 2 && p[0] == 0xFF && p[1] == 0xFE) {
+        enc = YEP_ENC_UTF16LE;
+        consumed = 2;
+    } else if (len >= 2 && p[0] == 0xFE && p[1] == 0xFF) {
+        enc = YEP_ENC_UTF16BE;
+        consumed = 2;
+    }
+
+    if (out != NULL) {
+        *out = enc;
+    }
+    return consumed;
+}

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

@@ -0,0 +1,63 @@
+/* encoding.h — the encoding front-end (TODO.impl/05).
+ *
+ * MECE law: charset truth lives ONLY here. The scan layer receives a
+ * buffer guaranteed valid UTF-8 and never re-validates; output is always
+ * UTF-8 (the libleptris serialization guarantee).
+ *
+ * Zero-copy policy: UTF-8 input is validated in place and borrowed;
+ * non-UTF-8 input is transcoded once (into a buffer allocated via the
+ * caller's allocator — item 07/11 re-home it into the document arena).
+ *
+ * v1 scope decisions (recorded in TODO.impl/05): validation is scalar
+ * with a SWAR ASCII fast path — the SIMD kernel lands only if item 06's
+ * profiles demand it; transcoding rejects ill-formed input (strict) —
+ * compat replacement policy arrives with the parse-options item (10).
+ */
+#ifndef YEP_ENCODING_H
+#define YEP_ENCODING_H
+
+#include <stddef.h>
+
+#include "memory/allocator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEP_ENC_UNKNOWN = 0,
+    YEP_ENC_UTF8,
+    YEP_ENC_UTF16LE,
+    YEP_ENC_UTF16BE,
+    YEP_ENC_UTF32LE,
+    YEP_ENC_UTF32BE,
+} yep_encoding;
+
+/* Sniffs a byte-order mark. Sets *out (UNKNOWN when none) and returns the
+ * BOM length in bytes (0 when none). Partial BOMs at end-of-input match
+ * nothing. UTF-32LE is checked before UTF-16LE (FF FE 00 00 is both).
+ * out may be NULL. */
+size_t yep_bom_sniff(const unsigned char* p, size_t len, yep_encoding* out);
+
+/* Validates UTF-8: 1 when [p, p+len) is well-formed (no overlongs, no
+ * surrogates, no > U+10FFFF, no truncation), else 0 with *err_pos set to
+ * the offset of the first offending byte (err_pos may be NULL). */
+int yep_utf8_validate(const unsigned char* p, size_t len, size_t* err_pos);
+
+/* Well-formed UTF-8 AND the YAML 1.2 c-printable charset: raw C0
+ * controls except TAB/LF/CR, DEL, C1 except NEL, U+FFFE/U+FFFF are
+ * rejected (charset SSOT — encoding/ is the only place that decides). */
+int yep_printable_validate(const unsigned char* p, size_t len, size_t* err_pos);
+
+/* Transcodes UTF-16/32 (any endianness) into freshly allocated UTF-8.
+ * On success returns 0, stores the buffer (owned by the caller, freed
+ * with the allocator) and its length. Errors: -1 allocation failure,
+ * -2 ill-formed input with *err_pos at the offending unit offset. */
+int yep_transcode_to_utf8(const yep_allocator* sys, yep_encoding enc, const unsigned char* src,
+                          size_t len, unsigned char** out, size_t* out_len, size_t* err_pos);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_ENCODING_H */

data/vendor/libyeptris/src/yeptris/encoding/transcode.c

@@ -0,0 +1,148 @@
+/* transcode.c — UTF-16/UTF-32 (either endianness) → UTF-8 (TODO.impl/05).
+ *
+ * Strict v1: ill-formed input (unpaired surrogates, values above
+ * U+10FFFF, truncated units) is an error at the offending unit; the
+ * compat replacement policy arrives with parse options (10).
+ * Worst-case sizing: UTF-16 unit 2 bytes → 3 UTF-8 bytes (1.5x);
+ * UTF-32 unit 4 → 4 bytes (1x).
+ */
+
+#include <stdint.h>
+
+#include "encoding.h"
+
+static unsigned char* yep_emit_utf8(unsigned char* o, uint32_t cp) {
+    if (cp < 0x80) {
+        *o++ = (unsigned char)cp;
+    } else if (cp < 0x800) {
+        *o++ = (unsigned char)(0xC0 | (cp >> 6));
+        *o++ = (unsigned char)(0x80 | (cp & 0x3F));
+    } else if (cp < 0x10000) {
+        *o++ = (unsigned char)(0xE0 | (cp >> 12));
+        *o++ = (unsigned char)(0x80 | ((cp >> 6) & 0x3F));
+        *o++ = (unsigned char)(0x80 | (cp & 0x3F));
+    } else {
+        *o++ = (unsigned char)(0xF0 | (cp >> 18));
+        *o++ = (unsigned char)(0x80 | ((cp >> 12) & 0x3F));
+        *o++ = (unsigned char)(0x80 | ((cp >> 6) & 0x3F));
+        *o++ = (unsigned char)(0x80 | (cp & 0x3F));
+    }
+    return o;
+}
+
+static uint16_t rd16(const unsigned char* p, int big_endian) {
+    return big_endian ? (uint16_t)((p[0] << 8) | p[1]) : (uint16_t)((p[1] << 8) | p[0]);
+}
+
+static int yep_is_surrogate(uint32_t cp) {
+    return cp >= 0xD800 && cp <= 0xDFFF;
+}
+
+static int yep_transcode_utf16(const yep_allocator* sys, int big_endian, const unsigned char* src,
+                               size_t len, unsigned char** out, size_t* out_len, size_t* err_pos) {
+    if (len % 2 != 0) { /* trailing partial unit */
+        if (err_pos != NULL) {
+            *err_pos = len - 1;
+        }
+        return -2;
+    }
+
+    size_t units = len / 2;
+    size_t max_out = units * 3;
+    unsigned char* dst = yep_alloc(sys, max_out ? max_out : 1);
+    if (dst == NULL) {
+        return -1;
+    }
+
+    unsigned char* o = dst;
+    for (size_t i = 0; i < units; i++) {
+        uint16_t u = rd16(src + i * 2, big_endian);
+        if (u >= 0xD800 && u <= 0xDBFF) {
+            if (i + 1 >= units) {
+                if (err_pos != NULL) {
+                    *err_pos = i * 2;
+                }
+                yep_free(sys, dst);
+                return -2; /* lone high surrogate */
+            }
+            uint16_t v = rd16(src + (i + 1) * 2, big_endian);
+            if (v < 0xDC00 || v > 0xDFFF) {
+                if (err_pos != NULL) {
+                    *err_pos = (i + 1) * 2;
+                }
+                yep_free(sys, dst);
+                return -2; /* high surrogate not followed by low */
+            }
+            uint32_t cp = 0x10000 + (((uint32_t)(u - 0xD800)) << 10) + (uint32_t)(v - 0xDC00);
+            o = yep_emit_utf8(o, cp);
+            i++;
+        } else if (u >= 0xDC00 && u <= 0xDFFF) {
+            if (err_pos != NULL) {
+                *err_pos = i * 2;
+            }
+            yep_free(sys, dst);
+            return -2; /* lone low surrogate */
+        } else {
+            o = yep_emit_utf8(o, u);
+        }
+    }
+
+    *out = dst;
+    *out_len = (size_t)(o - dst);
+    return 0;
+}
+
+static int yep_transcode_utf32(const yep_allocator* sys, int big_endian, const unsigned char* src,
+                               size_t len, unsigned char** out, size_t* out_len, size_t* err_pos) {
+    size_t units = len / 4;
+    unsigned char* dst = yep_alloc(sys, len ? len : 1);
+    if (dst == NULL) {
+        return -1;
+    }
+
+    unsigned char* o = dst;
+    for (size_t i = 0; i < units; i++) {
+        const unsigned char* p = src + i * 4;
+        uint32_t cp = big_endian ? ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
+                                       ((uint32_t)p[2] << 8) | (uint32_t)p[3]
+                                 : ((uint32_t)p[3] << 24) | ((uint32_t)p[2] << 16) |
+                                       ((uint32_t)p[1] << 8) | (uint32_t)p[0];
+        if (cp > 0x10FFFF || yep_is_surrogate(cp)) {
+            if (err_pos != NULL) {
+                *err_pos = i * 4;
+            }
+            yep_free(sys, dst);
+            return -2;
+        }
+        o = yep_emit_utf8(o, cp);
+    }
+
+    *out = dst;
+    *out_len = (size_t)(o - dst);
+    return 0;
+}
+
+int yep_transcode_to_utf8(const yep_allocator* sys, yep_encoding enc, const unsigned char* src,
+                          size_t len, unsigned char** out, size_t* out_len, size_t* err_pos) {
+    if (sys == NULL || out == NULL || out_len == NULL || (src == NULL && len != 0)) {
+        return -1;
+    }
+    if (len == 0) {
+        *out = NULL;
+        *out_len = 0;
+        return 0;
+    }
+
+    switch (enc) {
+    case YEP_ENC_UTF16LE:
+        return yep_transcode_utf16(sys, 0, src, len, out, out_len, err_pos);
+    case YEP_ENC_UTF16BE:
+        return yep_transcode_utf16(sys, 1, src, len, out, out_len, err_pos);
+    case YEP_ENC_UTF32LE:
+        return yep_transcode_utf32(sys, 0, src, len, out, out_len, err_pos);
+    case YEP_ENC_UTF32BE:
+        return yep_transcode_utf32(sys, 1, src, len, out, out_len, err_pos);
+    default:
+        return -2; /* not a transcoding source */
+    }
+}

data/vendor/libyeptris/src/yeptris/encoding/utf8_validate.c

@@ -0,0 +1,178 @@
+/* utf8_validate.c — well-formedness check with a SIMD-gated fast path
+ * (TODO.impl/05; TODO.restructure/69). Clean 32-byte chunks ride the
+ * gate_scan kernel (0 = every byte printable ASCII — validated in one
+ * pass); dirty chunks fall to the exact per-byte walk, which resumes
+ * the kernel at the next sequence boundary. The original SWAR path
+ * broke at the first non-ASCII byte and never recovered.
+ *
+ * Rules enforced (Unicode 15 well-formedness): no overlong encodings, no
+ * UTF-16 surrogate code points (U+D800..U+DFFF), nothing above U+10FFFF,
+ * continuation bytes only where a sequence expects them.
+ *
+ * yep_printable_validate additionally enforces the YAML 1.2 c-printable
+ * charset on the stream (the charset SSOT lives here): raw C0 controls
+ * except TAB/LF/CR, DEL, C1 except NEL (U+0085), and U+FFFE/U+FFFF are
+ * rejected wherever they appear. Escape sequences are decoded later —
+ * printable applies to source bytes only.
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "../common/simd_text.h"
+#include "encoding.h"
+
+static int ascii_ok(unsigned char b, int printable) {
+    if (!printable) {
+        return 1;
+    }
+    /* c-printable ASCII: TAB, LF, CR, 0x20..0x7E */
+    if (b == '\t' || b == '\n' || b == '\r') {
+        return 1;
+    }
+    return b >= 0x20 && b <= 0x7E;
+}
+
+/* Code point >= 0x80 allowed by c-printable? (surrogates are already
+ * rejected by the well-formedness rules above). */
+static int cp_printable(uint32_t cp) {
+    return cp == 0x85 || (cp >= 0xA0 && cp <= 0xFFFD) || cp >= 0x10000;
+}
+
+/* The exact per-byte walk: ASCII gate check plus the multibyte DFA.
+ * Advances *i by one byte or one whole sequence; returns 0 on error
+ * (with *err_pos set), 1 to continue. */
+static int step(const unsigned char* p, size_t len, size_t* i, size_t* err_pos, int printable) {
+    size_t at = *i;
+    unsigned char b = p[at];
+    if (b < 0x80) {
+        if (!ascii_ok(b, printable)) {
+            if (err_pos != NULL) {
+                *err_pos = at;
+            }
+            return 0;
+        }
+        *i = at + 1;
+        return 1;
+    }
+
+    size_t need;          /* continuation bytes expected */
+    unsigned char lo, hi; /* allowed range of the first continuation */
+    if (b >= 0xC2 && b <= 0xDF) {
+        need = 1;
+        lo = 0x80;
+        hi = 0xBF;
+    } else if (b == 0xE0) {
+        need = 2;
+        lo = 0xA0; /* no overlong two-byte */
+        hi = 0xBF;
+    } else if ((b >= 0xE1 && b <= 0xEC) || b == 0xEE || b == 0xEF) {
+        need = 2;
+        lo = 0x80;
+        hi = 0xBF;
+    } else if (b == 0xED) {
+        need = 2;
+        lo = 0x80;
+        hi = 0x9F; /* no surrogates */
+    } else if (b == 0xF0) {
+        need = 3;
+        lo = 0x90; /* no overlong three-byte */
+        hi = 0xBF;
+    } else if (b >= 0xF1 && b <= 0xF3) {
+        need = 3;
+        lo = 0x80;
+        hi = 0xBF;
+    } else if (b == 0xF4) {
+        need = 3;
+        lo = 0x80;
+        hi = 0x8F; /* no > U+10FFFF */
+    } else {
+        if (err_pos != NULL) {
+            *err_pos = at;
+        }
+        return 0;
+    }
+
+    /* The sequence spans [at, at + need]; all those bytes must exist. */
+    if (at + need >= len) {
+        if (err_pos != NULL) {
+            *err_pos = at;
+        }
+        return 0;
+    }
+
+    unsigned char c1 = p[at + 1];
+    if (c1 < lo || c1 > hi) {
+        if (err_pos != NULL) {
+            *err_pos = at + 1;
+        }
+        return 0;
+    }
+    for (size_t k = 2; k <= need; k++) {
+        if (p[at + k] < 0x80 || p[at + k] > 0xBF) {
+            if (err_pos != NULL) {
+                *err_pos = at + k;
+            }
+            return 0;
+        }
+    }
+    if (printable) {
+        uint32_t cp;
+        if (need == 1) {
+            cp = ((uint32_t)(b & 0x1F) << 6) | (uint32_t)(c1 & 0x3F);
+        } else if (need == 2) {
+            cp = ((uint32_t)(b & 0x0F) << 12) | ((uint32_t)(c1 & 0x3F) << 6) |
+                 (uint32_t)(p[at + 2] & 0x3F);
+        } else {
+            cp = ((uint32_t)(b & 0x07) << 18) | ((uint32_t)(c1 & 0x3F) << 12) |
+                 ((uint32_t)(p[at + 2] & 0x3F) << 6) | (uint32_t)(p[at + 3] & 0x3F);
+        }
+        if (!cp_printable(cp)) {
+            if (err_pos != NULL) {
+                *err_pos = at;
+            }
+            return 0;
+        }
+    }
+    *i = at + 1 + need;
+    return 1;
+}
+
+static int validate(const unsigned char* p, size_t len, size_t* err_pos, int printable) {
+    if (err_pos != NULL) {
+        *err_pos = 0;
+    }
+    if (p == NULL && len != 0) {
+        return 0;
+    }
+
+    size_t i = 0;
+
+    while (i + 32 <= len) {
+        if (yep_text_active()->gate_scan((const char*)p + i, 32) == 0) {
+            i += 32;
+            continue;
+        }
+        size_t edge = i + 32;
+        while (i < edge) {
+            if (!step(p, len, &i, err_pos, printable)) {
+                return 0;
+            }
+        }
+    }
+
+    while (i < len) {
+        if (!step(p, len, &i, err_pos, printable)) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int yep_utf8_validate(const unsigned char* p, size_t len, size_t* err_pos) {
+    return validate(p, len, err_pos, 0);
+}
+
+int yep_printable_validate(const unsigned char* p, size_t len, size_t* err_pos) {
+    return validate(p, len, err_pos, 1);
+}

data/vendor/libyeptris/src/yeptris/events/capture.c

@@ -0,0 +1,150 @@
+/* capture.c — the shared capture sink (TODO.impl/12). */
+
+#include "capture.h"
+
+#include <string.h>
+
+#include "../../include/yeptris/events.h"
+
+/* The record IS the public ABI shape (events.h pins it). */
+YEPTRIS_CT_ASSERT(sizeof(YeptrisEventRecord) == 36);
+
+void yep_rec_init(yep_rec_store* s) {
+    s->recs = NULL;
+    s->n = 0;
+    s->cap = 0;
+    s->arena = NULL;
+    s->arena_len = 0;
+    s->arena_cap = 0;
+}
+
+void yep_rec_reset(yep_rec_store* s) {
+    s->n = 0;
+    s->arena_len = 0;
+}
+
+void yep_rec_free(yep_rec_store* s) {
+    free(s->recs);
+    free(s->arena);
+    yep_rec_init(s);
+}
+
+static uint32_t arena_put(yep_rec_store* s, const char* p, uint32_t len) {
+    if (len == 0 || p == NULL) {
+        return 0;
+    }
+    if (s->arena_len + len > s->arena_cap) {
+        size_t cap = s->arena_cap ? s->arena_cap : 256;
+        while (s->arena_len + len > cap) {
+            cap *= 2;
+        }
+        char* na = realloc(s->arena, cap);
+        if (na == NULL) {
+            return 0; /* OOM: the string is dropped, not fatal */
+        }
+        s->arena = na;
+        s->arena_cap = cap;
+    }
+    memcpy(s->arena + s->arena_len, p, len);
+    uint32_t off = (uint32_t)s->arena_len;
+    s->arena_len += len;
+    return off;
+}
+
+int yep_rec_on_event(void* ctx, const yep_event* ev) {
+    yep_rec_store* s = (yep_rec_store*)ctx;
+    if (s->n == s->cap) {
+        size_t cap = s->cap ? s->cap * 2 : 64;
+        YeptrisEventRecord* nr = realloc(s->recs, cap * sizeof(*nr));
+        if (nr == NULL) {
+            return -1;
+        }
+        s->recs = nr;
+        s->cap = cap;
+    }
+    YeptrisEventRecord* r = &s->recs[s->n];
+    memset(r, 0, sizeof(*r));
+    switch (ev->type) {
+    case YEP_EV_STREAM_START:
+        r->type = YEPTRIS_EV_STREAM_START;
+        break;
+    case YEP_EV_STREAM_END:
+        r->type = YEPTRIS_EV_STREAM_END;
+        break;
+    case YEP_EV_DOCUMENT_START:
+        r->type = YEPTRIS_EV_DOCUMENT_START;
+        if (ev->style == 1) {
+            r->flags |= YEPTRIS_EF_EXPLICIT;
+        }
+        break;
+    case YEP_EV_DOCUMENT_END:
+        r->type = YEPTRIS_EV_DOCUMENT_END;
+        if (ev->style == 1) {
+            r->flags |= YEPTRIS_EF_EXPLICIT;
+        }
+        break;
+    case YEP_EV_SEQ_START:
+        r->type = YEPTRIS_EV_SEQUENCE_START;
+        break;
+    case YEP_EV_SEQ_END:
+        r->type = YEPTRIS_EV_SEQUENCE_END;
+        break;
+    case YEP_EV_MAP_START:
+        r->type = YEPTRIS_EV_MAPPING_START;
+        break;
+    case YEP_EV_MAP_END:
+        r->type = YEPTRIS_EV_MAPPING_END;
+        break;
+    case YEP_EV_SCALAR:
+        r->type = YEPTRIS_EV_SCALAR;
+        r->style = ev->style;
+        r->tag_id = ev->tag_id; /* the resolver's verdict, once */
+        if (ev->implicit) {
+            r->flags |= YEPTRIS_EF_IMPLICIT;
+        }
+        break;
+    case YEP_EV_ALIAS:
+        r->type = YEPTRIS_EV_ALIAS;
+        break;
+    default:
+        return 0;
+    }
+    if (ev->flow) {
+        r->flags |= YEPTRIS_EF_FLOW;
+    }
+    r->line = ev->line;
+    r->col = ev->col;
+    r->value_off = arena_put(s, (const char*)ev->value.p, (uint32_t)ev->value.len);
+    r->value_len = (uint32_t)ev->value.len;
+    r->anchor_off = arena_put(s, (const char*)ev->anchor.p, (uint32_t)ev->anchor.len);
+    r->anchor_len = (uint32_t)ev->anchor.len;
+    r->tag_off = arena_put(s, (const char*)ev->tag.p, (uint32_t)ev->tag.len);
+    r->tag_len = (uint32_t)ev->tag.len;
+    s->n++;
+    return 0;
+}
+
+void yep_rec_materialize(const yep_rec_store* s, size_t i, void* out) {
+    const YeptrisEventRecord* r = &s->recs[i];
+    YeptrisEvent* e = (YeptrisEvent*)out;
+    memset(e, 0, sizeof(*e));
+    e->type = (YeptrisEventType)r->type;
+    e->style = r->style;
+    e->flow = (r->flags & YEPTRIS_EF_FLOW) != 0;
+    e->explicit_marker = (r->flags & YEPTRIS_EF_EXPLICIT) != 0;
+    e->implicit = (r->flags & YEPTRIS_EF_IMPLICIT) != 0;
+    e->line = r->line;
+    e->col = r->col;
+    if (r->value_len > 0) {
+        e->value = s->arena + r->value_off;
+        e->value_len = r->value_len;
+    }
+    if (r->anchor_len > 0) {
+        e->anchor = s->arena + r->anchor_off;
+        e->anchor_len = r->anchor_len;
+    }
+    if (r->tag_len > 0) {
+        e->tag = s->arena + r->tag_off;
+        e->tag_len = r->tag_len;
+    }
+}

data/vendor/libyeptris/src/yeptris/events/capture.h

@@ -0,0 +1,39 @@
+/* capture.h — shared event capture (TODO.impl/12).
+ *
+ * One sink that appends fixed-size records plus copied strings into an
+ * arena. Pull, recorder and iterparse are storage policies over this
+ * machinery; push converts directly (no storage). The engine knows
+ * nothing about any of them (OCP).
+ */
+#ifndef YEP_EVENTS_CAPTURE_H
+#define YEP_EVENTS_CAPTURE_H
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "../../include/yeptris/events.h"
+#include "parse/engine.h"
+#include "parse/events.h"
+
+/* Growable records array + string arena; records are the public
+ * YeptrisEventRecord layout (the storage SSOT for pull/recorder/
+ * iterparse). */
+typedef struct {
+    YeptrisEventRecord* recs;
+    size_t n, cap;
+    char* arena;
+    size_t arena_len, arena_cap;
+} yep_rec_store;
+
+void yep_rec_init(yep_rec_store* s);
+void yep_rec_reset(yep_rec_store* s);
+void yep_rec_free(yep_rec_store* s);
+
+/* The sink: appends one record per event, strings copied to the arena. */
+int yep_rec_on_event(void* ctx, const yep_event* ev);
+
+/* Materializes record i into the public event shape; string pointers
+ * reference this store's arena. */
+void yep_rec_materialize(const yep_rec_store* s, size_t i, void* out /* YeptrisEvent* */);
+
+#endif /* YEP_EVENTS_CAPTURE_H */