yeptris 0.6.18.2-arm-linux-eabihf

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

@@ -0,0 +1,190 @@
+/* document.h / node.h surface — DOM accessors (TODO.impl/11).
+ * Pinned enums: bindings hard-code these values (test_abi). */
+
+#ifndef YEPTRIS_DOM_PUBLIC_H
+#define YEPTRIS_DOM_PUBLIC_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEPTRIS_NODE_SCALAR = 0,
+    YEPTRIS_NODE_SEQUENCE = 1,
+    YEPTRIS_NODE_MAPPING = 2,
+    YEPTRIS_NODE_ALIAS = 3,
+} YeptrisNodeKind;
+
+typedef enum {
+    YEPTRIS_STYLE_ANY = 0,
+    YEPTRIS_STYLE_PLAIN = 1,
+    YEPTRIS_STYLE_SINGLE_QUOTED = 2,
+    YEPTRIS_STYLE_DOUBLE_QUOTED = 3,
+    YEPTRIS_STYLE_LITERAL = 4,
+    YEPTRIS_STYLE_FOLDED = 5,
+} YeptrisScalarStyle;
+
+/* Releases the document and everything reachable from it (one call).
+ * Handles are invalid afterwards. NULL is accepted. */
+YEPTRIS_API void yeptris_document_free(YeptrisDocument doc);
+
+/* Number of documents in the parsed stream. */
+YEPTRIS_API size_t yeptris_document_count(YeptrisDocument doc);
+
+/* Root node of document i (0-based); NULL when out of range. */
+YEPTRIS_API YeptrisNode yeptris_document_root(YeptrisDocument doc, size_t index);
+
+YEPTRIS_API YeptrisNodeKind yeptris_node_kind(YeptrisNode node);
+
+/* Stable identity of the node within its document (bindings key
+ * wrapper caches on it; query handles are transient, ids are not).
+ * Only for equality — not an index into any public structure. */
+YEPTRIS_API uint32_t yeptris_node_id(YeptrisNode node);
+
+/* Scalar content / alias name. Returns NULL for collections.
+ * Memory: borrowed from the input (or document-owned when the value was
+ * folded/escaped) — valid until yeptris_document_free. */
+YEPTRIS_API const char* yeptris_node_value(YeptrisNode node, size_t* len);
+
+YEPTRIS_API YeptrisScalarStyle yeptris_node_style(YeptrisNode node);
+
+/* Node properties; empty (NULL, 0) when absent. */
+YEPTRIS_API const char* yeptris_node_tag(YeptrisNode node, size_t* len);
+YEPTRIS_API const char* yeptris_node_anchor(YeptrisNode node, size_t* len);
+
+/* Alias target node; NULL for non-aliases. */
+YEPTRIS_API YeptrisNode yeptris_node_alias_target(YeptrisNode node);
+
+/* Sequence entry count / entry i. */
+YEPTRIS_API size_t yeptris_node_seq_count(YeptrisNode node);
+YEPTRIS_API YeptrisNode yeptris_node_seq_at(YeptrisNode node, size_t index);
+
+/* Mapping pair count / value for a key (linear; interning lands with the
+ * full DOM item). The first matching key wins. */
+YEPTRIS_API size_t yeptris_node_map_count(YeptrisNode node);
+YEPTRIS_API YeptrisNode yeptris_node_map_get(YeptrisNode node, const char* key, size_t key_len);
+
+/* Ordered pair access: key and value of pair i (0-based). Returns 0
+ * and sets the out-params when the index is in range, -1 otherwise. */
+YEPTRIS_API int yeptris_node_map_at(YeptrisNode node, size_t index, YeptrisNode* key,
+                                    YeptrisNode* value);
+
+/* Bulk children drain — the O(n) iteration primitive (ruby #168: the
+ * per-index seq_at/map_at walks make an 80k-row sequence O(n^2)). One
+ * call walks the child list once and fills out[0..cap) with handles:
+ * sequence elements in order; mapping KEY,VALUE pairs interleaved.
+ * Returns the total child count (mapping pairs count twice); out==NULL
+ * or cap==0 returns the count without allocating handles. Handles come
+ * from the document's pool — document_free reclaims them. */
+YEPTRIS_API size_t yeptris_node_children(YeptrisNode node, YeptrisNode* out, size_t cap);
+
+/* ---- Construction (TODO.impl/11 phase 3) ----
+ *
+ * Build documents from scratch and mutate them; the emitter and every
+ * query API above work on synthesized documents unchanged. All values
+ * are COPIED into the document — nothing is borrowed from the caller.
+ * Nodes belong to exactly one parent (or one document root); a node
+ * already attached, a duplicate map key (add), cross-document links,
+ * and trees deeper than the nesting cap (YEPTRIS_ERROR_DEPTH) are
+ * rejected. Deletion unlinks but keeps arena lifetime: handles stay
+ * valid until yeptris_document_free. */
+
+/* An empty document with no input; build nodes and set the root. */
+YEPTRIS_API YeptrisDocument yeptris_document_new(void);
+
+/* Records a detached node as document i's root. */
+YEPTRIS_API int yeptris_document_set_root(YeptrisDocument doc, YeptrisNode root);
+
+YEPTRIS_API YeptrisNode yeptris_node_new_mapping(YeptrisDocument doc);
+YEPTRIS_API YeptrisNode yeptris_node_new_sequence(YeptrisDocument doc);
+
+/* Memory: value copied (document lifetime). Plain style types the copy
+ * through the schema resolver exactly like parse; quoted/block styles
+ * force string. */
+YEPTRIS_API YeptrisNode yeptris_node_new_scalar(YeptrisDocument doc, const char* value, size_t len,
+                                                YeptrisScalarStyle style);
+
+/* YEPTRIS_OK, or ERROR_ARG (cross-document/detached misuse),
+ * ERROR_MEMORY, ERROR_DEPTH, ERROR_PARSE (duplicate key). */
+YEPTRIS_API int yeptris_node_map_add(YeptrisNode map, const char* key, size_t key_len,
+                                     YeptrisNode value);
+
+/* Replace-or-add: an existing key keeps its position and swaps the
+ * value; a new key appends. */
+YEPTRIS_API int yeptris_node_map_set(YeptrisNode map, const char* key, size_t key_len,
+                                     YeptrisNode value);
+
+YEPTRIS_API int yeptris_node_seq_add(YeptrisNode seq, YeptrisNode value);
+YEPTRIS_API int yeptris_node_seq_del(YeptrisNode seq, size_t index);
+
+/* Replace the entry at index (same position kept). */
+YEPTRIS_API int yeptris_node_seq_set(YeptrisNode seq, size_t index, YeptrisNode value);
+YEPTRIS_API int yeptris_node_map_del(YeptrisNode map, const char* key, size_t key_len);
+
+/* ---- bulk build (TODO.impl/15 phase D: the dump-side mirror of the
+ * recorder's bulk drain — ONE call builds a whole document, so
+ * bindings never pay per-node FFI) ------------------------------------- */
+
+typedef enum {
+    YEPTRIS_BUILD_SCALAR = 1, /* push a scalar (value bytes in the blob) */
+    YEPTRIS_BUILD_SEQ = 2,    /* open a sequence */
+    YEPTRIS_BUILD_MAP = 3,    /* open a mapping */
+    YEPTRIS_BUILD_END = 4,    /* close the innermost open container */
+    YEPTRIS_BUILD_TAG = 5,    /* tag the last-placed node (tag bytes in
+                               * the blob) — #300: nil mapping keys need
+                               * Psych's explicit `!` tag */
+} YeptrisBuildOp;
+
+/* 12 bytes, ABI-pinned: op, style (scalar: YeptrisScalarStyle;
+ * ignored for containers), reserved, then the value slice. */
+typedef struct {
+    uint8_t op;
+    uint8_t style;
+    uint16_t reserved;
+    uint32_t off;
+    uint32_t len;
+} YeptrisBuildEntry;
+#if defined(__cplusplus)
+static_assert(sizeof(YeptrisBuildEntry) == 12, "build entry layout pinned");
+#else
+_Static_assert(sizeof(YeptrisBuildEntry) == 12, "build entry layout pinned");
+#endif
+
+/* Walks the entries in order — the same document-order grammar as the
+ * event stream: scalars link into the innermost open container (in a
+ * mapping, entries alternate key/value), SEQ/MAP open a child
+ * container, END closes it; after the last entry exactly one root
+ * must remain open-free and becomes the document root. Scalars copy
+ * their bytes from the blob (nothing is borrowed). Duplicate keys
+ * keep the LAST value, exactly as the parser accepts them (host
+ * mappings cannot produce one; the check would cost O(n^2) on wide
+ * maps). Returns YEPTRIS_OK, ERROR_ARG (NULL inputs),
+ * ERROR_PARSE (imbalanced walk: END on an empty stack, entries after
+ * the root closed, an unclosed container, a dangling key, a bad op
+ * or out-of-range slice), ERROR_DEPTH, or ERROR_MEMORY. */
+YEPTRIS_API YeptrisStatus yeptris_document_build(YeptrisDocument doc,
+                                                 const YeptrisBuildEntry* entries, size_t count,
+                                                 const char* blob, size_t blob_len);
+
+/* Appends a pre-built key node (duplicate rejected). */
+YEPTRIS_API int yeptris_node_map_add_node(YeptrisNode map, YeptrisNode key, YeptrisNode value);
+
+/* Props on synthesized nodes (copied in). An alias node carries its
+ * display name and resolves to `target` for queries/serialization. */
+YEPTRIS_API int yeptris_node_set_anchor(YeptrisNode node, const char* name, size_t len);
+YEPTRIS_API int yeptris_node_set_tag(YeptrisNode node, const char* tag, size_t len);
+YEPTRIS_API YeptrisNode yeptris_node_new_alias(YeptrisDocument doc, YeptrisNode target,
+                                               const char* name, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_DOM_PUBLIC_H */

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

@@ -0,0 +1,81 @@
+/* emit.h — serialization (TODO.impl/13).
+ *
+ * One writer engine serves DOM walks and (with 13C) event streams;
+ * sizing runs the SAME engine dry, so the size query and the write
+ * agree by construction — zero reallocations after the reserve.
+ *
+ * Roundtrip fidelity: re-serializing a parsed document re-emits its
+ * recorded scalar styles (a plain stays plain where safe, quoted stays
+ * quoted, block scalars stay block). Byte stability:
+ * serialize(parse(serialize(x))) == serialize(x) — gated by the
+ * corpus roundtrip test.
+ */
+#ifndef YEPTRIS_EMIT_H
+#define YEPTRIS_EMIT_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Emission options (13B). Versioned by size: initialize with
+ * {sizeof(yeptris_emit_options)} so future fields stay optional. */
+typedef struct yeptris_emit_options {
+    uint32_t size;          /* sizeof(yeptris_emit_options) */
+    int canonical;          /* fixed form: flow collections, quoted strings,
+                             * typed words, shortest floats; a parse of the
+                             * output re-serializes byte-identically */
+    int best_width;         /* 0 = library default (80): flow collections
+                             * wrap after a value when the current line
+                             * exceeds the width (13B) */
+    int explicit_doc_start; /* nonzero: every document carries the
+                             * leading --- marker (Psych/libyaml's
+                             * implicit=false parity). Default 0: a
+                             * single document is emitted bare. Only
+                             * read when the caller's struct is large
+                             * enough (size-versioned). */
+} yeptris_emit_options;
+
+/* Options-aware entries; opts == NULL selects the fidelity mode
+ * (recorded styles re-emitted). Same contracts as below. */
+YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument doc, const yeptris_emit_options* opts,
+                                             char* buf, size_t cap);
+YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument doc, const yeptris_emit_options* opts,
+                                       size_t* len);
+
+/* Serializes the document set. buf == NULL: returns the exact byte
+ * count needed and writes nothing. Otherwise writes at most cap bytes
+ * (NUL-terminated when cap allows) and returns the count written;
+ * when cap is too small nothing is written and the needed size is
+ * returned. Returns 0 on a NULL document. */
+YEPTRIS_API size_t yeptris_serialize_into(YeptrisDocument doc, char* buf, size_t cap);
+
+/* Streaming emission (13C): bytes are delivered in chunks to sink as
+ * the walk proceeds — memory bounded by the largest scalar, never the
+ * document. Returns the total byte count, or 0 on a NULL argument or
+ * when the sink aborts (nonzero return aborts the walk). */
+typedef int (*yeptris_emit_sink)(void* ctx, const char* bytes, size_t len);
+YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument doc, const yeptris_emit_options* opts,
+                                            yeptris_emit_sink sink, void* ctx);
+
+/* Convenience: serializes into a malloc'd buffer (caller frees).
+ * Returns NULL on allocation failure or a NULL document; *len (may be
+ * NULL) receives the byte count. The buffer is NUL-terminated. */
+YEPTRIS_API char* yeptris_serialize(YeptrisDocument doc, size_t* len);
+
+/* Frees a buffer the library returned (the serialize* family's
+ * "caller frees" contract). The buffer was allocated by THIS
+ * library's allocator — freeing it with the host's free is
+ * wrong-CRT on Windows (the #318 mingw lesson). NULL is a no-op. */
+YEPTRIS_API void yeptris_free(void* p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_EMIT_H */

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

@@ -0,0 +1,41 @@
+/* error.h — public status codes.
+ *
+ * Public entry points write only these codes (the internal error channel —
+ * thread-local + per-document messages with line/column — lands with
+ * TODO.impl/02). Enum values are ABI: bindings hard-code them and the ABI
+ * pinning test (test/unit/test_abi.cpp) fails if one shifts without a major
+ * version bump.
+ */
+#include <stdint.h>
+
+#ifndef YEPTRIS_ERROR_H
+#define YEPTRIS_ERROR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEPTRIS_OK = 0,                /* success */
+    YEPTRIS_ERROR_PARSE = 1,       /* malformed YAML (details + line/col via the error channel) */
+    YEPTRIS_ERROR_MEMORY = 2,      /* allocation failure; document remains freeable */
+    YEPTRIS_ERROR_DEPTH = 3,       /* nesting exceeds max_depth (default 1000) */
+    YEPTRIS_ERROR_ENCODING = 4,    /* invalid input encoding / ill-formed UTF-8 */
+    YEPTRIS_ERROR_IO = 5,          /* caller-supplied I/O failure */
+    YEPTRIS_ERROR_ARG = 6,         /* invalid argument (NULL handle, bad option) */
+    YEPTRIS_ERROR_UNSUPPORTED = 7, /* requested feature not built in */
+    YEPTRIS_ERROR_INTERNAL = 8,    /* invariant violation — a bug, please report */
+    YEPTRIS_ERROR_SCHEMA = 9, /* descriptor materialization: a REQUIRED node missing (issue #238) */
+} YeptrisStatus;
+
+/* Message of the most recent failure on the calling thread, with its
+ * 1-based line/column (0 = unknown). Returns "" when the last operation
+ * succeeded. Memory: thread-local static storage; valid until the next
+ * library call on this thread. */
+YEPTRIS_API const char* yeptris_last_error(uint32_t* line, uint32_t* col);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_ERROR_H */

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

