makiri 0.2.0 → 0.4.0

data/ext/makiri/glue/glue.h

@@ -8,11 +8,24 @@
 extern "C" {
 #endif
 
+/* A DOM node pointer of UNKNOWN representation - an HTML lxb_dom_node_t or an XML
+ * mkr_xml_node_t - as stored in a node wrapper or a NodeSet. It is an INCOMPLETE
+ * type on purpose: it cannot be dereferenced, and (unlike void*) it does not
+ * implicitly convert to a typed pointer, so reading a stored node AS a specific
+ * representation requires an explicit cast that the kind-checked accessors
+ * (mkr_html_node_unwrap / mkr_xml_node_unwrap) justify by the wrapper's TypedData type
+ * (or, for a NodeSet, by doc_is_xml). The stored pointer is only ever
+ * pointer-compared or cast through one of those accessors. */
+typedef struct mkr_raw_node mkr_raw_node_t;
+
 /* Wrapper for any DOM node except Document. The node memory is owned by the
- * document's Lexbor arena; we keep only the pointer plus a keepalive VALUE
- * reference to the Ruby Document so the arena outlives the wrapper. */
+ * document's arena (an HTML Lexbor arena or the XML node arena); we keep only the
+ * pointer plus a keepalive VALUE reference to the Ruby Document so the arena
+ * outlives the wrapper. The pointer is representation-opaque (mkr_raw_node_t):
+ * read it only through mkr_html_node_unwrap / mkr_xml_node_unwrap, which check the
+ * wrapper's representation (distinct TypedData types) before casting. */
 typedef struct {
-    lxb_dom_node_t *node;
+    mkr_raw_node_t *node;
     VALUE           document;
 } mkr_node_data_t;
 
@@ -31,14 +44,43 @@ extern const rb_data_type_t mkr_node_type;
 extern const rb_data_type_t mkr_doc_type;
 extern const rb_data_type_t mkr_node_set_type;
 
-/* Node bridge (glue/ruby_node.c). mkr_wrap_node returns the Document VALUE
+/* Node bridge (glue/ruby_node.c). mkr_wrap_html_node returns the Document VALUE
  * for the document node, Qnil for NULL, otherwise a freshly-wrapped Node. */
-VALUE           mkr_wrap_node(lxb_dom_node_t *node, VALUE document);
-lxb_dom_node_t *mkr_node_unwrap(VALUE rb_node);
+VALUE           mkr_wrap_html_node(lxb_dom_node_t *node, VALUE document);
 VALUE           mkr_node_document(VALUE rb_node);
 
+/* HTML and XML nodes are wrapped under DISTINCT TypedData types (both deriving
+ * from the shared base mkr_node_type), so a representation-specific accessor
+ * rejects the wrong kind via Ruby's type machinery. See ruby_node.c.
+ *   mkr_html_node_unwrap      -> lxb_dom_node_t* ; raises on an XML node/Document.
+ *   mkr_xml_node_unwrap-> mkr_xml_node_t* ; raises on an HTML node/Document (ruby_xml_node.c).
+ *   mkr_node_raw       -> void* ; kind-agnostic raw pointer for identity, or for a
+ *                         site where the kind is already guaranteed. Deref needs an
+ *                         explicit cast - never treat it as a typed pointer blindly.
+ *   mkr_node_id        -> uintptr_t ; node identity for ==/eql?/hash/pointer_id. */
+extern const rb_data_type_t mkr_html_node_type;
+extern const rb_data_type_t mkr_xml_node_type;
+lxb_dom_node_t *mkr_html_node_unwrap(VALUE rb_node);
+void           *mkr_node_raw(VALUE rb_node);
+uintptr_t       mkr_node_id(VALUE rb_node);
+
+/* Representation-neutral identity methods (ruby_node.c): depend only on
+ * mkr_node_id, so the HTML and XML NodeMethods modules bind ==/eql? to
+ * mkr_node_equals, hash to mkr_node_hash, and pointer_id to mkr_node_pointer_id -
+ * one implementation, not one per representation. */
+VALUE mkr_node_equals(VALUE self, VALUE other);
+VALUE mkr_node_pointer_id(VALUE self);
+VALUE mkr_node_hash(VALUE self);
+
+/* XML node bridge (glue/ruby_xml_node.c): wrap a custom XML node into the right
+ * Makiri::XML::* leaf (Qnil for NULL, the Document VALUE for the document node). */
+struct mkr_xml_node;
+VALUE mkr_wrap_xml_node(struct mkr_xml_node *node, VALUE document);
+/* XML node-pointer accessor; raises TypeError on an HTML node/Document. */
+struct mkr_xml_node *mkr_xml_node_unwrap(VALUE rb_node);
+
 /* Document bridge (glue/ruby_doc.c). */
-lxb_dom_document_t *mkr_doc_unwrap(VALUE rb_doc);
+lxb_dom_document_t *mkr_html_doc_unwrap(VALUE rb_doc);
 mkr_parsed_t       *mkr_doc_parsed(VALUE rb_doc);
 VALUE               mkr_wrap_document(mkr_parsed_t *parsed); /* GC takes ownership */
 
@@ -46,7 +88,7 @@ VALUE               mkr_wrap_document(mkr_parsed_t *parsed); /* GC takes ownersh
  * inner_html=/outer_html= so the UTF-8 sanitisation and import+template-fixup
  * are not duplicated.
  *
- * mkr_sanitize_html_input: decode rb_html for the fragment parser — *out / *out_len
+ * mkr_sanitize_html_input: decode rb_html for the fragment parser - *out / *out_len
  * are the bytes to parse, *owned a malloc'd buffer to free afterwards (NULL when
  * the input is used in place). Returns 0, or -1 on OOM (nothing allocated), so
  * the caller can release its parser before raising. See mkr_utf8_sanitize.
@@ -54,7 +96,7 @@ VALUE               mkr_wrap_document(mkr_parsed_t *parsed); /* GC takes ownersh
  * mkr_import_fragment_children: deep-import each child of `root` into `doc`, hand
  * it to `emit`, and fix up any <template> contents (which import_node omits).
  *
- * mkr_emit_append / mkr_emit_before: emit callbacks — append as last child of
+ * mkr_emit_append / mkr_emit_before: emit callbacks - append as last child of
  * `u`, or insert before the reference node `u`. */
 int  mkr_sanitize_html_input(VALUE html, const lxb_char_t **out, size_t *out_len,
                              lxb_char_t **owned);
@@ -69,9 +111,11 @@ void mkr_emit_before(lxb_dom_node_t *imported, void *u);
  * mkr_init_node. */
 VALUE mkr_node_clone_node(int argc, VALUE *argv, VALUE self);
 
-/* NodeSet bridge (glue/ruby_node_set.c). */
+/* NodeSet bridge (glue/ruby_node_set.c). mkr_raw_node_t (above): callers cast
+ * their typed node to it when pushing (forgetting the type is the safe, store
+ * direction); the single typed read-back lives in mkr_node_set_wrap. */
 VALUE mkr_node_set_new(VALUE document);
-void  mkr_node_set_push(VALUE rb_set, lxb_dom_node_t *node);
+void  mkr_node_set_push(VALUE rb_set, mkr_raw_node_t *node);
 
 #ifdef __cplusplus
 }

