perf: combined Tier 1 rollup

Octopus merge of the three independent perf branches into one rollup
so reviewers can evaluate the cumulative impact on a single bench run.
Each underlying branch is also pushed on its own and can land
independently.

Branches merged:
- perf/prepare-list-no-splice  (Closes syntax-tree#49, Refs syntax-tree#50)
- perf/dispatch-context-reuse
- perf/stable-node-shape

Cumulative impact, multi-run median-of-medians vs the baseline
(spread in parentheses):

  10,000 character entity references     -43.8%  (7.5%)
  10,000 single-level list items         -42.9%  (11.6%, borderline)
  CommonMark spec * 35  (~564 KB)        -13.8%  (1.0%, very clean)
  full CommonMark spec  (~16 KB)         -12.3%  (7.9%)
  CommonMark spec * 7  (~113 KB)          -8.5%  (1.0%, very clean)
  'xxxx' x 10,000  (~40 KB)               -4.0%  (9.0%)

Single-run full corpus shows wins on 20 of 27 inputs, ranging from
-1% to -43%. The largest pathological wins are inputs heavy in
character entity references (-42.2%), fenced code blocks (-40.7%),
single-level list items (-37.0%), tabs (-35.6%), ATX headings
(-28.2%), backtick code spans (-24.4%), inline links (-22.3%),
inline images (-21.5%), HTML blocks (-15.3%), and one CommonMark
example (-16.4%).

Trade-offs:

A 1 MB single paragraph reported +5.3% multi-run with a 9.4% spread,
and +11.6% on a single full-corpus run. None of the three changes
target the single-text-node path, so the small regression is the
edge of that input's noise band. A 256 KB Unicode-heavy input
reported +2.3% multi-run inside its 11.4% spread (treat as flat).
A 10,000-unmatched-asterisk input moved +0.8% multi-run (flat).

The pure emphasis stress inputs ('a**b' repeated 10,000 times and
similar) reported +44% and +58% on a single run, but their cross-run
spread is 44 to 53% on the baseline alone. The input shape (almost
all attentionSequence events that mostly do not match a handler, no
lists, no node-creation hot path) means none of the three
optimizations can target what these inputs exercise. Treat the
deltas as noise.

Tests pass: dev + prod 1448/1448, mdast-util-gfm 54/54,
mdast-util-mdx 11/13. The two failing mdx tests reproduce on
upstream/main and are not introduced by this branch.

Author: ChristianMurphy

dev/lib/index.js

@@ -212,7 +212,7 @@ function compiler(options) {
    */
   function compile(events) {
     /** @type {Root} */
-    let tree = {type: 'root', children: []}
+    let tree = {type: 'root', children: [], position: undefined}
     /** @type {Omit<CompileContext, 'sliceSerialize'>} */
     const context = {
       stack: [tree],
@@ -247,17 +247,25 @@ function compiler(options) {
 
     index = -1
 
+    // The handler this-binding receives the same fields as `context` plus a
+    // per-event `sliceSerialize`. Pre-allocate the merged object once outside
+    // the loop and mutate sliceSerialize per event instead of allocating a
+    // fresh merged object per event. Stack/tokenStack/data references stay
+    // shared with `context`, so mutations inside handlers remain visible to
+    // the post-loop code via `context.tokenStack`.
+    const callContext = /** @type {CompileContext} */ (
+      /** @type {unknown} */ (
+        Object.assign({sliceSerialize: undefined}, context)
+      )
+    )
+
     while (++index < events.length) {
-      const handler = config[events[index][0]]
-
-      if (own.call(handler, events[index][1].type)) {
-        handler[events[index][1].type].call(
-          Object.assign(
-            {sliceSerialize: events[index][2].sliceSerialize},
-            context
-          ),
-          events[index][1]
-        )
+      const event = events[index]
+      const handler = config[event[0]]
+
+      if (own.call(handler, event[1].type)) {
+        callContext.sliceSerialize = event[2].sliceSerialize
+        handler[event[1].type].call(callContext, event[1])
       }
     }
 
@@ -307,6 +315,14 @@ function compiler(options) {
     let firstBlankLineIndex
     /** @type {boolean | undefined} */
     let atMarker
+    /**
+     * Insertions accumulated in walk order: each {at, event} maps to an
+     * `events.splice(at, 0, event)` in the original implementation. Applied
+     * once at the end so a wide list's per-item O(n) splice cost collapses
+     * to a single batched rebuild.
+     * @type {Array<{at: number, event: Event}>}
+     */
+    const insertions = []
 
     while (++index <= length) {
       const event = events[index]
@@ -413,9 +429,10 @@ function compiler(options) {
             lineIndex ? events[lineIndex][1].start : event[1].end
           )
 
-          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])
-          index++
-          length++
+          insertions.push({
+            at: lineIndex || index,
+            event: ['exit', listItem, event[2]]
+          })
         }
 
         // Create a new list item.
@@ -429,17 +446,100 @@ function compiler(options) {
             end: undefined
           }
           listItem = item
-          events.splice(index, 0, ['enter', item, event[2]])
-          index++
-          length++
+          insertions.push({at: index, event: ['enter', item, event[2]]})
           firstBlankLineIndex = undefined
           atMarker = true
         }
       }
     }
 
+    // Apply all insertions outside the iteration loop so a wide list's
+    // O(n*k) shift cost collapses to a single batched rebuild.
+    //
+    // Two paths: small lists (most documents, including deep nesting) take
+    // the splice fast path, which avoids the cost of allocating a fresh
+    // newSub array. Wide lists go through the batched rebuild and use a
+    // chunked spread to stay under V8's argument-count limit.
+    if (insertions.length > 0) {
+      // The fast path costs one splice per insertion, each shifting the
+      // events suffix by 1; total cost is O(K * suffix). The rebuild path
+      // costs one allocation, one sort, and one splice replacing the
+      // whole range; total cost is O(N + K) plus a fixed allocation and
+      // sort overhead. Below some K the rebuild's constant overhead
+      // dominates the per-insertion splice work; above some K the fast
+      // path's K * suffix dominates the rebuild's bounded cost. The
+      // crossover varies by document shape, so this threshold is a
+      // balance between deeply nested lists (which favor staying on the
+      // fast path) and documents whose lists outgrow the constants
+      // (which favor the rebuild). The chosen value was confirmed by
+      // sweeping the threshold across representative inputs.
+      const SMALL_LIST_LIMIT = 8
+      if (insertions.length <= SMALL_LIST_LIMIT) {
+        // Splice from latest `at` to earliest so unsplice'd positions stay
+        // valid. Same-`at` groups are reversed compared to walk order, which
+        // produces the same final ordering the original splice loop did
+        // (exit before enter at the same insertion point).
+        let insertion = insertions.length
+        while (insertion-- > 0) {
+          events.splice(
+            insertions[insertion].at,
+            0,
+            insertions[insertion].event
+          )
+        }
+      } else {
+        insertions.sort((a, b) => a.at - b.at)
+        const rangeLength = length - start + 1
+        /** @type {Array<Event>} */
+        const replacement = Array.from({
+          length: rangeLength + insertions.length
+        })
+        let writeIndex = 0
+        let insertionIndex = 0
+        let sourceIndex = start
+        while (sourceIndex <= length) {
+          while (
+            insertionIndex < insertions.length &&
+            insertions[insertionIndex].at === sourceIndex
+          ) {
+            replacement[writeIndex++] = insertions[insertionIndex].event
+            insertionIndex++
+          }
+
+          replacement[writeIndex++] = events[sourceIndex++]
+        }
+
+        // V8 limits the number of arguments that can be spread into a
+        // function call before triggering a stack overflow. Splice into a
+        // single call when the new sub-array fits comfortably below that
+        // limit; otherwise empty the range with one splice and refill it
+        // in chunks so no individual call hits the limit. The chunk size
+        // matches the threshold micromark-util-chunked uses for its own
+        // splice helper, which tracks the same V8 constraint.
+        const SAFE_SPREAD = 10_000
+        if (replacement.length <= SAFE_SPREAD) {
+          events.splice(start, rangeLength, ...replacement)
+        } else {
+          events.splice(start, rangeLength)
+          let chunkStart = 0
+          while (chunkStart < replacement.length) {
+            const chunkEnd = Math.min(
+              chunkStart + SAFE_SPREAD,
+              replacement.length
+            )
+            events.splice(
+              start + chunkStart,
+              0,
+              ...replacement.slice(chunkStart, chunkEnd)
+            )
+            chunkStart = chunkEnd
+          }
+        }
+      }
+    }
+
     events[start][1]._spread = listSpread
-    return length
+    return length + insertions.length
   }
 
   /**
@@ -1137,19 +1237,31 @@ function compiler(options) {
   // Creaters.
   //
 
+  // Each node factory pre-declares `position` as undefined as the trailing
+  // property. enter() patches it to a real value, but the property already
+  // exists, so V8 sees a single hidden class for each node type from
+  // construction through the rest of the pipeline. Without the pre-declare,
+  // each node took a hidden-class transition when enter() added position.
+
   /** @returns {Blockquote} */
   function blockQuote() {
-    return {type: 'blockquote', children: []}
+    return {type: 'blockquote', children: [], position: undefined}
   }
 
   /** @returns {Code} */
   function codeFlow() {
-    return {type: 'code', lang: null, meta: null, value: ''}
+    return {
+      type: 'code',
+      lang: null,
+      meta: null,
+      value: '',
+      position: undefined
+    }
   }
 
   /** @returns {InlineCode} */
   function codeText() {
-    return {type: 'inlineCode', value: ''}
+    return {type: 'inlineCode', value: '', position: undefined}
   }
 
   /** @returns {Definition} */
@@ -1159,13 +1271,14 @@ function compiler(options) {
       identifier: '',
       label: null,
       title: null,
-      url: ''
+      url: '',
+      position: undefined
     }
   }
 
   /** @returns {Emphasis} */
   function emphasis() {
-    return {type: 'emphasis', children: []}
+    return {type: 'emphasis', children: [], position: undefined}
   }
 
   /** @returns {Heading} */
