yeptris 0.6.59.1-arm-linux-eabihf → 0.6.60.1-arm-linux-eabihf

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

@@ -36,6 +36,24 @@ YEPTRIS_API const char* yeptris_last_error(uint32_t* line, uint32_t* col) {
 static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisParseOptions* opts,
                                   int json_mode, int lazy, YeptrisStatus* status);
 
+/* The schema -> resolver dispatch point (OCP: the typing SSOT's ONE
+ * switch). Every build route selects its resolver here — the event
+ * entry, the engine and the direct-builder DOM, the fused block
+ * runner (and validate/stream.c's event route, through the event
+ * entry). */
+const yep_resolver* resolver_for_schema(YeptrisSchema schema) {
+    switch (schema) {
+    case YEPTRIS_SCHEMA_11_COMPAT:
+        return yep_resolver_compat11();
+    case YEPTRIS_SCHEMA_12_JSON:
+        return yep_resolver_json12();
+    case YEPTRIS_SCHEMA_12_FULL:
+        return yep_resolver_full12();
+    default:
+        return yep_resolver_core12(); /* 12_CORE and the zero default */
+    }
+}
+
 YEPTRIS_API YeptrisDocument yeptris_parse(const char* buf, size_t len, YeptrisStatus* status) {
     return yeptris_parse_ex(buf, len, NULL, status);
 }
@@ -63,8 +81,7 @@ yep_dom* yep_doc_dom(yeptris_document* doc) {
             yep_ytape* t = (yep_ytape*)doc->lazy_tape;
             yep_dom* dom = yep_dom_create(doc->sys);
             if (dom != NULL) {
-                dom->resolver = (doc->schema == YEPTRIS_SCHEMA_11_COMPAT) ? yep_resolver_compat11()
-                                                                          : yep_resolver_core12();
+                dom->resolver = resolver_for_schema(doc->schema);
             }
             if (dom != NULL && dom_from_ytape(dom, t) == 0) {
                 doc->dom = dom;
@@ -228,22 +245,22 @@ jfail:
     return NULL;
 }
 
-static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisParseOptions* opts,
-                                  int json_mode, int lazy, YeptrisStatus* status) {
-    YeptrisStatus st = YEPTRIS_OK;
-    if (buf == NULL && len != 0) {
-        st = YEPTRIS_ERROR_ARG;
-        goto fail;
-    }
-
+/* The shared parse front-end (the encoding law, one home): BOM sniff;
+ * borrow UTF-8, transcode the rest; printability; NEL normalization.
+ * Returns 0 ok, -1 failed (*st carries ENCODING). *transcoded owns any
+ * copy (the system allocator frees it); *data and *data_len point at
+ * the bytes the engine runs on. json_mode skips the YAML-only passes (the
+ * JSON reader validated its own grammar and well-formedness at the
+ * entry and keeps U+0085 raw inside strings). */
+static int parse_frontend(const char* buf, size_t len, const yep_allocator* sys, int json_mode,
+                          const char** data_out, size_t* data_len_out,
+                          unsigned char** transcoded_out, size_t* transcoded_len_out,
+                          int* norm_kept_raw_out, YeptrisStatus* st) {
     /* a NULL/0-byte stream is a valid empty input: parse it through a
      * non-null base so the BOM arithmetic never computes NULL+0
      * (clang's UBSan flags the zero-offset-null form; gcc's does not —
      * the schema-econ BadInputs pin surfaced it on the macOS arm64 leg) */
     const char* src = buf != NULL ? buf : "";
-    const yep_allocator* sys = yep_system_allocator();
-
-    /* Encoding front-end: BOM sniff; borrow UTF-8, transcode the rest. */
     const char* data = src;
     size_t data_len = len;
     unsigned char* transcoded = NULL;
@@ -258,7 +275,12 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
          * entry: no BOM, no transcoding, and never the printable set —
          * RFC 8259 allows DEL and noncharacters that YAML c-printable
          * excludes. The engine takes the bytes directly. */
-        goto engine_enter;
+        *data_out = data;
+        *data_len_out = data_len;
+        *transcoded_out = NULL;
+        *transcoded_len_out = 0;
+        *norm_kept_raw_out = 0;
+        return 0;
     }
 
     size_t bom = yep_bom_sniff((const unsigned char*)src, len, &enc);
@@ -274,8 +296,8 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
             yep_error_set(yep_error_tls(), YEP_ERR_ENCODING, 0, 0, terr,
                           "ill-formed input encoding");
             yep_free(sys, transcoded);
-            st = YEPTRIS_ERROR_ENCODING;
-            goto fail;
+            *st = YEPTRIS_ERROR_ENCODING;
+            return -1;
         }
         data = (const char*)transcoded;
         data_len = transcoded_len;
