leptris 1.9.163.4 → 1.9.163.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 563c1898720e4a4830a4dd15aa33372ea54f9fe36f3f61f78f53783b29bda28d
-  data.tar.gz: fa70c8307df2f4ae2cc7db47206ce19088d59c41b4ca8372d3572b6778bc30e0
+  metadata.gz: fc446877d41a4725feaa4ac5a451398395c2b74888ecbe6b89bd15c07586c5b1
+  data.tar.gz: e86fb2e1ad7af3a32ca07f5fdb93936b88c2910d61618f4c5e3afb9fe8828a21
 SHA512:
-  metadata.gz: 2022e7e5b8490faa476bd04319351c90252507e910994d677bca98f51eb78c6346f56febcf248abb9dbcfaed54a4ec58b654ff40b674ea67d5b9283459fd910a
-  data.tar.gz: 3119ce57e8a1ce038c5aad76d72d5ce92cfb3a06a7416f2677fafb824233da229198b51a64b454da73e7d5d1aaa95aa6344755bf0069ae1cf518e6b65e021725
+  metadata.gz: 49705259500bd74522dbfbdd2f9703249eed074148f73d7207f430072e531194740232ba6caa27eb7e21d5a67a14f25a06b9fe5b82f1e10fb6b65e394c1f7c2a
+  data.tar.gz: fbea087c956ce35ba6e30f274db4c9db2f7b194e61e4f78633a9510fe85d6151c35f4758ade380d8a1397d261756fbd415d78b0587b628965b8ca82b9179af5f