@@ -0,0 +1,157 @@
+/* events.h — the four consumption models over one engine (TODO.impl/12).
+ *
+ * push:     one callback per event (C users; ~1 µs/event through FFI —
+ *           bindings prefer the recorder's bulk drain).
+ * pull:     StAX-style cursor; zero C->host dispatch; event strings are
+ *           owned by the puller and valid UNTIL THE NEXT CALL.
+ * recorder: fixed-size records + one string arena; bulk drain, O(chunks)
+ *           host crossings. v1 buffers input until the final chunk; the
+ *           streaming feed (mid-document resumption) lands with
+ *           parse/feed.c and keeps this shape.
+ * iterparse: document-at-a-time over multi-document streams; one
+ *           document's events per call, memory bounded by the largest
+ *           document. Events valid UNTIL THE NEXT CALL.
+ *
+ * All four are sinks over the single parse engine: identical event
+ * streams, proven by the cross-model corpus check (test_events_cross).
+ */
+#ifndef YEPTRIS_EVENTS_H
+#define YEPTRIS_EVENTS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>   /* YeptrisStatus */
+#include <yeptris/resolve.h> /* YeptrisSchema */
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Event types (ABI-pinned order; mirrors the internal engine 1:1). */
+typedef enum {
+    YEPTRIS_EV_STREAM_START = 1,
+    YEPTRIS_EV_STREAM_END,
+    YEPTRIS_EV_DOCUMENT_START,
+    YEPTRIS_EV_DOCUMENT_END,
+    YEPTRIS_EV_SEQUENCE_START,
+    YEPTRIS_EV_SEQUENCE_END,
+    YEPTRIS_EV_MAPPING_START,
+    YEPTRIS_EV_MAPPING_END,
+    YEPTRIS_EV_SCALAR,
+    YEPTRIS_EV_ALIAS,
+} YeptrisEventType;
+
+/* Flag bits in YeptrisEventRecord.flags. */
+enum {
+    YEPTRIS_EF_FLOW = 1u << 0,     /* collection in flow style */
+    YEPTRIS_EF_EXPLICIT = 1u << 1, /* document with --- / ... marker */
+    YEPTRIS_EF_IMPLICIT = 1u << 2, /* plain scalar, no tag */
+};
+
+/* One event, string fields pointing into the owning model's storage. */
+typedef struct {
+    YeptrisEventType type;
+    int style;           /* YeptrisScalarStyle (dom.h) for scalars */
+    int flow;            /* collection: flow style */
+    int explicit_marker; /* document: --- / ... seen */
+    int implicit;        /* scalar: plain and untagged */
+    const char* value;   /* scalar content or alias name; NULL if empty */
+    size_t value_len;
+    const char* anchor; /* node property; NULL when absent */
+    size_t anchor_len;
+    const char* tag; /* resolved tag; NULL when absent */
+    size_t tag_len;
+    uint32_t line; /* 1-based node start */
+    uint32_t col;
+} YeptrisEvent;
+
+/* ---- push ------------------------------------------------------------- */
+
+/* Returns nonzero from the callback to abort the parse (surfaced as
+ * YEPTRIS_ERROR_PARSE with the last-error channel set). Event strings
+ * are valid only during the call. */
+typedef int (*yeptris_event_fn)(void* ctx, const YeptrisEvent* ev);
+
+YEPTRIS_API YeptrisStatus yeptris_push_parse(const char* buf, size_t len, yeptris_event_fn on_event,
+                                             void* ctx);
+
+/* ---- pull ------------------------------------------------------------- */
+
+YEPTRIS_API YeptrisPullParser yeptris_pull_new(const char* buf, size_t len);
+
+/* Next event (owned by the puller, valid until the next call), or
+ * NULL at stream end or on error — distinguish with yeptris_pull_status. */
+YEPTRIS_API const YeptrisEvent* yeptris_pull_next(YeptrisPullParser pull);
+
+/* Bulk cursor (the FFI shape): up to max events per call, strings in
+ * the puller's arena valid until the next pull call. Returns count. */
+YEPTRIS_API size_t yeptris_pull_next_batch(YeptrisPullParser pull, YeptrisEvent* out, size_t max);
+
+YEPTRIS_API YeptrisStatus yeptris_pull_status(const YeptrisPullParser pull, uint32_t* line,
+                                              uint32_t* col);
+YEPTRIS_API void yeptris_pull_free(YeptrisPullParser pull);
+
+/* ---- recorder --------------------------------------------------------- */
+
+/* Fixed-size record; strings slice the arena by offset+length. */
+typedef struct {
+    uint8_t type; /* YeptrisEventType */
+    uint8_t style;
+    uint8_t flags;  /* YEPTRIS_EF_* */
+    uint8_t tag_id; /* resolved implicit tag (YeptrisTagId, resolve.h) —
+                     * the typing SSOT, so hosts never re-scan. Uses the
+                     * struct's pad byte: sizeof stays 36 (ABI-pinned) */
+    uint32_t line;
+    uint32_t col;
+    uint32_t value_off;
+    uint32_t value_len;
+    uint32_t anchor_off;
+    uint32_t anchor_len;
+    uint32_t tag_off;
+    uint32_t tag_len;
+} YeptrisEventRecord;
+
+YEPTRIS_API YeptrisRecorder yeptris_recorder_new(void);
+
+/* Same, with the implicit-typing schema for the parse (bindings pass
+ * compat_11 to reproduce Psych's typing). */
+YEPTRIS_API YeptrisRecorder yeptris_recorder_new_ex(YeptrisSchema schema);
+
+/* Accumulates input; the parse advances whenever a complete document
+ * has arrived (its closing --- / ... marker line), and final != 0
+ * flushes the trailing document. Each feed's records — fixed-size
+ * array plus the arena — hold the documents closed by that chunk and
+ * are valid until the next feed: drain per chunk. Returns
+ * YEPTRIS_OK, YEPTRIS_ERROR_PARSE (terminal; drain what this feed
+ * recorded) or YEPTRIS_ERROR_ARG. */
+YEPTRIS_API YeptrisStatus yeptris_recorder_feed(YeptrisRecorder rec, const char* chunk, size_t len,
+                                                int final);
+
+/* Bulk accessors: the record array and the string arena. Valid until
+ * the next feed; reset at every feed entry (drain per chunk). */
+YEPTRIS_API const YeptrisEventRecord* yeptris_recorder_records(YeptrisRecorder rec, size_t* count);
+YEPTRIS_API const char* yeptris_recorder_arena(YeptrisRecorder rec, size_t* len);
+YEPTRIS_API void yeptris_recorder_free(YeptrisRecorder rec);
+
+/* ---- iterparse -------------------------------------------------------- */
+
+YEPTRIS_API YeptrisIterparse yeptris_iterparse_new(const char* buf, size_t len);
+
+/* The next document's events (owned by the iterator, valid until the
+ * next call): *count events, or NULL when the stream is exhausted.
+ * STREAM_START / STREAM_END frame the stream exactly once each; the
+ * DOCUMENT_* pair frames each yielded slice. */
+YEPTRIS_API const YeptrisEvent* yeptris_iterparse_next(YeptrisIterparse it, size_t* count);
+
+YEPTRIS_API YeptrisStatus yeptris_iterparse_status(const YeptrisIterparse it, uint32_t* line,
+                                                   uint32_t* col);
+YEPTRIS_API void yeptris_iterparse_free(YeptrisIterparse it);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_EVENTS_H */

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

