yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/include/yeptris/json.hpp

@@ -0,0 +1,258 @@
+// json.hpp — the nlohmann-flavored C++17 wrapper (TODO.impl/21).
+//
+// Value semantics over the C ABI: yeptris::json owns its document
+// (RAII), children are views into it. JSON in, JSON out — strict
+// parsing via yeptris_parse_json, output via the JSON writer.
+// Errors throw (nlohmann discipline); no exceptions in the C core.
+//
+// Deliberately a view, not a copy: j["k"] returns a child that stays
+// valid while the parent json lives (the nlohmann ergonomics without
+// the deep-template machinery).
+
+#ifndef YEPTRIS_JSON_HPP
+#define YEPTRIS_JSON_HPP
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#include <yeptris/dom.h>
+#include <yeptris/json.h>
+
+namespace yeptris {
+
+class parse_error : public std::runtime_error {
+  public:
+    explicit parse_error(const char* msg) : std::runtime_error(msg) {}
+};
+
+class type_error : public std::logic_error {
+  public:
+    explicit type_error(const char* msg) : std::logic_error(msg) {}
+};
+
+class json {
+  public:
+    json() = default;
+
+    json(const json&) = delete;
+    json& operator=(const json&) = delete;
+
+    json(json&& other) noexcept : doc_(other.doc_), node_(other.node_), owns_(other.owns_) {
+        other.doc_ = nullptr;
+        other.node_ = nullptr;
+        other.owns_ = false;
+    }
+
+    json& operator=(json&& other) noexcept {
+        if (this != &other) {
+            destroy();
+            doc_ = other.doc_;
+            node_ = other.node_;
+            owns_ = other.owns_;
+            other.doc_ = nullptr;
+            other.node_ = nullptr;
+            other.owns_ = false;
+        }
+        return *this;
+    }
+
+    ~json() {
+        destroy();
+    }
+
+    static json parse(std::string_view text) {
+        YeptrisStatus st = YEPTRIS_OK;
+        YeptrisDocument d = yeptris_parse_json(text.data(), text.size(), &st);
+        if (d == nullptr) {
+            uint32_t line = 0, col = 0;
+            const char* msg = yeptris_last_error(&line, &col);
+            throw parse_error(msg ? msg : "not valid JSON");
+        }
+        json j;
+        j.doc_ = d;
+        j.node_ = yeptris_document_root(d, 0);
+        j.owns_ = true;
+        return j;
+    }
+
+    std::string dump() const {
+        check_root();
+        size_t len = 0;
+        char* out = yeptris_serialize_json(doc_, &len);
+        if (out == nullptr) {
+            throw std::runtime_error("serialization failed");
+        }
+        std::string s(out, len);
+        free(out);
+        return s;
+    }
+
+    // ---- type queries (nlohmann names) ----
+    bool is_object() const {
+        return kind() == YEPTRIS_NODE_MAPPING;
+    }
+    bool is_array() const {
+        return kind() == YEPTRIS_NODE_SEQUENCE;
+    }
+    bool is_string() const {
+        return kind() == YEPTRIS_NODE_SCALAR && !is_number() && !is_boolean() && !is_null();
+    }
+    bool is_number() const {
+        return is_number_integer() || is_number_float();
+    }
+    bool is_number_integer() const {
+        return typed_ok<int64_t>();
+    }
+    bool is_number_float() const {
+        return typed_ok<double>();
+    }
+    bool is_boolean() const {
+        return typed_ok<bool>();
+    }
+    bool is_null() const;
+
+    // ---- object access ----
+    json operator[](std::string_view key) const {
+        require(YEPTRIS_NODE_MAPPING, "object");
+        YeptrisNode n = yeptris_node_map_get(node_, key.data(), key.size());
+        if (n == nullptr) {
+            throw std::out_of_range("key not found");
+        }
+        return child(n);
+    }
+
+    json at(std::string_view key) const {
+        return (*this)[key];
+    }
+
+    bool contains(std::string_view key) const {
+        return kind() == YEPTRIS_NODE_MAPPING &&
+               yeptris_node_map_get(node_, key.data(), key.size()) != nullptr;
+    }
+
+    size_t size() const {
+        if (kind() == YEPTRIS_NODE_MAPPING) {
+            return yeptris_node_map_count(node_);
+        }
+        if (kind() == YEPTRIS_NODE_SEQUENCE) {
+            return yeptris_node_seq_count(node_);
+        }
+        return 0;
+    }
+
+    // ---- array access ----
+    json operator[](size_t index) const {
+        require(YEPTRIS_NODE_SEQUENCE, "array");
+        if (index >= yeptris_node_seq_count(node_)) {
+            throw std::out_of_range("index out of range");
+        }
+        return child(yeptris_node_seq_at(node_, index));
+    }
+
+    json at(size_t index) const {
+        return (*this)[index];
+    }
+
+    // ---- typed getters ----
+    std::string get_string() const {
+        if (kind() != YEPTRIS_NODE_SCALAR) {
+            throw type_error("not a scalar");
+        }
+        size_t len = 0;
+        const char* v = yeptris_node_value(node_, &len);
+        return std::string(v ? v : "", len); /* json-c semantics: the
+            raw text — "1" for numbers, "true" for booleans */
+    }
+
+    int64_t get_int() const {
+        int64_t v = 0;
+        if (yeptris_node_int(node_, &v) != YEPTRIS_OK) {
+            throw type_error("not an integer");
+        }
+        return v;
+    }
+
+    double get_double() const {
+        double v = 0;
+        if (yeptris_node_float(node_, &v) != YEPTRIS_OK) {
+            throw type_error("not a float");
+        }
+        return v;
+    }
+
+    bool get_bool() const {
+        int v = 0;
+        if (yeptris_node_bool(node_, &v) != YEPTRIS_OK) {
+            throw type_error("not a boolean");
+        }
+        return v != 0;
+    }
+
+  private:
+    json(YeptrisDocument doc, YeptrisNode node) : doc_(doc), node_(node), owns_(false) {}
+
+    json child(YeptrisNode n) const {
+        return json(doc_, n);
+    }
+
+    void destroy() {
+        if (owns_ && doc_ != nullptr) {
+            yeptris_document_free(doc_);
+        }
+        doc_ = nullptr;
+        node_ = nullptr;
+        owns_ = false;
+    }
+
+    void check_root() const {
+        if (doc_ == nullptr) {
+            throw std::logic_error("empty json");
+        }
+    }
+
+    int kind() const {
+        return node_ != nullptr ? (int)yeptris_node_kind(node_) : -1;
+    }
+
+    void require(int k, const char* what) const {
+        if (kind() != k) {
+            throw type_error(what);
+        }
+    }
+
+    template <typename T> bool typed_ok() const {
+        if (node_ == nullptr || kind() != YEPTRIS_NODE_SCALAR) {
+            return false;
+        }
+        if constexpr (std::is_same_v<T, int64_t>) {
+            int64_t v;
+            return yeptris_node_int(node_, &v) == YEPTRIS_OK;
+        } else if constexpr (std::is_same_v<T, double>) {
+            double v;
+            return yeptris_node_float(node_, &v) == YEPTRIS_OK;
+        } else {
+            int v;
+            return yeptris_node_bool(node_, &v) == YEPTRIS_OK;
+        }
+    }
+
+    YeptrisDocument doc_ = nullptr;
+    YeptrisNode node_ = nullptr;
+    bool owns_ = false;
+};
+
+inline bool json::is_null() const {
+    if (kind() != YEPTRIS_NODE_SCALAR) {
+        return false;
+    }
+    size_t len = 0;
+    const char* v = yeptris_node_value(node_, &len);
+    return len == 4 && v != nullptr && std::string_view(v, len) == "null";
+}
+
+} // namespace yeptris
+
+#endif // YEPTRIS_JSON_HPP

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

