yeptris 0.6.18.2-arm-linux-eabihf → 0.6.20.1-arm-linux-eabihf

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

@@ -0,0 +1,77 @@
+/* ytape.h — the packed YAML record tape (#378, TODO.max-perf/12).
+ *
+ * The eager DOM builders' callback stream packed into 8-byte words:
+ * the common block ops carry spans only (the resolver call and the
+ * 48-byte node build defer to replay), the general event path packs
+ * into a props word plus span words. Replay calls the SAME builder
+ * functions with reconstructed views — resolution and placement
+ * semantics are the eager path's by construction (the differential
+ * gate pins tree identity across the corpora).
+ *
+ * Spans are input-relative when they fall inside [input, input+len]
+ * and fit 24 bits; anything else (pool content, oversized spans) is a
+ * generic (ptr, len) pair — the engine's finish pool owns that
+ * memory, its blocks are stable until the document frees it, and the
+ * lazy route keeps the pool on the document until replay copies (the
+ * builders copy exactly what must outlive the engine — dom_str_in).
+ *
+ * The recorder mirrors the eager builders' return-code discipline
+ * (depth caps answer 0 so the engine's event path owns the error;
+ * OOM answers <0) so error precedence survives the detour. */
+#ifndef YEP_YTAPE_H
+#define YEP_YTAPE_H
+
+#include <stddef.h>
+
+#include "parse/events.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct yep_pool yep_pool;
+
+typedef struct yep_ytape {
+    uint64_t* w;
+    uint32_t count;
+    uint32_t cap;
+    const char* input; /* the POST-BOM data pointer (span base) */
+    size_t input_len;
+    int depth;       /* the DOM's depth mirror (cap parity) */
+    int max_depth;   /* the engine's flow-walk limit, replayed */
+    int flow_strict; /* mirrors dom->flow_strict (0 everywhere today) */
+    int docs;        /* DOCUMENT_START count (the empty-stream check) */
+    int oom;
+    uint32_t flow_mark; /* record mark for the staged flow build */
+} yep_ytape;
+
+/* Record kinds — byte 7 of a word. */
+enum {
+    YTP_SPAN_IN = 0,      /* [off:32][len:24][0x00] */
+    YTP_EV_COMPACT = 1,   /* stream/document frames: [type:8][...][kind] */
+    YTP_EVENT = 2,        /* props + value + [tag] + [anchor] */
+    YTP_SCALAR = 3,       /* props + value + [tag] + [anchor]; is_item bit
+                           * routes the replay to the dash-item builder */
+    YTP_ITEM = 4,         /* borrowed dash item: [off:32][len:24][kind] */
+    YTP_PAIR = 5,         /* props + key + value + [anchor] + [anchor hi] */
+    YTP_OPEN = 6,         /* `key:`'s fresh map: [off:32][len:24][kind] */
+    YTP_FLOW = 7,         /* props + [open:32|len:32] + [tag] + [anchor] */
+    YTP_SPAN_POOL = 0xFF, /* [len:32][kind] + [ptr:64] */
+};
+
+/* Recorder lifecycle. Returns 0, or -1 when the word carve fails
+ * (caller answers YEPTRIS_ERROR_MEMORY — bounded-parse law). */
+int ytap_init(yep_ytape* t, const char* input, size_t len, int max_depth);
+void ytap_sink(yep_ytape* t, yep_sink* sink);
+void ytap_free(yep_ytape* t);
+
+/* Replay: builds the node tree through the eager builders. Returns 0,
+ * or -1 (a builder refused — allocation/depth; the lazy route treats
+ * it as the JSON tape route does). Sets d->input_base/len. */
+int dom_from_ytape(yep_dom* d, const yep_ytape* t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_YTAPE_H */

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

@@ -91,7 +91,12 @@ static void wr_put(yep_writer* w, const char* p, uint32_t n) {
         w->len += n;
         return;
     }
-    if (w->grow && w->len + n > w->cap) {
+    /* the +1 reserves the terminator slot: the serializers write the
+     * NUL at p[len] after the run, and a write landing exactly on cap
+     * (len + n == cap) put that NUL one byte past the buffer — the
+     * first byte of the next heap block's header (the #182 flake:
+     * corrupt deterministic, detected later, timing-varying) */
+    if (w->grow && w->len + n + 1 > w->cap) {
         wr_grow(w, n);
     }
     if (w->oom) {
@@ -114,7 +119,7 @@ static void wr_byte(yep_writer* w, char c) {
         w->len++;
         return;
     }
-    if (w->grow && w->len + 1 > w->cap) {
+    if (w->grow && w->len + 2 > w->cap) { /* +1 write, +1 terminator */
         wr_grow(w, 1);
     }
     if (w->oom) {

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

@@ -7,7 +7,7 @@
 #include "../../include/yeptris/events.h"
 
 /* The record IS the public ABI shape (events.h pins it). */
-YEPTRIS_CT_ASSERT(sizeof(YeptrisEventRecord) == 36);
+YEPTRIS_CT_ASSERT(sizeof(YeptrisEventRecord) == 44);
 
 void yep_rec_init(yep_rec_store* s) {
     s->recs = NULL;
@@ -114,6 +114,8 @@ int yep_rec_on_event(void* ctx, const yep_event* ev) {
     }
     r->line = ev->line;
     r->col = ev->col;
+    r->end_line = ev->end_line;
+    r->end_col = ev->end_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);
@@ -135,6 +137,8 @@ void yep_rec_materialize(const yep_rec_store* s, size_t i, void* out) {
     e->implicit = (r->flags & YEPTRIS_EF_IMPLICIT) != 0;
     e->line = r->line;
     e->col = r->col;
+    e->end_line = r->end_line;
+    e->end_col = r->end_col;
     if (r->value_len > 0) {
         e->value = s->arena + r->value_off;
         e->value_len = r->value_len;

data/vendor/libyeptris/src/yeptris/parse/engine.c

@@ -104,8 +104,11 @@ struct yep_engine {
         yep_view handle, prefix;
     } tagmap[8];
     int tagmap_n;
-    int saw_yaml; /* %YAML seen for the pending document */
-    void* step;   /* yep_stepstate: resumable stepping (07) */
+    int saw_yaml;     /* %YAML seen for the pending document */
+    size_t doc_begin; /* #179: first directive line of the pending doc
+                       * (SIZE_MAX = none) — libyaml's DOCUMENT_START
+                       * start_mark includes directives */
+    void* step;       /* yep_stepstate: resumable stepping (07) */
 
     /* Flow single-pair deferral: a sequence entry's events are buffered
      * until we know whether ':' follows ("[a: b]" needs MAP_START before
@@ -134,6 +137,34 @@ static uint32_t e_col(const yep_engine* e, size_t at) {
     return at >= e->line_start ? (uint32_t)(at - e->line_start) : 0;
 }
 
+/* #179: the (1-based line, 1-based col) of a byte offset. Unlike
+ * e_col this handles offsets on PRIOR lines — event ends whose scan
+ * already advanced past them (block scalars, collection closes).
+ * The backward walk covers only the span's own lines, so the total
+ * across a document stays linear in its size. */
+static void e_pos_mark(const yep_engine* e, size_t at, uint32_t* line, uint32_t* col) {
+    if (at >= e->line_start) {
+        *line = e->line;
+        *col = (uint32_t)(at - e->line_start) + 1;
+        return;
+    }
+    uint32_t l = e->line;
+    size_t ls = e->line_start;
+    while (at < ls && ls > 0) {
+        /* p[ls-1] is the newline ENDED the previous line: start the
+         * walk below it, or ls never decreases (the infinite-loop bug
+         * the Stepping.Directive hang found) */
+        size_t q = ls - 1;
+        while (q > 0 && e->p[q - 1] != '\n') {
+            q--;
+        }
+        ls = q; /* line_start(l-1) */
+        l--;
+    }
+    *line = l;
+    *col = (uint32_t)(at - ls) + 1;
+}
+
 static int e_fail(yep_engine* e, yep_err_code code, size_t at) {
     yep_error_set(&e->err, code, e->line, e_col(e, at) + 1, at, NULL);
     return -1;
@@ -374,6 +405,18 @@ static int e_open_seq(yep_engine* e, uint16_t col, uint32_t line, uint32_t coln,
     ev.tag = tag;
     ev.line = line;
     ev.col = coln;
+    ev.end_line = line; /* block opens are zero-span (libyaml) — except
+                         * the sequence at its parent mapping's column
+                         * ("k:\n- a"), which ends after the dash */
+    ev.end_col = coln;
+    for (int i = e->depth - 1; i >= 0; i--) {
+        if (e->frames[i].kind == YEP_FRAME_MAP) {
+            if (col == e->frames[i].col) {
+                ev.end_col = coln + 1;
+            }
+            break;
+        }
+    }
     return emit_now(e, &ev) == 0 ? 0 : -2;
 }
 
@@ -403,6 +446,8 @@ static int e_open_map(yep_engine* e, uint16_t col, uint32_t line, uint32_t coln,
     ev.tag = tag;
     ev.line = line;
     ev.col = coln;
+    ev.end_line = line; /* block opens are zero-span (libyaml) */
+    ev.end_col = coln;
     return emit_now(e, &ev) == 0 ? 0 : -2;
 }
 
@@ -436,6 +481,16 @@ static int e_close_to(yep_engine* e, int to_depth) {
         yep_event ev;
         e_event_init(&ev,
                      e->frames[e->depth].kind == YEP_FRAME_SEQ ? YEP_EV_SEQ_END : YEP_EV_MAP_END);
+        { /* libyaml: a block END's mark is the next token's position
+           * (zero-span) — the first non-space at the cursor, or EOF */
+            size_t at = e->pos;
+            while (at < e->len && e->p[at] == ' ') {
+                at++;
+            }
+            e_pos_mark(e, at, &ev.line, &ev.col);
+            ev.end_line = ev.line;
+            ev.end_col = ev.col;
+        }
         if (emit_now(e, &ev) != 0) {
             return -2;
         }
@@ -631,6 +686,7 @@ static int e_quoted_floor(yep_engine* e, yep_event* ev, uint16_t min_indent, int
         e->line_start = ls;
     }
     e->pos = after;
+    e_pos_mark(e, after, &ev->end_line, &ev->end_col);
     e_skip_inline_space(e);
     return 0;
 }
@@ -810,6 +866,7 @@ static int e_block_scalar(yep_engine* e, yep_event* ev, int parent_col) {
     ev->value.p = out; /* may be NULL for an empty block; len 0 */
     ev->borrowed = 0;
     ev->style = folded ? YEP_STYLE_FOLDED : YEP_STYLE_LITERAL;
+    e_pos_mark(e, e->pos, &ev->end_line, &ev->end_col);
     return 0;
 }
 
@@ -887,6 +944,11 @@ static int e_plain_multiline(yep_engine* e, yep_span s0, uint32_t block_floor, y
             break; /* the comment ends the scalar; later lines are new */
         }
     }
+    { /* #179: the source end = the last piece's content end */
+        const yep_view* last = &e->fold[e->fold_n - 1].content;
+        size_t lend = (size_t)(last->p - e->p) + last->len;
+        e_pos_mark(e, lend, &ev->end_line, &ev->end_col);
+    }
     if (e->fold_n == 1) {
         return 0; /* single line: the borrowed view stands */
     }
@@ -1082,6 +1144,7 @@ static int e_alias(yep_engine* e, yep_event* ev) {
                          the DOM borrows it like any plain scalar — no
                          arena copy per alias */
     ev->anchor_id = target;
+    e_pos_mark(e, e->pos, &ev->end_line, &ev->end_col);
     e_skip_inline_space(e);
     return 0;
 }
@@ -1224,6 +1287,7 @@ static int e_flow_node(yep_engine* e, yep_event* ev, int keyish) {
     if ((c == ',' || c == ']' || c == '}' || c == ':') &&
         (!yep_view_is_empty(anchor) || !yep_view_is_empty(tag))) {
         ev->implicit = 1; /* properties with no node: a tagged null */
+        e_pos_mark(e, e->pos, &ev->end_line, &ev->end_col);
         return 1;
     }
     if (c == '"' || c == '\'') {
@@ -1313,6 +1377,10 @@ static int e_flow_node(yep_engine* e, yep_event* ev, int keyish) {
     ev->style = YEP_STYLE_PLAIN;
     ev->implicit = 1;
     ev->multiline = (e->fold_n > 1) || crossed_break;
+    { /* #179: the source end = the last fold piece's content end */
+        const yep_view* lastp = &e->fold[e->fold_n - 1].content;
+        e_pos_mark(e, (size_t)(lastp->p - e->p) + lastp->len, &ev->end_line, &ev->end_col);
+    }
     return 1;
 }
 
@@ -1464,6 +1532,8 @@ static int e_flow_json(yep_engine* e, yep_view anchor, yep_view tag, uint32_t an
         ev.tag = tag;
         ev.line = cur_line;
         ev.col = (uint32_t)(open_pos + 1 - cur_ls) + 1;
+        ev.end_line = cur_line; /* flow opens end after the indicator */
+        ev.end_col = (uint32_t)(open_pos + 2 - cur_ls) + 1;
         if (emit_now(e, &ev) != 0) {
             return -2;
         }
@@ -1488,6 +1558,8 @@ static int e_flow_json(yep_engine* e, yep_view anchor, yep_view tag, uint32_t an
                 jx_advance_line(e, &cur_scan, i, &cur_line, &cur_ls);
             ev.line = cur_line;
             ev.col = (uint32_t)(i - cur_ls) + 1;
+            ev.end_line = cur_line;
+            ev.end_col = (uint32_t)(i + 1 - cur_ls) + 1;
             if (emit_now(e, &ev) != 0) {
                 return -2;
             }
@@ -1509,6 +1581,8 @@ static int e_flow_json(yep_engine* e, yep_view anchor, yep_view tag, uint32_t an
                 jx_advance_line(e, &cur_scan, i, &cur_line, &cur_ls);
             ev.line = cur_line;
             ev.col = (uint32_t)(i + 1 - cur_ls) + 1;
+            ev.end_line = cur_line; /* flow opens end after the indicator */
+            ev.end_col = (uint32_t)(i + 2 - cur_ls) + 1;
             if (emit_now(e, &ev) != 0) {
                 return -2;
             }
@@ -1582,6 +1656,11 @@ static int e_flow_json(yep_engine* e, yep_view anchor, yep_view tag, uint32_t an
                 return e_fail(e, YEP_ERR_KEY_TOO_LONG, vstart);
             }
         }
+        if (raw_end == vstart) {
+            raw_end = i; /* numbers/literals advance i, not raw_end */
+        }
+        ev.end_line = cur_line;
+        ev.end_col = (uint32_t)(raw_end - cur_ls) + 1;
         if (emit_now(e, &ev) != 0) {
             return -2;
         }
@@ -1652,6 +1731,8 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
     ev.tag = tag;
     ev.line = e->line;
     ev.col = e_col(e, e->pos);
+    ev.end_line = e->line; /* flow opens end after the indicator */
+    ev.end_col = e_col(e, e->pos) + 1;
     if (emit_now(e, &ev) != 0) {
         return -2;
     }
@@ -1755,6 +1836,8 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
             ev.tag = pt;
             ev.line = e->line;
             ev.col = e_col(e, e->pos);
+            ev.end_line = e->line; /* flow opens end after the indicator */
+            ev.end_col = e_col(e, e->pos) + 1;
             if (emit_now(e, &ev) != 0) {
                 return -2;
             }
@@ -1861,6 +1944,9 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                         mk.flow = 1;
                         mk.line = ev.line;
                         mk.col = ev.col;
+                        mk.end_line = ev.line; /* virtual opener: zero-span
+                                                * at the implied position */
+                        mk.end_col = ev.col;
                         if (emit_now(e, &mk) != 0) {
                             return -2;
                         }
@@ -2045,6 +2131,11 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
             }
             e->pos++;
             e_event_init(&ev, st[n - 1].kind ? YEP_EV_MAP_END : YEP_EV_SEQ_END);
+            /* the close indicator's span: e->pos sits just past it */
+            ev.line = e->line;
+            ev.col = e_col(e, e->pos - 1) + 1;
+            ev.end_line = e->line;
+            ev.end_col = e_col(e, e->pos) + 1;
             if (emit_now(e, &ev) != 0) {
                 return -2;
             }
@@ -2135,6 +2226,9 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 yep_event mk;
                 e_event_init(&mk, YEP_EV_MAP_START);
                 mk.flow = 1;
+                e_pos_mark(e, e->pos, &mk.line, &mk.col);
+                mk.end_line = mk.line; /* virtual opener: zero-span */
+                mk.end_col = mk.col;
                 if (emit_now(e, &mk) != 0) {
                     return -2;
                 }
@@ -2282,6 +2376,9 @@ static void e_key_event(const yep_engine* e, const yep_line_shape* sh, uint16_t
     kv->borrowed = 1;
     kv->line = line;
     kv->col = key_col + 1;
+    /* keys are single-line by the simple-key law; the cursor may have
+     * advanced past the line, so the mark comes from e_pos_mark */
+    e_pos_mark(e, sh->key_end, &kv->end_line, &kv->end_col);
 }
 
 static int e_classified(yep_engine* e, uint16_t floor_col) {
@@ -2786,6 +2883,7 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
         kv.borrowed = 1;
         kv.line = e->line;
         kv.col = key_col + 1;
+        e_pos_mark(e, s.end, &kv.end_line, &kv.end_col);
         if (emit_now(e, &kv) != 0) {
             return -2;
         }
@@ -2958,6 +3056,20 @@ empty_value: {
     e->pend_anchor_id = 0;
     e->pend_tag.p = NULL;
     e->pend_tag.len = 0;
+    { /* libyaml: the implicit null sits just past the key's colon
+       * ("k:   " -> col 2, not the line end), zero-span */
+        size_t at = e->pos;
+        while (at > 0 && (e->p[at - 1] == ' ' || e->p[at - 1] == '\t' || e->p[at - 1] == '\n' ||
+                          e->p[at - 1] == '\r')) {
+            at--; /* the cursor may sit lines past the deferred key */
+        }
+        if (at == 0 || e->p[at - 1] != ':') {
+            at = e->pos; /* not a plain "key:" defer: the cursor stands */
+        }
+        e_pos_mark(e, at, &ev.line, &ev.col);
+        ev.end_line = ev.line;
+        ev.end_col = ev.col;
+    }
     return emit_now(e, &ev) == 0 ? 0 : -2;
 }
 }
@@ -3300,6 +3412,7 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
     yep_nametab_clear(&e->anchors);
     e->tagmap_n = 0;
     e->saw_yaml = 0;
+    e->doc_begin = (size_t)-1;
     e->doc_content = 0;
     e->q_key_pending = 0;
     e->q_value_pending = 0;
@@ -3312,6 +3425,10 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
     yep_event ev;
     if (emit_start) {
         e_event_init(&ev, YEP_EV_STREAM_START);
+        ev.line = 1;
+        ev.col = 1;
+        ev.end_line = 1;
+        ev.end_col = 1;
         if (emit_now(e, &ev) != 0) {
             return -2;
         }
@@ -3406,6 +3523,11 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
                     e->tagmap_n++;
                 }
             }
+            if (e->doc_begin == (size_t)-1) {
+                e->doc_begin = li.offset; /* libyaml: DOCUMENT_START's
+                                           * start_mark includes the
+                                           * leading directive lines */
+            }
             e_line_done(e, li.end);
             continue;
         }
@@ -3428,6 +3550,10 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
                 }
                 e->doc_content = 0;
                 e_event_init(&ev, YEP_EV_DOCUMENT_END);
+                e_pos_mark(e, li.offset + li.indent, &ev.line, &ev.col);
+                ev.end_line = ev.line; /* zero-span at the new marker —
+                                        * libyaml's implicit close mark */
+                ev.end_col = ev.col;
                 if (emit_now(e, &ev) != 0) {
                     return -2;
                 }
@@ -3437,6 +3563,10 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
             }
             e_event_init(&ev, YEP_EV_DOCUMENT_START);
             ev.style = 1; /* explicit marker */
+            e_pos_mark(e, e->doc_begin != (size_t)-1 ? e->doc_begin : li.offset + li.indent,
+                       &ev.line, &ev.col);
+            e_pos_mark(e, li.offset + li.indent + 3, &ev.end_line, &ev.end_col);
+            e->doc_begin = (size_t)-1;
             if (emit_now(e, &ev) != 0) {
                 return -2;
             }
@@ -3485,7 +3615,9 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
                     }
                 }
                 e_event_init(&ev, YEP_EV_DOCUMENT_END);
-                ev.style = 1;    /* explicit "..." marker */
+                ev.style = 1; /* explicit "..." marker */
+                e_pos_mark(e, li.offset + li.indent, &ev.line, &ev.col);
+                e_pos_mark(e, li.offset + li.indent + 3, &ev.end_line, &ev.end_col);
                 e->tagmap_n = 0; /* directives are per-document */
                 yep_nametab_clear(&e->anchors);
                 if (emit_now(e, &ev) != 0) {
@@ -3494,6 +3626,7 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
                 doc_open = 0;
                 e->doc_content = 0;
                 e->saw_yaml = 0;
+                e->doc_begin = (size_t)-1;
             }
             e_line_done(e, li.end);
             continue;
@@ -3501,6 +3634,14 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
 
         if (!doc_open) {
             e_event_init(&ev, YEP_EV_DOCUMENT_START);
+            if (e->doc_begin != (size_t)-1) {
+                e_pos_mark(e, e->doc_begin, &ev.line, &ev.col);
+            } else {
+                e_pos_mark(e, li.offset + li.indent, &ev.line, &ev.col);
+            }
+            ev.end_line = ev.line;
+            ev.end_col = ev.col;
+            e->doc_begin = (size_t)-1;
             if (emit_now(e, &ev) != 0) {
                 return -2;
             }
@@ -3670,6 +3811,9 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
             }
         }
         e_event_init(&ev, YEP_EV_DOCUMENT_END);
+        e_pos_mark(e, e->len, &ev.line, &ev.col);
+        ev.end_line = ev.line;
+        ev.end_col = ev.col;
         if (emit_now(e, &ev) != 0) {
             return -2;
         }
@@ -3678,6 +3822,9 @@ static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep
     }
     if (emit_end) {
         e_event_init(&ev, YEP_EV_STREAM_END);
+        e_pos_mark(e, e->len, &ev.line, &ev.col);
+        ev.end_line = ev.line;
+        ev.end_col = ev.col;
         if (emit_now(e, &ev) != 0) {
             return -2;
         }

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

@@ -55,6 +55,12 @@ typedef struct yep_event {
                          * that key on it skip the name hash entirely. */
     uint32_t line;      /* 1-based position of the node start */
     uint32_t col;
+    uint32_t end_line; /* #179: 1-based position of the node's end —
+                        * libyaml's end_mark semantics: a START event
+                        * ends after its opening token, a scalar/alias
+                        * spans anchor/tag through content, an END
+                        * event spans its closing indicator */
+    uint32_t end_col;
 } yep_event;
 
 struct yep_block_value; /* value facts for on_block_pair (below) */