data/ext/makiri/glue/ruby_doc.c

@@ -1,6 +1,7 @@
 #include "glue.h"
 #include "../lexbor_compat/compat_internal.h" /* mkr_dom_preorder_next */
 #include "../core/mkr_core.h"
+#include "../xml/mkr_xml.h"   /* mkr_xml_doc_memsize for an XML-backed document */
 
 #include <lexbor/html/parser.h>
 #include <ruby/thread.h>
@@ -32,23 +33,47 @@ mkr_doc_free(void *ptr)
 static size_t
 mkr_doc_memsize(const void *ptr)
 {
-    /* The DOM arena size is not cheaply queryable; report the wrapper only. */
-    (void)ptr;
-    return sizeof(mkr_doc_data_t);
+    const mkr_doc_data_t *d = (const mkr_doc_data_t *)ptr;
+    size_t total = sizeof(mkr_doc_data_t);
+    /* The Lexbor (HTML) arena size is not cheaply queryable; report the wrapper
+     * only. The XML arena tracks its own byte total, so include it. */
+    if (d->parsed != NULL && mkr_parsed_kind(d->parsed) == MKR_DOC_XML) {
+        total += mkr_xml_doc_memsize(mkr_parsed_xml_doc(d->parsed));
+    }
+    return total;
 }
 