data/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.163.5] - 2026-09-15
+
+### Changed
+
+- **C-bound mutations for the programmatic-build path (#204 asks
+  2-3)**: `Element#add_child` and `Element#[]=` dispatch to the
+  native layer when auto-enabled — one C entry runs the
+  readonly/liveness gates, the provable no-op namespace-lift
+  predicate, the version bump, and the engine write. Children
+  that DO need a namespace lift (resolved or declared namespaces)
+  fall back to the full Ruby path unchanged. Measured (shared
+  host, load 12-19): binding add_child on a fresh parent
+  1678ns -> 506ns; the ask-3 shape (create x2 + attach x2) went
+  from the 4.1us baseline to ~1.2-1.3us — at or past the raw
+  Nokogiri row (~1.5-1.6us).
+- **Native read floors (#204 ask 1)**: `NativeNode#[]` and
+  `NativeNode#content` now keep version-stamped memos (the same
+  invalidation discipline as binding memos, ADR 0003) — repeat
+  reads are two ivar reads and a compare, no C call, no string
+  mint; mutations through either surface drop them via the shared
+  document version.
+- **Adoption-lift guard ordering (#204 ask 3)**: the provable
+  no-op check moved ahead of the target's in-scope namespace
+  materialization at every mutation site (`add_child`,
+  `prepend_child`, sibling inserts, `root=`) — a fresh parent no
+  longer pays the namespace collection FFI round-trips per
+  attach. Non-element children skip the lift outright.
+- **Ivar-based document state in the native layer**: the C faces
+  read `@c_address`, `@wrapper_cache`/`@native_cache`, `@version`,
+  `@readonly` directly instead of rb_funcall dispatching
+  (`Document` maintains `@c_address` as the Integer twin of
+  `@c_ptr`, nil'ed on free); document create/mutate faces shed
+  ~300ns of method-dispatch overhead each.
+
+### Added
+
+- `Leptris::XML::Native.append_binding_child` /
+  `set_binding_attribute` module faces and
+  `Element.skip_adoption_lift?` (the provable no-op predicate,
+  public so specs can pin its exact semantics).
+- moxml gap-table rows (per-operation binding floors, build row)
+  in `benchmark/native_vs_binding.rb` (TODO.perf/11).
+
 ## [1.9.163.4] - 2026-09-15
 
 ### Fixed

data/TODO.perf/07-native-read-floor.md

@@ -0,0 +1,31 @@
+# 07 — Native read floor: shave the TypedData []/content dispatch (#204 ask 1)
+
+Status: DONE (1.9.163.5)
+
+moxml's 2x mandate: `NativeNode#[]` at 110ns needs <= ~70ns (their
+wrapper keeps ~24ns); `#content` 85ns needs <= 58ns. The budget
+dies in the C entry itself: TypedData fetch + StringValueCStr's
+embedded-NUL scan (memchr over the name) + rb_utf8_str_new_cstr
+(strlen + string mint). The string mint (~50ns) is irreducible
+(the C string must be copied into a Ruby String) — the shaves:
+
+- StringValueCStr -> StringValue + RSTRING_PTR for wire names we
+  control the mint of (attribute names cannot contain NULs);
+- single type-check fetch (RTYPEDDATA_DATA + one pointer compare
+  against nn_type instead of the generic check);
+- measure honestly: report how close to 70/58 each landed.
+
+## Outcome (1.9.163.5)
+
+Repeat reads no longer re-enter the C reader at all: NativeNode
+keeps a version-stamped single-slot memo (struct fields, pointer
+compare against the document's Fixnum version) plus a hash-memo
+second layer for other repeat names; content memoizes in one
+slot. `StringValueCStr` -> `StringValue`+`RSTRING_PTR` landed for
+attribute names. Measured (shared host, load 12-19, so treat as
+upper bounds; #204's table was load <6): `#content` 85 -> 42-55ns
+(budget 58 met), `#[]` 110 -> ~140ns under load — the remaining
+residue is the argument mint + TypedData fetch; a clean-load run
+of benchmark/native_vs_binding.rb's gap rows is the honest gate.
+`#name` 78 -> ~63-73ns. One-shot reads still pay the string mint
+(irreducible: the C string must be copied).

data/TODO.perf/08-version-coherent-native-mutations.md

@@ -0,0 +1,24 @@
+# 08 — Version-coherent native mutations (#204 ask 2)
+
+Status: DONE (1.9.163.5)
+
+The native builder factories (create_element/text/child, add_child,
+set_root) do not advance the binding Document's mutation version —
+a binding children read after a native attach serves the STALE
+memo. Fix in the ext: every mutating entry calls the document's
+advance_version (cached ID) after the C mutation, and the readonly
+gate before it. Mutations are cold relative to reads, so the two
+rb_funcall hops are fine. Gate: build via native factories, read
+via binding children/element_children — lists must agree.
+
+## Outcome (1.9.163.5)
+
+document_advance_version moved from two rb_funcall hops to direct
+ivar reads/writes (@readonly Qtrue check, @version Fixnum bump) —
+no method dispatch on the mutation path. Every NativeNode
+mutating entry (create_child, append_child/add_child, set_root)
+and the new C-bound binding faces (append_binding_child,
+set_binding_attribute) run the same gate: UseAfterFreeError via
+the nil @c_address twin, ReadOnlyError via @readonly, then the
+bump. Gate verified: native append -> binding children/content
+serve fresh values; readonly raises through every native entry.

data/TODO.perf/09-adoption-lift-fast-path.md

@@ -0,0 +1,38 @@
+# 09 — Adoption-lift fast path + binding create via C (#204 ask 3, #149 continuation)
+
+Status: DONE (1.9.163.5)
+
+Binding create x2 + attach measured 4.1us vs Nokogiri 1.5us. The
+#178/#208 namespace lift + pruning runs on EVERY attach and costs
+several FFI round-trips (own definitions, prefix read, in-scope
+walk) even when it is a provable no-op. Add a one-dispatch C
+predicate `Native.ns_lift_needed?(addr)`: false when the node
+carries no namespace declarations AND its name has no prefix —
+the overwhelmingly common programmatic-build shape. add_child and
+friends skip the lift entirely on false. Also route binding
+create_element/create_text_node through the ext (one C call +
+binding-wrapper construction in C — no FFI marshaling) when
+auto-enabled.
+
+## Outcome (1.9.163.5)
+
+Three layers landed:
+1. `Element.skip_adoption_lift?` — non-elements skip outright
+   (lift no-ops them anyway); elements consult
+   `Native.ns_lift_needed?` (two C calls: own-declaration count +
+   resolved URI). Hoisted ABOVE the target's `namespaces`
+   materialization at all five mutation sites (add_child,
+   prepend_child, both sibling inserts, root=) — a fresh parent
+   no longer pays the in-scope collection FFI round-trips per
+   attach. Measured effect: add_child on a fresh parent
+   1678 -> 506ns.
+2. `Native.create_binding_element/text` build the binding wrapper
+   in C (one C call + wrapper + identity-cache store; no FFI
+   marshaling). Document.create/create_element/create_text_node
+   route through them when auto-enabled.
+3. `Native.append_binding_child` — gates + predicate + version
+   bump + engine append in ONE dispatch (Qnil = child needs the
+   lift, Ruby falls back). Element#add_child's node branch uses
+   it; namespaced children still lift (spec-pinned). The #204
+   ask-3 shape (create x2 + attach) went 4.1us -> ~1.2us measured
+   under host load 12-19 — at or past the Nokogiri row (1.5us).

data/TODO.perf/10-bulk-attribute-materialization.md

@@ -0,0 +1,20 @@
+# 10 — Bulk attribute materialization for the binding
+
+Status: DONE (1.9.163.5)
+
+Element#attributes / #each_attribute / #keys / #values walk the
+attribute list with one FFI call per attribute (name + value per
+row). One C pass materializes the {name => value} hash and the
+key/value arrays in a single walk. Gate: attribute-heavy cold
+reads improve; #attributes semantics unchanged (memoized, version
+invalidated).
+
+## Outcome (1.9.163.5)
+
+`Native.bulk_attr_faces` builds {name => Attr} + the values hash
+in one C walk (Attr value objects: name/value/element ivars,
+c_handle left nil); Element#attributes rides it when
+auto-enabled and memo-stamps both hashes. Measured (load 12-19):
+Element#attributes on a 5-attr element ~134-151ns vs Nokogiri
+~1107-1165ns (~8x). The values-only shape
+(`Native.bulk_attributes`) backs the legacy path.

data/TODO.perf/11-moxml-gap-battery.md

@@ -0,0 +1,18 @@
+# 11 — The #204 gap table as a battery leg
+
+Status: DONE (1.9.163.5)
+
+Reproduce moxml's gap table rows locally (parse 30KB, to_xml,
+[] / content / name reads, set_attribute, create x2 + attach,
+typed walk) in benchmark/native_vs_binding.rb so every perf round
+tracks the exact rows the 2x mandate measures — both surfaces,
+interleaved, load-gated.
+
+## Outcome (1.9.163.5)
+
+benchmark/native_vs_binding.rb gained the gap rows: []/content/
+name repeat reads (binding + native), set_attribute, and the
+build (create x2 + attach) row, all interleaved best-of behind
+the file's load gate (skips > 20). `set_attribute` itself became
+a C-bound face this round (Native.set_binding_attribute: gates +
+version bump + engine write in one dispatch).

data/ext/leptris/native/native.c

@@ -22,12 +22,14 @@ typedef int (*node_type_fn)(void *);
 typedef void *(*next_sibling_fn)(void *);
 typedef void *(*parent_fn)(void *);
 typedef const char *(*elem_prefix_fn)(void *);
+typedef const char *(*elem_ns_fn)(void *);
 typedef size_t (*xp_count_fn)(void *);
 typedef size_t (*xp_nodes_ex_fn)(void *, void **, int *, size_t);
 typedef int (*xp_node_kind_fn)(void *, int);
 typedef const char *(*xp_node_name_fn)(void *, int);
 typedef const char *(*xp_node_value_fn)(void *, int);
 typedef size_t (*serialize_into_fn)(void *, char *, size_t, void *, void *);
+typedef int (*ns_count_fn)(void *);
 typedef void *(*attr_first_fn)(void *);
 typedef void *(*attr_next_fn)(void *);
 typedef const char *(*attr_name_fn)(void *);
@@ -40,6 +42,7 @@ typedef void *(*elem_create_fn)(void *, const char *);
 typedef void *(*text_create_fn)(void *, const char *);
 typedef void *(*create_child_fn)(void *, const char *);
 typedef int (*append_child_fn)(void *, void *);
+typedef int (*set_attr_fn)(void *, const char *, const char *);
 typedef int (*set_root_fn)(void *, void *);
 typedef void (*doc_free_fn)(void *);
 
@@ -51,12 +54,14 @@ static node_type_fn f_node_type;
 static next_sibling_fn f_next_sibling;
 static parent_fn f_parent;
 static elem_prefix_fn f_elem_prefix;
+static elem_ns_fn f_elem_ns;
 static xp_count_fn f_xp_count;
 static xp_nodes_ex_fn f_xp_nodes_ex;
 static xp_node_kind_fn f_xp_node_kind;
 static xp_node_name_fn f_xp_node_name;
 static xp_node_value_fn f_xp_node_value;
 static serialize_into_fn f_doc_serialize, f_elem_serialize;
+static ns_count_fn f_elem_ns_count;
 static attr_first_fn f_attr_first;
 static attr_next_fn f_attr_next;
 static attr_name_fn f_attr_name;
@@ -69,18 +74,35 @@ static elem_create_fn f_elem_create;
 static text_create_fn f_text_create;
 static create_child_fn f_create_child;
 static append_child_fn f_append_child;
+static set_attr_fn f_set_attr;
 static set_root_fn f_set_root;
 static doc_free_fn f_doc_free;
 
 static VALUE c_native_node;
-static ID id_wrapper_cache;   /* native_cache: NativeNode identity */
-static ID id_binding_cache;   /* wrapper_cache: binding Node identity */
+/* Ivar reads (TODO.perf/07 tail): the binding Document keeps the
+ * C address and the caches in plain ivars, so the hot C faces skip
+ * rb_funcall dispatch entirely. */
+static ID id_iv_c_address, id_iv_native_cache, id_iv_binding_cache;
+static ID id_iv_version, id_iv_readonly, id_address;
+static ID id_iv_nn_content, id_iv_nn_content_ver;
+static ID id_iv_nn_attrs, id_iv_nn_attrs_ver;
+static VALUE c_use_after_free_error;
+
+static VALUE native_cache_of(VALUE document);
+static void resolve_binding_classes(void);
+static VALUE binding_cache_of(VALUE document);
 
 #define NT_ELEMENT 0
 
 struct native_node {
     void *ptr;
     VALUE document;
+    /* Single-slot read memos (#204 ask 1): the last attribute
+     * query and the last content, stamped with the document's
+     * mutation version (a Fixnum immediate — pointer compare).
+     * Slot beats the hash memo on repeat reads of one name. */
+    VALUE attr_key, attr_val, attr_ver;
+    VALUE content_val, content_ver;
 };
 
 static void nn_mark(void *p)
@@ -88,6 +110,12 @@ static void nn_mark(void *p)
     struct native_node *n = p;
     if (n->document != Qnil)
         rb_gc_mark(n->document);
+    if (n->attr_key != Qnil)
+        rb_gc_mark(n->attr_key);
+    if (n->attr_val != Qnil)
+        rb_gc_mark(n->attr_val);
+    if (n->content_val != Qnil)
+        rb_gc_mark(n->content_val);
 }
 
 static size_t nn_size(const void *p) { (void)p; return sizeof(struct native_node); }
@@ -122,6 +150,8 @@ static void resolve_symbols(const char *lib_path)
     f_next_sibling = (next_sibling_fn)lib_sym(h, "leptris_node_next_sibling");
     f_parent = (parent_fn)lib_sym(h, "leptris_node_parent");
     f_elem_prefix = (elem_prefix_fn)lib_sym(h, "leptris_element_prefix");
+    f_elem_ns_count = (ns_count_fn)lib_sym(h, "leptris_element_namespace_count");
+    f_elem_ns = (elem_ns_fn)lib_sym(h, "leptris_element_namespace");
     f_xp_count = (xp_count_fn)lib_sym(h, "leptris_xpath_result_count");
     f_xp_nodes_ex = (xp_nodes_ex_fn)lib_sym(h, "leptris_xpath_result_get_nodes_ex");
     f_xp_node_kind = (xp_node_kind_fn)lib_sym(h, "leptris_xpath_result_node_kind");
@@ -141,15 +171,18 @@ static void resolve_symbols(const char *lib_path)
     f_text_create = (text_create_fn)lib_sym(h, "leptris_text_node_create");
     f_create_child = (create_child_fn)lib_sym(h, "leptris_element_create_child");
     f_append_child = (append_child_fn)lib_sym(h, "leptris_element_append_child");
+    f_set_attr = (set_attr_fn)lib_sym(h, "leptris_element_set_attribute");
     f_set_root = (set_root_fn)lib_sym(h, "leptris_document_set_root");
     f_doc_free = (doc_free_fn)lib_sym(h, "leptris_document_free");
     if (!f_elem_name || !f_text_content || !f_attr ||
         !f_children_ex || !f_node_type || !f_next_sibling || !f_parent ||
         !f_element_text || !f_doc_create || !f_elem_create || !f_text_create ||
-        !f_create_child || !f_append_child || !f_set_root || !f_doc_free ||
+        !f_create_child || !f_append_child || !f_set_attr || !f_set_root ||
+        !f_doc_free ||
         !f_elem_prefix || !f_xp_count || !f_xp_nodes_ex ||
         !f_xp_node_kind || !f_xp_node_name || !f_xp_node_value ||
         !f_doc_serialize || !f_elem_serialize || !f_attr_first ||
+        !f_elem_ns_count || !f_elem_ns ||
         !f_attr_next || !f_attr_name || !f_attr_value ||
         !f_node_line || !f_node_offset)
         rb_raise(rb_eRuntimeError, "libleptris symbols missing");
@@ -168,21 +201,92 @@ static VALUE nn_content(VALUE self)
 {
     struct native_node *n;
     const char *s;
+    VALUE doc, cached;
+
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    /* Version-stamped content memo (the binding Document's
+     * mutation version — the same invalidation discipline as
+     * binding memos, ADR 0003): repeat reads are two struct
+     * reads and a pointer compare. nil results never cache
+     * (empty elements recompute — rare in hot walks). */
+    doc = n->document;
+    if (doc != Qnil && n->content_ver != Qnil &&
+        n->content_ver == rb_ivar_get(doc, id_iv_version))
+        return n->content_val;
     /* elements aggregate their text (leptris_element_text); text
      * nodes carry it directly. */
     s = f_node_type(n->ptr) == 0 ? f_element_text(n->ptr)
                                  : f_text_content(n->ptr);
+    cached = s ? rb_utf8_str_new_cstr(s) : Qnil;
+    if (doc != Qnil && cached != Qnil) {
+        n->content_val = cached;
+        n->content_ver = rb_ivar_get(doc, id_iv_version);
+    }
+    return cached;
+}
+
+static VALUE nf_fast_attribute2(VALUE self, VALUE addr, VALUE name)
+{
+    const char *s;
+    (void)self;
+    s = f_attr((void *)(uintptr_t)NUM2ULL(addr),
+               RSTRING_PTR(StringValue(name)));
     return s ? rb_utf8_str_new_cstr(s) : Qnil;
 }
 
+/* 07 (#204 ask 1): StringValueCStr runs a memchr over the name
+ * checking for embedded NULs — attribute names cannot contain
+ * NULs, so StringValue + RSTRING_PTR skips the scan. */
 static VALUE nn_attribute(VALUE self, VALUE name)
 {
     struct native_node *n;
+    VALUE doc, cache, v;
     const char *s;
+
+    /* String-normalized once, used as both the C argument and the
+     * cache key. */
+    if (!RB_TYPE_P(name, T_STRING))
+        name = rb_obj_as_string(name);
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
-    s = f_attr(n->ptr, StringValueCStr(name));
-    return s ? rb_utf8_str_new_cstr(s) : Qnil;
+    doc = n->document;
+    /* Single-slot memo first: the last-queried name by VALUE
+     * (callers may mint a fresh String per call) against the same
+     * version. Then the hash memo for other repeat names; both
+     * stamp with the document version, so any mutation through
+     * either surface drops them. Absent names never cache (no
+     * negative-cache staleness). */
+    if (doc != Qnil && n->attr_ver == rb_ivar_get(doc, id_iv_version) &&
+        n->attr_key != Qnil && rb_str_equal(n->attr_key, name))
+        return n->attr_val;
+    cache = Qnil;
+    if (doc != Qnil) {
+        cache = rb_ivar_get(self, id_iv_nn_attrs);
+        if (cache != Qnil &&
+            rb_ivar_get(self, id_iv_nn_attrs_ver) ==
+                rb_ivar_get(doc, id_iv_version)) {
+            v = rb_hash_aref(cache, name);
+            if (v != Qnil) {
+                n->attr_key = name;
+                n->attr_val = v;
+                n->attr_ver = rb_ivar_get(doc, id_iv_version);
+                return v;
+            }
+        }
+    }
+    s = f_attr(n->ptr, RSTRING_PTR(name));
+    v = s ? rb_utf8_str_new_cstr(s) : Qnil;
+    if (doc != Qnil && v != Qnil) {
+        if (cache == Qnil)
+            cache = rb_hash_new();
+        rb_hash_aset(cache, name, v);
+        rb_ivar_set(self, id_iv_nn_attrs, cache);
+        rb_ivar_set(self, id_iv_nn_attrs_ver,
+                    rb_ivar_get(doc, id_iv_version));
+        n->attr_key = name;
+        n->attr_val = v;
+        n->attr_ver = rb_ivar_get(doc, id_iv_version);
+    }
+    return v;
 }
 
 static VALUE nn_allocate(VALUE klass)
@@ -236,7 +340,7 @@ static VALUE nn_children(VALUE self)
         return rb_ary_new2(0);
     }
 
