satteri 0.10.5 → 0.11.3

package/dist/hast/generated/walk-decode.js

@@ -0,0 +1,61 @@
+// @generated by `cargo run -p satteri-layout-codegen`. Do not edit by hand.
+import { rstr } from "../../wire-read.js";
+import { restorePhantomSpaces } from "../../phantom.js";
+import { decodeElementProp } from "../element-props.js";
+import { decodeMdxJsxAttr } from "../../mdx-attr.js";
+export function readWalkElementTag(view, buf, pos) {
+    return rstr(buf, pos + 2, view.getUint16(pos, true));
+}
+export function walkElementPropsAt(view, pos) {
+    return pos + 2 + view.getUint16(pos, true);
+}
+export function walkElementPropCount(view, propsAt) {
+    return view.getUint16(propsAt, true);
+}
+export function decodeWalkElementProps(view, buf, pos) {
+    const count = view.getUint16(pos, true);
+    pos += 2;
+    const properties = {};
+    for (let i = 0; i < count; i++) {
+        const nameLen = view.getUint16(pos, true);
+        pos += 2;
+        const name = rstr(buf, pos, nameLen);
+        pos += nameLen;
+        const kind = buf[pos] ?? 0;
+        pos += 1;
+        const valueLen = view.getUint16(pos, true);
+        pos += 2;
+        const value = rstr(buf, pos, valueLen);
+        pos += valueLen;
+        properties[name] = decodeElementProp(kind, value);
+    }
+    return properties;
+}
+export function readWalkHastValue(view, buf, offset, nodeType) {
+    const value = rstr(buf, offset + 4, view.getUint32(offset, true));
+    return nodeType === 12 || nodeType === 14 ? restorePhantomSpaces(value) : value;
+}
+// A zero-length name represents an MDX fragment.
+export function readWalkMdxJsx(view, buf, pos) {
+    const headLen = view.getUint16(pos, true);
+    pos += 2;
+    const headName = headLen > 0 ? rstr(buf, pos, headLen) : null;
+    pos += headLen;
+    const count = view.getUint16(pos, true);
+    pos += 2;
+    const attributes = [];
+    for (let i = 0; i < count; i++) {
+        const kind = buf[pos] ?? 0;
+        pos += 1;
+        const nameLen = view.getUint16(pos, true);
+        pos += 2;
+        const name = rstr(buf, pos, nameLen);
+        pos += nameLen;
+        const valueLen = view.getUint32(pos, true);
+        pos += 4;
+        const value = rstr(buf, pos, valueLen);
+        pos += valueLen;
+        attributes.push(decodeMdxJsxAttr(kind, name, value));
+    }
+    return { name: headName, attributes };
+}

package/dist/hast/hast-materializer.d.ts

@@ -1,16 +1,9 @@
 import { HastReader } from "./hast-reader.js";
 import type { Root } from "hast";
 import type { HastNode } from "../types.js";
+import { CONTAINER_TYPES } from "./generated/node-types.js";
 export type { HastNode };
-/** Container node types (the ones that carry `children`); everything else is a leaf. */
-export declare const HAST_CONTAINER_TYPES: ReadonlySet<number>;
-/**
- * Materialize a single HAST node; scalars eager, `children` lazy, memoized per
- * `(reader, id)`; `frozen` (the plugin walk path) deep-freezes so plugins
- * cannot corrupt the shared cache.
- */
+export { CONTAINER_TYPES as HAST_CONTAINER_TYPES };
 export declare const materializeHastNode: (reader: HastReader, nodeId: number, frozen?: boolean, refs?: import("../visitor-shared.js").NodeRefs) => import("hast").Nodes;
-/**
- * Materialize the full HAST tree from root (nodeId=0).
- */
+/** Materialize the full HAST tree from root (nodeId=0) in one eager pass, breadth-first over the parents still to fill. */
 export declare function materializeHastTree(reader: HastReader): Root;

package/dist/hast/hast-materializer.js