@@ -0,0 +1,115 @@
+/* jsonc_compat.h — the json-c migration layer (TODO.impl/21).
+ *
+ * REAL json-c symbol names over the yeptris core: users link
+ * -lyeptris-jsonc instead of -ljson-c and change nothing else.
+ *
+ * Scope (v1, the read path): parsing, type queries, value getters,
+ * object/array access, and JSON output. The building API
+ * (json_object_new_ etc.) landed with DOM mutation
+ * (TODO.impl/11 phase 3): the new_object family, object_add,
+ * array_add, and the delete entry points.
+ *
+ * Lifetime: the object returned by json_tokener_parse owns the
+ * document; json_object_put frees it. Objects obtained by reference
+ * (children) are owned by their document — put on them is a no-op
+ * returning 1 (json-c children outlive callers the same way).
+ */
+#ifndef YEPTRIS_JSONC_COMPAT_H
+#define YEPTRIS_JSONC_COMPAT_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Values mirror json-c's json_type. */
+typedef enum {
+    json_type_null = 0,
+    json_type_boolean,
+    json_type_double,
+    json_type_int,
+    json_type_object,
+    json_type_array,
+    json_type_string
+} json_type;
+
+typedef struct json_object json_object;
+
+/* json-c's string flags for to_json_string_ext */
+#define JSON_C_TO_STRING_PLAIN 0
+#define JSON_C_TO_STRING_SPACED (1 << 0)
+#define JSON_C_TO_STRING_PRETTY (1 << 1)
+#define JSON_C_TO_STRING_PRETTY_TAB (1 << 2)
+#define JSON_C_TO_STRING_NOZERO (1 << 3)
+
+/* Parses one JSON document (strict; trailing whitespace allowed).
+ * Returns NULL on invalid input. The result owns its document —
+ * release with json_object_put. */
+json_object* json_tokener_parse(const char* str);
+json_object* json_tokener_parse_ex(const char* buf, int len);
+void json_tokener_free(json_object* obj);
+
+/* Lifetime: put on the ROOT frees the document (once); on a child it
+ * is a no-op returning 1. get returns the object unchanged. */
+int json_object_put(json_object* obj);
+json_object* json_object_get(json_object* obj);
+
+/* Type queries. */
+json_type json_object_get_type(const json_object* obj);
+int json_object_is_type(const json_object* obj, json_type type);
+
+/* Value getters (0 when the type does not match, like json-c). */
+const char* json_object_get_string(json_object* obj);
+int32_t json_object_get_int(const json_object* obj);
+int64_t json_object_get_int64(const json_object* obj);
+double json_object_get_double(const json_object* obj);
+int json_object_get_boolean(const json_object* obj);
+
+/* Object access: *value receives the field (a borrowed reference). */
+int json_object_object_get_ex(const json_object* obj, const char* key, json_object** value);
+size_t json_object_object_length(const json_object* obj);
+
+/* Array access (borrowed references). */
+size_t json_object_array_length(const json_object* obj);
+json_object* json_object_array_get_idx(const json_object* obj, size_t idx);
+
+/* Output: strict JSON. The returned pointer is owned by the object
+ * (freed with it) — json-c's contract. Roots only in v1: serializing
+ * an attached child returns NULL (subtree output arrives with the
+ * pretty printer). */
+const char* json_object_to_json_string(json_object* obj);
+const char* json_object_to_json_string_ext(json_object* obj, int flags);
+
+/* ---- Building (TODO.impl/21 v2, over DOM mutation 11/3) ----
+ *
+ * json-c semantics: new_* returns an unowned object; adding it to a
+ * parent transfers ownership (a put on it afterwards is a no-op); the
+ * caller's pointer stays valid until the ROOT is put. Values are
+ * copied. Duplicate keys replace in place (position kept). NULL val
+ * to object_add deletes the key (legacy json-c behavior). */
+json_object* json_object_new_object(void);
+json_object* json_object_new_array(void);
+json_object* json_object_new_string(const char* s);
+json_object* json_object_new_string_len(const char* s, int len);
+json_object* json_object_new_int(int32_t i);
+json_object* json_object_new_int64(int64_t i);
+json_object* json_object_new_double(double d);
+json_object* json_object_new_boolean(int b);
+
+/* 0 added, 1 replaced, -1 error (obj not an object, or OOM). */
+int json_object_object_add(json_object* obj, const char* key, json_object* val);
+int json_object_object_del(json_object* obj, const char* key);
+
+/* 0 ok, -1 error (obj not an array, or OOM). */
+int json_object_array_add(json_object* obj, json_object* val);
+int json_object_array_del_idx(json_object* obj, size_t idx, size_t count);
+
+/* index < len replaces in place; index == len appends. */
+int json_object_array_put_idx(json_object* obj, size_t idx, json_object* val);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_JSONC_COMPAT_H */

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