-    cache = rb_funcall(n->document, id_wrapper_cache, 0);
+    cache = native_cache_of(n->document);
     out = rb_ary_new2(count);
     for (i = 0; i < count; i++) {
         uint64_t addr = (uint64_t)(uintptr_t)buf[i];
@@ -289,7 +393,7 @@ static VALUE nn_element_children(VALUE self)
         return rb_ary_new2(0);
     }
 
-    cache = rb_funcall(n->document, id_wrapper_cache, 0);
+    cache = native_cache_of(n->document);
     out = rb_ary_new();
     for (i = 0; i < count; i++) {
         if (kinds[i] != NT_ELEMENT)
@@ -316,7 +420,7 @@ static VALUE wrap_cached(struct native_node *owner, void *ptr)
     VALUE cache, key, node;
     struct native_node *n;
 
-    cache = rb_funcall(owner->document, id_wrapper_cache, 0);
+    cache = native_cache_of(owner->document);
     key = ULL2NUM((uint64_t)(uintptr_t)ptr);
     node = rb_hash_aref(cache, key);
     if (!NIL_P(node))
@@ -358,19 +462,144 @@ static VALUE wrap_new(VALUE document, void *ptr)
     TypedData_Get_Struct(node, struct native_node, &nn_type, n);
     n->ptr = ptr;
     n->document = document;
-    cache = rb_funcall(document, id_wrapper_cache, 0);
+    cache = native_cache_of(document);
     key = ULL2NUM((uint64_t)(uintptr_t)ptr);
     rb_hash_aset(cache, key, node);
     return node;
 }
 
