rusteerio 1.1.1 → 1.1.2

package/native/src/tokenizer.rs

@@ -1,13 +1,15 @@
 //! Build htmlparser2-compatible trees from tokenizer events. Events come from
 //! the native tokenizer port or from an explicitly supplied JavaScript
 //! Tokenizer, whose recorded events directly determine the DOM.
-use crate::arena::{append_parsed, html_parser_void, implied_close, DomArena, DomNode};
+use crate::arena::{
+    append_parsed, append_parsed_new, append_parsed_text, html_parser_void, implied_close,
+    DomArena, DomNode,
+};
 use crate::markup_tokenizer::Token;
 use serde_json::{json, Map, Value};
 
 struct Pending {
     name: String,
-    attrs: Map<String, Value>,
     start: usize,
 }
 struct Builder<'a> {
@@ -16,6 +18,9 @@ struct Builder<'a> {
     parents: Vec<u32>,
     foreign: Vec<bool>,
     pending: Option<Pending>,
+    /// The pending tag's attributes in source order, collected so its map is
+    /// allocated once at its final size.
+    attributes: Vec<(String, String)>,
     attribute_name: String,
     attribute_value: String,
     start: usize,
@@ -40,14 +45,21 @@ impl<'a> Builder<'a> {
         let with_end_indices = options.get("withEndIndices") == Some(&Value::Bool(true));
         let recognize_self_closing = options.get("recognizeSelfClosing").and_then(Value::as_bool);
         let mut arena = DomArena::from_records(vec![DomNode::new("root")], options);
-        // Growing the arena one doubling at a time copies every node record again.
-        arena.nodes.reserve(source.units.len() / 48);
+        // Growing the arena one doubling at a time copies every node record
+        // again. Every node but text starts with `<`, and text lies between them.
+        let markup_starts = source
+            .units
+            .iter()
+            .filter(|unit| **unit == u16::from(b'<'))
+            .count();
+        arena.nodes.reserve(markup_starts + 1);
         Self {
             arena,
             source,
             parents: vec![0],
             foreign: vec![xml],
             pending: None,
+            attributes: Vec::new(),
             attribute_name: String::new(),
             attribute_value: String::new(),
             start: 0,
@@ -109,9 +121,9 @@ impl<'a> Builder<'a> {
                 self.foreign.push(false);
             }
         }
+        self.attributes.clear();
         self.pending = Some(Pending {
             name,
-            attrs: Map::new(),
             start: self.start,
         });
     }
@@ -123,18 +135,25 @@ impl<'a> Builder<'a> {
                 "style" if !self.xml => "style",
                 _ => "tag",
             };
-            let mut node = DomNode::new(kind);
             let lowercase_name = (pending.name.bytes().any(|byte| byte.is_ascii_uppercase()))
                 .then(|| pending.name.to_ascii_lowercase());
