leptris 1.9.201.4-arm-linux → 1.9.204.0-arm-linux

data/vendor-src/libleptris/src/CMakeLists.txt

@@ -156,8 +156,51 @@ if(LEPTRIS_AMALGAMATED)
 
     # Append #include for every source. Paths are relative to src/ so the
     # file's own #include directives resolve identically to the per-file build.
+    #
+    # Static helpers with the same name in different TUs collide once
+    # everything is one TU (#1217). The generator renames those tokens
+    # per file via #define around the #include — the source files stay
+    # untouched. A new collision surfaces as a conflicting-types error
+    # in the amalgamated CI job; add a line here.
+    set(_amalg_renames
+        "leptris/xpath/functions_exslt.c:arg_number=exslt_arg_number"
+        "leptris/xpath/functions_exslt.c:arg_string=exslt_arg_string"
+        "leptris/common/format_number.c:parse_pattern=fmt_num_parse_pattern"
+        "leptris/sax/iterparse.c:set_error=iterparse_set_error"
+        "leptris/xpath/vm.c:xpath_context_document=vm_xpath_context_document"
+        "leptris/xpath/xpath_public.c:xslt_register_ufn_handlers=xslt_register_ufn_handlers_impl"
+        "leptris/xslt/xslt_functions.c:xslt_register_ufn_handlers=xslt_register_ufn_handlers_impl"
+        "leptris/xslt/xslt_exec.c:utf8_encode=xslt_utf8_encode"
+        "leptris/xslt/xslt_exec.c:ws_only=xslt_ws_only"
+        "leptris/rng/validate.c:match_seq=rng_match_seq"
+        "leptris/sax/pull.c:cb_start_document=pull_cb_start_document"
+        "leptris/sax/pull.c:cb_end_document=pull_cb_end_document"
+        "leptris/sax/pull.c:cb_start_element=pull_cb_start_element"
+        "leptris/sax/pull.c:cb_end_element=pull_cb_end_element"
+        "leptris/sax/pull.c:cb_characters=pull_cb_characters"
+        "leptris/sax/pull.c:cb_comment=pull_cb_comment"
+        "leptris/sax/pull.c:cb_cdata=pull_cb_cdata"
+        "leptris/sax/pull.c:cb_pi=pull_cb_pi"
+        "leptris/sax/pull.c:cb_start_prefix=pull_cb_start_prefix"
+        "leptris/sax/pull.c:cb_end_prefix=pull_cb_end_prefix"
+        "leptris/sax/pull.c:cb_error=pull_cb_error"
+    )
     foreach(_src ${LEPTRIS_SOURCES})
-        file(APPEND "${LEPTRIS_AMALGAMATED_C}" "#include \"${_src}\"\n")
+        set(_amalg_defs "")
+        set(_amalg_undefs "")
+        foreach(_r ${_amalg_renames})
+            string(REPLACE ":" ";" _rr "${_r}")
+            string(REPLACE "=" ";" _rr "${_rr}")
+            list(GET _rr 0 _rfile)
+            list(GET _rr 1 _rold)
+            list(GET _rr 2 _rnew)
+            if(_rfile STREQUAL _src)
+                string(APPEND _amalg_defs "#define ${_rold} ${_rnew}\n")
+                string(APPEND _amalg_undefs "#undef ${_rold}\n")
+            endif()
+        endforeach()
+        file(APPEND "${LEPTRIS_AMALGAMATED_C}"
+             "${_amalg_defs}#include \"${_src}\"\n${_amalg_undefs}\n")
     endforeach()
 
     # Replace the source list with the amalgamated file so the object

data/vendor-src/libleptris/src/include/leptris/descriptor.h

@@ -31,7 +31,13 @@
 #ifdef _WIN32
 #define LEPTRIS_API
 #else
-#define LEPTRIS_API __attribute__((visibility("default")))
+/* Mirrors leptris.h (GCC LTO externalization, #1204). */
+#if defined(__GNUC__) && !defined(__clang__)
+#define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                    externally_visible))
+#else
+#define LEPTRIS_API __attribute__((visibility("default"), used))
+#endif
 #endif
 #endif
 

data/vendor-src/libleptris/src/include/leptris/dom/document.h