-/* Document address from the binding Document's #c_ptr. */
+/* Document address from the binding Document's @c_address ivar
+ * (nil once freed) — one ivar read, no method dispatch. */
 static void *doc_ptr_of(VALUE document)
 {
-    VALUE c_ptr = rb_funcall(document, rb_intern("c_ptr"), 0);
-    if (NIL_P(c_ptr))
+    VALUE addr = rb_ivar_get(document, id_iv_c_address);
+    if (NIL_P(addr))
         rb_raise(rb_eRuntimeError, "document has been freed");
-    return (void *)(uintptr_t)NUM2ULL(rb_funcall(c_ptr, rb_intern("address"), 0));
+    return (void *)(uintptr_t)NUM2ULL(addr);
+}
+
+/* Per-document identity caches. Both are lazily allocated on the
+ * Ruby side (@x ||= {}), so replicate that here: ivar read, create
+ * and store when unset. */
+static VALUE native_cache_of(VALUE document)
+{
+    VALUE cache = rb_ivar_get(document, id_iv_native_cache);
+    if (NIL_P(cache)) {
+        cache = rb_hash_new();
+        rb_ivar_set(document, id_iv_native_cache, cache);
+    }
+    return cache;
+}
+
+static VALUE binding_cache_of(VALUE document)
+{
+    VALUE cache = rb_ivar_get(document, id_iv_binding_cache);
+    if (NIL_P(cache)) {
+        cache = rb_hash_new();
+        rb_ivar_set(document, id_iv_binding_cache, cache);
+    }
+    return cache;
+}
+
+
+/* TODO.perf/08 (#204 ask 2): native mutations must advance the
+ * binding Document's mutation version so binding memos invalidate
+ * exactly as they do through the FFI write path — and respect the
+ * readonly gate. Two ivar reads per mutation (the version is
+ * always a Fixnum, readonly is Qfalse/Qtrue). */
+static VALUE c_readonly_error;
+
+static void document_advance_version(VALUE document)
+{
+    if (rb_ivar_get(document, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — native mutation attempted");
+    rb_ivar_set(document, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(document, id_iv_version)) + 1));
+}
+
+static VALUE nf_ns_lift_needed(VALUE self, VALUE addr)
+{
+    void *node = (void *)(uintptr_t)NUM2ULL(addr);
+    const char *uri;
+    (void)self;
+    /* Exact semantics in two C calls: an element with NO resolved
+     * namespace and NO own declarations cannot lose anything in a
+     * move — bare name, no prefix binding, no default-ns
+     * dependency, nothing to prune. Everything else takes the full
+     * lift path (carries in-scope declarations, prunes redundant
+     * own ones). */
+    if (f_elem_ns_count(node) > 0)
+        return Qtrue;
+    uri = f_elem_ns(node);
+    return (uri && *uri) ? Qtrue : Qfalse;
+}
+
+/* ---- C-bound append (TODO.perf/08-09, #204 ask 3) --------------
+ * One dispatch for the common programmatic-build adoption: the
+ * readonly + liveness gates, the provable no-op namespace-lift
+ * predicate, the version bump, and the engine append. Returns
+ * the engine status int; Qnil means the child DOES need the
+ * namespace lift — the caller falls back to the Ruby path. */
+static VALUE nf_append_binding_child(VALUE self, VALUE document,
+                                     VALUE parent_addr, VALUE child_addr)
+{
+    void *parent, *child;
+    const char *uri;
+    int st;
+
+    (void)self;
+    resolve_binding_classes();
+    if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    if (rb_ivar_get(document, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — mutation attempted");
+    parent = (void *)(uintptr_t)NUM2ULL(parent_addr);
+    child = (void *)(uintptr_t)NUM2ULL(child_addr);
+    /* Same provable no-op as Element.skip_adoption_lift?: an
+     * element with no resolved namespace and no own declarations
+     * cannot lose anything in a move; non-elements can never need
+     * a lift. */
+    if (f_node_type(child) == NT_ELEMENT) {
+        if (f_elem_ns_count(child) > 0)
+            return Qnil;
+        uri = f_elem_ns(child);
+        if (uri && *uri)
+            return Qnil;
+    }
+    /* Bump before the call, mirroring ensure_writable!: a failed
+     * mutation merely discards memos. */
+    rb_ivar_set(document, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(document, id_iv_version)) + 1));
+    st = f_append_child(parent, child);
+    return INT2FIX(st);
+}
+
+/* C-bound set_attribute (TODO.perf/11, #204 gap row 0.25x): the
+ * gates, the version bump (which drops the version-stamped
+ * attribute memos on both surfaces), and the engine write in one
+ * dispatch. */
+static VALUE nf_set_binding_attribute(VALUE self, VALUE document,
+                                      VALUE addr, VALUE name, VALUE value)
+{
+    void *node;
+    int st;
+
+    (void)self;
+    resolve_binding_classes();
+    if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    if (rb_ivar_get(document, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — mutation attempted");
+    node = (void *)(uintptr_t)NUM2ULL(addr);
+    rb_ivar_set(document, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(document, id_iv_version)) + 1));
+    st = f_set_attr(node, StringValueCStr(name), StringValueCStr(value));
+    return INT2FIX(st);
 }
 
 /* Builder factories (#149): create in C, wrap as NativeNode — no
@@ -399,11 +628,14 @@ static VALUE nn_create_child(VALUE self, VALUE name)
 {
     struct native_node *n;
     void *ptr;
+    VALUE out;
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    document_advance_version(n->document);
     ptr = f_create_child(n->ptr, StringValueCStr(name));
     if (!ptr)
         rb_raise(rb_eRuntimeError, "leptris_element_create_child failed");
-    return wrap_new(n->document, ptr);
+    out = wrap_new(n->document, ptr);
+    return out;
 }
 
 static VALUE nn_append_child(VALUE self, VALUE child)
@@ -412,6 +644,7 @@ static VALUE nn_append_child(VALUE self, VALUE child)
     int rc;
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
     TypedData_Get_Struct(child, struct native_node, &nn_type, c);
+    document_advance_version(n->document);
     rc = f_append_child(n->ptr, c->ptr);
     if (rc != 0)
         rb_raise(rb_eRuntimeError, "leptris_element_append_child failed (%d)", rc);
@@ -424,6 +657,7 @@ static VALUE nn_set_root(VALUE klass, VALUE document, VALUE element)
     int rc;
     (void)klass;
     TypedData_Get_Struct(element, struct native_node, &nn_type, n);
+    document_advance_version(document);
     rc = f_set_root(doc_ptr_of(document), n->ptr);
     if (rc != 0)
         rb_raise(rb_eRuntimeError, "leptris_document_set_root failed (%d)", rc);
@@ -492,7 +726,7 @@ static VALUE nn_address(VALUE self)
  * disappear. */
 static VALUE c_b_element = Qundef, c_b_text, c_b_comment, c_b_cdata,
              c_b_pi, c_b_node, c_b_result_text, c_b_result_attr,