@@ -1,57 +1,83 @@
-import { HastReader, HAST_ROOT, HAST_ELEMENT, HAST_TEXT, HAST_COMMENT, HAST_RAW, HAST_MDX_JSX_ELEMENT, HAST_MDX_JSX_TEXT_ELEMENT, HAST_MDX_FLOW_EXPRESSION, HAST_MDX_TEXT_EXPRESSION, HAST_MDX_ESM, } from "./hast-reader.js";
-import { TYPE_NAMES } from "./generated/node-types.js";
-import { restorePhantomSpaces } from "../phantom.js";
-import { createMaterializer } from "../materializer-cache.js";
-/** Container node types (the ones that carry `children`); everything else is a leaf. */
-export const HAST_CONTAINER_TYPES = new Set([
-    HAST_ROOT,
-    HAST_ELEMENT,
-    HAST_MDX_JSX_ELEMENT,
-    HAST_MDX_JSX_TEXT_ELEMENT,
-]);
+import { HastReader, HAST_MDX_JSX_ELEMENT, HAST_MDX_JSX_TEXT_ELEMENT } from "./hast-reader.js";
+import { CONTAINER_TYPES, TYPE_NAMES } from "./generated/node-types.js";
+import { createMaterializer, installNodeData } from "../materializer-cache.js";
+import { FIELD, W_CHILDREN_COUNT, W_CHILDREN_START } from "../generated/arena-layout.js";
+import { readHastWireNode } from "../generated/fused-wire.js";
+export { CONTAINER_TYPES as HAST_CONTAINER_TYPES };
+const IS_CONTAINER = new Uint8Array(256);
+for (const t of CONTAINER_TYPES)
+    IS_CONTAINER[t] = 1;
 const hastMaterializer = createMaterializer({
     label: "materializeHastNode",
     typeNames: TYPE_NAMES,
-    hasChildren: (nodeType) => HAST_CONTAINER_TYPES.has(nodeType),
+    hasChildren: (nodeType) => IS_CONTAINER[nodeType] === 1,
     populate(node, reader, nodeId, nodeType) {
-        switch (nodeType) {
-            case HAST_ELEMENT:
-                reader.readElementInto(nodeId, node);
-                break;
-            case HAST_TEXT:
-            case HAST_COMMENT:
-            case HAST_RAW:
-                node.value = reader.getTextValue(nodeId);
-                break;
-            case HAST_MDX_JSX_ELEMENT:
-            case HAST_MDX_JSX_TEXT_ELEMENT: {
-                const { name, attributes } = reader.getMdxJsxElementData(nodeId);
-                node.name = name;
-                node.attributes = attributes;
-                break;
-            }
-            case HAST_MDX_FLOW_EXPRESSION:
-            case HAST_MDX_TEXT_EXPRESSION:
-                node.value = restorePhantomSpaces(reader.getTextValue(nodeId));
-                break;
-            case HAST_MDX_ESM:
-                node.value = reader.getTextValue(nodeId);
-                break;
-            // HAST_ROOT / HAST_DOCTYPE: no extra properties
-            default:
-                break;
+        if (!readHastWireNode(reader.getWire(), nodeId, nodeType, node)) {
+            addHastTypeProperties(node, reader, nodeId, nodeType);
         }
     },
 });
-/**
- * Materialize a single HAST node; scalars eager, `children` lazy, memoized per
- * `(reader, id)`; `frozen` (the plugin walk path) deep-freezes so plugins
- * cannot corrupt the shared cache.
- */
 export const materializeHastNode = hastMaterializer.node;
-/**
- * Materialize the full HAST tree from root (nodeId=0).
- */
+function addHastTypeProperties(node, reader, nodeId, nodeType) {
+    if (nodeType === HAST_MDX_JSX_ELEMENT || nodeType === HAST_MDX_JSX_TEXT_ELEMENT) {
+        const { name, attributes } = reader.getMdxJsxElementData(nodeId);
+        const element = node;
+        element.name = name;
+        element.attributes = attributes;
+    }
+}
+// Not a per-call closure: fresh closures restart type feedback per tree, pinning small-tree calls to the slow tiers.
+function buildHastFused(reader, wire, nodeId, nodeType) {
+    const typeName = TYPE_NAMES[nodeType] ?? `unknown(${nodeType})`;
+    // Unified's assertNode requires a plain-object prototype.
+    const node = { type: typeName };
+    if (!readHastWireNode(wire, nodeId, nodeType, node)) {
+        addHastTypeProperties(node, reader, nodeId, nodeType);
+    }
+    return node;
+}
+/** Materialize the full HAST tree from root (nodeId=0) in one eager pass, breadth-first over the parents still to fill. */
 export function materializeHastTree(reader) {
-    return hastMaterializer.tree(reader, 0);
+    const wire = reader.getWire();
+    const { u8, u32, nodesB, nodesW, strideB, strideW, childrenW } = wire;
+    const dataTable = reader.getNodeDataTable();
+    const rootType = u8[nodesB + FIELD.node_type] ?? 0;
+    const root = buildHastFused(reader, wire, 0, rootType);
+    if (dataTable !== null) {
+        const raw = dataTable.get(0);
+        if (raw !== undefined)
+            installNodeData(root, raw, "materializeHastTree", 0);
+    }
+    if (IS_CONTAINER[rootType] !== 1)
+        return root;
+    const parents = [root];
+    const parentIds = [0];
+    for (let p = 0; p < parentIds.length; p++) {
+        const parent = parents[p];
+        const parentId = parentIds[p];
+        if (parent === undefined || parentId === undefined) {
+            throw new Error(`materializeHastTree: parent queue hole at ${p}`);
+        }
+        const w = nodesW + parentId * strideW;
+        const count = u32[w + W_CHILDREN_COUNT] ?? 0;
+        const cbase = childrenW + (u32[w + W_CHILDREN_START] ?? 0);
+        const kids = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const childId = u32[cbase + i] ?? 0;
+            const childType = u8[nodesB + childId * strideB + FIELD.node_type] ?? 0;
+            const child = buildHastFused(reader, wire, childId, childType);
+            kids[i] = child;
+            if (dataTable !== null) {
+                const raw = dataTable.get(childId);
+                if (raw !== undefined)
+                    installNodeData(child, raw, "materializeHastTree", childId);
+            }
+            if (IS_CONTAINER[childType] === 1) {
+                parents.push(child);
+                parentIds.push(childId);
+            }
+        }
+        parent.children = kids;
+    }
+    return root;
 }