@@ -0,0 +1,52 @@
+/* marshal.h — Ruby Marshal 4.8 emission (TODO.restructure/21).
+ *
+ * The binding materialization fast path: the C side converts the
+ * value records directly into Ruby's Marshal wire format, so the host
+ * materializes the whole object graph with ONE core-C call
+ * (Marshal.load) instead of walking per-value records in Ruby.
+ *
+ * Semantics are pinned to the binding walks (the ':sym' plain scan,
+ * Psych's single-char y/n and dot-required floats, alias identity
+ * via object links). Constructs the format cannot express return
+ * YEPTRIS_ERROR_UNSUPPORTED — the host falls back to the record walk.
+ *
+ * Memory: *out is a single malloc'd buffer; free with
+ * yeptris_marshal_free exactly once. */
+#ifndef YEPTRIS_MARSHAL_H
+#define YEPTRIS_MARSHAL_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/dom.h>
+#include <yeptris/resolve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    /* the whole stream as one Ruby Array of documents (load_all) */
+    YEPTRIS_MARSHAL_ALL_DOCS = 0,
+    /* just the first document's root (load) */
+    YEPTRIS_MARSHAL_FIRST_DOC = 1,
+} YeptrisMarshalMode;
+
+/* Parses `data` and emits Marshal 4.8 bytes of the object graph the
+ * value stream describes. Returns YEPTRIS_OK, YEPTRIS_ERROR_PARSE /
+ * _MEMORY / _ARG, or YEPTRIS_ERROR_UNSUPPORTED (merge keys or
+ * timestamps: materialize those through the record walk). */
+YEPTRIS_API YeptrisStatus yeptris_marshal(const char* data, size_t len, YeptrisSchema schema,
+                                          YeptrisMarshalMode mode, char** out, size_t* out_len);
+
+/* The same emission for one node subtree of a built document — the
+ * bulk path behind Node#to_ruby (one call, not one per node). */
+YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, size_t* out_len);
+
+YEPTRIS_API void yeptris_marshal_free(char* out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_MARSHAL_H */

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

@@ -0,0 +1,48 @@
+/* parse.h — the parse entry points (TODO.impl/07/11 public surface). */
+
+#ifndef YEPTRIS_PARSE_H
+#define YEPTRIS_PARSE_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/resolve.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Parses a YAML document set. buf must remain valid for the lifetime of
+ * the returned document (scalar values are borrowed zero-copy views).
+ * On failure returns NULL; *status (may be NULL) receives the code and
+ * yeptris_last_error() carries the message with line/column.
+ *
+ * Memory: the caller owns the document; free it with
+ * yeptris_document_free — one call releases everything. */
+YEPTRIS_API YeptrisDocument yeptris_parse(const char* buf, size_t len, YeptrisStatus* status);
+
+/* Per-parse options (TODO.impl/10): schema selects the implicit-typing
+ * resolver (default YEPTRIS_SCHEMA_12_CORE), max_depth caps nesting
+ * (0: the library default), strict/tab_policy/recover are reserved
+ * pins of the option shape (the strict grammar is the default today;
+ * lenient modes land with the recover work). Zero-initialized = the
+ * yeptris_parse defaults. */
+typedef struct YeptrisParseOptions {
+    YeptrisSchema schema;
+    int max_depth;
+    int strict;
+    int tab_policy;
+    int recover;
+} YeptrisParseOptions;
+
+YEPTRIS_API YeptrisDocument yeptris_parse_ex(const char* buf, size_t len,
+                                             const YeptrisParseOptions* opts,
+                                             YeptrisStatus* status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_PARSE_H */

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

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

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

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