satteri 0.10.4 → 0.11.1

package/dist/materializer-cache.js

@@ -1,18 +1,19 @@
-/**
- * Shared materializer machinery for the HAST and MDAST flavors: per-reader
- * node memo, lazy `children` descriptors, and the frozen-mode (plugin walk
- * path) freeze rules.
- */
 import { deepFreeze } from "./freeze.js";
-/**
- * Build a memoizing materializer, memoized per `(reader, id)`.
- *
- * `node` materializes one node with lazy `children`; `frozen` (the plugin walk
- * path) deep-freezes every node at construction so plugins cannot corrupt the
- * shared cache. `tree` materializes a whole tree eagerly, which is what the
- * step-by-step API wants: it asked for the tree, so laziness would only add
- * per-node accessor overhead.
- */
+export function installNodeData(node, rawData, label, nodeId) {
+    if (rawData === null)
+        return;
+    try {
+        const parsed = JSON.parse(rawData);
+        if (parsed && typeof parsed === "object" && Object.keys(parsed).length > 0) {
+            node.data = parsed;
+        }
+    }
+    catch (err) {
+        if (process.env.NODE_ENV !== "production") {
+            console.warn(`${label}: malformed node_data for nodeId=${nodeId}`, err);
+        }
+    }
+}
 export function createMaterializer(spec) {
     const readerCaches = new WeakMap();
     function materialize(reader, nodeId, frozen = false, refs) {
@@ -24,8 +25,7 @@ export function createMaterializer(spec) {
         }
         return node;
     }
-    /** Frozen-mode `children`: memoized in `cache.childLists` because the node
-     *  is frozen, so the accessor cannot self-replace with a data property. */
+    // A frozen node cannot replace its children getter, so cache the array separately.
     function frozenChildrenDescriptor(reader, cache) {
         return {
             get() {
@@ -46,9 +46,7 @@ export function createMaterializer(spec) {
             enumerable: true,
         };
     }
-    /** Mutable-mode `children`: self-replacing with a plain writable array on
-     *  first read. The id is captured rather than stored on the node, so a
-     *  materialized tree carries no marker for `toEqual` or a spread to find. */
+    // Capture the ID so mutable trees expose no arena identity marker.
     function mutableChildrenDescriptor(reader, nodeId) {
         return {
             get() {
@@ -88,16 +86,14 @@ export function createMaterializer(spec) {
         }
         return cache;
     }
-    function buildNode(reader, cache, nodeId, nodeType, eager = false) {
+    function buildNode(reader, cache, nodeId, nodeType) {
         const typeName = spec.typeNames[nodeType] ?? `unknown(${nodeType})`;
-        // Plain object, not a class: unified's `assertNode` rejects any other prototype.
+        // Unified's assertNode requires a plain-object prototype.
         const node = { type: typeName };
-        const position = reader.getPosition(nodeId);
-        if (position !== undefined) {
-            node.position = position;
-        }
+        // Populate before _nodeId so both materialization paths share V8 hidden classes.
+        spec.populate(node, reader, nodeId, nodeType);
         if (cache.frozen) {
-            // Non-enumerable so `nid()` never trusts an id that a spread copied.
+            // Non-enumerable IDs prevent spread copies from impersonating arena nodes.
             cache.refs?.set(node, nodeId);
             Object.defineProperty(node, "_nodeId", {
                 value: nodeId,
@@ -106,87 +102,19 @@ export function createMaterializer(spec) {
                 enumerable: false,
             });
         }
-        spec.populate(node, reader, nodeId, nodeType);
-        // Plugins can set `data` on any node type, so rehydrate generically
-        // (see website/content/docs/divergences.md for the code-block case).
-        const rawData = reader.getNodeData(nodeId);
-        if (rawData !== null) {
-            try {
-                const parsed = JSON.parse(rawData);
-                if (parsed && typeof parsed === "object" && Object.keys(parsed).length > 0) {
-                    Object.defineProperty(node, "data", {
-                        value: parsed,
-                        writable: true,
-                        configurable: true,
-                        enumerable: true,
-                    });
-                }
-            }
-            catch (err) {
-                if (process.env.NODE_ENV !== "production") {
-                    console.warn(`${spec.label}: malformed node_data for nodeId=${nodeId}`, err);
-                }
-            }
+        installNodeData(node, reader.getNodeData(nodeId), spec.label, nodeId);
+        if (cache.frozen) {
+            // All fields are eager until the children getter is installed below.
+            for (const value of Object.values(node))
+                deepFreeze(value);
         }
-        if (!eager && spec.hasChildren(nodeType, node, reader, nodeId)) {
+        if (spec.hasChildren(nodeType, node, reader, nodeId)) {
             Object.defineProperty(node, "children", cache.children ?? mutableChildrenDescriptor(reader, nodeId));
         }
         if (cache.frozen) {
-            // Deep-freeze the eager own values but not the lazy `children` accessor;
-            // freeze eagerly even for containers so nothing is writable while cached.
-            const descriptors = Object.getOwnPropertyDescriptors(node);
-            for (const key of Object.keys(descriptors)) {
-                const desc = descriptors[key];
-                if (desc !== undefined && "value" in desc) {
-                    deepFreeze(desc.value);
-                }
-            }
             Object.freeze(node);
         }
         return node;
     }
-    /**
-     * Iterative on purpose: recursing to full document depth overflows on deeply
-     * nested input, and nothing else here descends more than one level.
-     *
-     * Breadth-first over the parents still to fill, so every node is built and
-     * every child list decoded exactly once, and a child is wired into its
-     * parent's array as it is built rather than in a second pass.
-     */
-    function fillTree(reader, cache, rootId) {
-        const rootType = reader.getNodeType(rootId);
-        const root = buildNode(reader, cache, rootId, rootType, true);
-        if (!spec.hasChildren(rootType, root, reader, rootId))
-            return root;
-        const parents = [root];
-        const parentIds = [rootId];
-        for (let p = 0; p < parentIds.length; p++) {
-            const parent = parents[p];
-            const parentId = parentIds[p];
-            if (parent === undefined || parentId === undefined)
-                continue;
-            const ids = reader.getChildIds(parentId);
-            const kids = new Array(ids.length);
-            for (let i = 0; i < ids.length; i++) {
-                const childId = ids[i];
-                if (childId === undefined)
-                    continue;
-                const childType = reader.getNodeType(childId);
-                const child = buildNode(reader, cache, childId, childType, true);
-                kids[i] = child;
-                if (spec.hasChildren(childType, child, reader, childId)) {
-                    parents.push(child);
-                    parentIds.push(childId);
-                }
-            }
-            // Assignment beats defineProperty here; `eager` left `children` uninstalled.
-            parent.children = kids;
-        }
-        return root;
-    }
-    /** Whole tree at once: the caller will walk it, so lazy accessors cost more than they defer. */
-    function materializeTree(reader, rootId) {
-        return fillTree(reader, readerCache(reader, false, undefined), rootId);
-    }
-    return { node: materialize, tree: materializeTree };
+    return { node: materialize };
 }

package/dist/mdast/child-stub.d.ts

@@ -2,19 +2,8 @@ import type { LazyChildResolver } from "../lazy-child-resolver.js";
 import type { MdastNode } from "../types.js";
 import type { MdastReader } from "./mdast-reader.js";
 type MdastResolver = LazyChildResolver<MdastReader, MdastNode>;
-/**
- * Walk-path child stub: arena id + `type` eagerly, every other field a lazy
- * forward to the materialized node (first read snapshots the arena via
- * `materializeOne`, which enforces the handle epoch). Spread/identity rules
- * are enforced by `nid()` (authoritative doc in hast-visitor.ts).
- *
- * A user-defined node's `type` is the one exception: it lives in the arena,
- * not the tag, so it joins the lazy fields rather than making every sibling
- * list snapshot the arena up front.
- */
 export declare class MdastChildStub {
-    _resolver: MdastResolver;
-    _id: number;
+    #private;
     type: string;
     constructor(resolver: MdastResolver, id: number, nodeType: number);
 }

package/dist/mdast/child-stub.js

@@ -3,8 +3,6 @@ import { MDAST_LAYOUT_KEYS } from "./generated/layout.js";
 import { NAME_TO_TYPE, TYPE_NAMES } from "./generated/node-types.js";
 import { LEAF_TYPES } from "./mdast-materializer.js";
 const N = NAME_TO_TYPE;
-/** Per-type stub fields for the types `addTypeProperties` hand-writes; the
- *  fixed-layout types come from the generated `MDAST_LAYOUT_KEYS`. */
 const HAND_WRITTEN_FIELDS = {
     [N.list]: ["ordered", "start", "spread"],
     [N.listItem]: ["spread", "checked"],
@@ -17,9 +15,7 @@ const HAND_WRITTEN_FIELDS = {
     [N.mdxJsxTextElement]: ["name", "attributes"],
 };
 const TYPE_NAME_BY_TAG = flatByTag(TYPE_NAMES);
-/** Internal tag for user-defined nodes; its stored `name` field is folded into
- *  the open `node.type`, so the stub exposes `value` (leaf content) but no
- *  separate `name`. */
+// Custom nodes expose their stored name as type, without a separate name field.
 const MDAST_CUSTOM = NAME_TO_TYPE.custom;
 const MDAST_STUB_DESCRIPTORS = [];
 for (const tag of Object.keys(TYPE_NAMES)) {
@@ -32,25 +28,15 @@ for (const tag of Object.keys(TYPE_NAMES)) {
         fields.push("children");
     MDAST_STUB_DESCRIPTORS[nodeType] = stubDescriptors(fields);
 }
-/** Unknown node types still expose the prelude-backed lazy fields. */
 const FALLBACK_DESCRIPTORS = stubDescriptors([]);
-/**
- * Walk-path child stub: arena id + `type` eagerly, every other field a lazy
- * forward to the materialized node (first read snapshots the arena via
- * `materializeOne`, which enforces the handle epoch). Spread/identity rules
- * are enforced by `nid()` (authoritative doc in hast-visitor.ts).
- *
- * A user-defined node's `type` is the one exception: it lives in the arena,
- * not the tag, so it joins the lazy fields rather than making every sibling
- * list snapshot the arena up front.
- */
+// Custom type names live in the arena, so reading type must remain lazy too.
 export class MdastChildStub {
-    _resolver;
-    _id;
+    #resolver;
+    #id;
     type;
     constructor(resolver, id, nodeType) {
-        this._resolver = resolver;
-        this._id = id;
+        this.#resolver = resolver;
+        this.#id = id;
         if (nodeType === MDAST_CUSTOM) {
             installLazyCustomType(this);
             installLazyCustomChildren(this);
@@ -62,16 +48,22 @@ export class MdastChildStub {
     }
     /** @internal */
     get _refs() {
-        return this._resolver.refs;
+        return this.#resolver.refs;
+    }
+    /** @internal */
+    get _id() {
+        return this.#id;
+    }
+    /** @internal */
+    _materialize() {
+        return this.#resolver.materializeOne(this.#id);
     }
 }
-/** `children` as a self-replacing accessor, and self-*removing* for a leaf: the
- *  stub only knows the tag, so it cannot tell a leaf from a parent until the
- *  arena snapshot says which shape this node has. */
+// A custom node’s leafness is unknown until materialization; leaf stubs must lose their children field.
 function installLazyCustomChildren(stub) {
     Object.defineProperty(stub, "children", {
         get() {
-            const real = this._resolver.materializeOne(this._id);
+            const real = this._materialize();
             const value = real.children;
             if (value === undefined) {
                 delete this.children;
@@ -89,12 +81,10 @@ function installLazyCustomChildren(stub) {
         configurable: true,
     });
 }
-/** `type` as a self-replacing accessor: the materialized node folds the stored
- *  name into `type`. Enumerable so a spread copy still carries it. */
 function installLazyCustomType(stub) {
     Object.defineProperty(stub, "type", {
         get() {
-            const value = this._resolver.materializeOne(this._id).type;
+            const value = this._materialize().type;
             Object.defineProperty(this, "type", {
                 value,
                 writable: true,

package/dist/mdast/column-align.d.ts

@@ -1 +1 @@
-export declare function decodeColumnAlign(byte: number): string | null;
+export declare function decodeColumnAlign(byte: number): "left" | "right" | "center" | null;

package/dist/mdast/column-align.js

@@ -1,5 +1,3 @@
-/** Decode a table column-alignment byte — shared by the generated walk decoder
- *  and the snapshot reader so the mapping lives in one place. */
 const ALIGN_NAMES = [null, "left", "right", "center"];
 export function decodeColumnAlign(byte) {
     return ALIGN_NAMES[byte] ?? null;

package/dist/mdast/generated/layout.d.ts

@@ -1,18 +1,2 @@
-import type { MdastReader } from "../mdast-reader.js";
-/** Materialized property names per tag (the non-skip `js` names above),
- *  exported for the child-stub field tables. */
 export declare const MDAST_LAYOUT_KEYS: Readonly<Record<number, readonly string[]>>;
-/**
- * Decode a node's type-specific `type_data` from the walk buffer onto `node`,
- * driven by `MDAST_LAYOUTS` (fixed-field types) and `MDAST_TAILS` (counted
- * attribute lists). Returns `false` for tags in neither, so the caller falls
- * through to the remaining hand-written cases (list, listItem).
- */
 export declare function decodeMdastTypeData(view: DataView, buf: Uint8Array, start: number, nodeType: number, node: Record<string, unknown>): boolean;
-/**
- * Attach a node's fixed `type_data` fields, materialized from the arena
- * snapshot, driven by `MDAST_LAYOUTS`. Returns `false` for tags with no entry,
- * so the materializer falls through to its hand-written cases (list, table,
- * directives, MDX JSX). Fields are eager plain stores.
- */
-export declare function materializeMdastFields(reader: MdastReader, node: object, nodeId: number, nodeType: number): boolean;

package/dist/mdast/generated/layout.js

@@ -3,7 +3,6 @@ import { ru16, ru32, rstr } from "../../wire-read.js";
 import { restorePhantomSpaces } from "../../phantom.js";
 import { decodeMdxJsxAttr } from "../../mdx-attr.js";
 import { decodeColumnAlign } from "../column-align.js";
-/** Walk-wire fields per node-type tag (see Rust `write_mdast_type_data_inline`). */
 const MDAST_LAYOUTS = {
     2: [{ js: "depth", offset: 0, kind: "u8", default: 1 }],
     7: [{ js: "value", offset: 0, kind: "str32" }],
@@ -64,8 +63,6 @@ const MDAST_LAYOUTS = {
     103: [{ js: "value", offset: 0, kind: "str32", phantom: true }],
     104: [{ js: "value", offset: 0, kind: "str32", phantom: true }],
 };
-/** Materialized property names per tag (the non-skip `js` names above),
- *  exported for the child-stub field tables. */
 export const MDAST_LAYOUT_KEYS = {
     2: ["depth"],
     7: ["value"],
@@ -88,10 +85,6 @@ export const MDAST_LAYOUT_KEYS = {
     103: ["value"],
     104: ["value"],
 };
-/** Walk-wire tail descriptors (a name head, then a counted item list) for
- *  the variable-length attribute types the generic decoder below handles
- *  without a hand-written case: `map` is a string key/value object
- *  (directives), `jsx` a typed MDX-JSX attribute array. */
 const MDAST_TAILS = {
     21: { head: [], item: [{ js: "align", kind: "u8" }], bytes: { attrsKey: "align" } },
     30: {
@@ -137,13 +130,12 @@ const MDAST_TAILS = {
         jsx: { attrsKey: "attributes" },
     },
 };
-/**
- * Decode a node's type-specific `type_data` from the walk buffer onto `node`,
- * driven by `MDAST_LAYOUTS` (fixed-field types) and `MDAST_TAILS` (counted
- * attribute lists). Returns `false` for tags in neither, so the caller falls
- * through to the remaining hand-written cases (list, listItem).
- */
 export function decodeMdastTypeData(view, buf, start, nodeType, node) {
+    if (nodeType === 7 || nodeType === 10 || nodeType === 13 || nodeType === 25 || nodeType === 26) {
+        const len = ru32(view, start);
+        node.value = rstr(buf, start + 4, len);
+        return true;
+    }
     const fields = MDAST_LAYOUTS[nodeType];
     if (fields !== undefined) {
         let pos = start;
@@ -170,9 +162,7 @@ export function decodeMdastTypeData(view, buf, start, nodeType, node) {
     const tail = MDAST_TAILS[nodeType];
     if (tail !== undefined) {
         let pos = start;
-        // Reads are inlined and advance `pos` in place (no per-field tuple): this
-        // runs per attribute item in the matched-node decode path, and the
-        // unoptimized tiers CodSpeed measures won't elide the allocation.
+        // Inline reads avoid allocating a tuple per attribute field in unoptimized V8 tiers.
         for (const f of tail.head) {
             let value;
             if (f.kind === "u8") {
@@ -186,7 +176,6 @@ export function decodeMdastTypeData(view, buf, start, nodeType, node) {
                 pos += len;
                 value = f.phantom ? restorePhantomSpaces(raw) : raw;
             }
-            // MDX JSX elements carry a nullable name (empty → null); map heads keep it.
             node[f.js] = tail.jsx !== undefined && value === "" ? null : value;
         }
         const count = ru16(view, pos);
@@ -236,33 +225,3 @@ export function decodeMdastTypeData(view, buf, start, nodeType, node) {
     }
     return false;
 }
-/**
- * Attach a node's fixed `type_data` fields, materialized from the arena
- * snapshot, driven by `MDAST_LAYOUTS`. Returns `false` for tags with no entry,
- * so the materializer falls through to its hand-written cases (list, table,
- * directives, MDX JSX). Fields are eager plain stores.
- */
-export function materializeMdastFields(reader, node, nodeId, nodeType) {
-    const fields = MDAST_LAYOUTS[nodeType];
-    if (fields === undefined)
-        return false;
-    const out = node;
-    for (const f of fields) {
-        if (f.skip)
-            continue;
-        if (f.kind === "u8") {
-            // Short type_data falls back to the layout's declared default,
-            // matching the Rust walk serializer.
-            const b = reader.fieldU8(nodeId, f.offset, f.default ?? 0);
-            out[f.js] = f.values ? (f.values[b] ?? f.values[0]) : b;
-        }
-        else {
-            // Short type_data (e.g. a 20-byte ReferenceData-only imageReference)
-            // reads as empty, mirroring the Rust decoders' bounds checks.
-            const raw = reader.fieldString(nodeId, f.offset);
-            const s = f.nullable && raw === "" ? null : raw;
-            out[f.js] = f.phantom && typeof s === "string" ? restorePhantomSpaces(s) : s;
-        }
-    }
-    return true;
-}

package/dist/mdast/generated/node-types.d.ts

@@ -1,6 +1,4 @@
-/** Node-type tag -> canonical AST name. */
 export declare const TYPE_NAMES: Readonly<Record<number, string>>;
-/** Canonical AST name -> node-type tag. */
 export declare const NAME_TO_TYPE: Readonly<Record<string, number>>;
 /** Node-type tag by Rust enum variant name. */
 export declare const NodeType: Readonly<{
@@ -50,13 +48,7 @@ export declare const NodeType: Readonly<{
 }>;
 /** Node-type tag -> Rust variant name (`typeName` diagnostics). */
 export declare const NodeTypeName: Readonly<Record<number, string>>;
-/** Names a plugin can subscribe to (every node except `root`). */
 export declare const VISITOR_KEYS: ReadonlySet<string>;
-/** Name -> tag for the types the op-stream can encode; one lookup gates AND
- *  resolves the emit-path tag. Excluded names (see `*_OPSTREAM_EXCLUDED` in
- *  schema.rs) have no encoding — the visitor throws for them. */
 export declare const MDAST_OPSTREAM_TYPES: Readonly<Record<string, number>>;
-/** Names of the variable-length `custom` node types (hand-written or
- *  `Tail`-generated codec). The op-stream round-trip oracle asserts it covers
- *  every one, so a forgotten or drifted encode/decode arm fails loudly. */
 export declare const MDAST_CUSTOM_TYPES: readonly string[];
+export declare const LEAF_TYPES: ReadonlySet<number>;

package/dist/mdast/generated/node-types.js

@@ -1,5 +1,4 @@
 // @generated by `cargo run -p satteri-layout-codegen`. Do not edit by hand.
-/** Node-type tag -> canonical AST name. */
 export const TYPE_NAMES = {
     0: "root",
     1: "paragraph",
@@ -45,7 +44,6 @@ export const TYPE_NAMES = {
     103: "mdxTextExpression",
     104: "mdxjsEsm",
 };
-/** Canonical AST name -> node-type tag. */
 export const NAME_TO_TYPE = {
     root: 0,
     paragraph: 1,
@@ -183,7 +181,6 @@ export const NodeTypeName = {
     103: "MdxTextExpression",
     104: "MdxjsEsm",
 };
-/** Names a plugin can subscribe to (every node except `root`). */
 export const VISITOR_KEYS = new Set([
     "paragraph",
     "heading",
@@ -228,9 +225,6 @@ export const VISITOR_KEYS = new Set([
     "mdxTextExpression",
     "mdxjsEsm",
 ]);
-/** Name -> tag for the types the op-stream can encode; one lookup gates AND
- *  resolves the emit-path tag. Excluded names (see `*_OPSTREAM_EXCLUDED` in
- *  schema.rs) have no encoding — the visitor throws for them. */
 export const MDAST_OPSTREAM_TYPES = {
     paragraph: 1,
     heading: 2,
@@ -275,9 +269,6 @@ export const MDAST_OPSTREAM_TYPES = {
     mdxTextExpression: 103,
     mdxjsEsm: 104,
 };
-/** Names of the variable-length `custom` node types (hand-written or
- *  `Tail`-generated codec). The op-stream round-trip oracle asserts it covers
- *  every one, so a forgotten or drifted encode/decode arm fails loudly. */
 export const MDAST_CUSTOM_TYPES = [
     "list",
     "listItem",
@@ -289,3 +280,6 @@ export const MDAST_CUSTOM_TYPES = [
     "mdxJsxFlowElement",
     "mdxJsxTextElement",
 ];
+export const LEAF_TYPES = new Set([
+    3, 7, 8, 9, 10, 13, 14, 16, 18, 20, 25, 26, 27, 28, 102, 103, 104,
+]);

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

@@ -1,19 +1,11 @@
 import type { Root } from "mdast";
 import type { MdastReader } from "./mdast-reader.js";
-export declare const LEAF_TYPES: ReadonlySet<number>;
-/** A `custom` node is a leaf when it has a non-empty `value` and no children or
- *  `data.h*`. Leafness is per node there, not per type, so the read paths ask
- *  this instead of {@link LEAF_TYPES}.
- *  @see {@link Custom} */
+import { LEAF_TYPES } from "./generated/node-types.js";
+export { LEAF_TYPES };
 export declare function isCustomLeaf(node: {
     readonly value?: unknown;
     readonly data?: unknown;
 }, childCount: number): boolean;
-/**
- * Materialize a single MDAST node; scalars eager, `children` lazy, memoized
- * per `(reader, id)`; `frozen` (the plugin walk path) deep-freezes so plugins
- * cannot corrupt the shared cache.
- */
 export declare const materializeNode: (reader: MdastReader, nodeId: number, frozen?: boolean, refs?: import("../visitor-shared.js").NodeRefs) => import("mdast").Nodes;
-/** Materialize the full tree from root (nodeId=0). */
+/** Materialize the full tree from root (nodeId=0) in one eager pass, breadth-first over the parents still to fill. */
 export declare function materializeMdastTree(reader: MdastReader): Root;