package/dist/hast/hast-reader.d.ts

@@ -1,6 +1,6 @@
-import type { BufferHeader } from "../types.js";
-import type { MdxJsxAttribute, MdxJsxExpressionAttribute } from "../mdx-types.js";
 import type { Position } from "unist";
+import type { MdxJsxAttribute, MdxJsxExpressionAttribute } from "../mdx-types.js";
+import type { BufferHeader } from "../types.js";
 export type { MdxJsxAttribute, MdxJsxExpressionAttribute };
 export declare const HAST_ROOT: number;
 export declare const HAST_ELEMENT: number;
@@ -19,57 +19,28 @@ export interface HastProperty {
 export declare class HastReader {
     #private;
     constructor(buffer: ArrayBuffer | Uint8Array);
-    /**
-     * Per-node JSON `data` blob (set via `Arena::set_node_data` on the Rust
-     * side). Returns `null` when the node has no entry. Lazy-builds a
-     * `Map<id, string>` on first call so a materialization pass on a
-     * data-heavy tree stays O(nodes) rather than O(nodes × entries).
-     */
+    /** Per-node JSON data, or null when absent. */
     getNodeData(nodeId: number): string | null;
     get nodeCount(): number;
     get header(): BufferHeader;
-    /** The full string pool (original input + interning heap). Not the document
-     * source as written; for that, read `ctx.source` from a plugin. */
+    /** Full string pool, including interned strings; use ctx.source for the original document. */
     getStringPool(): string;
-    /** Read a substring from the string pool by byte offset and length. */
+    /** Wire string refs use UTF-16 units, so substring preserves their offsets. */
     getString(offset: number, len: number): string;
-    /** Get position data for a node. */
+    /** A zero start line marks a synthesized node with no source range (unist
+     *  lines are 1-based), surfaced as `undefined`. */
     getPosition(nodeId: number): Position | undefined;
     /** Get the node_type byte for a given node ID. */
     getNodeType(nodeId: number): number;
     /** Get the parent id for a given node (0xffffffff at the root). */
     getParentId(nodeId: number): number;
-    /** Get child node IDs for a given node. */
+    getChildrenCount(nodeId: number): number;
     getChildIds(nodeId: number): number[];
-    /** Push child node IDs directly onto a stack array (reverse order for depth-first). */
-    pushChildIds(nodeId: number, stack: number[]): void;
     /** Get the raw type_data bytes for a node. */
     getTypeData(nodeId: number): Uint8Array;
-    /** Element `tagName`, `properties` count, and the i-th property, read without
-     *  building the intermediate views and records `getElementData` allocates. */
-    getElementTagName(nodeId: number): string;
-    getElementPropCount(nodeId: number): number;
-    getElementPropName(nodeId: number, index: number): string;
-    getElementPropValue(nodeId: number, index: number): HastProperty["value"];
-    getElementData(nodeId: number): {
-        tagName: string;
-        properties: HastProperty[];
-    };
-    /**
-     * Get MDX JSX element data: name and attributes.
-     *
-     * MDX JSX element type_data layout:
-     *   [name: StringRef(8B)][attr_count: u32(4B)][_pad: u32(4B)] = 16-byte header
-     *   then attr_count * 20 bytes:
-     *     [kind: u8(1B)][_pad: [u8;3](3B)][name: StringRef(8B)][value: StringRef(8B)]
-     */
+    /** A zero-length element name represents an MDX fragment. */
     getMdxJsxElementData(nodeId: number): {
         name: string | null;
         attributes: (MdxJsxAttribute | MdxJsxExpressionAttribute)[];
     };
-    /**
-     * Get the string value for HAST_TEXT, HAST_COMMENT, or HAST_RAW nodes.
-     * These store a single StringRef (8 bytes) as their type_data.
-     */
-    getTextValue(nodeId: number): string;
 }