@@ -284,8 +306,8 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
             yep_error_set(yep_error_tls(), YEP_ERR_ENCODING, 0, 0, pverr,
                           "non-printable character at byte %zu", pverr);
             yep_free(sys, transcoded);
-            st = YEPTRIS_ERROR_ENCODING;
-            goto fail;
+            *st = YEPTRIS_ERROR_ENCODING;
+            return -1;
         }
     } else {
         /* The encoding gate rides the cheap gate_scan kernel; sizing
@@ -299,8 +321,8 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
             if (!yep_printable_validate((const unsigned char*)data, data_len, &verr)) {
                 yep_error_set(yep_error_tls(), YEP_ERR_ENCODING, 0, 0, verr,
                               "ill-formed or non-printable UTF-8 at byte %zu", verr);
-                st = YEPTRIS_ERROR_ENCODING;
-                goto fail;
+                *st = YEPTRIS_ERROR_ENCODING;
+                return -1;
             }
         }
     }
@@ -325,18 +347,131 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
         }
     }
 
+    *data_out = data;
+    *data_len_out = data_len;
+    *transcoded_out = transcoded;
+    *transcoded_len_out = transcoded_len;
+    *norm_kept_raw_out = norm_kept_raw;
+    return 0;
+}
+
+/* parse.c's sink-entry seam (#902): the DOM route's exact front-end and
+ * engine run into a caller sink — no DOM, no tape. Statuses are the
+ * parse route's (OK, or PARSE / DEPTH / ENCODING / MEMORY; the sink's
+ * own failure rides MEMORY like the DOM builder's). on_input (may be
+ * NULL) receives the run's input view — the DOM route's input_base law
+ * (the transcoded copy, or the caller's bytes) and its post-BOM length
+ * — immediately before the engine runs, because the events' borrowed
+ * views subtract from it. The bytes live only for the run. */
+YeptrisStatus yep_parse_events(const char* buf, size_t len, YeptrisSchema schema,
+                               const yep_sink* sink,
+                               void (*on_input)(void* ctx, const char* base, size_t len),
+                               void* on_ctx) {
+    if (sink == NULL || (buf == NULL && len != 0)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    const yep_allocator* sys = yep_system_allocator();
+    const char* data = NULL;
+    size_t data_len = 0;
+    unsigned char* transcoded = NULL;
+    size_t transcoded_len = 0;
+    int norm_kept_raw = 0;
+    YeptrisStatus st = YEPTRIS_OK;
+    if (parse_frontend(buf, len, sys, 0, &data, &data_len, &transcoded, &transcoded_len,
+                       &norm_kept_raw, &st) != 0) {
+        return st;
+    }
+    yep_engine* eng = yep_engine_create(sys);
+    if (eng == NULL) {
+        yep_free(sys, transcoded);
+        return YEPTRIS_ERROR_MEMORY;
+    }
+    /* the typing SSOT: the family's resolver (resolver_for_schema is
+     * the one switch) */
+    yep_engine_set_resolver(eng, resolver_for_schema(schema));
+    if (schema == YEPTRIS_SCHEMA_11_COMPAT) {
+        /* the compat schema is the psych/libyaml surface (see
+         * parse_impl's twin comment) */
+        yep_engine_set_compat_grammar(eng, 1);
+    }
+    {
+        /* the nametab reserve survives: a memchr chain for '&' is far
+         * cheaper than the class sweep it replaced */
+        yep_text_stats amp_only = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        const char* q = data == NULL ? "" : data;
+        const char* end = q + data_len;
+        if (q != NULL) {
+            while ((q = memchr(q, '&', (size_t)(end - q))) != NULL) {
+                amp_only.amp++;
+                q++;
+            }
+        }
+        yep_engine_prepare(eng, &amp_only);
+    }
+    yep_engine_front_done(eng);
+    if (on_input != NULL) {
+        on_input(on_ctx, transcoded ? (const char*)transcoded : buf, data_len);
+    }
+    int rc = yep_engine_run(eng, data, data_len, sink);
+    if (rc != 0) {
+        /* the error CODE decides the public status — the parse route's
+         * law (parse_impl carries the full comment): a CLEAN channel
+         * under a failed run means the SINK failed */
+        const yep_error* ee = yep_engine_error(eng);
+        yep_err_code code = (ee && ee->code != YEP_ERR_NONE) ? ee->code : YEP_ERR_MEMORY;
+        if (ee) {
+            yep_error* tls = yep_error_tls();
+            *tls = *ee;
+        }
+        yep_pool* finish = yep_engine_detach_pool(eng);
+        yep_pool_destroy(finish);
+        yep_engine_destroy(eng);
+        yep_free(sys, transcoded);
+        return (code == YEP_ERR_MEMORY)  ? YEPTRIS_ERROR_MEMORY
+               : (code == YEP_ERR_DEPTH) ? YEPTRIS_ERROR_DEPTH
+                                         : YEPTRIS_ERROR_PARSE;
+    }
+    yep_pool* finish = yep_engine_detach_pool(eng);
+    yep_pool_destroy(finish); /* nothing borrows the finish pool: every
+                               * consumer copies (snapshot law) */
+    yep_engine_destroy(eng);
+    yep_free(sys, transcoded);
+    return YEPTRIS_OK;
+}
+
+static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisParseOptions* opts,
+                                  int json_mode, int lazy, YeptrisStatus* status) {
+    YeptrisStatus st = YEPTRIS_OK;
+    if (buf == NULL && len != 0) {
+        st = YEPTRIS_ERROR_ARG;
+        goto fail;
+    }
+
+    const yep_allocator* sys = yep_system_allocator();
+
+    /* Encoding front-end (parse_frontend owns the law): BOM sniff;
+     * borrow UTF-8, transcode the rest; NEL normalization. */
+    const char* data = NULL;
+    size_t data_len = 0;
+    unsigned char* transcoded = NULL;
+    size_t transcoded_len = 0;
+    int norm_kept_raw = 0; /* raw NEL/LS/PS survived the quote-aware
+                            * walk: the engine route owns the document
+                            * (the tape runner predates the cut) */
+
+    if (parse_frontend(buf, len, sys, json_mode, &data, &data_len, &transcoded, &transcoded_len,
+                       &norm_kept_raw, &st) != 0) {
+        goto fail;
+    }
+
     /* Engine → DOM. */
+    const YeptrisSchema schema = opts != NULL ? opts->schema : YEPTRIS_SCHEMA_12_CORE;
     yep_engine* eng = NULL;
-engine_enter:
     eng = yep_engine_create(sys);
     if (opts != NULL) {
-        /* the typing SSOT: the family's resolver (compat11 when asked,
-         * json12 for the 12_JSON validation family, core12 otherwise) */
-        yep_engine_set_resolver(eng, opts->schema == YEPTRIS_SCHEMA_11_COMPAT
-                                         ? yep_resolver_compat11()
-                                         : (opts->schema == YEPTRIS_SCHEMA_12_JSON
-                                                ? yep_resolver_json12()
-                                                : yep_resolver_core12()));
+        /* the typing SSOT: the family's resolver (resolver_for_schema
+         * is the one switch) */
+        yep_engine_set_resolver(eng, resolver_for_schema(schema));
         if (opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
             /* the compat schema is the psych/libyaml surface: its grammar
              * must accept what libyaml accepts (the flow floor is suite-
@@ -366,13 +501,7 @@ engine_enter:
         }
         /* the direct builders resolve with the engine's schema (the typing
          * SSOT — one resolver decision per scalar, whichever path builds) */
-        if (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
-            dom->resolver = yep_resolver_compat11();
-        } else if (opts != NULL && opts->schema == YEPTRIS_SCHEMA_12_JSON) {
-            dom->resolver = yep_resolver_json12();
-        } else {
-            dom->resolver = yep_resolver_core12();
-        }
+        dom->resolver = resolver_for_schema(schema);
         /* BEFORE the run: input-slice strings borrow as views (zero copy)
          * — the document keeps `transcoded` alive for exactly this. Set
          * after, every scalar was arena-copied (found 2026-09-10). */
@@ -433,11 +562,7 @@ engine_enter:
         yep_engine_destroy(eng);
         eng = NULL;
     } else if (have_tape && !norm_kept_raw &&
-               ytap_fused_run(&yt, (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
-                                       ? yep_resolver_compat11()
-                                   : (opts != NULL && opts->schema == YEPTRIS_SCHEMA_12_JSON)
-                                       ? yep_resolver_json12()
-                                       : yep_resolver_core12()) == 0) {
+               ytap_fused_run(&yt, resolver_for_schema(schema)) == 0) {
         /* the fused block runner owned the whole document — the engine
          * never runs (TODO.restructure/79). Its only cost was the parse
          * front-end above; on a bail it unwound and the engine runs. */
@@ -695,10 +820,14 @@ YEPTRIS_API YeptrisTagId yeptris_node_tag_id(YeptrisNode handle) {
     if (n == NULL) {
         return YEPTRIS_TAG_CUSTOM;
     }
-    if (n->kind == YEPTRIS_NODE_SEQUENCE) {
+    /* the INTERNAL kind space here (#904 item 6): n->kind is the
+     * dom's yep_dom_kind — the public YEPTRIS_NODE_* constants ride
+     * the same values today only by coincidence, and the boundary
+     * conversion is yeptris_node_kind's switch alone */
+    if (n->kind == YEP_DOM_SEQUENCE) {
         return YEPTRIS_TAG_SEQ;
     }
-    if (n->kind == YEPTRIS_NODE_MAPPING) {
+    if (n->kind == YEP_DOM_MAPPING) {
         return YEPTRIS_TAG_MAP;
     }
     return (YeptrisTagId)n->tag_id;
@@ -847,7 +976,8 @@ YEPTRIS_API size_t yeptris_node_map_count(YeptrisNode handle) {
 YEPTRIS_API int yeptris_node_map_at(YeptrisNode handle, size_t index, YeptrisNode* key,
                                     YeptrisNode* value) {
     const yep_dnode* n = node_of(handle);
-    if (n == NULL || n->kind != YEPTRIS_NODE_MAPPING || index >= n->count / 2) {
+    /* the internal kind space (#904 item 6, see yeptris_node_tag_id) */
+    if (n == NULL || n->kind != YEP_DOM_MAPPING || index >= n->count / 2) {
         return -1;
     }
     yeptris_node* h = (yeptris_node*)handle;

data/vendor/libyeptris/src/yeptris/resolve/compat11.c

@@ -335,7 +335,7 @@ static yep_tag_id compat11(void* ctx, const char* p, uint32_t n) {
     return 0; /* str */
 }
 
-static const yep_resolver k_compat11 = {compat11, NULL, NULL};
+static const yep_resolver k_compat11 = {compat11, NULL, NULL, 0};
 
 const yep_resolver* yep_resolver_compat11(void) {
     return &k_compat11;

data/vendor/libyeptris/src/yeptris/resolve/core12.c

@@ -11,6 +11,10 @@
  * and signs take the number walk. The old chain tried the word memcmps
  * for every length-4/5 scalar before ruling (anchor-heavy: 42 cycles
  * per call on gate-passing strings).
+ *
+ * yep_core12_plain is the ONE classifier (the yep_json12_plain
+ * precedent): the resolver wraps it, and the full-1.2 family composes
+ * it (full12.c's timestamp lane rides the same truth table).
  */
 
 #include <stdint.h>
@@ -18,8 +22,7 @@
 
 #include "resolver.h"
 
-static yep_tag_id core12(void* ctx, const char* p, uint32_t n) {
-    (void)ctx;
+yep_tag_id yep_core12_plain(const char* p, uint32_t n) {
     if (n == 0) {
         return 4; /* null */
     }
@@ -133,12 +136,17 @@ static yep_tag_id core12(void* ctx, const char* p, uint32_t n) {
     return 0;
 }
 
+static yep_tag_id core12(void* ctx, const char* p, uint32_t n) {
+    (void)ctx;
+    return yep_core12_plain(p, n);
+}
+
 static yep_tag_id core12_number(void* ctx, int is_float) {
     (void)ctx;
     return is_float ? 2 : 1;
 }
 
-static const yep_resolver k_core12 = {core12, core12_number, NULL};
+static const yep_resolver k_core12 = {core12, core12_number, NULL, 0};
 
 const yep_resolver* yep_resolver_core12(void) {
     return &k_core12;

data/vendor/libyeptris/src/yeptris/resolve/full12.c

@@ -0,0 +1,201 @@
+/* full12.c — the FULL YAML 1.2 family resolver (#906 slice 3).
+ *
+ * The spec's schema chapter names two families (10.2 JSON, 10.3 core)
+ * and leaves the rest to 10.4 "Other Schemas": interoperable schemas
+ * "make use of global tags", may add their own resolution regexes, and
+ * are "strongly recommended ... based on the core schema". The
+ * historical full schema is the yaml.org type repository carried
+ * forward in practice — libyaml implements nothing of it; PyYAML's
+ * SafeLoader resolves timestamps, and that is the de-facto full
+ * behavior the ecosystem knows. This resolver is that family:
+ *
+ *   core12's productions verbatim (the spec-refereed base — NOT
+ *     psych's numeric quirks: underscores, sexagesimal, leading-0
+ *     octal and y/n booleans stay in compat11, which is the 1.1
+ *     practice lane, not a 1.2 family);
+ * + timestamps on untagged plains: spec example 2.22's four shapes —
+ *     canonical (2001-12-15T02:59:43.1Z), iso8601
+ *     (2001-12-14t21:59:43.10-05:00), spaced (2001-12-14 21:59:43.10
+ *     -5), date (2002-12-14) — classified by PyYAML 6.0.2's
+ *     timestamp regex, the practice oracle (see pyyaml_timestamp
+ *     below for the production-by-production account);
+ * + the merge/value words ('<<' / '='), the 1.1 full schema's
+ *     grammar-adjacent tags PyYAML also resolves implicitly;
+ * - binary: NEVER implicit (nowhere, in any edition) — the explicit
+ *     !!binary tag rides as consumer-defined passthrough (PyYAML's
+ *     base64 shaping is a CONSTRUCTION step; keeping shaping out of
+ *     resolution is the documented passthrough policy).
+ *
+ * The validator family-checks explicit !!timestamp content through the
+ * same classifier (the resolver's `timestamped` capability), so a
+ * resolution change lands once and both move together.
+ */
+
+#include <stdint.h>
+
+#include "resolver.h"
+
+/* PyYAML 6.0.2 resolver.py's timestamp_regexp, production by
+ * production (re.X whitespace stripped):
+ *
+ *   [0-9]{4}-[0-9]{2}-[0-9]{2}                      date-only: month
+ *                                                   and day are EXACTLY
+ *                                                   two digits
+ * | [0-9]{4}-[0-9]{1,2}-[0-9]{1,2}                  with a time part:
+ *                                                   month/day/hour are
+ *                                                   1-2 digits, the
+ *     (?:[Tt]|[ \t]+)[0-9]{1,2}                     separator T/t/space-
+ *                                                   run, minutes and
+ *     :[0-9]{2}:[0-9]{2}(?:\.[0-9]*)?               seconds EXACTLY two,
+ *                                                   fraction zero+ digits
+ *     (?:[ \t]*(?:Z|[-+][0-9]{1,2}(?::[0-9]{2})?))? tz OPTIONAL: Z or a
+ *                                                   signed 1-2-digit
+ *                                                   offset, minutes
+ *                                                   optional
+ *
+ * The two-oracle divergences this keeps (PyYAML's resolver is the
+ * oracle, deliberately): NO sign on the year (psych allows -?); NO
+ * calendar range checks (2001-13-14 resolves timestamp — PyYAML's own
+ * resolver agrees, only its constructor raises; resolution is not
+ * calendar validation, the consumer's date type owns ranges). The
+ * spec's plain-scalar colon law is what keeps the spaced forms
+ * unquoted ("a:1" is a plain scalar; "a: 1" is a pair — 5.3.2's note
+ * cites timestamps as the canonical case).
+ */
+static int pyyaml_timestamp(const char* p, uint32_t n) {
+    uint32_t k = 0;
+    for (int d = 0; d < 4; d++) { /* year: exactly four digits, no sign */
+        if (k >= n || p[k] < '0' || p[k] > '9') {
+            return 0;
+        }
+        k++;
+    }
+    if (k >= n || p[k] != '-') {
+        return 0;
+    }
+    k++;
+    uint32_t mdig = 0, ddig = 0;
+    for (int seg = 0; seg < 2; seg++) {
+        const uint32_t start = k;
+        while (k < n && k - start < 2 && p[k] >= '0' && p[k] <= '9') {
+            k++;
+        }
+        if (seg == 0) {
+            mdig = k - start;
+            if (mdig == 0 || k >= n || p[k] != '-') {
+                return 0;
+            }
+            k++;
+        } else {
+            ddig = k - start;
+            if (ddig == 0) {
+                return 0;
+            }
+        }
+    }
+    if (k == n) {
+        /* date-only: the branch demands EXACTLY two-digit month/day
+         * ("2001-1-1" is a string — PyYAML's own verdict) */
+        return mdig == 2 && ddig == 2;
+    }
+    /* the time part is MANDATORY on the second branch */
+    if (p[k] == 'T' || p[k] == 't') {
+        k++;
+    } else if (p[k] == ' ' || p[k] == '\t') {
+        while (k < n && (p[k] == ' ' || p[k] == '\t')) {
+            k++;
+        }
+    } else {
+        return 0;
+    }
+    const uint32_t hstart = k; /* hour: 1-2 digits */
+    while (k < n && k - hstart < 2 && p[k] >= '0' && p[k] <= '9') {
+        k++;
+    }
+    if (k == hstart) {
+        return 0;
+    }
+    for (int seg = 0; seg < 2; seg++) { /* :dd:dd — exactly two each */
+        if (k >= n || p[k] != ':') {
+            return 0;
+        }
+        k++;
+        const uint32_t start = k;
+        while (k < n && k - start < 2 && p[k] >= '0' && p[k] <= '9') {
+            k++;
+        }
+        if (k - start != 2) {
+            return 0;
+        }
+    }
+    if (k < n && p[k] == '.') { /* fraction: dot then zero+ digits */
+        k++;
+        while (k < n && p[k] >= '0' && p[k] <= '9') {
+            k++;
+        }
+    }
+    /* tz: greedy, OPTIONAL — a malformed tail backtracks to empty and
+     * the overall match then fails at the tail byte (regex semantics) */
+    const uint32_t save = k;
+    while (k < n && (p[k] == ' ' || p[k] == '\t')) {
+        k++;
+    }
+    if (k < n && p[k] == 'Z') {
+        k++;
+    } else if (k < n && (p[k] == '+' || p[k] == '-')) {
+        k++;
+        const uint32_t ostart = k; /* offset hour: 1-2 digits */
+        while (k < n && k - ostart < 2 && p[k] >= '0' && p[k] <= '9') {
+            k++;
+        }
+        int ok = k - ostart > 0;
+        if (ok && k < n && p[k] == ':') { /* optional :mm — exactly two */
+            const uint32_t mstart = k + 1;
+            ok = mstart + 1 < n && p[mstart] >= '0' && p[mstart] <= '9' && p[mstart + 1] >= '0' &&
+                 p[mstart + 1] <= '9';
+            if (ok) {
+                k = mstart + 2;
+            }
+        }
+        if (!ok) {
+            k = save;
+        }
+    } else {
+        k = save;
+    }
+    return k == n;
+}
+
+static yep_tag_id full12(void* ctx, const char* p, uint32_t n) {
+    (void)ctx;
+    /* the merge/value words: exact compares, ahead of everything (the
+     * 1.1 full schema's grammar-adjacent tags, PyYAML-resolved) */
+    if (n == 1 && p[0] == '=') {
+        return 10; /* value */
+    }
+    if (n == 2 && p[0] == '<' && p[1] == '<') {
+        return 9; /* merge */
+    }
+    /* the core base, verbatim */
+    yep_tag_id core = yep_core12_plain(p, n);
+    if (core != 0) {
+        return core;
+    }
+    /* timestamps: gate on the shape (four digits, '-', >= 10 bytes) —
+     * every accepted form starts with four digits */
+    if (n >= 10 && p[0] >= '0' && p[0] <= '9' && pyyaml_timestamp(p, n)) {
+        return 5;
+    }
+    return 0;
+}
+
+static yep_tag_id full12_number(void* ctx, int is_float) {
+    (void)ctx;
+    return is_float ? 2 : 1; /* full numbers are core numbers */
+}
+
+static const yep_resolver k_full12 = {full12, full12_number, NULL, 1};
+
+const yep_resolver* yep_resolver_full12(void) {
+    return &k_full12;
+}

data/vendor/libyeptris/src/yeptris/resolve/json12.c

@@ -6,17 +6,23 @@
  *   bool:  true | false
  *   int:   -? ( 0 | [1-9] [0-9]* )
  *   float: -? ( 0 | [1-9] [0-9]* ) ( \. [0-9]* )? ( [eE] [-+]? [0-9]+ )?
- *   *  -> Error (the validator's business; the resolver stays str)
+ *   *  -> str (see below: example 10.8 governs; the Error row does not)
  *
  * Deliberately NOT accepted (the core schema's extensions): "True"/
  * "False"/"NULL" casings, "~"/empty nulls, +signs, 0o/0x radix, .inf/
  * .nan, underscores. The example-10.8 Invalid list pins each one.
  *
  * Shape: yep_json12_plain is the ONE classifier — the resolver wraps
- * it, and the validator re-asks it per plain scalar (no second truth
- * table anywhere). Parse never errors here: a scalar outside the
- * productions resolves str so the DOM stays family-neutral; the
- * validation face turns the spec's Error row into diagnostics.
+ * it, and the validator re-asks it per plain scalar key (no second
+ * truth table anywhere). SPEC NOTE (the 10.2.2 contradiction): the
+ * table's `* -> Error` row says no-match plains "should be considered
+ * an error", but example 10.8 — the spec's own JSON Tag Resolution
+ * demonstration — resolves no-match plains as strings BOTH as keys
+ * ("A null", "Booleans") and as values (the "Invalid" list). Example
+ * 10.8 wins: a scalar outside the productions resolves str so the DOM
+ * stays family-neutral, and the validation face does NOT turn no-match
+ * plains into diagnostics; the family's teeth are the string-key
+ * demand (12_JSON) and explicit non-JSON tags.
  */
 
 #include <stdint.h>
@@ -96,7 +102,7 @@ static yep_tag_id json12_number(void* ctx, int is_float) {
     return is_float ? 2 : 1;
 }
 
-static const yep_resolver k_json12 = {json12, json12_number, NULL};
+static const yep_resolver k_json12 = {json12, json12_number, NULL, 0};
 
 const yep_resolver* yep_resolver_json12(void) {
     return &k_json12;

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

@@ -25,6 +25,12 @@ typedef struct yep_resolver {
      * skips the digit re-walk resolve() would pay. NULL = resolve(). */
     yep_tag_id (*resolve_number)(void* ctx, int is_float);
     void* ctx;
+    /* 1 when timestamp:yaml.org,2002 is IN the family's implicit set —
+     * the validator family-checks explicit !!timestamp content through
+     * resolve() (#906 slice 3). Core leaves it consumer-defined (the
+     * core schema has no timestamp, spec 10.3); 11_COMPAT is not a
+     * validation family; json12 rejects the tag wholesale. */
+    int timestamped;
 } yep_resolver;
 
 /* Typing for a validated number span, through whichever hook the
@@ -39,6 +45,9 @@ static inline yep_tag_id yep_resolve_number(const yep_resolver* r, int is_float)
 /* The two built-in resolvers (no ctx). */
 const yep_resolver* yep_resolver_core12(void);
 const yep_resolver* yep_resolver_compat11(void);
+/* The core schema's plain-scalar classifier (the core truth table):
+ * the resolver wraps it and the full family composes it. */
+yep_tag_id yep_core12_plain(const char* p, uint32_t n);
 
 /* The spec 10.2 JSON schema resolver (#882): null/true/false exact,
  * the JSON int and float productions, everything else str. Parse stays
@@ -49,6 +58,17 @@ const yep_resolver* yep_resolver_json12(void);
  * truth table for the 12_JSON family (validate/ re-asks it). */
 int yep_json12_plain(const char* p, uint32_t n);
 
+/* The FULL 1.2 family resolver (#906 slice 3): the core productions
+ * verbatim (spec 10.4: interoperable schemas are "strongly recommended
+ * ... based on the core schema") extended with the yaml.org type
+ * repository's carried-forward set — RFC3339-era timestamps on untagged
+ * plains (spec 2.22's canonical/iso8601/spaced/date forms; PyYAML's
+ * timestamp regex as the practice oracle) and the merge/value words.
+ * The 1.1 NUMERIC quirks (underscores, sexagesimal, leading-0 octal,
+ * y/n booleans) stay in compat11 — full is spec-refereed, not
+ * psych-refereed. */
+const yep_resolver* yep_resolver_full12(void);
+
 /* core tag id <-> canonical URI (tags.c is the identity SSOT). */
 const char* yep_tag_uri(yep_tag_id id);