yeptris 0.6.18.2-arm-linux-eabihf

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

@@ -0,0 +1,816 @@
+/* writer.c — the single writer engine (TODO.impl/13).
+ *
+ * One recursive emitter drives both sizing (dry: counts only) and
+ * output (wet): the size query and the bytes agree by construction.
+ *
+ * Layout contract (indent = the CONTENT column of the node):
+ *   block map value:  "key: <inline>" or "key:\n<indent+2>…"
+ *   block seq item:   "- <inline>" (compact: nested block collections
+ *                     start on the dash line at indent+2)
+ *   flow collections re-emit compact: {k: v, k2: v2} / [a, b]
+ *   scalars re-emit their recorded style; plain values that are not
+ *   plain-safe in position fall back to double quotes; any multiline
+ *   scalar emits as a literal block (deterministic upgrade: parse of
+ *   the upgrade records literal, so byte stability holds)
+ *   anchors: "&name " before the node; aliases: "*name"
+ *   multi-document streams mark every document with "---"
+ */
+
+#include "writer.h"
+
+#include <string.h>
+
+#include "style.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "../../include/yeptris/resolve.h"
+#include "float/api.h"
+#include "resolve/resolver.h"
+
+/* Decodes a compact node string for the writer's configured run. */
+static yep_view wv(const yep_writer* w, yep_sview sv) {
+    yep_view v = {NULL, 0};
+    if (sv.len == 0) {
+        return v;
+    }
+    v.len = sv.len;
+    v.p = (sv.off & YEP_SV_INPUT ? w->sv_arena : w->sv_input) + (sv.off & YEP_SV_OFF);
+    return v;
+}
+
+/* Streaming flush (13C): append-only output means any high-water
+ * crossing is a safe cut point. */
+static void wr_maybe_flush(yep_writer* w) {
+    if (w->sink == NULL || w->dry || w->len < w->watermark) {
+        return;
+    }
+    if (w->sink(w->sink_ctx, w->p, w->len) != 0) {
+        w->sink_aborted = 1;
+        return;
+    }
+    w->flushed += w->len;
+    w->len = 0;
+}
+
+static void wr_col_update(yep_writer* w, const char* p, uint32_t n) {
+    for (uint32_t i = n; i > 0; i--) { /* last newline wins */
+        if (p[i - 1] == '\n') {
+            w->col = (int)(n - i);
+            return;
+        }
+    }
+    w->col += (int)n;
+}
+
+static void wr_grow(yep_writer* w, size_t need) {
+    if (w->oom || w->p == NULL) {
+        w->oom = w->p == NULL;
+        return;
+    }
+    size_t want = w->len + need + 1;
+    if (want < w->cap * 2) {
+        want = w->cap * 2;
+    }
+    char* np = (char*)realloc(w->p, want);
+    if (np == NULL) {
+        w->oom = 1;
+        return;
+    }
+    w->p = np;
+    w->cap = want;
+}
+
+static void wr_put(yep_writer* w, const char* p, uint32_t n) {
+    if (n > 0) {
+        w->last = p[n - 1];
+    }
+    wr_col_update(w, p, n);
+    if (w->dry) {
+        w->len += n;
+        return;
+    }
+    if (w->grow && w->len + n > w->cap) {
+        wr_grow(w, n);
+    }
+    if (w->oom) {
+        w->len += n; /* keep counting: the caller fails on oom */
+        return;
+    }
+    memcpy(w->p + w->len, p, n);
+    w->len += n;
+    wr_maybe_flush(w);
+}
+
+static void wr_byte(yep_writer* w, char c) {
+    w->last = c;
+    if (c == '\n') {
+        w->col = 0;
+    } else {
+        w->col++;
+    }
+    if (w->dry) {
+        w->len++;
+        return;
+    }
+    if (w->grow && w->len + 1 > w->cap) {
+        wr_grow(w, 1);
+    }
+    if (w->oom) {
+        w->len++;
+        return;
+    }
+    w->p[w->len] = c;
+    w->len++;
+    wr_maybe_flush(w);
+}
+
+static void wr_indent(yep_writer* w, int depth) {
+    for (int i = 0; i < depth; i++) {
+        wr_byte(w, ' ');
+    }
+}
+
+static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
+    wr_byte(w, '"');
+    uint32_t run = 0;
+    for (uint32_t i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)p[i];
+        if (c >= 0x20 && c != '"' && c != '\\' && c != 0x7f) {
+            run++;
+            continue;
+        }
+        if (run) {
+            wr_put(w, p + i - run, run);
+            run = 0;
+        }
+        if (c == '"' || c == '\\') {
+            wr_byte(w, '\\');
+            wr_byte(w, (char)c);
+        } else if (c == '\n') {
+            wr_put(w, "\\n", 2);
+        } else if (c == '\r') {
+            wr_put(w, "\\r", 2);
+        } else if (c == '\t') {
+            wr_put(w, "\\t", 2);
+        } else if (c < 0x20 || c == 0x7f) {
+            static const char* named[6] = {"\\0", "\\a", "\\b", "\\v", "\\f", "\\e"};
+            static const unsigned char code[6] = {0x00, 0x07, 0x08, 0x0b, 0x0c, 0x1b};
+            int k;
+            for (k = 0; k < 6; k++) {
+                if (code[k] == c) {
+                    break;
+                }
+            }
+            if (k < 6) {
+                wr_put(w, named[k], 2);
+            } else {
+                static const char hd[] = "0123456789abcdef";
+                char hex[4] = {'\\', 'x', hd[(c >> 4) & 0xf], hd[c & 0xf]};
+                wr_put(w, hex, 4);
+            }
+        }
+    }
+    if (run) {
+        wr_put(w, p + n - run, run);
+    }
+    wr_byte(w, '"');
+}
+
+static void emit_sq(yep_writer* w, const char* p, uint32_t n) {
+    wr_byte(w, '\'');
+    for (uint32_t i = 0; i < n; i++) {
+        if (p[i] == '\'') {
+            wr_put(w, "''", 2);
+        } else {
+            wr_byte(w, p[i]);
+        }
+    }
+    wr_byte(w, '\'');
+}
+
+/* JSON string escapes: \" \\ \b \f \n \r \t and \uXXXX for other
+ * controls; raw UTF-8 passes through (RFC 8259). */
+static void emit_dq_json(yep_writer* w, const char* p, uint32_t n) {
+    wr_byte(w, '"');
+    static const char* named[32] = {
+        NULL, NULL,  NULL,  NULL, NULL, NULL, NULL, NULL, "\\b", "\\t", "\\n",
+        NULL, "\\f", "\\r", NULL, NULL, NULL, NULL, NULL, NULL,  NULL,  NULL,
+        NULL, NULL,  NULL,  NULL, NULL, NULL, NULL, NULL, NULL,  NULL,
+    };
+    for (uint32_t i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)p[i];
+        if (c < 32 && named[c] != NULL) {
+            wr_put(w, named[c], 2);
+        } else if (c == '"' || c == '\\') {
+            wr_byte(w, '\\');
+            wr_byte(w, (char)c);
+        } else if (c < 0x20) {
+            static const char hd[] = "0123456789abcdef";
+            char hex[6] = {'\\', 'u', '0', '0', hd[(c >> 4) & 0xf], hd[c & 0xf]};
+            wr_put(w, hex, 6);
+        } else {
+            wr_byte(w, (char)c);
+        }
+    }
+    wr_byte(w, '"');
+}
+
+/* Literal block: header at the cursor, body lines at parent_col+2.
+ * The explicit indicator is always '2' because the pad is defined as
+ * parent_col+2 everywhere (the contract that keeps it valid). */
+static void emit_literal(yep_writer* w, const yep_dnode* n, int parent_col) {
+    yep_view vdec = wv(w, n->value);
+    const char* p = (const char*)vdec.p;
+    uint32_t len = vdec.len;
+    uint32_t trail = 0;
+    while (trail < len && p[len - 1 - trail] == '\n') {
+        trail++;
+    }
+    uint32_t body = len - trail;
+    wr_byte(w, '|');
+    if (trail == 0) {
+        wr_byte(w, '-');
+    } else if (trail > 1) {
+        wr_byte(w, '+');
+    }
+    /* libyaml's indicator rules (#290 family 4): the explicit indent
+     * appears when the first body line starts with a space or is
+     * blank — the base indent is unambiguous otherwise (the pad is
+     * parent_col+2 by contract; F6MC's leading-blank folded bodies) */
+    if (body > 0 && (p[0] == ' ' || p[0] == '\n')) {
+        wr_byte(w, '2');
+    }
+    wr_byte(w, '\n');
+    int pad = parent_col + 2;
+    wr_indent(w, pad);
+    for (uint32_t i = 0; i < body; i++) {
+        wr_byte(w, p[i]);
+        if (p[i] == '\n' && i + 1 < body) {
+            if (p[i + 1] == '\n') {
+                continue; /* blank interior lines ride unpadded (libyaml) */
+            }
+            wr_indent(w, pad);
+        }
+    }
+    for (uint32_t i = 0; i < trail; i++) {
+        wr_byte(w, '\n');
+    }
+}
+
+/* Canonical scalar (13B): typed words and numbers plain, everything
+ * else double-quoted; floats re-print through the shortest printer so
+ * canonical output is a fixed point (parse of canonical re-prints
+ * identically — the byte-stability gate). */
+static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
+    yep_view vdec = wv(w, n->value);
+    const char* p = (const char*)vdec.p;
+    uint32_t len = vdec.len;
+    if (n->tag.len == 0) {
+        switch (n->tag_id) {
+        case YEPTRIS_TAG_NULL:
+            if (w->json) {
+                wr_put(w, "null", 4);
+            } else {
+                wr_put(w, "~", 1);
+            }
+            return;
+        case YEPTRIS_TAG_BOOL:
+            if (len == 4) { /* true/TRUE/True/null-ish variants */
+                wr_put(w, (p[0] == 't' || p[0] == 'T') ? "true" : "null", 4);
+            } else { /* false family (5 chars) */
+                wr_put(w, "false", 5);
+            }
+            return;
+        case YEPTRIS_TAG_FLOAT: {
+            const char* word = yep_tag_float_word(p, len);
+            if (word != NULL) {
+                wr_put(w, word, (uint32_t)strlen(word));
+                return;
+            }
+            char buf[40];
+            char* end = NULL;
+            char tmp[40];
+            uint32_t tl = len < sizeof(tmp) - 1 ? len : (uint32_t)sizeof(tmp) - 1;
+            memcpy(tmp, p, tl);
+            tmp[tl] = '\0';
+            double d = strtod(tmp, &end);
+            if (end != NULL && *end == '\0' && end != tmp) {
+                int wl = yep_d2s_shortest(d, buf);
+                wr_put(w, buf, (uint32_t)wl);
+                return;
+            }
+            break; /* unparseable view: fall through to quoting */
+        }
+        case YEPTRIS_TAG_INT:
+            wr_put(w, p, len);
+            return;
+        default:
+            break;
+        }
+    }
+    if (w->json) {
+        emit_dq_json(w, p, len);
+    } else {
+        emit_dq(w, p, len);
+    }
+}
+
+/* The fidelity-mode emission route for one scalar (#352): the dry
+ * pass derives it exactly once; the wet pass consumes the recorded
+ * byte and skips the multiline/blockable/safety analysis entirely. */
+enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
+#define YEP_SC_MEMO_MIN 32u /* bytes; derive-below, memoize-above */
+
+static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
+                        int has_tag) {
+    if ((sty_in == 1) && len > 0 &&
+        (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len))) {
+        return YEP_SC_PLAIN; /* plain-safe implies no breaks: memchr skipped */
+    }
+    int multiline = (len > 0 && memchr(p, '\n', len) != NULL);
+    int blockable = 0;
+    if (multiline && !as_key) {
+        int allws = 1;
+        int has_cr = 0;
+        for (uint32_t i = 0; i < len; i++) {
+            if (p[i] != ' ' && p[i] != '\t' && p[i] != '\n' && p[i] != '\r') {
+                allws = 0;
+            }
+            if (p[i] == '\r') {
+                has_cr = 1;
+            }
+        }
+        blockable = !allws && !has_cr;
+    }
+    uint8_t sty = sty_in;
+    if (sty == 4 || sty == 5) {
+        if (multiline && as_key) {
+            return YEP_SC_DQ;
+        }
+        if (multiline && blockable) {
+            return YEP_SC_LITERAL;
+        }
+        if (multiline) {
+            return YEP_SC_DQ;
+        }
+        if (len == 0) {
+            return YEP_SC_DQ;
+        }
+        /* A TAGGED block scalar keeps the block form even single-line
+         * (psych's !binary emits `!binary |-` + one base64 line; an
+         * untagged single-line literal re-emits plain — libyaml parity,
+         * the #290 family) */
+        if (has_tag) {
+            return YEP_SC_LITERAL;
+        }
+        sty = 1;
+    }
+    switch (sty) {
+    case 1:
+        if (len == 0) {
+            return as_key ? YEP_SC_DQ : YEP_SC_NOTHING;
+        }
+        if (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len)) {
+            return YEP_SC_PLAIN;
+        }
+        if (!multiline) {
+            for (uint32_t i = 0; i < len; i++) {
+                if ((unsigned char)p[i] < 0x20 || (unsigned char)p[i] == 0x7f) {
+                    return YEP_SC_DQ;
+                }
+            }
+            return YEP_SC_SQ;
+        }
+        return YEP_SC_DQ;
+    case 2:
+        return multiline ? YEP_SC_DQ : YEP_SC_SQ;
+    default:
+        return YEP_SC_DQ;
+    }
+}
+
+static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int as_key) {
+    yep_view vdec = wv(w, n->value);
+    const char* p = (const char*)vdec.p;
+    uint32_t len = vdec.len;
+    if (w->canonical || w->json) {
+        emit_canonical_scalar(w, n);
+        return;
+    }
+    (void)0;
+    uint8_t route;
+    /* The memo pays only for LONG scalars: the derive cost scales with
+     * len (safety walk, quote scans) while the memo is a fixed store +
+     * cold load — on the short scalars of table-shaped documents the
+     * memo measured SLOWER than re-deriving (the #357 first artifact:
+     * json-users -36%, scalar-heavy +24%). Below the threshold both
+     * passes derive; the consumption-order index covers only the
+     * memoized long scalars, in visit order either way. */
+    if (w->sc_dec != NULL && len >= YEP_SC_MEMO_MIN) {
+        if (w->dry) {
+            route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
+            w->sc_dec[w->sc_i] = route;
+        } else {
+            route = w->sc_dec[w->sc_i];
+        }
+        w->sc_i++;
+    } else {
+        route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
+    }
+    switch (route) {
+    case YEP_SC_NOTHING:
+        break; /* an empty plain value emits as nothing (libyaml's null
+                  rendering, issue #290) */
+    case YEP_SC_PLAIN:
+        wr_put(w, p, len);
+        break;
+    case YEP_SC_SQ:
+        emit_sq(w, p, len);
+        break;
+    case YEP_SC_LITERAL:
+        emit_literal(w, n, parent_col);
+        break;
+    default:
+        emit_dq(w, p, len);
+        break;
+    }
+}
+
+/* Canonical mode renames anchors to generated names (a0, a1, ...):
+ * exotic source names (flow indicators inside them) cannot survive
+ * flow context raw, and renaming preserves the binding semantics.
+ * Deterministic by definition order -> byte-stable across roundtrips.
+ * The emitter's nametab lives in yep_emitter (owner: yep_emit_run). */
+static void emit_anchor_ex(yep_emitter* em, const yep_dnode* n) {
+    yep_writer* w = &em->w;
+    if (n->anchor.len == 0) {
+        return;
+    }
+    wr_byte(w, '&');
+    yep_view adec = wv(w, n->anchor);
+    if (w->canonical) {
+        uint32_t idx = yep_nametab_get(&em->canon_names, adec);
+        if (idx == YEP_NAMETAB_NIL) {
+            idx = em->canon_names.count;
+            yep_nametab_set(&em->canon_names, adec, idx);
+        }
+        char name[24];
+        int nl = snprintf(name, sizeof(name), "a%u", idx);
+        wr_put(w, name, (uint32_t)nl);
+    } else {
+        wr_put(w, (const char*)adec.p, adec.len);
+    }
+    wr_byte(w, ' ');
+}
+
+static void emit_alias_ex(yep_emitter* em, const yep_dnode* n) {
+    yep_writer* w = &em->w;
+    yep_view name_v = wv(w, n->value);
+    wr_byte(w, '*');
+    if (w->canonical) {
+        uint32_t idx = yep_nametab_get(&em->canon_names, name_v);
+        char name[24];
+        int nl;
+        if (idx == YEP_NAMETAB_NIL) {
+            nl = snprintf(name, sizeof(name), "%.*s", (int)name_v.len, (const char*)name_v.p);
+        } else {
+            nl = snprintf(name, sizeof(name), "a%u", idx);
+        }
+        wr_put(w, name, (uint32_t)nl);
+    } else {
+        wr_put(w, (const char*)name_v.p, name_v.len);
+    }
+}
+
+/* Explicit tag, verbatim URI form ("!<tag:…> "). Never skipped: a
+ * recorded tag always re-emits (implied-by-style skipping made the
+ * roundtrip byte-unstable: plain+!!str and ""+!!str collided). */
+static void emit_tag(yep_writer* w, const yep_dnode* n) {
+    if (n->tag.len == 0) {
+        return;
+    }
+    yep_view tdec = wv(w, n->tag);
+    if (tdec.len > 0 && tdec.p[0] == '!') {
+        /* already a shorthand ("!ruby/object:K", "!foo"): verbatim —
+         * the !<...> wrapper is for verbatim URIs only */
+        wr_put(w, (const char*)tdec.p, tdec.len);
+        wr_byte(w, ' ');
+        return;
+    }
+    wr_byte(w, '!');
+    wr_byte(w, '<');
+    wr_put(w, (const char*)tdec.p, tdec.len);
+    wr_byte(w, '>');
+    wr_byte(w, ' ');
+}
+
+/* Line-tail properties for block collections: "!<t> &a" after
+ * "key:"/"-" — properties may not precede a dash entry directly (the
+ * suite's SY6V rule). */
+static void emit_props_tail(yep_writer* w, const yep_dnode* n) {
+    if (n->tag.len > 0) {
+        wr_byte(w, ' ');
+        yep_view tdec2 = wv(w, n->tag);
+        wr_byte(w, '!');
+        wr_byte(w, '<');
+        wr_put(w, (const char*)tdec2.p, tdec2.len);
+        wr_byte(w, '>');
+    }
+    if (n->anchor.len > 0) {
+        wr_byte(w, ' ');
+        yep_view adec2 = wv(w, n->anchor);
+        wr_byte(w, '&');
+        wr_put(w, (const char*)adec2.p, adec2.len);
+    }
+}
+
+static void emit_node(yep_emitter* em, uint32_t id, int parent_col, int as_key);
+
+static void emit_flow(yep_emitter* em, uint32_t id) {
+    yep_writer* w = &em->w;
+    const yep_dom* d = em->doc->dom;
+    const yep_dnode* n = yep_dom_node(d, id);
+    emit_tag(w, n);
+    emit_anchor_ex(em, n);
+    int map = (n->kind == 2);
+    wr_byte(w, map ? '{' : '[');
+    int flow_indent = w->col;
+    if (w->json_pretty && n->count > 0) {
+        w->pretty_depth++;
+        flow_indent = w->pretty_depth * 2; /* 2 spaces per level */
+        wr_byte(w, '\n');
+        wr_indent(w, flow_indent);
+    }
+    uint32_t child = n->first_child;
+    uint32_t idx = 0;
+    while (child != UINT32_MAX) {
+        const yep_dnode* cn = yep_dom_node(d, child);
+        if (idx > 0) {
+            /* 13B: past best_width, break AFTER the previous value
+             * (value boundaries only, never inside a scalar) and
+             * re-indent to the opening bracket's column */
+            if (w->json_pretty) {
+                wr_put(w, ",\n", 2);
+                wr_indent(w, w->pretty_depth * 2);
+            } else if (w->json_compact) {
+                wr_byte(w, ',');
+            } else if (w->best_width > 0 && w->col > w->best_width) {
+                wr_byte(w, ',');
+                wr_byte(w, '\n');
+                wr_indent(w, flow_indent);
+            } else {
+                wr_put(w, ", ", 2);
+            }
+        }
+        if (map) {
+            int explicit_key = cn->anchor.len > 0 || cn->tag.len > 0 || cn->kind != 0;
+            if (explicit_key) {
+                wr_put(w, "? ", 2);
+                emit_node(em, child, 0, 1);
+                wr_put(w, " : ", 3);
+            } else {
+                emit_node(em, child, 0, 1);
+                if (w->json_pretty) {
+                    wr_put(w, ": ", 2);
+                } else if (w->json_compact) {
+                    wr_byte(w, ':');
+                } else {
+                    wr_put(w, ": ", 2);
+                }
+            }
+            emit_node(em, cn->next_sibling, 0, 0);
+            child = cn->next_sibling;
+            cn = yep_dom_node(d, child);
+        } else {
+            emit_node(em, child, 0, 0);
+        }
+        idx++;
+        child = cn->next_sibling;
+    }
+    if (w->json_pretty && idx > 0) {
+        wr_byte(w, '\n');
+        wr_indent(w, (w->pretty_depth - 1) * 2);
+        w->pretty_depth--;
+    }
+    wr_byte(w, map ? '}' : ']');
+}
+
+/* Block map: first key at the cursor (the caller placed it at
+ * content_col = parent_col+2); following keys on new lines there. */
+static void emit_block_map(yep_emitter* em, uint32_t id, int content_col) {
+    yep_writer* w = &em->w;
+    const yep_dom* d = em->doc->dom;
+    const yep_dnode* n = yep_dom_node(d, id);
+    uint32_t child = n->first_child;
+    uint32_t pair = 0;
+    while (child != UINT32_MAX) {
+        const yep_dnode* kn = yep_dom_node(d, child);
+        const yep_dnode* vn = yep_dom_node(d, kn->next_sibling);
+        if (pair > 0) {
+            if (w->last != '\n') {
+                wr_byte(w, '\n'); /* keep-chomped bodies own their break */
+            }
+            wr_indent(w, content_col);
+        }
+        int complex_key = (kn->kind != 0);
+        if (complex_key) {
+            w->force_flow = 1; /* collections as flow keys: compact and
+                                  free of the block '?' layout edges */
+            wr_put(w, "? ", 2);
+            emit_props_tail(w, kn); /* the key's props ride "? " */
+            if (kn->anchor.len > 0 || kn->tag.len > 0) {
+                wr_byte(w, '\n');
+                wr_indent(w, content_col + 2);
+            }
+            emit_node(em, child, content_col, 1);
+            wr_byte(w, '\n');
+            wr_indent(w, content_col);
+            wr_put(w, ": ", 2);
+            w->force_flow = 0;
+            emit_node(em, kn->next_sibling, content_col, 0);
+        } else {
+            emit_tag(w, kn);
+            emit_anchor_ex(em, kn);
+            emit_scalar(w, kn, content_col, 1);
+            wr_byte(w, ':');
+            /* empty collections ride the key line flow (k: [] / k: {})
+             * like libyaml — a block-empty has no valid next-line form at
+             * the seq indent (an empty [] at the key's column is not a
+             * legal value; pyyaml rejects it, issue #52's differential).
+             * An implicit-empty plain value rides bare (k:) with no
+             * trailing space — libyaml's null rendering (#290) */
+            if (vn->kind == 0 || vn->kind == 3 || vn->flow || vn->count == 0) {
+                int empty_plain = vn->kind == 0 && vn->style == 1 && vn->anchor.len == 0 &&
+                                  vn->tag.len == 0 && wv(w, vn->value).len == 0 && !w->canonical &&
+                                  !w->json;
+                if (!empty_plain) {
+                    wr_byte(w, ' ');
+                }
+                emit_node(em, kn->next_sibling, content_col, 0);
+            } else {
+                /* nested block collection: next line. libyaml parity:
+                 * a SEQUENCE value sits at the key's column (zero
+                 * extra indent); mappings indent +2 (issue #95) */
+                int seq_val = (vn->kind == 1 && !vn->flow);
+                int val_col = seq_val ? content_col : content_col + 2;
+                emit_props_tail(w, vn);
+                wr_byte(w, '\n');
+                wr_indent(w, val_col);
+                /* emit_block_seq dashes at parent_col+2: pass val_col-2
+                 * so the dashes land at val_col exactly */
+                emit_node(em, kn->next_sibling, val_col - 2, 0);
+            }
+        }
+        pair++;
+        child = vn->next_sibling;
+    }
+}
+
+/* Block seq: "- item" lines at content_col = parent_col+2. */
+static void emit_block_seq(yep_emitter* em, uint32_t id, int content_col) {
+    yep_writer* w = &em->w;
+    const yep_dom* d = em->doc->dom;
+    const yep_dnode* n = yep_dom_node(d, id);
+    uint32_t child = n->first_child;
+    uint32_t idx = 0;
+    while (child != UINT32_MAX) {
+        const yep_dnode* cn = yep_dom_node(d, child);
+        if (idx > 0) {
+            if (w->last != '\n') {
+                wr_byte(w, '\n'); /* keep-chomped bodies own their break */
+            }
+            wr_indent(w, content_col);
+        }
+        if (cn->kind == 0 && cn->style == 1 && cn->anchor.len == 0 && cn->tag.len == 0 &&
+            wv(w, cn->value).len == 0 && !w->canonical && !w->json) {
+            wr_put(w, "-\n", 2); /* libyaml: a null item is a bare dash */
+            idx++;
+            child = cn->next_sibling;
+            continue;
+        }
+        wr_put(w, "- ", 2);
+        if (cn->kind != 0 && cn->kind != 3 && !cn->flow &&
+            (cn->anchor.len > 0 || cn->tag.len > 0)) {
+            /* props may not precede a dash: they ride the dash line and
+             * the collection starts on the next line (SY6V) */
+            emit_props_tail(w, cn);
+            wr_byte(w, '\n');
+            wr_indent(w, content_col + 2);
+            emit_node(em, child, content_col, 0);
+        } else {
+            /* compact: a block collection starts right after "- " */
+            emit_node(em, child, content_col, 0);
+        }
+        idx++;
+        child = cn->next_sibling;
+    }
+}
+
+static void emit_node(yep_emitter* em, uint32_t id, int parent_col, int as_key) {
+    yep_writer* w = &em->w;
+    const yep_dom* d = em->doc->dom;
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        return;
+    }
+    if (n->kind == 3) { /* alias */
+        emit_alias_ex(em, n);
+        return;
+    }
+    if ((n->kind == 1 || n->kind == 2) && (n->flow || w->canonical || w->json || w->force_flow)) {
+        /* force_flow holds through the subtree: a complex key's nested
+         * collections all render flow (scalars are never collections) */
+        emit_flow(em, id);
+        return;
+    }
+    if (n->kind == 2) { /* mapping */
+        if (n->count == 0) {
+            emit_tag(w, n);
+            emit_anchor_ex(em, n);
+            wr_put(w, "{}", 2);
+        } else {
+            emit_block_map(em, id, parent_col + 2);
+        }
+        return;
+    }
+    if (n->kind == 1) { /* sequence */
+        if (n->count == 0) {
+            emit_tag(w, n);
+            emit_anchor_ex(em, n);
+            wr_put(w, "[]", 2);
+        } else {
+            emit_block_seq(em, id, parent_col + 2);
+        }
+        return;
+    }
+    emit_tag(w, n);
+    emit_anchor_ex(em, n);
+    if (parent_col < 0) {
+        parent_col = 0; /* root scalar: block body at column 2 */
+    }
+    emit_scalar(w, n, parent_col, as_key);
+}
+
+size_t yep_emit_run(yep_emitter* em, int dry) {
+    yep_writer* w = &em->w;
+    const yep_dom* d = em->doc->dom;
+    w->dry = dry;
+    w->len = 0;
+    w->last = 0;
+    w->force_flow = 0;
+    w->flushed = 0;
+    w->sink_aborted = 0;
+    w->col = 0;
+    w->sc_i = 0;
+    yep_nametab_clear(&em->canon_names);
+    if (w->json) {
+        /* JSON has no multi-document streams and no document marker */
+        if (d->dcount == 1) {
+            const yep_dnode* root = yep_dom_node(d, d->docs[0]);
+            emit_node(em, d->docs[0], -2, 0);
+            if (root != NULL && root->kind != 0 && w->last != '\n') {
+                wr_byte(w, '\n');
+            }
+        }
+        return w->flushed + w->len;
+    }
+    int multi = (d->dcount > 1) || w->canonical;
+    for (uint32_t i = 0; i < d->dcount; i++) {
+        const yep_dnode* root = yep_dom_node(d, d->docs[i]);
+        if (multi || w->explicit_doc_start) {
+            /* libyaml parity: a scalar root rides the marker line
+             * ("--- 42"); collections take the marker alone */
+            wr_put(w,
+                   (w->explicit_doc_start && root != NULL && root->kind == YEP_DOM_SCALAR &&
+                    !root->flow)
+                       ? "--- "
+                       : "---\n",
+                   4);
+        }
+        if (root != NULL && (root->kind == 1 || root->kind == 2) && !root->flow && !w->canonical &&
+            (root->tag.len > 0 || root->anchor.len > 0)) {
+            /* root block-collection props ride their own leading line;
+             * scalars and flow collections carry them inline */
+            if (root->tag.len > 0) {
+                yep_view tdec3 = wv(w, root->tag);
+                wr_byte(w, '!');
+                wr_byte(w, '<');
+                wr_put(w, (const char*)tdec3.p, tdec3.len);
+                wr_byte(w, '>');
+            }
+            if (root->anchor.len > 0) {
+                yep_view adec3 = wv(w, root->anchor);
+                wr_byte(w, '&');
+                wr_put(w, (const char*)adec3.p, adec3.len);
+            }
+            wr_byte(w, '\n');
+        }
+        emit_node(em, d->docs[i], -2, 0); /* root content at column 0 */
+        if (w->last != '\n') {
+            wr_byte(w, '\n');
+        }
+    }
+    return w->flushed + w->len;
+}