+/* Like nodes, HTML and XML Documents share the mkr_doc_data_t layout and GC
+ * functions but are wrapped under DISTINCT TypedData types (both deriving from
+ * the shared base mkr_doc_type), so mkr_html_doc_unwrap - which reinterprets the
+ * parsed document as a Lexbor lxb_html_document_t - RAISES TypeError on an XML
+ * Document via Ruby's type machinery, instead of relying on the (NDEBUG-erased)
+ * assert in mkr_parsed_html_doc. mkr_doc_type (base) is kept for the kind-agnostic
+ * accessors (mkr_doc_parsed, #errors) that legitimately accept either. */
 const rb_data_type_t mkr_doc_type = {
     "Makiri::Document",
     { mkr_doc_mark, mkr_doc_free, mkr_doc_memsize, },
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
 };
+static const rb_data_type_t mkr_html_doc_type = {
+    "Makiri::HTML::Document",
+    { mkr_doc_mark, mkr_doc_free, mkr_doc_memsize, },
+    &mkr_doc_type, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+static const rb_data_type_t mkr_xml_doc_type = {
+    "Makiri::XML::Document",
+    { mkr_doc_mark, mkr_doc_free, mkr_doc_memsize, },
+    &mkr_doc_type, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 lxb_dom_document_t *
-mkr_doc_unwrap(VALUE rb_doc)
+mkr_html_doc_unwrap(VALUE rb_doc)
 {
     mkr_doc_data_t *d;
-    TypedData_Get_Struct(rb_doc, mkr_doc_data_t, &mkr_doc_type, d);
-    return (lxb_dom_document_t *)d->parsed->doc;
+    /* mkr_html_doc_type rejects an XML Document at the type boundary (its type
+     * chain does not include mkr_html_doc_type). */
+    TypedData_Get_Struct(rb_doc, mkr_doc_data_t, &mkr_html_doc_type, d);
+    return (lxb_dom_document_t *)mkr_parsed_html_doc(d->parsed);
 }
 
 mkr_parsed_t *
@@ -59,13 +84,19 @@ mkr_doc_parsed(VALUE rb_doc)
     return d->parsed;
 }
 
-/* Wrap an owned mkr_parsed_t as a Makiri::Document. GC takes ownership of
- * +parsed+ (freed in dfree). Used to back a standalone DocumentFragment. */
+/* Wrap an owned mkr_parsed_t as a Document. GC takes ownership of +parsed+
+ * (freed in dfree). The Ruby leaf class is chosen by kind: a Lexbor-backed
+ * handle becomes Makiri::Document (HTML), an arena-backed one
+ * Makiri::XML::Document (§2.3). Used to back a parsed document or a standalone
+ * DocumentFragment. */
 VALUE
 mkr_wrap_document(mkr_parsed_t *parsed)
 {
+    int is_xml = (mkr_parsed_kind(parsed) == MKR_DOC_XML);
+    VALUE klass = is_xml ? mkr_cXmlDocument : mkr_cHtmlDocument;
     mkr_doc_data_t *d;
-    VALUE obj = TypedData_Make_Struct(mkr_cDocument, mkr_doc_data_t, &mkr_doc_type, d);
+    VALUE obj = TypedData_Make_Struct(klass, mkr_doc_data_t,
+                                      is_xml ? &mkr_xml_doc_type : &mkr_html_doc_type, d);
     d->parsed = parsed;
     d->errors = rb_ary_new();
     return obj;
@@ -95,7 +126,7 @@ mkr_resolve_fragment_context(lxb_dom_document_t *doc, VALUE context,
     }
 
     if (rb_obj_is_kind_of(context, mkr_cNode)) {
-        lxb_dom_node_t *cn = mkr_node_unwrap(context);
+        lxb_dom_node_t *cn = mkr_html_node_unwrap(context);   /* reject an XML node before lxb use */
         if (cn->type != LXB_DOM_NODE_TYPE_ELEMENT) {
             rb_raise(rb_eArgError, "fragment context node must be an element");
         }
@@ -109,10 +140,10 @@ mkr_resolve_fragment_context(lxb_dom_document_t *doc, VALUE context,
     mkr_ruby_borrowed_text_t cv = mkr_ruby_verified_text(context, "fragment context element");
     const lxb_char_t *p = (const lxb_char_t *)cv.ptr;
     size_t n = cv.len;
-    if (n == 3 && memcmp(p, "svg", 3) == 0) {
+    if (mkr_bytes_eq(p, n, "svg", 3)) {
         *out_tag = LXB_TAG_SVG;  *out_ns = LXB_NS_SVG;  return;
     }
-    if (n == 4 && memcmp(p, "math", 4) == 0) {
+    if (mkr_bytes_eq(p, n, "math", 4)) {
         *out_tag = LXB_TAG_MATH; *out_ns = LXB_NS_MATH; return;
     }
     lxb_tag_id_t tid = lxb_tag_id_by_name(doc->tags, p, n);
@@ -207,17 +238,45 @@ mkr_sanitize_html_input(VALUE html, const lxb_char_t **out, size_t *out_len,
     /* Browser-compatible decoding: invalid UTF-8 -> U+FFFD; valid input is used
      * in place (no copy, *owned == NULL). Returns -1 on OOM (nothing allocated)
      * so the caller can release its parser before raising. */
-    mkr_ruby_borrowed_bytes_t hv = mkr_ruby_bytes_view(html);
+    VALUE u8 = mkr_ruby_to_utf8(html); /* honour the input encoding (-> UTF-8) */
+    mkr_ruby_borrowed_bytes_t hv = mkr_ruby_bytes_view(u8);
+
+    if (u8 != html) {
+        /* Transcoded to UTF-8: a fresh String that nothing keeps alive past this
+         * return, so we must NOT borrow its bytes. It is already valid UTF-8, so
+         * copy it into an owned buffer (the caller frees *owned) - no sanitise. */
+        size_t n = (hv.len > 0) ? hv.len : 1;
+        char  *buf = mkr_reallocarray(NULL, n, 1);
+        if (buf == NULL) {
+            return -1;
+        }
+        if (hv.len > 0) {
+            memcpy(buf, hv.ptr, hv.len);
+        }
+        *owned   = (lxb_char_t *)buf;
+        *out     = (const lxb_char_t *)buf;
+        *out_len = hv.len;
+        RB_GC_GUARD(hv.value);
+        return 0;
+    }
+
+    /* Not transcoded (UTF-8 / US-ASCII / binary): input Ruby already knows is
+     * valid UTF-8 is borrowed in place (the caller keeps `html` alive);
+     * otherwise sanitise as before. */
+    if (mkr_ruby_str_known_valid_utf8(html)) {
+        *owned   = NULL;
+        *out     = (const lxb_char_t *)hv.ptr;
+        *out_len = hv.len;
+        return 0;
+    }
     lxb_char_t *clean = NULL;
     size_t      clean_len = 0;
     if (mkr_utf8_sanitize((const lxb_char_t *)hv.ptr, hv.len, &clean, &clean_len) != 0) {
-        RB_GC_GUARD(hv.value);
         return -1;
     }
     *owned   = clean;
     *out     = (clean != NULL) ? clean : (const lxb_char_t *)hv.ptr;
     *out_len = (clean != NULL) ? clean_len : hv.len;
-    RB_GC_GUARD(hv.value);
     return 0;
 }
 
@@ -249,7 +308,7 @@ mkr_import_fragment_children(lxb_dom_document_t *doc, lxb_dom_node_t *root,
 }
 
 /* Node#clone_node(deep = false): a shallow (or deep, with deep truthy) copy of
- * this node, owned by the same document and detached from any parent — the DOM
+ * this node, owned by the same document and detached from any parent - the DOM
  * cloneNode, whose `deep` defaults to false (a missing/nil/false argument =>
  * shallow). Built on the same import_node + <template>-content fixup the
  * fragment parser uses, so a deep-cloned <template> carries its contents (which
@@ -262,7 +321,7 @@ mkr_node_clone_node(int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01", &deep_v);
     bool deep = RTEST(deep_v);
 
-    lxb_dom_node_t *node = mkr_node_unwrap(self);
+    lxb_dom_node_t *node = mkr_html_node_unwrap(self);
     lxb_dom_document_t *doc = node->owner_document;
 
     lxb_dom_node_t *clone = lxb_dom_document_import_node(doc, node, deep);
@@ -272,11 +331,11 @@ mkr_node_clone_node(int argc, VALUE *argv, VALUE self)
     if (deep) {
         mkr_fixup_template_content(doc, node, clone);
     }
-    return mkr_wrap_node(clone, mkr_node_document(self));
+    return mkr_wrap_html_node(clone, mkr_node_document(self));
 }
 
 /* Document#import_node(node, deep = false): a shallow (or deep, with deep
- * truthy) copy of +node+ owned by THIS document — the DOM importNode, whose
+ * truthy) copy of +node+ owned by THIS document - the DOM importNode, whose
  * `deep` defaults to false (a missing/nil/false argument => shallow). Unlike
  * Node#clone_node, the copy is owned by the receiver rather than the node's own
  * document, so it is the way to bring a node across documents (Makiri never
@@ -290,8 +349,8 @@ mkr_doc_import_node(int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "11", &node_v, &deep_v);
     bool deep = RTEST(deep_v);
 
-    lxb_dom_node_t   *src = mkr_node_unwrap(node_v);
-    lxb_dom_document_t *doc = mkr_doc_unwrap(self);
+    lxb_dom_node_t   *src = mkr_html_node_unwrap(node_v);   /* reject an XML node before lxb use */
+    lxb_dom_document_t *doc = mkr_html_doc_unwrap(self);
 
     lxb_dom_node_t *imp = lxb_dom_document_import_node(doc, src, deep);
     if (imp == NULL) {
@@ -300,7 +359,7 @@ mkr_doc_import_node(int argc, VALUE *argv, VALUE self)
     if (deep) {
         mkr_fixup_template_content(doc, src, imp);
     }
-    return mkr_wrap_node(imp, self);
+    return mkr_wrap_html_node(imp, self);
 }
 
 /* Parse +rb_html+ as a fragment in the given (tag id, namespace) context and
@@ -315,7 +374,7 @@ mkr_build_fragment_ctx(VALUE document, VALUE rb_html,
                        lxb_tag_id_t ctx_tag, lxb_ns_id_t ctx_ns)
 {
     VALUE html = rb_String(rb_html);
-    lxb_dom_document_t *doc = mkr_doc_unwrap(document);
+    lxb_dom_document_t *doc = mkr_html_doc_unwrap(document);
 
     lxb_dom_document_fragment_t *frag = lxb_dom_document_fragment_interface_create(doc);
     if (frag == NULL) {
@@ -349,7 +408,7 @@ mkr_build_fragment_ctx(VALUE document, VALUE rb_html,
 
     lxb_html_parser_destroy(parser);
     RB_GC_GUARD(html);
-    return mkr_wrap_node(frag_node, document);
+    return mkr_wrap_html_node(frag_node, document);
 }
 
 /* document.fragment(html, context: ...) -> DocumentFragment bound to this
@@ -363,7 +422,7 @@ mkr_doc_fragment(int argc, VALUE *argv, VALUE self)
                                 : rb_hash_aref(opts, ID2SYM(rb_intern("context")));
     lxb_tag_id_t tag;
     lxb_ns_id_t  ns;
-    mkr_resolve_fragment_context(mkr_doc_unwrap(self), context, &tag, &ns);
+    mkr_resolve_fragment_context(mkr_html_doc_unwrap(self), context, &tag, &ns);
     return mkr_build_fragment_ctx(self, html, tag, ns);
 }
 
@@ -379,14 +438,14 @@ mkr_frag_s_parse(int argc, VALUE *argv, VALUE klass)
                                 : rb_hash_aref(opts, ID2SYM(rb_intern("context")));
 
     static const lxb_char_t shell[] = "<html><body></body></html>";
-    mkr_parsed_t *parsed = mkr_parse_html(shell, sizeof(shell) - 1);
+    mkr_parsed_t *parsed = mkr_parse_html(shell, sizeof(shell) - 1, true);
     if (parsed == NULL) {
         rb_raise(mkr_eError, "failed to create fragment document");
     }
     VALUE document = mkr_wrap_document(parsed); /* GC now owns parsed */
     lxb_tag_id_t tag;
     lxb_ns_id_t  ns;
-    mkr_resolve_fragment_context(mkr_doc_unwrap(document), context, &tag, &ns);
+    mkr_resolve_fragment_context(mkr_html_doc_unwrap(document), context, &tag, &ns);
     return mkr_build_fragment_ctx(document, html, tag, ns);
 }
 
@@ -396,7 +455,7 @@ mkr_frag_s_parse(int argc, VALUE *argv, VALUE klass)
 static VALUE
 mkr_node_parse(VALUE self, VALUE rb_html)
 {
-    lxb_dom_node_t *node = mkr_node_unwrap(self);
+    lxb_dom_node_t *node = mkr_html_node_unwrap(self);
     if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
         rb_raise(rb_eArgError, "Node#parse requires an element context");
     }
@@ -415,6 +474,7 @@ mkr_node_parse(VALUE self, VALUE rb_html)
 typedef struct {
     const lxb_char_t *src;
     size_t            len;
+    bool              assume_valid;
     mkr_parsed_t     *result;
 } mkr_parse_nogvl_t;
 
@@ -425,7 +485,7 @@ static void *
 mkr_parse_nogvl(void *p)
 {
     mkr_parse_nogvl_t *a = (mkr_parse_nogvl_t *)p;
-    a->result = mkr_parse_html(a->src, a->len);
+    a->result = mkr_parse_html(a->src, a->len, a->assume_valid);
     return NULL;
 }
 
@@ -440,26 +500,36 @@ static VALUE
 mkr_doc_s_parse(VALUE klass, VALUE rb_source)
 {
     StringValue(rb_source);
-
-    /* Allocate the wrapper first (with parsed == NULL) so that if parsing
-     * fails the GC-managed object frees cleanly. */
-    mkr_doc_data_t *d;
-    VALUE obj = TypedData_Make_Struct(klass, mkr_doc_data_t, &mkr_doc_type, d);
-    d->parsed = NULL;
-    d->errors = rb_ary_new();
-
-    /* Copy the source into a C buffer so the parse can run with the GVL
-     * released without racing GC/compaction on the Ruby String's backing
-     * store. The source is not retained past the parse (Lexbor copies what it
-     * needs into the arena and the line table is built up front), so the
-     * buffer is freed immediately after. */
+    /* Honour the input's encoding: UTF-8/US-ASCII/binary pass through (no
+     * degradation), anything else is transcoded to UTF-8 so its content is
+     * preserved rather than read as raw UTF-8 bytes. */
+    rb_source = mkr_ruby_to_utf8(rb_source);
+
+    /* Copy the source into a C buffer up front - BEFORE allocating the wrapper
+     * (a Ruby allocation, and thus a GC point) - so no GC can run between
+     * obtaining rb_source (possibly a fresh transcoded String) and copying its
+     * bytes, and the parse can then run with the GVL released without racing
+     * GC/compaction on the Ruby String's backing store. The source is not
+     * retained past the parse (Lexbor copies what it needs into the arena and
+     * the line table is built up front), so the buffer is freed immediately
+     * after. The coderange is read first (no scan): a source Ruby already knows
+     * is valid UTF-8 lets the parse skip its sanitisation scan. */
+    bool assume_valid = mkr_ruby_str_known_valid_utf8(rb_source);
     mkr_owned_bytes_t source = {0};
     if (mkr_ruby_copy_bytes(rb_source, &source) != 0) {
         rb_raise(mkr_eError, "out of memory copying source");
     }
-    RB_GC_GUARD(rb_source);
 
-    mkr_parse_nogvl_t args = { (const lxb_char_t *)source.ptr, source.len, NULL };
+    /* Allocate the wrapper (with parsed == NULL) so that if parsing fails the
+     * GC-managed object frees cleanly. This is the HTML parse entry (defined on
+     * Makiri::HTML::Document), so the result is always HTML. */
+    mkr_doc_data_t *d;
+    VALUE obj = TypedData_Make_Struct(klass, mkr_doc_data_t, &mkr_html_doc_type, d);
+    d->parsed = NULL;
+    d->errors = rb_ary_new();
+
+    mkr_parse_nogvl_t args = { (const lxb_char_t *)source.ptr, source.len,
+                               assume_valid, NULL };
     rb_thread_call_without_gvl(mkr_parse_nogvl, &args, NULL, NULL);
     mkr_owned_bytes_clear(&source);
 
@@ -479,8 +549,8 @@ mkr_doc_s_parse(VALUE klass, VALUE rb_source)
 static VALUE
 mkr_doc_root(VALUE self)
 {
-    lxb_dom_document_t *doc = mkr_doc_unwrap(self);
-    return mkr_wrap_node(lxb_dom_document_root(doc), self);
+    lxb_dom_document_t *doc = mkr_html_doc_unwrap(self);
+    return mkr_wrap_html_node(lxb_dom_document_root(doc), self);
 }
 
 /* Get the document <title>, or "" if absent. */
@@ -489,7 +559,7 @@ mkr_doc_title(VALUE self)
 {
     size_t len = 0;
     const lxb_char_t *str =
-        lxb_html_document_title((lxb_html_document_t *)mkr_doc_unwrap(self), &len);
+        lxb_html_document_title((lxb_html_document_t *)mkr_html_doc_unwrap(self), &len);
     return (str == NULL) ? rb_utf8_str_new("", 0)
                          : rb_utf8_str_new((const char *)str, len);
 }
@@ -500,10 +570,10 @@ mkr_doc_title(VALUE self)
 static VALUE
 mkr_doc_internal_subset(VALUE self)
 {
-    lxb_dom_node_t *doc = (lxb_dom_node_t *)mkr_doc_unwrap(self);
+    lxb_dom_node_t *doc = (lxb_dom_node_t *)mkr_html_doc_unwrap(self);
     for (lxb_dom_node_t *c = doc->first_child; c != NULL; c = c->next) {
         if (c->type == LXB_DOM_NODE_TYPE_DOCUMENT_TYPE) {
-            return mkr_wrap_node(c, self);
+            return mkr_wrap_html_node(c, self);
         }
     }
     return Qnil;
@@ -515,7 +585,7 @@ mkr_doc_internal_subset(VALUE self)
 static VALUE
 mkr_doc_quirks_mode(VALUE self)
 {
-    return INT2NUM((int)mkr_doc_unwrap(self)->compat_mode);
+    return INT2NUM((int)mkr_html_doc_unwrap(self)->compat_mode);
 }
 
 /* Parse warnings. Reserved; currently always empty. */
@@ -530,18 +600,18 @@ mkr_doc_errors(VALUE self)
 void
 mkr_init_document(void)
 {
-    rb_define_singleton_method(mkr_cDocument, "_parse", mkr_doc_s_parse, 1);
-    rb_define_method(mkr_cDocument, "root",     mkr_doc_root,     0);
-    rb_define_method(mkr_cDocument, "title",    mkr_doc_title,    0);
-    rb_define_method(mkr_cDocument, "errors",   mkr_doc_errors,   0);
-    rb_define_method(mkr_cDocument, "internal_subset", mkr_doc_internal_subset, 0);
-    rb_define_method(mkr_cDocument, "quirks_mode", mkr_doc_quirks_mode, 0);
-    rb_define_method(mkr_cDocument, "fragment", mkr_doc_fragment, -1);
-    rb_define_method(mkr_cDocument, "import_node", mkr_doc_import_node, -1);
+    rb_define_singleton_method(mkr_cHtmlDocument, "_parse", mkr_doc_s_parse, 1);
+    rb_define_method(mkr_cHtmlDocument, "root",     mkr_doc_root,     0);
+    rb_define_method(mkr_cHtmlDocument, "title",    mkr_doc_title,    0);
+    rb_define_method(mkr_cHtmlDocument, "errors",   mkr_doc_errors,   0);
+    rb_define_method(mkr_cHtmlDocument, "internal_subset", mkr_doc_internal_subset, 0);
+    rb_define_method(mkr_cHtmlDocument, "quirks_mode", mkr_doc_quirks_mode, 0);
+    rb_define_method(mkr_cHtmlDocument, "fragment", mkr_doc_fragment, -1);
+    rb_define_method(mkr_cHtmlDocument, "import_node", mkr_doc_import_node, -1);
 
     rb_define_singleton_method(mkr_cDocumentFragment, "parse", mkr_frag_s_parse, -1);
 
     /* Node#parse(html): fragment-parse in this element's context (Nokogiri
      * compatible). Defined here, next to the fragment machinery it reuses. */
-    rb_define_method(mkr_cNode, "parse", mkr_node_parse, 1);
+    rb_define_method(mkr_mHtmlNodeMethods, "parse", mkr_node_parse, 1);
 }