-            node.name = Some(pending.name);
-            node.attribs = pending.attrs;
-            let id = append_parsed(
+            let id = append_parsed_new(
                 &mut self.arena,
                 *self.parents.last().unwrap(),
-                node,
+                kind,
                 pending.start,
                 self.end,
             );
+            let node = &mut self.arena.nodes[id as usize];
+            node.name = Some(pending.name);
+            let mut attribs = Map::with_capacity(self.attributes.len());
+            for (name, value) in self.attributes.drain(..) {
+                // A repeated attribute keeps its first value, as htmlparser2 does.
+                if let serde_json::map::Entry::Vacant(entry) = attribs.entry(name) {
+                    entry.insert(Value::String(value));
+                }
+            }
+            node.attribs = attribs.into();
             let name = lowercase_name
                 .as_deref()
                 .or(self.arena.nodes[id as usize].name.as_deref())
@@ -153,12 +172,10 @@ impl<'a> Builder<'a> {
     }
     fn text(&mut self, data: String, end: usize) {
         self.end = end.saturating_sub(1);
-        let mut node = DomNode::new("text");
-        node.data = Some(data);
-        append_parsed(
+        append_parsed_text(
             &mut self.arena,
             *self.parents.last().unwrap(),
-            node,
+            data,
             self.start,
             self.end,
         );
@@ -422,12 +439,9 @@ impl Builder<'_> {
     fn on_attribute_end(&mut self, end: usize) {
         self.end = end;
         let value = std::mem::take(&mut self.attribute_value);
-        if let Some(pending) = self.pending.as_mut() {
-            if !pending.attrs.contains_key(&self.attribute_name) {
-                pending
-                    .attrs
-                    .insert(self.attribute_name.clone(), Value::String(value));
-            }
+        if self.pending.is_some() {
+            self.attributes
+                .push((std::mem::take(&mut self.attribute_name), value));
         }
     }
     fn on_close_tag(&mut self, start: usize, end: usize) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rusteerio",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Cheerio-compatible HTML processing with a Rust engine and parallel, non-blocking extraction",
   "license": "MIT",
   "repository": {

package/src/extract.ts

@@ -1,8 +1,11 @@
 import { Cheerio, nativeExtractionMethods } from './selection.js';
 import { types } from 'node:util';
 import { compileExtractPlan, hydrateExtractResult } from './extract-plan.js';
-import { writeCount } from './router.js';
-import type { AnyNode, Element, ExtractMap, ExtractedMap, ExtractDescriptor } from './types.js';
+import { decodeJson } from './codec.js';
+import { DOCUMENT, writeCount } from './router.js';
+import type { AnyNode, CheerioOptions, Element, ExtractMap, ExtractedMap, ExtractDescriptor } from './types.js';
+
+type ExtractPlan = NonNullable<ReturnType<typeof compileExtractPlan>>;
 
 export interface ExtractMethods<T = AnyNode> {
   extract<M extends ExtractMap>(map: M): ExtractedMap<M>;
@@ -12,26 +15,32 @@ function plainKeys(map: ExtractMap): string[] | undefined {
   return !types.isProxy(map) && (Object.getPrototypeOf(map) === Object.prototype || Object.getPrototypeOf(map) === null) ? Object.keys(map) : undefined;
 }
 function nativePrefix(scope: Cheerio<AnyNode>, map: ExtractMap, keys: string[] | undefined, key: string): { keys: string[]; values: Record<string, unknown> } | undefined {
-  if (!keys || scope._make !== nativeExtractionMethods.make || scope._findBySelector !== nativeExtractionMethods.find || scope.prop !== nativeExtractionMethods.prop || scope.extract !== nativeExtractionMethods.extract) return undefined;
+  if (!keys || !hasNativeExtraction(scope)) return undefined;
+  const prefix = prefixPlan(map, keys, key, scope.options);
+  // A single scalar entry costs one selector call and one property call; the
+  // native plan also avoids constructing an intermediate selection for each.
+  if (!prefix) return undefined;
+  return { keys: prefix.names, values: runPlan(scope, prefix.plan) };
+}
+
+/** The native plan for the longest run of entries from `key` on that compile to one. */
+function prefixPlan(map: ExtractMap, keys: string[], key: string, options: CheerioOptions): { names: string[]; plan: ExtractPlan } | undefined {
   const prefix: ExtractMap = Object.create(null);
-  let count = 0;
-  let plan: ReturnType<typeof compileExtractPlan>;
-  const index = keys.indexOf(key);
-  for (let position = index; position < keys.length; position++) {
+  let plan: ExtractPlan | undefined;
+  for (let position = keys.indexOf(key); position < keys.length; position++) {
     const name = keys[position];
     const slot = Object.getOwnPropertyDescriptor(map, name);
     if (!slot || !slot.enumerable || !('value' in slot)) break;
     Object.defineProperty(prefix, name, { value: slot.value, enumerable: true, configurable: true });
-    const compiled = compileExtractPlan(prefix, scope.options);
+    const compiled = compileExtractPlan(prefix, options);
     if (!compiled) { delete prefix[name]; break; }
-    plan = compiled; count++;
+    plan = compiled;
   }
-  // A single scalar entry costs one selector call and one property call; the
-  // native plan also avoids constructing an intermediate selection for each.
-  if (!plan || !count) return undefined;
-  const values = scope.op<Record<string, unknown>>('extractPlan', { ids: scope.ids, plan });
-  hydrateExtractResult(values, plan.entries);
-  return { keys: Object.keys(prefix), values };
+  return plan ? { names: Object.keys(prefix), plan } : undefined;
+}
+
+function hasNativeExtraction(scope: Cheerio<AnyNode>): boolean {
+  return scope._make === nativeExtractionMethods.make && scope._findBySelector === nativeExtractionMethods.find && scope.prop === nativeExtractionMethods.prop && scope.extract === nativeExtractionMethods.extract;
 }
 
 /** Descriptor callbacks stay in JavaScript; matching and properties use Rust. */
@@ -87,8 +96,19 @@ interface NativeRows { keys: Set<string>; rows: Record<string, unknown>[]; write
  * exactly the fields before it, as in Cheerio.
  */
 function nativeRows(scope: Cheerio<AnyNode>, key: string, all: boolean, selector: string, map: ExtractMap): NativeRows | undefined {
+  if (!hasNativeExtraction(scope)) return undefined;
+  const planned = rowsPlan(key, all, selector, map, scope.options);
+  if (!planned) return undefined;
+  const writes = writeCount();
+  const extracted = runPlan(scope, planned.plan)[key];
+  const rows = (all ? extracted : extracted === undefined ? [] : [extracted]) as Record<string, unknown>[];
+  return Array.isArray(rows) ? { keys: planned.nativeKeys, rows, writes } : undefined;
+}
+
+/** The native plan for the fields of `map` that compile to one, when only some do. */
+function rowsPlan(key: string, all: boolean, selector: string, map: ExtractMap, options: CheerioOptions): { nativeKeys: Set<string>; plan: ExtractPlan } | undefined {
   const keys = plainKeys(map);
-  if (!keys || scope._make !== nativeExtractionMethods.make || scope._findBySelector !== nativeExtractionMethods.find || scope.prop !== nativeExtractionMethods.prop || scope.extract !== nativeExtractionMethods.extract) return undefined;
+  if (!keys) return undefined;
   const subset: ExtractMap = Object.create(null);
   const nativeKeys = new Set<string>();
   for (const name of keys) {
@@ -96,21 +116,94 @@ function nativeRows(scope: Cheerio<AnyNode>, key: string, all: boolean, selector
     if (!slot || !slot.enumerable || !('value' in slot)) continue;
     const single: ExtractMap = Object.create(null);
     Object.defineProperty(single, name, { value: slot.value, enumerable: true, configurable: true });
-    if (!compileExtractPlan(single, scope.options)) continue;
+    if (!compileExtractPlan(single, options)) continue;
     Object.defineProperty(subset, name, { value: slot.value, enumerable: true, configurable: true });
     nativeKeys.add(name);
   }
   if (!nativeKeys.size || nativeKeys.size === keys.length) return undefined;
   const outer: ExtractMap = Object.create(null);
   Object.defineProperty(outer, key, { value: all ? [{ selector, value: subset }] : { selector, value: subset }, enumerable: true, configurable: true });
-  const plan = compileExtractPlan(outer, scope.options);
-  if (!plan) return undefined;
-  const writes = writeCount();
-  const values = scope.op<Record<string, unknown>>('extractPlan', { ids: scope.ids, plan });
+  const plan = compileExtractPlan(outer, options);
+  return plan ? { nativeKeys, plan } : undefined;
+}
+
+/**
+ * The plans a walk of `map` from a document's root runs first, in order, so
+ * a batch can run them on its parsing threads. Callbacks may change the
+ * document, so later plans of the walk stay on the calling thread.
+ */
+export function rootExtractPlans(map: ExtractMap, options: CheerioOptions): ExtractPlan[] {
+  // Reading a map ahead of the walk must not run code the walk would run in
+  // a different order, and a malformed map fails later with the walk's own error.
+  if (!isPlainData(map, 0) || hasInheritedEntryFields()) return [];
+  try { return collectRootExtractPlans(map, options); } catch { return []; }
+}
+
+/** Whether reading `value` and everything it holds runs no code: no proxies, accessors or class instances. */
+function isPlainData(value: unknown, depth: number): boolean {
+  if (typeof value !== 'object' || value === null) return true;
+  if (depth > 32 || types.isProxy(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== Array.prototype && prototype !== null) return false;
+  for (const key of Reflect.ownKeys(value)) {
+    const slot = Object.getOwnPropertyDescriptor(value, key)!;
+    if (!('value' in slot) || !isPlainData(slot.value, depth + 1)) return false;
+  }
+  return true;
+}
+
+function hasInheritedEntryFields(): boolean {
+  return 'selector' in Object.prototype || 'value' in Object.prototype || '0' in Array.prototype;
+}
+
+function collectRootExtractPlans(map: ExtractMap, options: CheerioOptions): ExtractPlan[] {
+  const plans: ExtractPlan[] = [];
+  const keys = plainKeys(map);
+  const processed = new Set<string>();
+  for (const key in map) {
+    if (processed.has(key)) continue;
+    const prefix = keys ? prefixPlan(map, keys, key, options) : undefined;
+    if (prefix) {
+      for (const name of prefix.names) processed.add(name);
+      plans.push(prefix.plan);
+      continue;
+    }
+    const entry = map[key];
+    const all = Array.isArray(entry);
+    const descriptor = (all ? entry[0] : entry) as string | ExtractDescriptor;
+    const value = typeof descriptor === 'string' ? 'textContent' : descriptor.value ?? 'textContent';
+    if (typeof value !== 'object' || value === null) continue;
+    const planned = rowsPlan(key, all, typeof descriptor === 'string' ? descriptor : descriptor.selector, value, options);
+    if (planned) plans.push(planned.plan);
+  }
+  return plans.filter((plan) => !JSON.stringify(plan).includes('innerHTML'));
+}
+
+/** Results of root plans a batch ran while parsing, valid while no document changes. */
+const preparedPlans = new WeakMap<object, { writes: number; results: Map<string, string> }>();
+
+export function prepareExtractPlans(document: object, plans: ExtractPlan[], results: (string | null)[] | null | undefined): void {
+  if (!results) return;
+  const prepared = new Map<string, string>();
+  for (let index = 0; index < plans.length; index++) {
+    const result = results[index];
+    if (typeof result === 'string') prepared.set(JSON.stringify(plans[index]), decodeJson(result));
+  }
+  preparedPlans.set(document, { writes: writeCount(), results: prepared });
+}
+
+export function releaseExtractPlans(document: object): void {
+  preparedPlans.delete(document);
+}
+
+function runPlan(scope: Cheerio<AnyNode>, plan: ExtractPlan): Record<string, unknown> {
+  const document = scope[DOCUMENT] as { rootId(): number };
+  const prepared = preparedPlans.get(document);
+  const isRoot = prepared !== undefined && prepared.writes === writeCount() && scope.ids.length === 1 && scope.ids[0] === document.rootId();
+  const result = isRoot ? prepared.results.get(JSON.stringify(plan)) : undefined;
+  const values = result !== undefined ? JSON.parse(result) as Record<string, unknown> : scope.op<Record<string, unknown>>('extractPlan', { ids: scope.ids, plan });
   hydrateExtractResult(values, plan.entries);
-  const extracted = values[key];
-  const rows = (all ? extracted : extracted === undefined ? [] : [extracted]) as Record<string, unknown>[];
-  return Array.isArray(rows) ? { keys: nativeKeys, rows, writes } : undefined;
+  return values;
 }
 
 /**

package/src/index.ts

@@ -1,14 +1,14 @@
 import * as nativeDOM from './dom.js';
 import { parseNativeDocument, parserOptions, deliverParseErrors, hasParserHooks, cleanParserOptions, createTreeAdapterSession } from './hooks.js';
 import { compileExtractPlan, hydrateExtractResult } from './extract-plan.js';
-import { extractCooperatively } from './extract.js';
+import { extractCooperatively, prepareExtractPlans, releaseExtractPlans, rootExtractPlans } from './extract.js';
 import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
 import { availableParallelism } from 'node:os';
 import { requireNative, nativeStatus, type NativeDocument, type NativeQuery } from './native.js';
 import { Cheerio } from './selection.js';
 import { getNode, importNodes, nodeBinding, operation, rootNode, viewIdIn } from './nodes.js';
 import { isHtml } from './utils.js';
-import { DOCUMENT, exposeDocumentTo, resumeCollection, routeDocument, sameNodeSpace } from './router.js';
+import { DOCUMENT, exposeDocumentTo, resumeCollection, routeDocument, sameNodeSpace, usePreparedSnapshot } from './router.js';
 import type { AnyNode, Document, CheerioAPI, CheerioOptions, LoadContent, ParallelOptions, ExtractMap, ExtractedMap } from './types.js';
 
 export type * from './types.js';
@@ -26,7 +26,11 @@ export { configureWorkers, workerPoolInfo } from './workers.js';
 export type { WorkerOptions, WorkerPoolInfo } from './workers.js';
 export { loadBuffer, stringStream, decodeStream, fromURL } from './io.js';
 
+const defaultOptions: CheerioOptions = { _useHtmlParser2: false };
+
+/** Cheerio's option merge: without overrides, calls share the base options object. */
 export function flattenOptions(options?: CheerioOptions | null, base?: CheerioOptions): CheerioOptions {
+  if (!options) return base ?? defaultOptions;
   const result: CheerioOptions = { _useHtmlParser2: false, ...base, ...options };
   if (options?.xml) { result._useHtmlParser2 = true; result.xmlMode = true; if (options.xml !== true) Object.assign(result, options.xml); }
   else if (options?.xmlMode) result._useHtmlParser2 = true;
@@ -181,13 +185,29 @@ function parallelOptions(options?: ParallelOptions | null): { options: CheerioOp
 }
 
 export async function loadAll(content: readonly string[], options?: ParallelOptions | null, isDocument = true): Promise<CheerioAPI[]> {
+  return loadAllWithPlans(content, options, isDocument);
+}
+
+/**
+ * Loads documents in parallel. With `plans`, the parsing threads also run
+ * them on each root and build each document's snapshot, which extraction
+ * with callbacks would otherwise do on the calling thread when it needs them.
+ */
+async function loadAllWithPlans(content: readonly string[], options: ParallelOptions | null | undefined, isDocument: boolean, plans?: ReturnType<typeof rootExtractPlans>): Promise<CheerioAPI[]> {
   const { options: opts, threads } = parallelOptions(options);
   if (!Array.isArray(content) || content.some((item) => typeof item !== 'string')) throw new TypeError('loadAll expects an array of HTML strings');
   if (!content.length) return [];
   const binding = requireNative();
   if (!binding.parseManyAsync || hasParserHooks(opts)) return Promise.all(content.map((html) => loadAsync(html, opts, isDocument)));
-  const documents = await binding.parseManyAsync([...content], isDocument, threads, JSON.stringify(opts));
-  return documents.map((document) => createAPI(routeDocument(document, opts), opts));
+  const documents = await binding.parseManyAsync([...content], isDocument, threads, JSON.stringify(opts), plans && JSON.stringify(plans));
+  return documents.map((document) => {
+    const routed = routeDocument(document, opts);
+    if (plans) {
+      usePreparedSnapshot(routed);
+      prepareExtractPlans(routed, plans, document.takePreparedPlans?.());
+    }
+    return createAPI(routed, opts);
+  });
 }
 
 function nativeQueries(map: ExtractMap, options: CheerioOptions): NativeQuery[] | undefined {
@@ -223,11 +243,12 @@ export async function extractAll<M extends ExtractMap>(content: readonly string[
     }
     return results as ExtractedMap<M>[];
   }
-  const documents = await loadAll(content, { ...opts, threads });
+  const documents = await loadAllWithPlans(content, { ...opts, threads }, true, hasParserHooks(opts) ? undefined : rootExtractPlans(map, opts));
   const results: ExtractedMap<M>[] = [];
   let yieldedAt = performance.now();
   for (const document of documents) {
-    results.push((await extractCooperatively(document.root(), map)).value);
+    const root = document.root();
+    try { results.push((await extractCooperatively(root, map)).value); } finally { releaseExtractPlans(root[DOCUMENT]); }
     if (performance.now() - yieldedAt >= 4) { await yieldToEventLoop(); yieldedAt = performance.now(); }
   }
   return results;

package/src/match.ts

@@ -1,6 +1,6 @@
 import type { NativeDocument } from './native.js';
 import type { CheerioOptions } from './types.js';
-import { attributeAt, isRouted, plainSnapshot, recordAt, stateIn, type DocumentState } from './router.js';
+import { attributeAt, isRouted, recordAt, stateIn, structureSnapshot, type DocumentState } from './router.js';
 import { NodeSnapshot } from './snapshot.js';
 
 /**
@@ -88,13 +88,13 @@ export function selectSimpleWithin(document: NativeDocument, contexts: readonly
 const isElementType = (type: string | undefined): boolean => type === 'tag' || type === 'script' || type === 'style';
 
 function typeAt(state: DocumentState, local: number): string | undefined {
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   return snapshot ? snapshot.typeOf(local) : recordAt(state, local)?.type;
 }
 
 /** Pushes children last to first, so they pop in document order. */
 function pushChildren(state: DocumentState, local: number, stack: number[]): void {
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   if (snapshot) {
     for (let index = snapshot.childCount(local) - 1; index >= 0; index--) stack.push(snapshot.childAt(local, index));
     return;
@@ -116,7 +116,7 @@ function sameMatchOptions(documentOptions: CheerioOptions, isXml: boolean, isLow
 }
 
 function matchesCompound(state: DocumentState, local: number, compound: Compound, isLowerCaseTags: boolean, isLowerCaseAttributes: boolean): boolean {
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   const record = snapshot ? undefined : recordAt(state, local);
   if (!snapshot && !record) return false;
   if (!isElementType(snapshot ? snapshot.typeOf(local) : record!.type)) return false;

package/src/native.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { wrapNativeBinding } from './transport.js';
+import type { NativeSnapshot } from './snapshot.js';
 
 export interface NativeNodeRecord {
   id: number;
@@ -41,6 +42,8 @@ export interface NativeDocument {
   tagName(id: number): string | undefined | null;
   exportTree(): string;
   rootId(): number;
+  takePreparedPlans?(): (string | null)[] | null;
+  takePreparedSnapshot?(isWanted: boolean): NativeSnapshot | null;
   parserDiagnostics?(): string;
 }
 
@@ -76,6 +79,7 @@ export interface NativeBinding {
     isDocument: boolean,
     threads: number,
     optionsJson?: string,
+    plansJson?: string,
   ) => Promise<NativeDocument[]>;
   extractManyAsync?: (
     html: string[],

package/src/nodes.ts

@@ -1,8 +1,8 @@
 import type { NativeDocument, NativeNodeRecord } from './native.js';
-import type { NodeSnapshot } from './snapshot.js';
+import { NodeSnapshot } from './snapshot.js';
 import type { AnyNode } from './types.js';
 import { nodePrototype } from './dom.js';
-import { cachedView, cacheView, exposeTo, isLocalState, isRouted, onViewRefresh, plainSnapshot, recordAt, routedFor, stateIn, VIEW_ATTRIBUTES, VIEW_CHILD_TARGET, VIEW_LOCAL, VIEW_SELF, VIEW_STATE, type DocumentState } from './router.js';
+import { cachedView, cacheView, exposeTo, isLocalState, isRouted, onViewRefresh, plainSnapshot, recordAt, routedFor, stateIn, structureSnapshot, VIEW_ATTRIBUTES, VIEW_CHILD_TARGET, VIEW_LOCAL, VIEW_SELF, VIEW_STATE, type DocumentState } from './router.js';
 
 export interface NodeBinding { document: NativeDocument; id: number }
 
@@ -85,6 +85,10 @@ export function traverseRecords(document: NativeDocument, ids: number[], kind: s
   for (const id of ids) {
     const state = stateIn(document, id);
     const { base } = state;
+    // Attribute writes leave a snapshot's links and types current, and other
+    // writes discard it, so its arrays answer without records.
+    const snapshot = state.bulk instanceof NodeSnapshot ? state.bulk : undefined;
+    if (snapshot?.isPresent(id - base) && traverseSnapshot(snapshot, base, id - base, kind, result)) continue;
     const node = recordAt(state, id - base);
     if (!node) continue;
     const isElement = (local: number): boolean => isElementType(recordAt(state, local)?.type);
@@ -126,15 +130,62 @@ export function traverseRecords(document: NativeDocument, ids: number[], kind: s
   return result;
 }
 
+/** `traverseRecords` for one node of a current snapshot; false for kinds it leaves to records. */
+function traverseSnapshot(snapshot: NodeSnapshot, base: number, local: number, kind: string, result: number[]): boolean {
+  const pushChildren = (parent: number, isElementsOnly: boolean, except: number): void => {
+    const count = snapshot.childCount(parent);
+    for (let index = 0; index < count; index++) {
+      const child = snapshot.childAt(parent, index);
+      if (child !== except && (!isElementsOnly || snapshot.isElementAt(child))) result.push(base + child);
+    }
+  };
+  switch (kind) {
+    case 'children': pushChildren(local, true, -1); return true;
+    case 'contents': pushChildren(local, false, -1); return true;
+    case 'siblings': {
+      const parent = snapshot.linkOf(local, 1);
+      if (parent !== null && snapshot.isPresent(parent)) pushChildren(parent, true, local);
+      return true;
+    }
+    case 'parent': {
+      const parent = snapshot.linkOf(local, 1);
+      if (parent !== null && snapshot.isPresent(parent) && snapshot.isElementAt(parent)) result.push(base + parent);
+      return true;
+    }
+    case 'parents': case 'ancestors': {
+      let parent = snapshot.linkOf(local, 1);
+      for (let steps = 0; parent !== null && steps < snapshot.size && snapshot.isPresent(parent) && !snapshot.isRootAt(parent); steps++) {
+        if (snapshot.isElementAt(parent)) result.push(base + parent);
+        parent = snapshot.linkOf(parent, 1);
+      }
+      return true;
+    }
+    case 'next': case 'prev': case 'nextAll': case 'prevAll': {
+      const offset = kind === 'next' || kind === 'nextAll' ? 3 : 2;
+      const isSingle = kind === 'next' || kind === 'prev';
+      let sibling = snapshot.linkOf(local, offset);
+      for (let steps = 0; sibling !== null && steps < snapshot.size && snapshot.isPresent(sibling); steps++) {
+        if (snapshot.isElementAt(sibling)) {
+          result.push(base + sibling);
+          if (isSingle) break;
+        }
+        sibling = snapshot.linkOf(sibling, offset);
+      }
+      return true;
+    }
+    default: return false;
+  }
+}
+
 /** The node object for an arena slot, created on first use and then shared. */
 export function viewAt(state: DocumentState, local: number): AnyNode | undefined {
   const existing = state.views[local] ?? cachedView(state, local);
   if (existing) return existing as AnyNode;
   const parsed = state.adapterNodes?.[local];
   if (parsed) { state.adapterNodes![local] = undefined; return adoptObject(state, local, parsed); }
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   let constructor: ViewConstructor;
-  if (snapshot) constructor = viewConstructor(snapshot.typeOf(local), false);
+  if (snapshot && !snapshot.hasExtraFields(local)) constructor = viewConstructor(snapshot.typeOf(local), false);
   else {
     const record = recordAt(state, local);
     if (!record) return undefined;
@@ -342,14 +393,23 @@ function fillChildren(view: object): void {
   if (!target) return;
   const state = (view as View)[VIEW_STATE];
   const local = (view as View)[VIEW_LOCAL];
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   if (snapshot && state.stale.size === 0) {
     fillFromSnapshot(state, snapshot, local, target);
     return;
   }
   const locals = viewRecord(view as View).children ?? [];
-  target.length = locals.length;
   for (let index = 0; index < locals.length; index++) target[index] = viewAt(state, locals[index])!;
+  truncate(target, locals.length);
+}
+
+/**
+ * Children are written in order and the length is trimmed afterwards:
+ * presetting the length of a fresh array makes it holey and costs more than
+ * filling it.
+ */
+function truncate(target: AnyNode[], length: number): void {
+  if (target.length !== length) target.length = length;
 }
 
 /**
@@ -364,17 +424,17 @@ function fillFromSnapshot(state: DocumentState, snapshot: NodeSnapshot, local: n
   const views = state.views;
   const isStrong = !state.adapterNodes;
   const constructors = snapshotConstructors(snapshot);
-  target.length = count;
   for (let index = 0; index < count; index++) {
     const child = childIds[first + index];
     let node = (views[child] ?? (state.weakViews.size ? cachedView(state, child) : undefined)) as AnyNode | undefined;
     if (node === undefined) {
-      const constructor = isStrong && child < state.baseline && snapshot.isPlain(child) ? constructors(snapshot.typeReference(child)) : undefined;
+      const constructor = isStrong && child < state.baseline && snapshot.isPresent(child) && !snapshot.hasExtraFields(child) ? constructors(snapshot.typeReference(child)) : undefined;
       if (constructor) views[child] = node = new constructor(state, child) as unknown as AnyNode;
       else node = viewAt(state, child)!;
     }
     target[index] = node;
   }
+  truncate(target, count);
 }
 
 function snapshotConstructors(snapshot: NodeSnapshot): (reference: number) => ViewConstructor {
@@ -397,7 +457,7 @@ const snapshotField = (field: 'type' | 'name' | 'data'): Accessor => ({
   get() {
     const state = this[VIEW_STATE];
     const local = this[VIEW_LOCAL];
-    const snapshot = plainSnapshot(state, local);
+    const snapshot = field === 'data' ? plainSnapshot(state, local) : structureSnapshot(state, local);
     if (snapshot) return field === 'type' ? snapshot.typeOf(local) : field === 'name' ? snapshot.nameOf(local) : snapshot.dataOf(local);
     return (viewRecord(this) as any)[field];
   },
@@ -408,7 +468,7 @@ const pointerField = (field: 'parent' | 'prev' | 'next'): Accessor => ({
   get() {
     const state = this[VIEW_STATE];
     const local = this[VIEW_LOCAL];
-    const snapshot = plainSnapshot(state, local);
+    const snapshot = structureSnapshot(state, local);
     return linkedView(this, snapshot ? snapshot.linkOf(local, linkOffsets[field]) : viewRecord(this)[field]);
   },
   set(value) { setPointer(this, field, value); },