@@ -1174,28 +1287,41 @@ function compiler(options) {
       type: 'heading',
       // @ts-expect-error `depth` will be set later.
       depth: 0,
-      children: []
+      children: [],
+      position: undefined
     }
   }
 
   /** @returns {Break} */
   function hardBreak() {
-    return {type: 'break'}
+    return {type: 'break', position: undefined}
   }
 
   /** @returns {Html} */
   function html() {
-    return {type: 'html', value: ''}
+    return {type: 'html', value: '', position: undefined}
   }
 
   /** @returns {Image} */
   function image() {
-    return {type: 'image', title: null, url: '', alt: null}
+    return {
+      type: 'image',
+      title: null,
+      url: '',
+      alt: null,
+      position: undefined
+    }
   }
 
   /** @returns {Link} */
   function link() {
-    return {type: 'link', title: null, url: '', children: []}
+    return {
+      type: 'link',
+      title: null,
+      url: '',
+      children: [],
+      position: undefined
+    }
   }
 
   /**
@@ -1208,7 +1334,8 @@ function compiler(options) {
       ordered: token.type === 'listOrdered',
       start: null,
       spread: token._spread,
-      children: []
+      children: [],
+      position: undefined
     }
   }
 
@@ -1221,28 +1348,29 @@ function compiler(options) {
       type: 'listItem',
       spread: token._spread,
       checked: null,
-      children: []
+      children: [],
+      position: undefined
     }
   }
 
   /** @returns {Paragraph} */
   function paragraph() {
-    return {type: 'paragraph', children: []}
+    return {type: 'paragraph', children: [], position: undefined}
   }
 
   /** @returns {Strong} */
   function strong() {
-    return {type: 'strong', children: []}
+    return {type: 'strong', children: [], position: undefined}
   }
 
   /** @returns {Text} */
   function text() {
-    return {type: 'text', value: ''}
+    return {type: 'text', value: '', position: undefined}
   }
 
   /** @returns {ThematicBreak} */
   function thematicBreak() {
-    return {type: 'thematicBreak'}
+    return {type: 'thematicBreak', position: undefined}
   }
 }