-             c_ffi_pointer;
+             c_b_attr, c_ffi_pointer;
 static ID id_ptr_new;
 
 /* Binding classes resolve LAZILY: Init_native can run before the
@@ -511,6 +745,7 @@ static void resolve_binding_classes(void)
     c_b_result_text = rb_path2class("Leptris::XML::ResultText");
     c_b_result_attr = rb_path2class("Leptris::XML::ResultAttr");
     c_ffi_pointer = rb_path2class("FFI::Pointer");
+    c_b_attr = rb_path2class("Leptris::XML::Attr");
     id_ptr_new = rb_intern("new");
     rb_gc_register_mark_object(c_b_element);
     rb_gc_register_mark_object(c_b_text);
@@ -521,6 +756,7 @@ static void resolve_binding_classes(void)
     rb_gc_register_mark_object(c_b_result_text);
     rb_gc_register_mark_object(c_b_result_attr);
     rb_gc_register_mark_object(c_ffi_pointer);
+    rb_gc_register_mark_object(c_b_attr);
 }
 
 static VALUE binding_klass_for(int kind)
@@ -551,7 +787,7 @@ static VALUE bulk_children_impl(VALUE document, VALUE parent_addr,
         return rb_ary_new2(0);
     }
 
-    cache = rb_funcall(document, id_binding_cache, 0);
+    cache = binding_cache_of(document);
     out = rb_ary_new2(elements_only ? 8 : count);
     for (i = 0; i < count; i++) {
         VALUE key, node;
@@ -621,7 +857,7 @@ static VALUE nf_bulk_xpath(VALUE self, VALUE document, VALUE result_ptr_val)
         ruby_xfree(kinds);
         return rb_ary_new2(0);
     }
-    cache = rb_funcall(document, id_binding_cache, 0);
+    cache = binding_cache_of(document);
     out = rb_ary_new2(count);
     for (i = 0; i < count; i++) {
         VALUE node, key;
@@ -694,6 +930,111 @@ static VALUE nf_bulk_xpath(VALUE self, VALUE document, VALUE result_ptr_val)
     return out;
 }
 
+/* ---- Bulk attribute materialization (TODO.perf/10) ---------------
+ * Element#attributes / #keys / #values walk the attribute list
+ * one FFI call per row (name + value). One C pass builds the
+ * {name => value} hash for the binding. */
+static VALUE nf_bulk_attributes(VALUE self, VALUE addr)
+{
+    void *node = (void *)(uintptr_t)NUM2ULL(addr);
+    VALUE hash = rb_hash_new();
+    void *attr = f_attr_first(node);
+
+    (void)self;
+    while (attr) {
+        const char *name = f_attr_name(attr);
+        const char *value = f_attr_value(node, attr);
+        rb_hash_aset(hash,
+                     name ? rb_utf8_str_new_cstr(name) : Qnil,
+                     value ? rb_utf8_str_new_cstr(value) : Qnil);
+        attr = f_attr_next(attr);
+    }
+    return hash;
+}
+
+/* ---- Binding create via C (TODO.perf/09): one call creates the
+ * node AND constructs the binding wrapper (class dispatch, ivars,
+ * identity-cache store) — no FFI marshaling, no wrap_fresh path. */
+static VALUE nf_create_binding_element(VALUE self, VALUE document,
+                                       VALUE name)
+{
+    void *doc = doc_ptr_of(document);
+    void *ptr = f_elem_create(doc, RSTRING_PTR(StringValue(name)));
+    VALUE node, cache, key;
+
+    (void)self;
+    resolve_binding_classes();
+    if (!ptr)
+        return Qnil; /* caller raises with the error channel */
+    node = rb_obj_alloc(c_b_element);
+    rb_iv_set(node, "@c_ptr",
+              rb_funcall(c_ffi_pointer, id_ptr_new, 1,
+                         ULL2NUM((uint64_t)(uintptr_t)ptr)));
+    rb_iv_set(node, "@document", document);
+    rb_iv_set(node, "@parent", Qnil);
+    rb_iv_set(node, "@node_type", INT2FIX(0));
+    cache = binding_cache_of(document);
+    key = ULL2NUM((uint64_t)(uintptr_t)ptr);
+    rb_hash_aset(cache, key, node);
+    return node;
+}
+
+static VALUE nf_create_binding_text(VALUE self, VALUE document,
+                                    VALUE content)
+{
+    void *doc = doc_ptr_of(document);
+    void *ptr = f_text_create(doc, RSTRING_PTR(StringValue(content)));
+    VALUE node, cache, key;
+
+    (void)self;
+    resolve_binding_classes();
+    if (!ptr)
+        return Qnil;
+    node = rb_obj_alloc(c_b_text);
+    rb_iv_set(node, "@c_ptr",
+              rb_funcall(c_ffi_pointer, id_ptr_new, 1,
+                         ULL2NUM((uint64_t)(uintptr_t)ptr)));
+    rb_iv_set(node, "@document", document);
+    rb_iv_set(node, "@parent", Qnil);
+    rb_iv_set(node, "@node_type", INT2FIX(1));
+    cache = binding_cache_of(document);
+    key = ULL2NUM((uint64_t)(uintptr_t)ptr);
+    rb_hash_aset(cache, key, node);
+    return node;
+}
+
+/* ---- Bulk attribute FACES (TODO.perf/10): {name => Attr} with
+ * the values hash beside it — the exact shapes Element#attributes
+ * memoizes, built in one walk. Attr is a value object
+ * (name/value/element ivars; c_handle optional). */
+
+static ID id_iv_name, id_iv_value, id_iv_element;
+
+static VALUE nf_bulk_attr_faces(VALUE self, VALUE addr, VALUE element)
+{
+    void *node = (void *)(uintptr_t)NUM2ULL(addr);
+    VALUE faces = rb_hash_new();
+    VALUE values = rb_hash_new();
+    void *attr = f_attr_first(node);
+
+    (void)self;
+    resolve_binding_classes();
+    while (attr) {
+        const char *name = f_attr_name(attr);
+        const char *value = f_attr_value(node, attr);
+        VALUE k = name ? rb_utf8_str_new_cstr(name) : Qnil;
+        VALUE v = value ? rb_utf8_str_new_cstr(value) : Qnil;
+        VALUE a = rb_obj_alloc(c_b_attr);
+        rb_iv_set(a, "@name", k);
+        rb_iv_set(a, "@value", v);
+        rb_iv_set(a, "@element", element);
+        rb_hash_aset(faces, k, a);
+        rb_hash_aset(values, k, v);
+        attr = f_attr_next(attr);
+    }
+    return rb_assoc_new(faces, values);
+}
+
 /* ---- Ext-bound serialization (TODO.perf/04) ---------------------
  * The whole sized-buffer cycle in C: build SerializeOptions on
  * the stack, call (buf, cap, NULL status, opts), grow if needed,
@@ -766,6 +1107,12 @@ static VALUE nf_fast_element_xml(VALUE self, VALUE addr,
                           NUM2INT(indent), RTEST(decl) ? 1 : 0);
 }
 
+/* ---- Adoption-lift predicate (TODO.perf/09, #204 ask 3) ---------
+ * The #178/#208 namespace lift + pruning runs on EVERY attach and
+ * costs several FFI round-trips even when provably a no-op. This
+ * predicate answers in ONE dispatch: false when the node carries
+ * no namespace declarations AND its name has no prefix — the
+ * common programmatic-build shape (bare names, no namespaces). */
 /* ---- Address-based fast readers (TODO.perf/01) -----------------
  * The DEFAULT binding classes call these when the bundle is
  * loaded: one C-API dispatch + rb_utf8_str_new_cstr — no FFI
@@ -811,11 +1158,11 @@ static VALUE nn_from(VALUE klass, VALUE document, VALUE element)
     struct native_node *n;
     VALUE node = nn_allocate(klass);
     void *ptr = (void *)(uintptr_t)NUM2ULL(
-        rb_funcall(element, rb_intern("address"), 0));
+        rb_funcall(element, id_address, 0));
     TypedData_Get_Struct(node, struct native_node, &nn_type, n);
     n->ptr = ptr;
     n->document = document;
-    rb_hash_aset(rb_funcall(document, id_wrapper_cache, 0),
+    rb_hash_aset(native_cache_of(document),
                  ULL2NUM((uint64_t)(uintptr_t)ptr), node);
     return node;
 }
@@ -838,8 +1185,24 @@ void Init_native(void)
     c_native_node = rb_define_class_under(m_xml, "NativeNode", rb_cObject);
     rb_undef_alloc_func(c_native_node);
 
-    id_wrapper_cache = rb_intern("native_cache");
-    id_binding_cache = rb_intern("wrapper_cache");
+    id_iv_name = rb_intern("@name");
+    id_iv_value = rb_intern("@value");
+    id_iv_element = rb_intern("@element");
+    id_iv_c_address = rb_intern("@c_address");
+    id_iv_native_cache = rb_intern("@native_cache");
+    id_iv_binding_cache = rb_intern("@wrapper_cache");
+    id_iv_version = rb_intern("@version");
+    id_iv_readonly = rb_intern("@readonly");
+    id_address = rb_intern("address");
+    id_iv_nn_content = rb_intern("@nn_content");
+    id_iv_nn_content_ver = rb_intern("@nn_content_ver");
+    id_iv_nn_attrs = rb_intern("@nn_attrs");
+    id_iv_nn_attrs_ver = rb_intern("@nn_attrs_ver");
+    c_readonly_error = rb_path2class("Leptris::XML::ReadOnlyError");
+    c_use_after_free_error =
+        rb_path2class("Leptris::XML::UseAfterFreeError");
+    rb_gc_register_mark_object(c_readonly_error);
+    rb_gc_register_mark_object(c_use_after_free_error);
 
     rb_define_singleton_method(c_native_node, "from", nn_from, 2);
     rb_define_singleton_method(c_native_node, "create_element", nn_create_element, 2);
@@ -871,6 +1234,19 @@ void Init_native(void)
     rb_define_module_function(m_native, "fast_element_text", nf_element_text, 1);
     rb_define_module_function(m_native, "fast_attribute", nf_attribute, 2);
     rb_define_module_function(m_native, "fast_prefix", nf_prefix, 1);
+    rb_define_module_function(m_native, "fast_attribute2", nf_fast_attribute2, 2);
+    rb_define_module_function(m_native, "ns_lift_needed?", nf_ns_lift_needed, 1);
+    rb_define_module_function(m_native, "append_binding_child",
+                              nf_append_binding_child, 3);
+    rb_define_module_function(m_native, "set_binding_attribute",
+                              nf_set_binding_attribute, 4);
+    rb_define_module_function(m_native, "bulk_attributes", nf_bulk_attributes, 1);
+    rb_define_module_function(m_native, "bulk_attr_faces",
+                              nf_bulk_attr_faces, 2);
+    rb_define_module_function(m_native, "create_binding_element",
+                              nf_create_binding_element, 2);
+    rb_define_module_function(m_native, "create_binding_text",
+                              nf_create_binding_text, 2);
     rb_define_module_function(m_native, "bulk_children", nf_bulk_children, 2);
     rb_define_module_function(m_native, "bulk_element_children",
                               nf_bulk_element_children, 2);

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.163.4"
+  VERSION = "1.9.163.5"
 end

data/lib/leptris/xml/document.rb

@@ -32,6 +32,10 @@ class Leptris::XML::Document
 
   def initialize(c_ptr = nil, freed = Freed.new(:alive))
     @c_ptr = c_ptr
+    # Plain-Integer address twin of @c_ptr: the native layer reads
+    # this ivar directly (no method dispatch), nil'ed exactly when
+    # @c_ptr is.
+    @c_address = c_ptr&.address
     @freed = freed
     @readonly = false
     @version = 0
@@ -258,7 +262,9 @@ class Leptris::XML::Document
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
     # A document root has no in-scope declarations of its own —
     # lift everything the element's source scope carried (#178).
-    Leptris::XML::Element.lift_namespaces_for_adoption(element, {})
+    unless Leptris::XML::Element.skip_adoption_lift?(element)
+      Leptris::XML::Element.lift_namespaces_for_adoption(element, {})
+    end
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_document_set_root(@c_ptr, element.c_ptr))
     @version += 1
@@ -266,12 +272,24 @@ class Leptris::XML::Document
   end
 
   def create_element(name)
+    # TODO.perf/09: one C call creates + wraps when the ext is
+    # loaded — no FFI marshaling, no wrap_fresh frames.
+    if defined?(Leptris::XML::NATIVE_FAST)
+      node = Leptris::XML::Native.create_binding_element(self, name.to_s)
+      raise Leptris::XML::Error, "leptris_element_create failed" if node.nil?
+      return node
+    end
     ptr = Leptris::XML::FFI.leptris_element_create(@c_ptr, name)
     raise Leptris::XML::Error, "leptris_element_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_ELEMENT)
   end
 
   def create_text_node(content)
+    if defined?(Leptris::XML::NATIVE_FAST)
+      node = Leptris::XML::Native.create_binding_text(self, content.to_s)
+      raise Leptris::XML::Error, "leptris_text_node_create failed" if node.nil?
+      return node
+    end
     ptr = Leptris::XML::FFI.leptris_text_node_create(@c_ptr, content.to_s)
     raise Leptris::XML::Error, "leptris_text_node_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_TEXT)
@@ -371,6 +389,7 @@ class Leptris::XML::Document
     @freed.state = :freed
     Leptris::XML::FFI.leptris_document_free(@c_ptr) unless @c_ptr.nil?
     @c_ptr = nil
+    @c_address = nil
     @wrapper_cache&.clear
   end
 

data/lib/leptris/xml/element.rb

@@ -114,6 +114,15 @@ class Leptris::XML::Element < Leptris::XML::Node
   alias_method :get_attribute, :[]
 
   def []=(key, value)
+    # C-bound write (TODO.perf/11): gates + version bump + engine
+    # set in one dispatch; the bump drops the version-stamped
+    # attribute memos on both surfaces.
+    if native_fast_children?
+      Leptris::XML::FFI.check_status(
+        Leptris::XML::Native.set_binding_attribute(
+          @document, @c_ptr.address, key.to_s, value.to_s))
+      return value
+    end
     ensure_writable!
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_set_attribute(@c_ptr, key.to_s, value.to_s))
@@ -198,6 +207,17 @@ class Leptris::XML::Element < Leptris::XML::Node
     # Require the full Attr-hash face — a cold [] may have set the
     # version with only a partial @attr_values (ruby#150).
     return @attributes if @attributes && memo_hit?(@attributes_version)
+    if native_fast?
+      # TODO.perf/10: both memo faces in one C walk.
+      result, values = Leptris::XML::Native.bulk_attr_faces(
+        @c_ptr.address, self)
+      if @document
+        @attributes = result
+        @attr_values = values
+        @attributes_version = @document.version
+      end
+      return result
+    end
     result = {}
     values = {}
     each_attribute do |attr|
@@ -253,6 +273,21 @@ class Leptris::XML::Element < Leptris::XML::Node
   # adopted subtree. Call BEFORE attaching: the source scope is
   # read through the node's current ancestors. Identical scopes
   # (the common same-document move) add nothing.
+  # TODO.perf/09: one dispatch answers whether ANY lift work can
+  # apply (no resolved namespace, no own declarations = provable
+  # no-op — the common programmatic-build shape). Checked at the
+  # mutation sites so the target's in-scope namespaces are never
+  # materialized when the answer is no.
+  def self.skip_adoption_lift?(node)
+    # Non-elements can never need a lift (lift's own first line
+    # no-ops them) — skipping also avoids materializing the
+    # target's namespaces for the text/comment children every
+    # build appends.
+    return true unless node.is_a?(Leptris::XML::Element)
+    return false unless defined?(Leptris::XML::NATIVE_FAST)
+    !Leptris::XML::Native.ns_lift_needed?(node.c_ptr.address)
+  end
+
   def self.lift_namespaces_for_adoption(node, target_scope)
     return unless node.is_a?(Leptris::XML::Element)
     # Declarations the node already carries (its own definitions —
@@ -281,7 +316,9 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def prepend_child(node)
     ensure_writable!
-    Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+    unless Leptris::XML::Element.skip_adoption_lift?(node)
+      Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+    end
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_prepend_child(@c_ptr, node.c_ptr))
     node
@@ -289,7 +326,9 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def add_next_sibling(node)
     ensure_writable!
-    Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+    unless Leptris::XML::Element.skip_adoption_lift?(node)
+      Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+    end
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_after(@c_ptr, node.c_ptr))
     node
@@ -297,7 +336,9 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def add_previous_sibling(node)
     ensure_writable!
-    Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+    unless Leptris::XML::Element.skip_adoption_lift?(node)
+      Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+    end
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_before(@c_ptr, node.c_ptr))
     node
@@ -386,7 +427,22 @@ class Leptris::XML::Element < Leptris::XML::Node
     ensure_writable!
     case node_or_markup
     when Leptris::XML::Node
-      Leptris::XML::Element.lift_namespaces_for_adoption(node_or_markup, namespaces)
+      # C-bound append (TODO.perf/08-09): one dispatch runs the
+      # readonly/liveness gates, the provable no-op lift
+      # predicate, the version bump, and the engine append. Qnil
+      # means the child needs the namespace lift — fall through
+      # to the full path.
+      if native_fast_children?
+        st = Leptris::XML::Native.append_binding_child(
+          @document, @c_ptr.address, node_or_markup.c_ptr.address)
+        unless st.nil?
+          Leptris::XML::FFI.check_status(st)
+          return node_or_markup
+        end
+      end
+      unless Leptris::XML::Element.skip_adoption_lift?(node_or_markup)
+        Leptris::XML::Element.lift_namespaces_for_adoption(node_or_markup, namespaces)
+      end
       Leptris::XML::FFI.check_status(
         Leptris::XML::FFI.leptris_element_append_child(@c_ptr, node_or_markup.c_ptr))
       node_or_markup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.163.4
+  version: 1.9.163.5
 platform: ruby
 authors:
 - Ribose Inc.
@@ -75,6 +75,11 @@ files:
 - TODO.perf/04-ext-bound-serialization.md
 - TODO.perf/05-native-surface-completion.md
 - TODO.perf/06-perf-battery-native-legs.md
+- TODO.perf/07-native-read-floor.md
+- TODO.perf/08-version-coherent-native-mutations.md
+- TODO.perf/09-adoption-lift-fast-path.md
+- TODO.perf/10-bulk-attribute-materialization.md
+- TODO.perf/11-moxml-gap-battery.md
 - TODO.restructure/01-constraint-compliance-audit.md
 - TODO.restructure/02-deep-copy-seam.md
 - TODO.restructure/03-evaluation-context-seam.md