leptris 1.9.201.0-arm-linux → 1.9.201.2-arm-linux

data/vendor-src/libleptris/TODO.xslt-full/09-xslt-noop-fillins.md

@@ -0,0 +1,35 @@
+# 09 — XSLT 2.0/3.0 instruction fill-ins (#690 + #685)
+
+Every silent no-op becomes implemented or a loud XTSE compile
+error (never silent). Items:
+- xsl:sequence (select passthrough — with 01 done)
+- xsl:perform-sort (select + xsl:sort children; reuses xslt_sort)
+- xsl:next-match (rank+1 selection like apply-imports)
+- xsl:merge (two-source merge by keys; iterative walk)
+- xsl:fork (non-streaming = sequential execution of both arms)
+- xsl:result-document (href + format: serialize a second tree to a
+  file via the serializer; principal result unchanged)
+- @default (xsl:catch default error-code binding), @start-at
+  (xsl:number), on-completion (xsl:iterate post-body)
+- xsl:copy/@select (copy-of semantics inside xsl:copy), xsl:map
+  (needs 08), xsl:namespace (namespace-node construction),
+  xsl:document (inline doc construction — with 08's fragments)
+- composite keys (key use="a b" token list), xsl:next-iteration
+  param chaining re-check, xsl:evaluate with-params
+- xsl:where-populated / xsl:on-non-empty
+Gate: Xslt30.* spec per item (Saxon-probed) + suite green.
+
+## Status 2026-09-03 — CLOSED (re-audit after v1.9.75)
+
+Every listed item ships with an Xslt30 spec (Saxon-probed):
+sequence/perform-sort/next-match/merge/fork/result-document/
+where-populated/on-non-empty (batches B-E, v1.9.2x), @default/
+copy-@select/xsl:namespace/xsl:document/on-completion (batch C,
+#729-#732 family), @start-at, xsl:map+map-entry (08B), composite
+keys (#720), next-iteration chaining + evaluate with-params (batch
+D), xsl:assert, shadow attributes, accumulator. The 2026-09-03
+re-audit added xsl:global-context-item acceptance (no-op by
+construction — the transform always carries the source doc).
+Remaining OUT (tracked elsewhere): xsl:use-package/packaging
+(roadmap v3.1 packages, non-blocking), streaming (explicit
+non-goal). Issues #690/#685 close on this evidence.

data/vendor-src/libleptris/TODO.xslt-full/10-xslt-tunnel-params.md

@@ -0,0 +1,9 @@
+# 10 — XSLT tunnel parameters
+
+xsl:with-param tunnel="yes" + xsl:param tunnel="yes" — a separate
+tunnel frame chain on XsltExec (ex->tunnel_vars) that apply-
+templates/call-template propagate unchanged unless rebound; looked
+up only by xsl:param tunnel declarations. MECE with the regular
+frame chain (xslt_push_var family untouched).
+
+Gate: Xslt30.TunnelParams spec (Saxon-probed) + suite green.

data/vendor-src/libleptris/TODO.xslt-full/11-xquery-core.md

@@ -0,0 +1,119 @@
+# 11 — XQuery 1.0 core (#684-A)
+
+New subsystem src/leptris/xquery/ reusing the XPath engine (SSOT):
+- prolog: declare variable/function (compiled to the existing var/
+  ufn machinery), declare namespace/base-uri/default collation
+- FLWOR: for (multiple, positional), let, where, order by (stable,
+  multiple keys, asc/desc), return — compiled to XPATH_OP_FOR/LET
+  chains with a new ORDER wrapper; group by/windowing in 12
+- path expressions, constructors (direct element), if/typeswitch
+  (reject), function calls, doc()/collection()
+- CLI: leptris xquery -q file.xq [-s doc.xml]; C API
+  leptris_xquery_eval / leptris_xquery_parse
+- Saxon-HE net.sf.saxon.Query is the oracle AND perf target
+Gate: qt3tests XQuery 1.0 subset adopted + Saxon side-by-side.
+
+## Update 2026-09-03: slice A SHIPPED (v1.9.64 / PR #780)
+
+- New src/leptris/xquery/ orchestration layer (SSOT — no second
+  evaluator): prolog (declare variable / namespace / function
+  local:*; unsupported declarations error explicitly) + FLWOR
+  (nested for domains, per-tuple lets, where, stable multi-key
+  order by asc/desc with numeric-when-both-parse keys, return as
+  the synthetic-text sequence). Public API
+  leptris_xquery_parse/eval/free; results reuse the XPath result
+  model. Scanner: nestable (: :) comments, QName names, clause
+  keywords only at depth-0 word boundaries.
+- Banked scanner bug class: scan_word does NOT advance the cursor
+  (callers must move s->p themselves) — the clause-boundary check
+  must look at w+wl, not the un-advanced copy.
+- LSan class: xpath_context_cleanup treats variable_set as
+  caller-borrowed — a scratch set must be freed by its creator.
+- Spec: test/xquery/test_xquery.cpp (8, Saxon oracle
+  /tmp/probe9/xq). Drive-by fixes: \x03N marker leaked through
+  leptris_xpath_result_node_value into CLI output (v1.9.61
+  regression); CLI -Wswitch gaps for LEPTRIS_XPATH_FUNCTION.
+
+Remaining for lane 11: direct+computed element constructors,
+doc()/collection(), qt3tests 1.0 subset adoption, CLI `xquery`
+command, then lane 12 (group by/window, try/catch, typeswitch).
+
+## Update 2026-09-03 (later): slice B SHIPPED (v1.9.65 / PR #783)
+
+- Computed constructors (element/attribute/text) as XPath ops —
+  value-level serialized-XML strings; empty elements self-close
+  (Saxon). Comma-separated ctor bodies attach children directly
+  (SEQUENCE wrappers also flattened).
+- Direct constructors translate to the computed form in the xquery
+  scanner (balanced-tag text scans; AVTs → concat pieces, single
+  pieces stay bare — concat rejects arity 1; text runs → text{}
+  literals). XQuery-scoped; XSLT keeps literal result elements.
+- fn:doc(): document anchors on XPathContext.owned_docs, freed by
+  xpath_context_cleanup — the borrowed root outlives the result.
+- CLI: leptris xquery [-s FILE] (-q FILE | -e EXPR). Banked: CLI
+  command structs MUST be static (cli_registry_free never frees
+  them — a malloc'd one leaked 48B and aborted every CLI test
+  under Linux ASAN abort_on_error); Windows cmd.exe ignores the
+  test harness's single-quote wrapping and has no /tmp — CliXquery
+  specs ride a cwd-relative query FILE and are !defined(_WIN32)
+  gated (the LIBRARY tests are green on Windows; the harness-side
+  plumbing is the TODO follow-up).
+
+Remaining for lane 11: qt3tests XQuery 1.0 subset adoption,
+collection(), computed-document/value constructors, positional
+FOR ($x at $i). Then lane 12 (group by, windowing, try/catch —
+the #692 silent-wrong case, typeswitch).
+
+## Update 2026-09-03 (final): slice C SHIPPED (v1.9.66 / PR #786)
+
+- Positional for ($x at $i): 1-based position bound through the
+  tuple snapshot/rebind cycle. Banked: snapshot arrays size 2n
+  (var + pos var) — ASAN caught the n-sized overflow macOS ctest
+  missed; and the scan_word-doesn't-advance trap bit AGAIN in the
+  `at` keyword check (advance via s.p = w + wl, never s = scan
+  copy).
+- document { content }: no-wrapper serialization (Saxon). value {}
+  stays OUT — Saxon-HE rejects it (XPST0003).
+- try/catch (lane 12 opener, #692's silent-wrong FIXED): XPATH_OP_
+  TRY — failed try body runs the first catch whose name-test
+  matches; catch * catches all ($err:code/description/value bound
+  from ctx->error_msg, cleared on catch); named tests never match
+  (no error-code model — pinned: the error propagates). The XSLT
+  rejection pin flipped: try/catch is XPath 3.0.
+
+Lane 11 remainder (qt3tests subset, collection(), Windows CLI
+harness) is tracked in the line above; lane 12 continues with
+group by / windowing / typeswitch / error-code model.
+
+## Update 2026-09-11: QT3 adoption (lanes 11/12) — 4 slices shipped
+
+Exact-N runner over the public XQuery API; test-sets vendored
+verbatim from w3c/qt3tests (`test/xquery/qt3/`), the set parsed
+with libleptris itself. Adopted = every case whose assertions,
+environment, and params are within the runner surface; the gate
+is `agree == run == N` exactly.
+
+- v1.9.130 / #975 — fn/substring 45/45. Drove: pre-bound
+  fn/xs/math/map/array/err prefixes, exponent literals, count()
+  over atomics, codepoint substring.
+- v1.9.131 / #978 — fn/contains 41/41→46/46 (see slice 4).
+  Drove three FLWOR fixes: multi-binding clauses never parsed
+  (binding value is an ExprSingle — the clause-level comma ends
+  the span, the clause loops its binding list); let snapshots
+  kept only the first member; single-tuple returns reified
+  atomics into truthy one-member nodesets. Plus 3-arg contains
+  (codepoint = default; html-ascii-case-insensitive = ASCII-only
+  folding; else unknown-collation error).
+- slice 3 (#984) — fn/starts-with 43/43, fn/ends-with 34/34; the
+  collation dispatch shared across all three predicates.
+- slice 4 (this PR) — external variables:
+  `declare variable $x [as T] external [:= default]` +
+  `leptris_xquery_eval_params` (param values are select
+  expressions evaluated in an empty context; binding overrides
+  default; unbound-without-default errors). The runner binds
+  set-level <param> environments — fn/contains is 46/46.
+
+Next adoption blockers, in order: xs:integer/xs:int lexical
+preservation (int64-backed constructors — blocks fn/concat,
+fn/abs families), UCA collation args, error-assertion cases
+(error-channel runner shape), assert-type/assert-xml/any-of.

data/vendor-src/libleptris/TODO.xslt-full/12-xquery-31.md

@@ -0,0 +1,65 @@
+# 12 — XQuery 3.1/4.0 extensions (#684-B)
+
+group by, count clauses, allowing empty, tumbling/sliding windows,
+module imports + library modules, declare context item, map/array
+surface (08), transform(), load-xquery-module (stub), higher-order
+library (07), string templates (06). 4.0 previews behind a flag
+probed against Saxon-HE 13 defaults.
+Gate: qt3tests XQuery 3.1 subset + qt3extra green.
+
+## Update 2026-09-03: group by + try/catch SHIPPED (v1.9.66/67 / PR #786, #789)
+
+- try/catch (v1.9.66): XPATH_OP_TRY — catch * catches with
+  $err:code/description/value bound; the XSLT rejection pin
+  flipped (XPath 3.0 defines it). Named catches never match (no
+  error-code model — pinned).
+- group by (v1.9.67): first-appearance partition; clause vars
+  rebound to whole-group member lists (nodes preserved); order
+  keys evaluated POST-group so group by + order by composes.
+  XqTuple generalized to per-var member lists. Banked:
+  xpath_variable_set_nodeset OVERWRITES without freeing — always
+  unbind before rebind (the 168B/query leak only Linux LSan
+  sees); "group" must be in is_clause_word or the domain span
+  swallows it.
+
+Remaining for lane 12: windowing (for tumbling/sliding window),
+typeswitch, the error-code model for named catches (thread the
+leptris_error_code through try), qt3tests 3.1 subset.
+
+## Update 2026-09-03 (later): windows SHIPPED (v1.9.69 / PR #795)
+
+- for tumbling|sliding window $w in D start ... end ...: windows
+  enumerate over the domain — $w = the member list (BORROWED from
+  the domain nodeset; claiming ownership freed the members
+  mid-iteration — the corrupted-output signature), boundary vars
+  ($s/$sp/$e/$ep) as singles. Tumbling resumes after the end,
+  sliding after the start. Tuple snapshots carry $w whole.
+- XPath 2.0 value-comparison keywords (eq/ne/lt/le/gt/ge) in the
+  relational parser — bare NCNames at operand boundaries only.
+- Banked: xq_unbind_all must cover window names (the 2184B/query
+  overwrite leak, Linux LSan only); scan_word needs scan_ws FIRST
+  after a keyword token (the fifth bite of that invariant).
+
+Remaining for lane 12: typeswitch, error-code model for named
+catches, qt3tests 3.1 subset. Lane 11 tail: collection(),
+qt3tests 1.0 subset, Windows CLI harness.
+
+## Update 2026-09-03 (final): typeswitch + error codes + collection SHIPPED (v1.9.70 / PR #798)
+
+- typeswitch (E) case T return R ... default return RD — dispatch
+  through xpath_result_matches_type, the ONE SequenceType
+  classifier shared with instance-of (the type-name parse must
+  stop at 'return' — the keyword was swallowed into the type).
+- Error-code model: XPathContext.error_code (local part only) —
+  doc()/collection() set FODC0002, cast-lexical failures FORG0001;
+  named catches match, $err:code binds, channels clear on catch.
+- collection() = 'No default collection has been defined' (Saxon).
+- Drive-by: FOR's scalar-domain branch marks numeric members;
+  xpath_nodeset_deep_copy copies RAW content — its get_node_text
+  round-trip stripped the \x03N marker ($v instance of xs:integer
+  was false through any let/var deep-copy path — the typeswitch
+  bisect exposed a latent instance-of bug).
+
+Lane 12 language surface COMPLETE except qt3tests subset
+adoption. Lane 11 tail: qt3tests 1.0 subset, Windows CLI harness
+(collection() landed here).

data/vendor-src/libleptris/TODO.xslt-full/13-perf-inprocess.md

@@ -0,0 +1,425 @@
+# 13 — Performance: in-process parity + superiority (#682)
+
+#682: dispatch ~2.6x behind in-process libxslt (the v1.9.31/32
+comparison used xsltproc WALL time — in-process libx2 xsltApplyStylesheet
+is the honest reference). Work:
+- twin bench: bench_xslt_transform_libxml2 (in-process libxslt via
+  libxsltApplyStylesheet; the libxslt checkout + brew lib are
+  available) for s1/s2/s3 + XSLTMark corpus
+- profile s2 (13.5ms) against libxslt (~5ms): per-invoke template
+  overhead (frames, current_* save/restore), result-tree element
+  creation (out_append_elem path), attribute copies
+- levers: frame-free invoke fast path when no params/ns; pooled
+  result nodes reuse across iterations; sort index reuse
+- gates: fresh Release dirs, min-of-8 interleaved (benchmark-
+  discipline memory); PerfRegression budget updates; the harness
+  becomes the release scorecard (site G2/G3)
+Gate: s1/s2/s3 >= libxslt in-process on this machine, documented.
+
+## Status 2026-09-03 (v1.9.71-74) — three quadratics killed, gap
+## 12.83 → 10.56 ms vs lxml 4.69 ms (2.25x)
+
+Shipped:
+- v1.9.71 AVT compile cache (XsltExec.avt_cache — one compile per
+  transform, not per evaluation) + direct-mapped 8-slot mutation
+  tail cache (doc->mut_tail[(addr>>4)&7]; the single slot thrashed
+  on interleaved result-tree parents, ~2M sibling hops/transform).
+- v1.9.72 fragment tail caches (XsltExec.root_sib_tail/frag_tail —
+  fragment-level appends walked the chain per node; 50k top-level
+  value-of texts 1424ms → 10.6ms = 135x) + value-of select="."
+  parse-time fast path (select_is_dot → get_node_text).
+- v1.9.74 subtree duplicate: copy_subtree_detached threads the
+  dest pool (C 0.111→0.048ms; Ruby dup 2.27x Nokogiri).
+- Measured-and-DISCARDED: out_place_elem internal append (doc
+  resolution already O(1) via the name backpointer).
+
+Remaining (profile is DIFFUSE — no single >10% lever):
+- allocator churn ~7% (per-eval nodeset/result wrappers; a scratch
+  pool risks the clean document-scoped ownership model)
+- interpreter self: xslt_exec_instrs 7.4%, invoke_template 4.5%,
+  op_result_elem 4.5% — frame-free invoke fast path when a
+  template has no params/sorts is the next measurable lever
+- template dispatch: name-keyed candidate index (libxslt-style)
+  for stylesheets with many templates
+- harness: promote /tmp/dispatch_bench.c + vo_bench.c into
+  benchmarks/ as the release scorecard
+Open measurement protocol: best-of-batches, never mean.
+
+
+
+## Status 2026-09-04 (v1.9.79 candidate)
+
+- One-pass template selection shipped (PR #833): both selectors
+  matched every pattern alternative TWICE (any-match test + the
+  per-alternative priority loop); now one walk. Honest bench note:
+  inside the noise band on the 4-template scorecard (9.25-9.51ms
+  best-of-9 either way) — single-alternative ladders fail fast on
+  name mismatch; the win scales with alternative/template counts.
+- invoke_template is ALREADY stack-frame-free (stack arrays, var
+  pointer save/restore); bind_param_defaults breaks on the first
+  non-param instruction — the "frame-free invoke" lever from the
+  earlier profile is effectively free already.
+
+Remaining, in expected-value order:
+1. allocator churn ~7%: per-eval nodeset/result wrappers; a scratch
+   pool risks the document-scoped ownership model — needs a design
+   conversation before touching the memory model.
+2. op_call_template named-call scan is linear in template count —
+   a name-keyed index matters for template-heavy stylesheets, not
+   for the current scorecard (4 templates).
+3. profile again with a template-heavy fixture before claiming the
+   next lever (the 2000-book profile is diffuse by design).
+
+## Status 2026-09-05 — #682 phase A: template-heavy fixture shipped
+
+bench_xslt_dispatch_heavy (120 templates: 30 names x 3 modes +
+30-link named chain, 2400 elements) + heavy_lxml.py reference.
+
+Baseline (this machine, best of 9):
+- leptris 10.21 ms vs in-process lxml 3.12 ms = 3.27x
+  (the diffuse 2000-book profile reads 2.25x) — template-count-
+  scaled overhead confirmed. Next: sample this bench (not the
+  diffuse one) — expected suspects: op_call_template named-call
+  linear scan (60 templates), pattern alternative scan per
+  element (90 alternatives), mode-switch machinery.
+
+## Status 2026-09-05 (later) — #682 phase B: dispatch indexes shipped
+
+Three levers, exact-semantics-preserving:
+- named-template hash (open-addressed, inserts in sheet order so a
+  hit IS the last declaration = the §11.6 winner the linear scan
+  produced);
+- mode buckets (per-mode candidate arrays in sheet order);
+- bare-Name dispatch fast path (lone expr_name_only alternative =
+  child::NAME: name + no-ns check, no doc climb, no ladder).
+
+Numbers (same machine): heavy 10.21 -> 5.56 ms (1.83x; vs lxml
+3.12 = 1.78x behind, from 3.27x); light dispatch 10.5 -> 8.97 ms;
+transform/valueof unchanged. Full ctest 1285/1285.
+
+Post-fix profile (sample): tlv_get_addr 335 (TLS thunks - the
+free-lists), select_template self 167 + strcmp 162 (30-candidate
+scans - name-bucketing blocked by priority interplay), attr churn
+set_attribute 148 + probe 95 + rehash 92 (result-tree attrs),
+get_document 99 + get_pool 51 (per-result-element doc climbs),
+malloc/free ~244. NEXT SLICES in expected-value order: (1) result
+attr-index churn, (2) TLS/allocator consolidation - needs the
+design conversation (document-scoped ownership, TODO 13 item 1).
+
+## Measured-and-discarded 2026-09-05: attr-index lazy registration
+
+Below-4-attrs elements skipping doc-level attr-index registration
+(walk instead of sentinel+entry): heavy bench 5.56 -> 5.60ms =
+noise. The attr cluster in the profile is mut_str_carve + sv
+copies, not index maintenance. Reverted; do not re-try. The
+residual 1.78x gap is the diffuse remainder: TLS thunks (the
+nodeset/result free-lists), per-result-element doc/pool climbs,
+serializer, allocator - i.e. the consolidation item below, which
+needs the design conversation (document-scoped ownership).
+
+## 2x bar status (user directive 2026-09-06) + measured scorecard
+
+Bar: every XSLT bench >= 2x libxslt AND Saxon. References on
+byte-identical fixtures (best of 9): lxml in-process t=1.35ms
+l=2.72ms h=2.88ms p=32.1ms; xsltproc wall 7.3-9.9ms; Saxon-HE 12.5
+CLI wall ~500-600ms (JVM startup dominates; amortized-only
+comparisons need a persistent-JVM harness).
+
+Current (v1.9.93): transform 0.27ms = 5.0x AHEAD; pred 2.06ms =
+15.6x ahead; light 3.93ms = 0.69x BEHIND; heavy 5.13ms = 0.56x
+behind. Need ~3x on light+heavy.
+
+Light-bench profile today: node_get_next_sibling 143 (append tail
+walks on alternating fresh parents - the doc 64-slot cache still
+misses ~1/64 of ~6000 appends into a 1000-long chain), tlv_get_addr
+56 (TLS), malloc/free ~43. MEASURED-AND-REVERTED same day: exec-
+local two-entry append hint - neutral perf BUT orphaned nodes on
+include/attribute-heavy sheets (unrouted comment/PI/attr appends
+invalidate the hint; bug-107/129/195/196 in the 205-suite caught
+it; the 197-test unit suite did NOT). Any retry must route EVERY
+result append through the hint or invalidate on non-routed
+appends. Next levers: TLS consolidation (context-carried
+free-lists, authorized), serializer, per-result-element
+doc/pool climbs.
+
+## 2x arc instrumentation (2026-09-06, session tail)
+
+Measured with walk-counters + fresh profile: the light bench's
+next_sibling samples are NOT chain walks - 100k "walks" per 10
+transforms are all O(1) EMPTY-chain lookups (3 fresh-parent appends
+per book). The cost is CALL OVERHEAD + tlv_get_addr 437/3756 (11.6%)
++ malloc/free ~400 (10.6%). A doc-level repeated-parent hot entry
+(16B/doc, suite-green) measured NEUTRAL and was reverted to keep
+main pure - the thrash theory is DEAD; do not retry cache-shaped
+fixes. The remaining light/heavy gap = the consolidation arc and
+ONLY that: (1) per-call overhead in append/get_next_sibling (inline
+the empty-chain fast path: if !first_child return NULL - one branch
+in the CALLER), (2) TLS consolidation (context-carried free-lists),
+(3) malloc churn (result-tree text nodes). Next session starts with
+lever (1) - it is a 2-line change per call site with no invariants.
+
+## Lever-1 measured-and-discarded (same day): inline empty-chain fast path
+
+Patched both append miss paths to skip leptris_elem_last_child via a
+first_child_off check: suite green, light 3.99-4.11ms vs 3.89
+baseline = NEUTRAL. Both micro-levers (hot entry, inline fast path)
+are dead; the sampler's next_sibling weight is leaf-attribution
+noise. The light/heavy gap is TLS (11.6%) + malloc/free (10.6%) +
+diffuse eval serialization - the consolidation arc ONLY. Do not
+attempt further call-site micro-fixes; start at TLS.
+
+## Consolidation arc round 2 (2026-09-06, v1.9.94→95 session)
+
+Frame-pointer profile build (buildprof, -fno-omit-frame-pointer +
+RelWithDebInfo) got real stacks where the default build collapsed
+to main. Heavy-bench self-time ladder BEFORE this round:
+set_attribute 229 + attr_index_rehash 73 (largest block),
+serialize_element_internal 67, node_parent 55, select_template 45.
+
+LANDED (PR #887): (1) TLS consolidation - the 4 xpath free-list
+__thread vars collapse into one g_xpath_tls struct; light 3.83→3.57,
+heavy 4.96→4.45 best. (2) Walk-first attr dup check - elements with
+<=8 attrs walk the hash-prefiltered list instead of doc-index
+register+probe+put (XSLT result elements carry 1-3 attrs; the index
+was pure overhead). Note: the earlier "lazy registration" discard
+predates the #866/#873 dispatch indexes - its neutral verdict was
+stale; walk-first measured 4.45→3.83 heavy. Elements >8 attrs still
+lazily bulk-register (2000-attr O(N^2) specs green).
+
+LANDED (PR #889): ns-fixup walk skip - result_ns_in_scope + the
+bug-130 default-ns climb gated on result-doc has_namespaces (the
+exact any-declaration gate). Heavy 3.83→3.57.
+
+MEASURED-AND-DISCARDED this round (do not re-try):
+- Two-slot (root, doc) memo ring in get_document: heavy 3.57→3.98
+  (8% REGRESSION) despite the source/result alternation theory.
+  Single-slot memo stays.
+- Contiguous text-create swap in leptris_text_node_create: C-side
+  already 15-18ns/op in BOTH shapes (borrowed+strdup vs contiguous).
+  ruby#149's 884ns is ~98% ffi-gem seam. Binding-side fix required
+  (batch entry or C-ext hot path); findings posted on leptris-ruby
+  #147/#149.
+
+Scorecard after v1.9.95 + #889 (best of 9): light 3.57 (lxml 2.72
+= 0.76x), heavy 3.57 (lxml 2.88 = 0.81x), transform 0.27 (5.0x),
+pred 2.06 (15.6x). Heavy profile now diffuse: serialize 111,
+select_template 87, op_result_elem 87, get_next_sibling 59,
+get_document 56, exec_instrs 51, element_create 49, eval_avt 47.
+Next slices: serializer result path, result-element creation
+cluster, eval_avt. All call-site micro-levers remain dead (banked
+below).
+
+## Round 3 status + the honest 2x-bar math (2026-09-07)
+
+ruby#150 answered engine-side (direct attr read = 23-28ns/op,
+borrowed pointer, zero C allocs; 568ns is the ffi-gem seam; options
+posted on the binding issue). Heavy profile on current main
+(v1.9.97): serialize 122, set_attribute 109 (sampler attribution
+swings between builds; the index is GONE - walk-first holds),
+op_result_elem 91, select_template 82, node_parent 71,
+get_next_sibling 59, get_document 59, element_create 57,
+apply_templates 55, eval_avt 53, exec_instrs 46, ast_cache 40+24,
+append 38. NOTHING above 5%. version bump = plain field++, not a
+lever.
+
+2x-BAR CEILING ANALYSIS (the design conversation the bank keeps
+deferring): light 3.57 / heavy 3.57 vs lxml 2.72 / 2.88 = 0.76x /
+0.81x. The bar (>=2x = light <=1.36ms, heavy <=1.44ms) needs a 60%
+runtime cut. Remaining coherent levers and their quantified
+ceilings: (a) result-tree STREAMING for apply_string (skip DOM
+materialization when the sheet holds no RTFs/keys-on-result -
+serializes during construction): replaces ~18% of samples (create
++ set_attribute + append + serialize cluster) minus the emit cost
+it adds ~= 10-15% net. (b) eval-side (select_template/apply/instrs/
+avt/ast_cache) rewrites ~= 10% at heroic effort. (c) remaining
+micro levers ~= 5-8%. TOTAL PLAUSIBLE ~= 25-30% => ~2.6ms ~= 1.1x
+lxml. THE 2x BAR ON THE DISPATCH FIXTURES IS NOT REACHABLE by
+optimization alone while libxslt does the identical work at 2.88ms
+- we are 24% behind a 20-year-tuned C engine on ITS core shape.
+Where we ARE >=2x: transform 5.0x, pred 15.6x (the shapes users
+actually transform with). DECISION FOR THE USER: (1) pursue
+streaming anyway (buys ~15%, lands us ~1.1-1.2x - still "behind"
+by the letter of the bar), or (2) re-scope the bar for dispatch
+shapes to ">=1x in-process libxslt + >=2x xsltproc wall" (already
+true: xsltproc wall 7.3-9.9ms vs our 3.57), or (3) accept the
+fixture verdict and close #682. Do NOT silently grind micro-levers
+expecting the bar to appear.
+
+LATENT HAZARD found + hardened (same session): leptris_elem_
+split_qname advances e->name past the colon but kept the Round-21
+namebp flag set - name[-1] would read NAME BYTES as a doc pointer
+for unattached prefixed elements. Masked by register-on-create
+(map hit precedes the backpointer fallback). Fix: split_qname
+clears the flag; RED spec MutNameBackpointer.PrefixedSplit-
+ClearsBackpointerFlag pins it. LESSON: register-on-create is the
+ONLY backstop for split-name elements - any register-elision perf
+work must first restructure the backpointer to survive the split.
+## PARITY MANDATE + streaming design (2026-09-07, user decision)
+
+User: "We must beat it, at least we must reach parity now and
+improve speed later. Then start and finish HTML and RNG." PARITY
+TARGETS: heavy <= 2.88ms (now 3.59 after register-elision), light
+<= 2.72ms (now ~3.55). Remaining gap ~20%.
+
+THE DESIGNATED PATH: streaming result emission for apply_string.
+Key soundness fact: the XSLT data model forbids reading the
+principal result tree during execution - streaming it is ALWAYS
+spec-safe. Phase plan:
+- Phase 1: result-sink abstraction in xslt_exec (mode: TREE |
+  STREAM). STREAM = SerializeBuffer + open-element stack +
+  pending-tag buffer (xsl:attribute must land inside the open tag
+  before the first child - libxslt's pending-writer pattern).
+- Phase 2: element/text/attr fast-path emitters at the out_* funnels
+  (out_place_elem / out_append_elem / text appends); tree ops fall
+  back by flushing pending tags.
+- Phase 3: gate = sheet scan at parse time (xsl:variable/@select
+  RTF shapes don't matter - only the PRINCIPAL result streams;
+  disable for d-o-e edge shapes the 205-suite pins if any diverge).
+- Red zone: bug-98 ws_mixed, cdata-section-elements, character
+  maps, indent (depth tracking), html method. Each needs its
+  stream-side twin or the gate excludes the sheet.
+Expected: ~15% on dispatch shapes + register-elision's 4% ~= parity.
+LANDED this round: register-elision (PR #897, heavy ~4%); #869
+digest (PR #896) - orthogonal capability.
+NEXT SESSION ORDER: streaming phases 1-3 -> HTML #659 (implied head
+-> foster -> AA; the 865-case bucket) -> RNG #878 phases 1-4.
+
+## SAX binding-drain: kind-strip shipped, field-strip inconclusive (2026-09-07)
+
+PR leptris-ruby#156 MERGED (user-directed after repeated asks): cold
+bare Elem#[] 17.2 -> 4.0 allocs/read; SAX kind-strip (get_uint8 per
+event, no full-record copy/unpack) 24.2 -> 23.0ms quiet-window.
+FOLLOW-UP TRIED AND NOT SHIPPED: universal field strip (one unpack
+per chunk: kind + name_off/len + text_off/len per record, template
+"Cx7LLLLx#{STRIDE - NAME_OFF - 16}") — the tail skip is
+STRIDE - NAME_OFF - 16 (four Ls END at NAME_OFF+16); TEXT_LEN is an
+OFFSET not a size (first attempt overran; the arity spec caught
+it). Corrected version measured INCONCLUSIVE under load 30-100
+(fix 32.7-35.8 tight vs main 25.9-44.0 spread — windows not
+comparable): the ~300k-value unpack + array allocation costs
+roughly what the ~120k get_uint32 (~60ns each) saved. RETRY only on
+a quiet machine, best-of-20; if it loses again the drain residual
+is Ruby dispatch itself and the real lever is an ENGINE-side
+batched drain API (parallel arrays out of one call) — file as an
+issue when picked up.
+
+## CLOSED 2026-09-12 (measured): moxml NS-heavy reads 0.69x —
+## the expanded-name/prefixed-path lever
+
+HYPOTHESIS DISPROVEN. Built the full parse-time stamping design
+(DParser scope-binding stack + element ns_uri stamp + attr
+resolved-uri side-cache + public fast paths), guard specs green
+— and the C-level bench did not move: expanded-name reads are
+~20ns either way (first-pass 0.336ms -> 0.344ms / 15k attr
+reads; element traversal identical; the lazy element cache and
+the short decl lists keep the walk off the profile). The 0.69x
+row is NOT in the C resolver — it lives in the leptris-ruby
+adapter loop (FFI call count / per-read Ruby allocations).
+NEXT ACTION (leptris-ruby repo, PR-only): profile the moxml
+adapter's expanded-name loop in Ruby (benchmark-ips + stackprof);
+candidate levers = batched expanded-name reads (one C call
+returning name+prefix+uri, e.g. a leptris_element_expanded_name
+out-param API the adapter uses instead of 3 FFI calls) and
+memoized Ruby-side wrappers. The C-side work is banked in this
+file's git history if the batched accessor lands (branch
+
+
+## CLOSED 2026-09-12 (final): the moxml 0.69x row — measured to
+## the bottom, four ways
+
+1. C resolver: parse-time stamping built + guard-specs green —
+   bench unmoved (~20ns/read either way; the walk is off the
+   profile). Discarded unpushed.
+2. Raw FFI fan-out: 3 calls 48ms vs 1 batched+3 reads 52ms per
+   180k reads — batching does not pay at this call cost (~80ns).
+3. Gem steady-state: identical (memoization already absorbs
+   repeats; the loop cost is element_children wrapper allocs).
+4. Gem cold first-touch: batching SLOWER (63ms -> 100ms; the
+   buffer+tuple allocation per element outweighs the saved
+   crossing). Reverted.
+
+VERDICT: the row sits in moxml's own wrapper/materializer layer
+(its adapter rides the leptris GEM, and our gem layers are
+measured off the deficit). leptris_element_expanded_name ships
+(v1.9.144) as an adapter-available primitive for anyone who does
+pay per-read fan-out; our gem keeps per-accessor calls. If the
+row must move, the work is in moxml's repo (external-PR style):
+profile their NS-read bench (benchmark-ips + stackprof) and fix
+their materializer — the leptris stack underneath is not the
+cost.
+
+## DOM vs pugixml race (2026-09-12, user directive: "why are we not
+## zero-copy?")
+
+Answer: the PARSER already is (names/attrs/values NUL-terminated
+in-place in the buffer copy, same strategy as pugixml load_buffer).
+The losses were bookkeeping, and the big one is FIXED (PR #1017):
+
+- attr-heavy-5k parse: 2086 -> 769 us (2.7x faster; 4.9x -> 1.96x
+  vs pugixml). Root cause: the #635 raw-view was built with one
+  pool_alloc + tail walk PER ATTR + one ns_cache alloc per
+  attr-bearing element; the #542 owner stamp added a post-loop
+  memchr per attr. Fix: 128-entry chunk carve + parser-local tail;
+  owner cache inline at colon detection. Specs:
+  RawAttributesAcrossChunkBoundaries (two chunk exhaustions).
+- Remaining parse gap (769 vs 393): element path (name-hash walk,
+  register-on-create bookkeeping), the fused sizing pre-scan +
+  buffer copy, per-element ns_cache alloc. Next levers, ranked by
+  expected value: (1) ns_cache chunk carve, (2) element name-hash
+  fusion with the split walk (already fused — dp_split_hash_name),
+  (3) the sizing pre-scan. Each ~5-10%.
+
+## Measured-and-BANKED: the mutation rows (append 3.4x, set-attr
+## 2.4x behind pugixml) are a NODE-LAYOUT lane, not tweaks
+
+Split (best-of-200 harness, 10k ops): create-only 20.6 ns/op,
+append-only 18.9 ns/op; pugixml append_child 11.6 ns/op for BOTH.
+Structural floor for the current 96-byte element: memset ~4ns +
+two pool carves ~5ns + FNV hash ~2ns (create >= 12ns); call chain
++ double parent decode + type-dispatching sibling setter + ~8
+stores (append >= 8ns) ~= 20ns floor vs pugi 44-byte nodes at
+11.6ns. Cheap swings identified (dispatch-free sibling store,
+wrapper chain collapse) total <= 10% — below the effort bar.
+Reaching <= 1x needs the compact-node redesign (44-56B nodes,
+lazy name-hash/init) — the same class of decision as the #682
+scope call; USER CALL. Do NOT micro-grind this row awaiting it.
+Known hazard from the split_qname incident: register-on-create
+elision (part of any lazy-init design) must FIRST restructure the
+name backpointer to survive in-place QName splits.
+
+## RESOLVED same day: the carve ships as PR #1023
+
+ROOT CAUSE (pointer instrumentation, 15 min after 3 failed
+hypotheses): the chunk-exhaustion branch wrote `c = cursor = c + 1`
+— returns entry 1 while the cursor POINTS AT entry 1, so the next
+fresh allocation reuses the same address (cache aliasing: the
+second element's cache zeroed the first's xmlns declarations ->
+52/205 libxslt failures). The fix = the shipped raw-attr form
+(`cursor = c + 1`, use entry 0). v1.9.147's raw-attr path verified
+already-correct. Result: attr-heavy 684 -> 641 us, suite 205/205,
+parity held. META-LESSON: the three failed hypotheses were all
+"equivalent rewrite" reasoning; one instrumented run ended it.
+
+## Measured-and-REVERTED 2026-09-12 (round 3): ns_cache chunk carve
+
+The per-element ns_cache pool_alloc (5000 on attr-heavy) replaced by
+a 64-entry chunk carve measured 684 -> 640 us (-6.4%) BUT broke the
+libxslt suite deterministically (52/205; the gate caught what the
+standalone tree probe missed). Isolated symptom: on
+<xsl:stylesheet xmlns:xsl=...>, leptris_element_expanded_name
+returns prefix=xsl uri=NULL with the carve (uri resolves on main).
+Both halves independently contribute (xmlns-branch reroute alone:
+52; dp_raw_attr ensure-cache alone: 36). NOT re-applied — root
+cause unfound; next attempt starts by tracing the element_query
+prefix->URI resolver (own cache slot vs declarations walk) before
+touching allocation. LESSON: allocation-pattern changes in the
+parse path are LAYOUT-SENSITIVE here; the suite is the gate, single
+-shape probes are not. READ-PATH MAPPED for
+the next attempt: get_namespace_uri is LAZY (element.c:449 —
+cache slot first, then lookup_namespace walking
+ns_cache->declarations, result cached back into the slot); the
+parse interleaves dp_split_hash_name's set_prefix (creates the
+cache, inits ONLY 3 of 7 fields — raw_attrs/doc_next/heap-flags
+left raw on dirty pages) with the xmlns-branch wiring. Compare the
+cache LIFETIME ordering (set_prefix-created vs carve-created) on a
+prefixed+declaring element before re-applying.