@@ -32,7 +32,13 @@ extern "C" {
 #      define LEPTRIS_API
 #    endif
 #  else
-#    define LEPTRIS_API __attribute__((visibility("default")))
+     /* Mirrors leptris.h (GCC LTO externalization, #1204). */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
 #  endif
 #endif
 

data/vendor-src/libleptris/src/include/leptris/dom/element.h

@@ -32,7 +32,13 @@ extern "C" {
 #      define LEPTRIS_API
 #    endif
 #  else
-#    define LEPTRIS_API __attribute__((visibility("default")))
+     /* Mirrors leptris.h (GCC LTO externalization, #1204). */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
 #  endif
 #endif
 

data/vendor-src/libleptris/src/include/leptris/dom/serialize.h

@@ -31,7 +31,13 @@ extern "C" {
 #      define LEPTRIS_API
 #    endif
 #  else
-#    define LEPTRIS_API __attribute__((visibility("default")))
+     /* Mirrors leptris.h (GCC LTO externalization, #1204). */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
 #  endif
 #endif
 

data/vendor-src/libleptris/src/include/leptris/dtd.h

@@ -10,6 +10,39 @@
 
 #include <stddef.h>
 
+/* Export macro: mirrors leptris.h/sax.h so dtd.h is includable
+ * standalone (bindings include sub-headers directly). See TODO 80. */
+/* Export macro.  Defined fully in leptris.h; sax.h allows standalone
+ * inclusion (leptris.h is not required) so we mirror the same logic.
+ * See TODO 80 (visibility preset) and TODO 122 (SAX surface). */
+#ifndef LEPTRIS_API
+#  ifdef LEPTRIS_FOR_BINDGEN
+#    define LEPTRIS_API
+#  elif defined(_WIN32)
+#    ifdef LEPTRIS_BUILD_SHARED
+#      define LEPTRIS_API __declspec(dllexport)
+#    elif defined(LEPTRIS_BUILDING_DLL)
+       /* Mirrors leptris.h (issue #278): CMake defines
+        * LEPTRIS_BUILDING_DLL on the objects that build the DLL. */
+#      define LEPTRIS_API __declspec(dllexport)
+#    elif defined(LEPTRIS_USE_SHARED)
+#      define LEPTRIS_API __declspec(dllimport)
+#    else
+#      define LEPTRIS_API
+#    endif
+#  else
+     /* Mirrors leptris.h: GCC LTO needs externally_visible or it
+      * internalizes public symbols with no in-library caller
+      * (#1154/#1196/#1204 class). */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
+#  endif
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -57,7 +90,7 @@ typedef struct {
  *
  * Memory: Caller must free with leptris_dtd_free()
  */
-LeptrisDTD* leptris_dtd_parse(const char* dtd_content, size_t len);
+LEPTRIS_API LeptrisDTD* leptris_dtd_parse(const char* dtd_content, size_t len);
 
 /**
  * Get the document's DTD (the declarations parsed from the DOCTYPE
@@ -101,7 +134,7 @@ LEPTRIS_API LeptrisDTD* leptris_document_get_dtd(LeptrisDocument doc);
  *   leptris_dtd_parse_external_subset(dtd, buffer, len);
  *   int valid = leptris_dtd_validate(doc, dtd, &error);
  */
-int leptris_dtd_parse_external_subset(LeptrisDTD* dtd, const char* content,
+LEPTRIS_API int leptris_dtd_parse_external_subset(LeptrisDTD* dtd, const char* content,
                                       size_t len);
 
 /**
@@ -112,9 +145,12 @@ int leptris_dtd_parse_external_subset(LeptrisDTD* dtd, const char* content,
  * this loader for the resource named by the system id. Same pattern
  * as leptris_dtd_parse_external_subset: the library never does I/O.
  *
- * The loader returns a malloc'd (or calloc'd) buffer in *out_len
- * bytes, which the parser consumes and frees; return NULL for
- * "unavailable" (the reference is then skipped, leniently).
+ * The loader returns a buffer in *out_len bytes, which the parser
+ * consumes and frees through the engine's allocator; return NULL
+ * for "unavailable" (the reference is then skipped, leniently).
+ * FFI loaders MUST allocate the buffer with leptris_alloc_buffer
+ * (#1219) so allocator/CRT mismatches cannot corrupt the heap —
+ * in-process C loaders may keep using plain malloc.
  *
  * The loader is consulted when DTD CONTENT IS PARSED — register it
  * before leptris_dtd_parse_external_subset (or before parsing a
@@ -126,7 +162,7 @@ int leptris_dtd_parse_external_subset(LeptrisDTD* dtd, const char* content,
  * @param loader Callback (NULL clears it)
  * @param user_data Opaque pointer handed to the loader
  */
-void leptris_dtd_set_pe_loader(LeptrisDTD* dtd,
+LEPTRIS_API void leptris_dtd_set_pe_loader(LeptrisDTD* dtd,
                                char* (*loader)(void* user_data,
                                                const char* system_id,
                                                size_t* out_len),
@@ -153,14 +189,15 @@ void leptris_dtd_set_pe_loader(LeptrisDTD* dtd,
  *       leptris_dtd_error_free(&error);
  *   }
  */
-int leptris_dtd_validate(LeptrisDocument doc, LeptrisDTD* dtd, LeptrisDTDError* error);
+LEPTRIS_API int leptris_dtd_validate(LeptrisDocument doc, LeptrisDTD* dtd,
+                                        LeptrisDTDError* error);
 
 /**
  * Free DTD object
  *
  * @param dtd DTD to free (can be NULL)
  */
-void leptris_dtd_free(LeptrisDTD* dtd);
+LEPTRIS_API void leptris_dtd_free(LeptrisDTD* dtd);
 
 /**
  * Free DTD error
@@ -169,7 +206,7 @@ void leptris_dtd_free(LeptrisDTD* dtd);
  *
  * @param error Error to free (can be NULL)
  */
-void leptris_dtd_error_free(LeptrisDTDError* error);
+LEPTRIS_API void leptris_dtd_error_free(LeptrisDTDError* error);
 
 #ifdef __cplusplus
 }

data/vendor-src/libleptris/src/include/leptris/error.h

@@ -19,7 +19,13 @@
 #      define LEPTRIS_API __declspec(dllimport)
 #    endif
 #  else
-#    define LEPTRIS_API __attribute__((visibility("default")))
+     /* Mirrors leptris.h (GCC LTO externalization, #1204). */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
 #  endif
 #endif
 

data/vendor-src/libleptris/src/include/leptris/html.h

@@ -0,0 +1,79 @@
+#ifndef LEPTRIS_HTML_H
+#define LEPTRIS_HTML_H
+
+/* ============================================================================
+ * HTML parsing (issue #659) — the WHATWG-conformant engine plus the
+ * libxml2/Nokogiri-compatibility mode. Split out of leptris.h so the
+ * HTML surface is discoverable as a subsystem (TODO 99 convention:
+ * headers split by subsystem; bindings include sub-headers directly).
+ * ============================================================================ */
+
+#include <stddef.h>
+#include "types.h"
+
+/* Export macro: mirrors leptris.h/sax.h so html.h is includable
+ * standalone. See TODO 80 (visibility preset). */
+#ifndef LEPTRIS_API
+#  ifdef LEPTRIS_FOR_BINDGEN
+#    define LEPTRIS_API
+#  elif defined(_WIN32)
+#    ifdef LEPTRIS_BUILD_SHARED
+#      define LEPTRIS_API __declspec(dllexport)
+#    elif defined(LEPTRIS_BUILDING_DLL)
+#      define LEPTRIS_API __declspec(dllexport)
+#    elif defined(LEPTRIS_USE_SHARED)
+#      define LEPTRIS_API __declspec(dllimport)
+#    else
+#      define LEPTRIS_API
+#    endif
+#  else
+#    define LEPTRIS_API __attribute__((visibility("default")))
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Parse an HTML string into a document (issue #659)
+ *
+ * Tolerant HTML4/5 parse into the standard DOM: implied end tags
+ * (p/li/td/tr/th/dt/dd/option/...), void elements, raw-text
+ * <script>/<style>, minimized + unquoted attribute values,
+ * case-insensitive tag/attribute names, and the HTML named-entity
+ * table. Behaviors follow libxml2's HTMLparser as exposed by
+ * Nokogiri (fragment shape: no synthesized <html>/<head>/<body>,
+ * no implied <tbody>). Malformed input never fails the parse — it
+ * degrades to text; a document with no nodes at all is an error.
+ * The result serializes and queries (XPath/XSLT) like any
+ * libleptris document.
+ *
+ * @param html HTML input (must be valid UTF-8)
+ * @param length Length of input in bytes
+ * @param status Output status code (can be NULL)
+ * @return Document handle or NULL on error
+ *
+ * Memory: Caller must call leptris_document_free() when done
+ * Thread safety: Not thread-safe. One document per thread.
+ */
+LEPTRIS_API LeptrisDocument leptris_parse_html_string(const char* html,
+                                                      size_t length,
+                                                      LeptrisStatus* status);
+
+/* HTML4/libxml2-compatibility mode (#659): identical tolerant
+ * tokenizer and Nokogiri document shape, except leading
+ * script/style content stays in <body> (libxml2's shape —
+ * title/meta/link/base still lift into the implied head). Bindings
+ * that must match Nokogiri byte-for-byte pin this entry;
+ * leptris_parse_html_string is the WHATWG-conformant engine.
+ * Memory contract identical to leptris_parse_html_string. */
+LEPTRIS_API LeptrisDocument leptris_parse_html4_string(const char* html,
+                                                       size_t length,
+                                                       LeptrisStatus* status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LEPTRIS_HTML_H */

data/vendor-src/libleptris/src/include/leptris/sax/sax.h

@@ -31,7 +31,15 @@
 #      define LEPTRIS_API
 #    endif
 #  else
-#    define LEPTRIS_API __attribute__((visibility("default")))
+     /* Mirrors leptris.h: GCC LTO needs externally_visible or it
+      * internalizes public symbols with no in-library caller
+      * (#1154/#1196/#1204 class). */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
 #  endif
 #endif
 
@@ -293,6 +301,17 @@ LEPTRIS_API void leptris_sax_parser_free(LeptrisSAXParser* parser);
  */
 LEPTRIS_API int leptris_sax_parser_set_streaming(LeptrisSAXParser* parser, int streaming);
 
+/**
+ * Mark the input as one-shot: the whole document arrives in a
+ * single feed() and stays alive for the parser's lifetime. The
+ * tokenizer then uses in-place scans with single-copy name storage
+ * instead of the chunk-safe carry paths. No effect on correctness
+ * for any conforming caller; only enable when the input truly is
+ * one-shot (leptris_pull_new does this for its memory source).
+ */
+LEPTRIS_API void leptris_sax_parser_set_one_shot(LeptrisSAXParser* parser,
+                                                 int one_shot);
+
 /* ============================================================================
  * Pull (StAX-style) API — TODO.bindings/04, issue #510 Tier 2
  * ============================================================================ */

data/vendor-src/libleptris/src/include/leptris/xpath/xpath.h

@@ -31,7 +31,13 @@ extern "C" {
 #      define LEPTRIS_API
 #    endif
 #  else
-#    define LEPTRIS_API __attribute__((visibility("default")))
+     /* Mirrors leptris.h (GCC LTO externalization, #1204). */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
 #  endif
 #endif
 

data/vendor-src/libleptris/src/include/leptris.h

@@ -44,7 +44,17 @@ extern "C" {
 #      define LEPTRIS_API
 #    endif
 #  else
-#    define LEPTRIS_API __attribute__((visibility("default"), used))
+     /* GCC LTO internalizes even visibility("default") symbols with
+      * no in-library caller (#1154/#1196/#1204 class: the CLI under
+      * -flto, ppc64le shared builds). `externally_visible` is the
+      * GCC-side partner of `used`; clang accepts and ignores it, so
+      * it is scoped to GCC to keep -Wall clean elsewhere. */
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
 #  endif
 #endif
 #endif  /* LEPTRIS_FOR_BINDGEN */
@@ -793,42 +803,7 @@ LEPTRIS_API LeptrisStatus leptris_document_set_root(LeptrisDocument doc,
  */
 LEPTRIS_API LeptrisDocument leptris_parse_string(const char* xml, size_t length, LeptrisStatus* status);
 
-/**
- * Parse an HTML string into a document (issue #659)
- *
- * Tolerant HTML4/5 parse into the standard DOM: implied end tags
- * (p/li/td/tr/th/dt/dd/option/...), void elements, raw-text
- * <script>/<style>, minimized + unquoted attribute values,
- * case-insensitive tag/attribute names, and the HTML named-entity
- * table. Behaviors follow libxml2's HTMLparser as exposed by
- * Nokogiri (fragment shape: no synthesized <html>/<head>/<body>,
- * no implied <tbody>). Malformed input never fails the parse — it
- * degrades to text; a document with no nodes at all is an error.
- * The result serializes and queries (XPath/XSLT) like any
- * libleptris document.
- *
- * @param html HTML input (must be valid UTF-8)
- * @param length Length of input in bytes
- * @param status Output status code (can be NULL)
- * @return Document handle or NULL on error
- *
- * Memory: Caller must call leptris_document_free() when done
- * Thread safety: Not thread-safe. One document per thread.
- */
-LEPTRIS_API LeptrisDocument leptris_parse_html_string(const char* html,
-                                                      size_t length,
-                                                      LeptrisStatus* status);
-
-/* HTML4/libxml2-compatibility mode (#659): identical tolerant
- * tokenizer and Nokogiri document shape, except leading
- * script/style content stays in <body> (libxml2's shape —
- * title/meta/link/base still lift into the implied head). Bindings
- * that must match Nokogiri byte-for-byte pin this entry;
- * leptris_parse_html_string is the WHATWG-conformant engine.
- * Memory contract identical to leptris_parse_html_string. */
-LEPTRIS_API LeptrisDocument leptris_parse_html4_string(const char* html,
-                                                       size_t length,
-                                                       LeptrisStatus* status);
+#include "leptris/html.h"
 
 /* ---- RELAX NG (#878) ------------------------------------------------
  * Phase 1: parse a RELAX NG XML-syntax schema into the compiled
@@ -1092,6 +1067,18 @@ LEPTRIS_API LeptrisStatus leptris_document_set_encoding(
 LEPTRIS_API LeptrisStatus leptris_document_set_standalone(
     LeptrisDocument doc, int standalone);
 
+/**
+ * Un-set the XML declaration (#1229): the document stops being
+ * declaration-bearing and serialization emits none — exactly as if
+ * the input had none. Clears the version/encoding strings and the
+ * standalone marker. Idempotent.
+ *
+ * @param doc Document handle
+ * @return LEPTRIS_OK, or LEPTRIS_ERROR_NULL_ARG
+ */
+LEPTRIS_API LeptrisStatus leptris_document_clear_declaration(
+    LeptrisDocument doc);
+
 /**
  * Programmatic DOCTYPE (#1094): create and set the document's
  * DOCTYPE (root name + optional PUBLIC/SYSTEM external
@@ -1105,6 +1092,19 @@ LEPTRIS_API LeptrisDoctype leptris_document_set_doctype(
     LeptrisDocument doc, const char* name,
     const char* public_id, const char* system_id);
 
+/**
+ * Un-set the document's DOCTYPE (#1229). The LeptrisDoctype node
+ * stays pool-owned and readable until leptris_document_free; it
+ * simply leaves the document children chain and the serializer's
+ * view. leptris_document_internal_subset returns NULL afterwards.
+ *
+ * @param doc Document handle
+ * @return LEPTRIS_OK; LEPTRIS_ERROR_NOT_FOUND when no DOCTYPE is
+ *         set; LEPTRIS_ERROR_NULL_ARG for a NULL document.
+ */
+LEPTRIS_API LeptrisStatus leptris_document_remove_doctype(
+    LeptrisDocument doc);
+
 /**
  * Get the document's internal DTD subset — the DOCTYPE declaration
  * (TODO 148 Phase 2).
@@ -3537,6 +3537,28 @@ LEPTRIS_API leptris_allocation_function leptris_get_memory_allocation_function(v
  */
 LEPTRIS_API leptris_deallocation_function leptris_get_memory_deallocation_function(void);
 
+/**
+ * Allocate a buffer from the engine's heap (#1219).
+ *
+ * FFI callers that must hand the engine a buffer it later frees —
+ * notably DTD parameter-entity loaders (leptris_dtd_set_pe_loader)
+ * — allocate through this entry so allocator/CRT mismatches cannot
+ * corrupt the heap (the engine DLL may link a different CRT than
+ * the host language runtime). Routes through the custom allocator
+ * when one is installed (leptris_set_memory_management_functions),
+ * malloc otherwise; the engine releases loader buffers through the
+ * matching deallocation path.
+ *
+ * @param len Bytes to allocate
+ * @return Buffer from the engine's heap (release with
+ *         `leptris_free_string`), or NULL when len is 0 or the
+ *         allocation fails
+ *
+ * Memory: Caller-owned unless handed to the engine (PE-loader
+ *         buffers are consumed and freed by the parser).
+ */
+LEPTRIS_API char* leptris_alloc_buffer(size_t len);
+
 /* ============================================================================
  * Per-Document Allocator Hooks (TODO 74)
  *

data/vendor-src/libleptris/src/leptris/core.c

@@ -96,6 +96,14 @@ LEPTRIS_API leptris_deallocation_function leptris_get_memory_deallocation_functi
     return g_leptris_dealloc_function;
 }
 
+/* #1219: engine-heap buffer for FFI callers whose buffers the
+ * engine later frees (DTD PE loaders). The hook pair keeps the
+ * custom-allocator configuration symmetric. */
+LEPTRIS_API char* leptris_alloc_buffer(size_t len) {
+    if (len == 0) return NULL;
+    return (char*)leptris_alloc_hook(len);
+}
+
 LEPTRIS_API LeptrisStatus leptris_document_set_allocators(
     LeptrisDocument doc,
     leptris_allocation_function alloc,
@@ -199,3 +207,23 @@ LEPTRIS_API LeptrisStatus leptris_document_set_standalone(
     doc->had_declaration = 1;
     return LEPTRIS_OK;
 }
+
+/* #1229: the remove-half — back to as-if-the-input-had-none. The
+ * setters' malloc'd strings are released here (document_free checks
+ * for NULL), and the standalone marker returns to unset. */
+LEPTRIS_API LeptrisStatus leptris_document_clear_declaration(
+    struct leptris_document* doc) {
+    if (!doc) return LEPTRIS_ERROR_NULL_ARG;
+    if (doc->xml_version) {
+        leptris_free(doc->xml_version);
+        doc->xml_version = NULL;
+    }
+    if (doc->encoding) {
+        leptris_free(doc->encoding);
+        doc->encoding = NULL;
+    }
+    doc->standalone = -1;
+    doc->decl_encoding_verbatim = 0;
+    doc->had_declaration = 0;
+    return LEPTRIS_OK;
+}

data/vendor-src/libleptris/src/leptris/dom/doctype.c

@@ -74,6 +74,33 @@ LEPTRIS_API LeptrisDoctype leptris_document_set_doctype(
     return (LeptrisDoctype)dt;
 }
 
+/* #1229: the remove-half of set_doctype. The node is pool-owned, so
+ * it is unlinked (document children chain, when linked) — never
+ * freed; it stays readable until leptris_document_free. */
+LEPTRIS_API LeptrisStatus leptris_document_remove_doctype(
+    LeptrisDocument doc) {
+    if (!doc) return LEPTRIS_ERROR_NULL_ARG;
+    LeptrisDoctypeNode* dt = (LeptrisDoctypeNode*)doc->doctype;
+    if (!dt) return LEPTRIS_ERROR_NOT_FOUND;
+    LeptrisNode* prev = NULL;
+    for (LeptrisNode* c = (LeptrisNode*)doc->doc_children_head; c; ) {
+        LeptrisNode* next = leptris_node_get_next_sibling(c);
+        if (c == (LeptrisNode*)dt) {
+            if (prev)
+                leptris_node_set_next_sibling(prev, next);
+            else
+                doc->doc_children_head = next;
+            if (doc->doc_children_tail == c)
+                doc->doc_children_tail = prev;
+            break;
+        }
+        prev = c;
+        c = next;
+    }
+    doc->doctype = NULL;
+    return LEPTRIS_OK;
+}
+
 LEPTRIS_API const char* leptris_doctype_get_name(LeptrisDoctypeNode* doctype) {
     return doctype ? doctype->name : NULL;
 }

data/vendor-src/libleptris/src/leptris/dom/element.c

@@ -687,19 +687,50 @@ const char* leptris_element_lookup_namespace(LeptrisElement elem,
 }
 
 /* Children manipulation */
-void leptris_element_append_child_internal_doc(LeptrisElement elem, LeptrisNode* child,
-                                              struct leptris_document* doc);
+void leptris_element_append_child_hint_doc(LeptrisElement elem,
+                                           LeptrisNode* child,
+                                           struct leptris_document* doc,
+                                           LeptrisNode* hint);
 void leptris_element_append_child_internal(LeptrisElement elem, LeptrisNode* child) {
     if (!elem || !child) return;
-    leptris_element_append_child_internal_doc(elem, child,
-                                             leptris_element_get_document(elem));
+    leptris_element_append_child_hint_doc(elem, child,
+                                          leptris_element_get_document(elem),
+                                          NULL);
+}
+
+/* #1225: caller-supplied tail hint. The HTML builder tracks each
+ * open element's last child itself — the shared direct-mapped
+ * tail cache loses a persistent parent to an address collision
+ * every ~1KB of fresh pool allocations, and each eviction costs
+ * an O(children) walk (quadratic on table/text-heavy pages). The
+ * hint is validated (parent back-pointer + no next sibling) and
+ * silently ignored when stale — callers stay correct through the
+ * cache/walk fallback. */
+void leptris_element_append_child_tail(LeptrisElement elem,
+                                       LeptrisNode* child,
+                                       struct leptris_document* doc,
+                                       LeptrisNode* hint) {
+    if (!elem || !child) return;
+    if (hint &&
+        (leptris_node_parent_inline(hint) != (LeptrisElement)elem ||
+         leptris_node_get_next_sibling(hint) != NULL))
+        hint = NULL;
+    leptris_element_append_child_hint_doc(elem, child, doc, hint);
 }
 
-/* doc is the caller-resolved document (NULL for detached trees) —
- * the public mutation path resolves it once instead of paying the
- * root walk + map lookup on every append (TODO 195c). */
 void leptris_element_append_child_internal_doc(LeptrisElement elem, LeptrisNode* child,
                                               struct leptris_document* doc) {
+    leptris_element_append_child_hint_doc(elem, child, doc, NULL);
+}
+
+/* doc is the caller-resolved document (NULL for detached trees) —
+ * the public mutation path resolves it once instead of paying the
+ * root walk + map lookup on every append (TODO 195c). hint is a
+ * pre-validated last-child hint (NULL = none). */
+void leptris_element_append_child_hint_doc(LeptrisElement elem,
+                                           LeptrisNode* child,
+                                           struct leptris_document* doc,
+                                           LeptrisNode* hint) {
     if (!elem || !child) return;
 
     /* SAFETY: Verify node type field is valid before accessing it
@@ -746,6 +777,12 @@ void leptris_element_append_child_internal_doc(LeptrisElement elem, LeptrisNode*
             mut_tail = s->child;
     }
 
+    /* An empty child list must win over any cached tail: a NULL
+     * first_child with a non-NULL tail is a stale cache (or stale
+     * tail pointer), and appending through it splices the child
+     * onto a detached node while first_child stays NULL (#1220). */
+    int list_empty = (leptris_elem_first_child(elem) == NULL);
+
     /* For element children, set up linked list structure */
     if (child->type == LEPTRIS_NODE_TYPE_ELEMENT) {
         LeptrisElement child_elem = (LeptrisElement)child;
@@ -757,7 +794,11 @@ void leptris_element_append_child_internal_doc(LeptrisElement elem, LeptrisNode*
         /* Append to end of children list.
          * last_child may point to any node type (text/comment/etc.) so
          * we set its next_sibling via the type-dispatching setter. */
-        LeptrisNode* last_node = mut_tail ? mut_tail : leptris_elem_last_child(elem);
+        LeptrisNode* last_node =
+            list_empty ? NULL
+                       : (hint ? hint
+                               : (mut_tail ? mut_tail
+                                           : leptris_elem_last_child(elem)));
         if (last_node) {
             /* Lane 18 P3: sequential appends' tail is an element —
              * the offset store directly; the type-dispatching node
@@ -776,7 +817,11 @@ void leptris_element_append_child_internal_doc(LeptrisElement elem, LeptrisNode*
         elem->child_count++;
     } else {
         /* For non-element children (text, cdata, comment, pi), append to linked list */
-        LeptrisNode* last = mut_tail ? mut_tail : leptris_elem_last_child(elem);
+        LeptrisNode* last =
+            list_empty ? NULL
+                       : (hint ? hint
+                               : (mut_tail ? mut_tail
+                                           : leptris_elem_last_child(elem)));
         if (last) {
             leptris_node_set_next_sibling(last, (LeptrisNode*)child);
             leptris_elem_set_last_child(elem, (LeptrisNode*)child);