@@ -0,0 +1,45 @@
+/* json.h — strict JSON mode (TODO.impl/08C/21).
+ *
+ * YAML 1.2 strictly contains JSON, but users of json-c-shaped APIs
+ * want RFC 8259 semantics exactly: this entry validates the whole
+ * input against the strict grammar (scan/json.c is the one truth)
+ * before the engine runs, so an accepted input is guaranteed to be
+ * pure JSON and every invalid one fails with the violation offset.
+ * Charset note: JSON strings allow DEL and forbid raw C0 — the
+ * opposite corner of YAML c-printable — so this path validates
+ * UTF-8 well-formedness only, never the printable set.
+ */
+#ifndef YEPTRIS_JSON_H
+#define YEPTRIS_JSON_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/parse.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Parses one strict-JSON document. Same contract as yeptris_parse:
+ * a YeptrisDocument handle (queries via the DOM API) or NULL with
+ * *st set; violations carry the byte offset via yeptris_last_error. */
+YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* data, size_t len, YeptrisStatus* st);
+
+/* Serializes the document's FIRST document as strict JSON (flow
+ * collections, JSON escapes, shortest floats, null/true/false words).
+ * Returns a malloc'd NUL-terminated buffer (caller frees) with *len
+ * (may be NULL) set, or NULL on a NULL document / allocation
+ * failure / zero documents. */
+YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument doc, size_t* len);
+
+/* The compact variant: no padding spaces (JSON.generate's shape);
+ * compact == 0 is byte-identical to yeptris_serialize_json. */
+YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument doc, size_t* len, int compact);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_JSON_H */