satteri 0.1.0 → 0.1.1

package/dist/command-buffer.js

@@ -8,9 +8,7 @@
  * All multi-byte integers are little-endian to match native x86/ARM layout and
  * avoid byte-swapping on the Rust side.
  */
-// ---------------------------------------------------------------------------
 // Command bytes (0x01–0x0F)
-// ---------------------------------------------------------------------------
 const CMD_REMOVE = 0x01;
 const CMD_INSERT_BEFORE = 0x05;
 const CMD_INSERT_AFTER = 0x06;
@@ -19,15 +17,11 @@ const CMD_APPEND_CHILD = 0x08;
 const CMD_WRAP = 0x09;
 const CMD_REPLACE = 0x0b;
 const CMD_SET_PROPERTY = 0x0c;
-// ---------------------------------------------------------------------------
 // Payload types (0x10+, distinct range from commands)
-// ---------------------------------------------------------------------------
 const PAYLOAD_RAW_MARKDOWN = 0x10;
 const PAYLOAD_RAW_HTML = 0x11;
 const PAYLOAD_SERDE_JSON = 0x12;
-// ---------------------------------------------------------------------------
 // Value types for CMD_SET_PROPERTY (must match commands.rs PROP_* constants)
-// ---------------------------------------------------------------------------
 const PROP_STRING = 0;
 const PROP_BOOL_TRUE = 1;
 const PROP_BOOL_FALSE = 2;
@@ -46,9 +40,7 @@ export function classifyReturn(value) {
         return "structured_node";
     throw new Error("Invalid return value from visitor: must have raw, rawHtml, or type");
 }
-// ---------------------------------------------------------------------------
 // CommandBuffer
-// ---------------------------------------------------------------------------
 const INITIAL_SIZE = 4096;
 const encoder = new TextEncoder();
 const EMPTY_U8 = new Uint8Array(0);
@@ -62,7 +54,6 @@ export class CommandBuffer {
         this.view = new DataView(this.buffer);
         this.bytes = new Uint8Array(this.buffer);
     }
-    // -- Public command methods -----------------------------------------------
     removeNode(nodeId) {
         this.ensureCapacity(5);
         this.writeU8(CMD_REMOVE);
@@ -154,7 +145,6 @@ export class CommandBuffer {
         this.writeU32(encoded.length);
         this.writeBytes(encoded);
     }
-    // -- Result accessors -----------------------------------------------------
     /** Return a Uint8Array view of the written bytes (no copy). */
     getBuffer() {
         return new Uint8Array(this.buffer, 0, this.offset);
@@ -170,7 +160,6 @@ export class CommandBuffer {
         this.bytes = new Uint8Array(this.buffer);
         this.offset = 0;
     }
-    // -- Private helpers ------------------------------------------------------
     writeStructuralCommand(cmd, nodeId, node) {
         const v = node;
         if (typeof v.raw === "string") {
@@ -192,7 +181,7 @@ export class CommandBuffer {
             this.writeBytes(encoded);
         }
         else {
-            // Structured node — serialize as JSON
+            // Structured node, serialize as JSON
             const json = JSON.stringify(node);
             const encoded = encoder.encode(json);
             this.ensureCapacity(10 + encoded.length);
@@ -228,4 +217,3 @@ export class CommandBuffer {
         this.offset += data.length;
     }
 }
-//# sourceMappingURL=command-buffer.js.map

package/dist/compile.d.ts

@@ -1,5 +1,5 @@
 /**
- * Top-level compile functions — the primary public API.
+ * Top-level compile functions, the primary public API.
  *
  * Both MDAST and HAST arenas stay in Rust memory via opaque handles.
  * Only matched nodes and mutation commands cross the NAPI boundary.

package/dist/compile.js

@@ -1,5 +1,5 @@
 /**
- * Top-level compile functions — the primary public API.
+ * Top-level compile functions, the primary public API.
  *
  * Both MDAST and HAST arenas stay in Rust memory via opaque handles.
  * Only matched nodes and mutation commands cross the NAPI boundary.
@@ -7,9 +7,7 @@
 import { visitHastHandle, resolveSubscriptions } from "./hast/hast-visitor.js";
 import { visitMdastHandle, resolveMdastSubscriptions, } from "./mdast/mdast-visitor.js";
 import { parseToHtml, compileMdx, createHastHandle, createMdxHastHandle, renderHandle, compileHandle, applyCommandsToHandle, dropHandle, createMdastHandle, createMdxMdastHandle, applyCommandsToMdastHandle, convertMdastToHastHandle, applyCommandsAndConvertToHastHandle, getHandleSource, } from "../index.js";
-// ---------------------------------------------------------------------------
 // Helpers
-// ---------------------------------------------------------------------------
 function initPlugins(plugins) {
     return plugins.map((def) => ({
         instance: def.createOnce(),
@@ -49,9 +47,7 @@ function runMdastPluginsOnHandle(handle, plugins, filename) {
     }
     return runNext();
 }
-// ---------------------------------------------------------------------------
 // HAST plugin runner (handle-based)
-// ---------------------------------------------------------------------------
 function runHastPluginsOnHandle(handle, plugins, source, filename) {
     if (plugins.length === 0)
         return;
@@ -119,10 +115,8 @@ export function compileMdxToJs(source, options = {}) {
     }
     return finish(handleResult);
 }
-// ---------------------------------------------------------------------------
 // Pipeline: parse → mdast plugins → hast conversion → hast plugins
 // All arenas stay in Rust. No intermediate buffer copies to JS.
-// ---------------------------------------------------------------------------
 /** Parse + mdast plugins + convert to HAST handle. */
 function createHastHandleFromMdast(source, mdastPlugins, mdx, filename) {
     if (mdastPlugins.length === 0) {
@@ -141,4 +135,3 @@ function createHastHandleFromMdast(source, mdastPlugins, mdx, filename) {
     }
     return convert(mdastResult);
 }
-//# sourceMappingURL=compile.js.map

package/dist/hast/hast-materializer.js

@@ -147,4 +147,3 @@ export function materializeHastNode(reader, nodeId) {
 export function materializeHastTree(reader) {
     return materializeHastNode(reader, 0);
 }
-//# sourceMappingURL=hast-materializer.js.map

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

@@ -1,5 +1,5 @@
 import type { BufferHeader } from "../types.js";
-import type { MdxJsxAttribute, MdxJsxExpressionAttribute } from "mdast-util-mdx-jsx";
+import type { MdxJsxAttribute, MdxJsxExpressionAttribute } from "../mdx-types.js";
 export type { MdxJsxAttribute, MdxJsxExpressionAttribute };
 export declare const HAST_ROOT = 0;
 export declare const HAST_ELEMENT = 1;

package/dist/hast/hast-reader.js

@@ -21,7 +21,7 @@ const MDX_ATTR_BOOLEAN_PROP = 0;
 const MDX_ATTR_LITERAL_PROP = 1;
 const MDX_ATTR_EXPRESSION_PROP = 2;
 const MDX_ATTR_SPREAD = 3;
-// HastNode field offsets (same layout as MDAST — shared binary format)
+// HastNode field offsets (same layout as MDAST, shared binary format)
 //   id: u32          @ 0
 //   node_type: u8    @ 4
 //   _pad: [u8; 3]    @ 5
@@ -277,4 +277,3 @@ export class HastReader {
         return this.getString(ref.offset, ref.len);
     }
 }
-//# sourceMappingURL=hast-reader.js.map

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

@@ -1,9 +1,9 @@
 import { type HastNode } from "./hast-materializer.js";
 import type { HastRaw } from "../types.js";
 import type { Element, Text, Comment, Doctype } from "hast";
-import type { MdxJsxFlowElementHast, MdxJsxTextElementHast } from "mdast-util-mdx-jsx";
-import type { MdxFlowExpressionHast, MdxTextExpressionHast } from "mdast-util-mdx-expression";
-import type { MdxjsEsmHast } from "mdast-util-mdxjs-esm";
+import type { MdxJsxFlowElementHast, MdxJsxTextElementHast } from "../mdx-types.js";
+import type { MdxFlowExpressionHast, MdxTextExpressionHast } from "../mdx-types.js";
+import type { MdxjsEsmHast } from "../mdx-types.js";
 export type HastHandle = any;
 /** ESTree-compatible Program node returned by `parseExpression()`. */
 export type EstreeProgram = Record<string, any>;

package/dist/hast/hast-visitor.js

@@ -82,12 +82,12 @@ class HastVisitorContextImpl {
     setProperty(node, key, value) {
         const id = nid(node);
         if (node.type === "element") {
-            // Fast binary path — no materialization, no JSON serialization
+            // Fast binary path, no materialization, no JSON serialization
             this.#commandBuffer.setProperty(id, key, value);
             return;
         }
         if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
-            // MDX JSX nodes use `attributes`, not `properties` — keep replaceNode path
+            // MDX JSX nodes use `attributes`, not `properties`, keep replaceNode path
             const current = this.#pendingNodes.get(id) ?? node;
             const updated = { ...current };
             const attrs = [...(updated.attributes ?? [])];
@@ -104,7 +104,7 @@ class HastVisitorContextImpl {
             this.replaceNode(node, updated);
             return;
         }
-        // Text-like nodes (text, comment, raw, expressions, esm) — fast binary path.
+        // Text-like nodes (text, comment, raw, expressions, esm), fast binary path.
         // Rust handles "value" setProperty directly on these types.
         this.#commandBuffer.setProperty(id, key, value);
     }
@@ -144,7 +144,7 @@ export function resolveSubscriptions(plugin) {
             }
         }
         else {
-            // Bare function — empty filter matches all nodes of this type
+            // Bare function, empty filter matches all nodes of this type
             subs.push({ nodeType, tagFilter: [], visitFn: value });
         }
     }
@@ -201,7 +201,7 @@ function decodeProperties(view, buf, pos) {
 }
 /**
  * Walk-path element node: uses prototype getters instead of per-instance
- * Object.defineProperty. V8 optimises shared hidden classes far better —
+ * Object.defineProperty. V8 optimises shared hidden classes far better,
  * this is ~16x faster for construction than the defineProperty approach.
  *
  * The buffer reference data is stored on private instance fields so the
@@ -279,7 +279,7 @@ function readElementFromBinary(view, buf, offset, nodeId, resolver) {
     const ids = [];
     for (let i = 0; i < childCount; i++)
         ids.push(view.getUint32(childIdsPos + i * 4, true));
-    // Build node using class (prototype getters — no per-instance defineProperty)
+    // Build node using class (prototype getters, no per-instance defineProperty)
     const node = new WalkElement();
     node.tagName = tagName;
     node._view = view;
@@ -385,11 +385,9 @@ function readMatchedNode(view, buf, offset, nodeId, nodeType, resolver) {
     nodeIdMap.set(node, nodeId);
     return node;
 }
-// ---------------------------------------------------------------------------
 // Shared helpers
-// ---------------------------------------------------------------------------
 /**
- * Lazy child materializer — serializes the handle's buffer once when first
+ * Lazy child materializer, serializes the handle's buffer once when first
  * child is accessed, then materializes children from it via HastReader.
  */
 class LazyChildResolver {
@@ -501,9 +499,7 @@ function mergeAndReset(returnBuffer, ctx) {
     ctxCmdBuf.reset();
     return { merged, hasMutations: totalLen > 0 };
 }
-// ---------------------------------------------------------------------------
 // Handle-based visitor
-// ---------------------------------------------------------------------------
 /**
  * Walk a handle's arena in Rust, dispatch matched nodes to JS visitor functions,
  * and apply mutations back to the handle. No arena buffers cross NAPI.
@@ -534,4 +530,3 @@ function applyMutations(handle, returnBuffer, ctx) {
         applyCommandsToHandle(handle, merged);
     }
 }
-//# sourceMappingURL=hast-visitor.js.map

package/dist/hast-types.d.ts

@@ -1,5 +1,3 @@
 export type { Root, Element, Text, Comment, Doctype, Properties, Nodes, RootContent, ElementContent, Data, Literal, Parent, } from "hast";
-export type { MdxJsxFlowElementHast, MdxJsxTextElementHast, MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxAttributeValueExpression, } from "mdast-util-mdx-jsx";
-export type { MdxFlowExpressionHast, MdxTextExpressionHast } from "mdast-util-mdx-expression";
-export type { MdxjsEsmHast } from "mdast-util-mdxjs-esm";
+export type { MdxJsxFlowElementHast, MdxJsxTextElementHast, MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxAttributeValueExpression, MdxFlowExpressionHast, MdxTextExpressionHast, MdxjsEsmHast, } from "./mdx-types.js";
 export type { HastRaw } from "./types.js";

package/dist/hast-types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=hast-types.js.map

package/dist/index.js

@@ -1,5 +1,4 @@
-// Public API — compile functions
+// Public API: compile functions
 export { compileMarkdownToHtml, compileMdxToJs } from "./compile.js";
 // Plugin definitions
 export { defineMdastPlugin, defineHastPlugin } from "./plugin.js";
-//# sourceMappingURL=index.js.map

package/dist/lazy-props.js

@@ -48,4 +48,3 @@ export function lazyGroup(node, keys, resolve) {
         });
     }
 }
-//# sourceMappingURL=lazy-props.js.map

package/dist/mdast/mdast-materializer.js

@@ -159,4 +159,3 @@ export function materializeNode(reader, nodeId) {
 export function materializeTree(reader) {
     return materializeNode(reader, 0);
 }
-//# sourceMappingURL=mdast-materializer.js.map

package/dist/mdast/mdast-reader.js

@@ -211,7 +211,6 @@ export class ArenaReader {
         const { typeDataOffset } = this.#header;
         return new Uint8Array(this.#view.buffer, this.#view.byteOffset + typeDataOffset + node.dataOffset, node.dataLen);
     }
-    // ── Low-level helpers ──────────────────────────────────────────────────────
     /** Read a StringRef (offset: u32 LE, len: u32 LE) from type data. */
     readStringRef(typeData, byteOffset = 0) {
         const view = new DataView(typeData.buffer, typeData.byteOffset + byteOffset);
@@ -220,7 +219,6 @@ export class ArenaReader {
             len: view.getUint32(4, true),
         };
     }
-    // ── Type-specific data accessors ───────────────────────────────────────────
     /** HeadingData: depth u8 @ 0. */
     getHeadingDepth(nodeId) {
         return this.getTypeData(nodeId)[0];
@@ -455,7 +453,6 @@ export class ArenaReader {
         const valueRef = this.readStringRef(data, 0);
         return this.getString(valueRef.offset, valueRef.len);
     }
-    // ── Tree walking ──────────────────────────────────────────────────────────
     /**
      * Walk the tree depth-first. Return false from visitor to skip children.
      */
@@ -478,4 +475,3 @@ export class ArenaReader {
         this.walk((nodeId) => visitor(this.getNode(nodeId)), rootId);
     }
 }
-//# sourceMappingURL=mdast-reader.js.map

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

@@ -1,9 +1,9 @@
 import { CommandBuffer } from "../command-buffer.js";
 import type { MdastNode, Toml, MathNode, InlineMath } from "../types.js";
 import type { Blockquote, Break, Code, Definition, Delete, Emphasis, FootnoteDefinition, FootnoteReference, Heading, Html, Image, ImageReference, InlineCode, Link, LinkReference, List, ListItem, Paragraph, Root, Strong, Table, TableRow, TableCell, Text, ThematicBreak, Yaml } from "mdast";
-import type { MdxJsxFlowElement, MdxJsxTextElement } from "mdast-util-mdx-jsx";
-import type { MdxFlowExpression, MdxTextExpression } from "mdast-util-mdx-expression";
-import type { MdxjsEsm } from "mdast-util-mdxjs-esm";
+import type { MdxJsxFlowElement, MdxJsxTextElement } from "../mdx-types.js";
+import type { MdxFlowExpression, MdxTextExpression } from "../mdx-types.js";
+import type { MdxjsEsm } from "../mdx-types.js";
 export interface MdastDiagnostic {
     message: string;
     nodeId?: number | undefined;
@@ -14,7 +14,7 @@ export declare class MdastVisitorContext {
     #private;
     readonly source: string;
     readonly filename: string;
-    constructor(source: string, filename: string);
+    constructor(handle: MdastHandle, source: string, filename: string);
     removeNode(node: MdastNode): void;
     insertBefore(node: MdastNode, newNode: MdastNode): void;
     insertAfter(node: MdastNode, newNode: MdastNode): void;
@@ -23,6 +23,11 @@ export declare class MdastVisitorContext {
     appendChild(node: MdastNode, childNode: MdastNode): void;
     replaceNode(node: MdastNode, newNode: MdastNode): void;
     setProperty(node: MdastNode, key: string, value: unknown): void;
+    /** Collect the concatenated text of all descendant text nodes (like mdast-util-to-string). */
+    textContent(node: MdastNode, options?: {
+        includeImageAlt?: boolean;
+        includeHtml?: boolean;
+    }): string;
     report({ message, node, severity, }: {
         message: string;
         node?: MdastNode;

package/dist/mdast/mdast-visitor.js

@@ -1,7 +1,7 @@
 import { materializeNode, TYPE_NAMES } from "./mdast-materializer.js";
 import { ArenaReader } from "./mdast-reader.js";
 import { CommandBuffer, classifyReturn } from "../command-buffer.js";
-import { walkMdastHandle, serializeMdastHandle, getNodeData as napiGetNodeData, setNodeData, } from "../../index.js";
+import { walkMdastHandle, serializeMdastHandle, getNodeData as napiGetNodeData, setNodeData, mdastTextContentHandle, } from "../../index.js";
 const MutationType = {
     Replace: "replace",
     Remove: "remove",
@@ -56,9 +56,11 @@ function nid(node) {
 export class MdastVisitorContext {
     #commandBuffer = new CommandBuffer();
     #diagnostics = [];
+    #handle;
     source;
     filename;
-    constructor(source, filename) {
+    constructor(handle, source, filename) {
+        this.#handle = handle;
         this.source = source;
         this.filename = filename;
     }
@@ -86,6 +88,10 @@ export class MdastVisitorContext {
     setProperty(node, key, value) {
         this.#commandBuffer.setProperty(nid(node), key, value);
     }
+    /** Collect the concatenated text of all descendant text nodes (like mdast-util-to-string). */
+    textContent(node, options) {
+        return mdastTextContentHandle(this.#handle, nid(node), options);
+    }
     report({ message, node, severity = "error", }) {
         this.#diagnostics.push({
             message,
@@ -205,7 +211,7 @@ class MdastLazyChildResolver {
 const encoder = new TextEncoder();
 function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, dirtyData, resolver) {
     let pos = dataOffset;
-    // Node data (JSON bytes) — always first
+    // Node data (JSON bytes), always first
     const dataJsonLen = ru32(view, pos);
     pos += 4;
     let initialData = null;
@@ -225,7 +231,7 @@ function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, dirtyData
         end: { offset: ru32(view, pos + 4), line: ru32(view, pos + 16), column: ru32(view, pos + 20) },
     };
     pos += 24;
-    // Children — read IDs, materialize lazily via resolver
+    // Children, read IDs, materialize lazily via resolver
     const childCount = ru16(view, pos);
     pos += 2;
     const childIds = [];
@@ -497,7 +503,7 @@ function applyMdastVisitResult(result, nodeId, returnBuffer, originalNode) {
  * or Promise<MdastVisitResult> if any visitor is async.
  */
 export function visitMdastHandle(handle, plugin, subs, source, filename) {
-    const context = new MdastVisitorContext(source, filename);
+    const context = new MdastVisitorContext(handle, source, filename);
     const returnBuffer = new CommandBuffer();
     const dirtyData = new Map();
     const resolver = new MdastLazyChildResolver(handle);
@@ -540,4 +546,3 @@ function finalizeMdastVisit(handle, context, returnBuffer, dirtyData) {
     const { merged, hasMutations } = mergeAndReset(returnBuffer, context);
     return { commandBuffer: merged, diagnostics: context.getDiagnostics(), hasMutations };
 }
-//# sourceMappingURL=mdast-visitor.js.map

package/dist/mdast-types.d.ts

@@ -1,5 +1,3 @@
 export type { Root, Nodes, RootContent, Blockquote, Break, Code, Definition, Delete, Emphasis, FootnoteDefinition, FootnoteReference, Heading, Html, Image, ImageReference, InlineCode, Link, LinkReference, List, ListItem, Paragraph, Strong, Table, TableRow, TableCell, Text, ThematicBreak, Yaml, Data, Literal, Parent, } from "mdast";
-export type { MdxJsxFlowElement, MdxJsxTextElement, MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxAttributeValueExpression, } from "mdast-util-mdx-jsx";
-export type { MdxFlowExpression, MdxTextExpression } from "mdast-util-mdx-expression";
-export type { MdxjsEsm } from "mdast-util-mdxjs-esm";
+export type { MdxJsxFlowElement, MdxJsxTextElement, MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxAttributeValueExpression, MdxFlowExpression, MdxTextExpression, MdxjsEsm, } from "./mdx-types.js";
 export type { Toml, MathNode, InlineMath } from "./types.js";

package/dist/mdast-types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=mdast-types.js.map

package/dist/mdx-types.d.ts

@@ -0,0 +1,140 @@
+import type { Data as HastData, ElementContent, Literal as HastLiteral, Parent as HastParent } from "hast";
+import type { BlockContent, Data as MdastData, DefinitionContent, Literal as MdastLiteral, Parent as MdastParent, PhrasingContent } from "mdast";
+import type { Data, Node } from "unist";
+export interface MdxJsxAttributeValueExpression extends Node {
+    type: "mdxJsxAttributeValueExpression";
+    value: string;
+    data?: MdxJsxAttributeValueExpressionData | undefined;
+}
+export interface MdxJsxAttributeValueExpressionData extends Data {
+    estree?: unknown;
+}
+export interface MdxJsxExpressionAttribute extends Node {
+    type: "mdxJsxExpressionAttribute";
+    value: string;
+    data?: MdxJsxExpressionAttributeData | undefined;
+}
+export interface MdxJsxExpressionAttributeData extends Data {
+    estree?: unknown;
+}
+export interface MdxJsxAttribute extends Node {
+    type: "mdxJsxAttribute";
+    name: string;
+    value?: MdxJsxAttributeValueExpression | string | null | undefined;
+    data?: MdxJsxAttributeData | undefined;
+}
+export interface MdxJsxAttributeData extends Data {
+}
+export interface MdxJsxFlowElement extends MdastParent {
+    type: "mdxJsxFlowElement";
+    name: string | null;
+    attributes: Array<MdxJsxAttribute | MdxJsxExpressionAttribute>;
+    children: Array<BlockContent | DefinitionContent>;
+    data?: MdxJsxFlowElementData | undefined;
+}
+export interface MdxJsxFlowElementData extends MdastData {
+}
+export interface MdxJsxTextElement extends MdastParent {
+    type: "mdxJsxTextElement";
+    name: string | null;
+    attributes: Array<MdxJsxAttribute | MdxJsxExpressionAttribute>;
+    children: PhrasingContent[];
+    data?: MdxJsxTextElementData | undefined;
+}
+export interface MdxJsxTextElementData extends MdastData {
+}
+export interface MdxJsxFlowElementHast extends HastParent {
+    type: "mdxJsxFlowElement";
+    name: string | null;
+    attributes: Array<MdxJsxAttribute | MdxJsxExpressionAttribute>;
+    children: ElementContent[];
+    data?: MdxJsxFlowElementHastData | undefined;
+}
+export interface MdxJsxFlowElementHastData extends HastData {
+}
+export interface MdxJsxTextElementHast extends HastParent {
+    type: "mdxJsxTextElement";
+    name: string | null;
+    attributes: Array<MdxJsxAttribute | MdxJsxExpressionAttribute>;
+    children: ElementContent[];
+    data?: MdxJsxTextElementHastData | undefined;
+}
+export interface MdxJsxTextElementHastData extends HastData {
+}
+export interface MdxFlowExpression extends MdastLiteral {
+    type: "mdxFlowExpression";
+    data?: MdxFlowExpressionData | undefined;
+}
+export interface MdxFlowExpressionData extends MdastData {
+    estree?: unknown;
+}
+export interface MdxTextExpression extends MdastLiteral {
+    type: "mdxTextExpression";
+    data?: MdxTextExpressionData | undefined;
+}
+export interface MdxTextExpressionData extends MdastData {
+    estree?: unknown;
+}
+export interface MdxFlowExpressionHast extends HastLiteral {
+    type: "mdxFlowExpression";
+    data?: MdxFlowExpressionHastData | undefined;
+}
+export interface MdxFlowExpressionHastData extends HastData {
+    estree?: unknown;
+}
+export interface MdxTextExpressionHast extends HastLiteral {
+    type: "mdxTextExpression";
+    data?: MdxTextExpressionHastData | undefined;
+}
+export interface MdxTextExpressionHastData extends HastData {
+    estree?: unknown;
+}
+export interface MdxjsEsm extends MdastLiteral {
+    type: "mdxjsEsm";
+    data?: MdxjsEsmData | undefined;
+}
+export interface MdxjsEsmData extends MdastData {
+    estree?: unknown;
+}
+export interface MdxjsEsmHast extends HastLiteral {
+    type: "mdxjsEsm";
+    data?: MdxjsEsmHastData | undefined;
+}
+export interface MdxjsEsmHastData extends HastData {
+    estree?: unknown;
+}
+declare module "mdast" {
+    interface BlockContentMap {
+        mdxJsxFlowElement: MdxJsxFlowElement;
+        mdxFlowExpression: MdxFlowExpression;
+    }
+    interface PhrasingContentMap {
+        mdxJsxTextElement: MdxJsxTextElement;
+        mdxTextExpression: MdxTextExpression;
+    }
+    interface RootContentMap {
+        mdxJsxFlowElement: MdxJsxFlowElement;
+        mdxJsxTextElement: MdxJsxTextElement;
+        mdxTextExpression: MdxTextExpression;
+        mdxFlowExpression: MdxFlowExpression;
+        mdxjsEsm: MdxjsEsm;
+    }
+    interface FrontmatterContentMap {
+        mdxjsEsm: MdxjsEsm;
+    }
+}
+declare module "hast" {
+    interface ElementContentMap {
+        mdxJsxTextElement: MdxJsxTextElementHast;
+        mdxJsxFlowElement: MdxJsxFlowElementHast;
+        mdxFlowExpression: MdxFlowExpressionHast;
+        mdxTextExpression: MdxTextExpressionHast;
+    }
+    interface RootContentMap {
+        mdxJsxTextElement: MdxJsxTextElementHast;
+        mdxJsxFlowElement: MdxJsxFlowElementHast;
+        mdxFlowExpression: MdxFlowExpressionHast;
+        mdxTextExpression: MdxTextExpressionHast;
+        mdxjsEsm: MdxjsEsmHast;
+    }
+}

package/dist/mdx-types.js

@@ -0,0 +1,7 @@
+// Manually-defined MDX AST node types.
+//
+// These replicate the type definitions from mdast-util-mdx-jsx,
+// mdast-util-mdx-expression, and mdast-util-mdxjs-esm so we can avoid
+// pulling in those packages (and their massive transitive dependency trees)
+// just for a handful of interfaces.
+export {};

package/dist/plugin.js

@@ -16,4 +16,3 @@ export function defineHastPlugin(definition) {
     }
     return definition;
 }
-//# sourceMappingURL=plugin.js.map

package/dist/types.d.ts

@@ -2,10 +2,8 @@ import type { Position } from "unist";
 import type { Literal as MdastLiteral, Nodes as MdastStdNodes } from "mdast";
 import type { Nodes as HastStdNodes } from "hast";
 export type { Position, Point } from "unist";
-export type { MdxJsxFlowElement, MdxJsxTextElement, MdxJsxAttribute as MdxJsxAttributeNode, MdxJsxExpressionAttribute as MdxJsxExpressionAttributeNode, MdxJsxAttributeValueExpression as MdxJsxAttributeValueExpressionNode, } from "mdast-util-mdx-jsx";
-export type { MdxFlowExpression, MdxTextExpression } from "mdast-util-mdx-expression";
-export type { MdxjsEsm } from "mdast-util-mdxjs-esm";
-import type { MdxJsxAttribute, MdxJsxExpressionAttribute } from "mdast-util-mdx-jsx";
+export type { MdxJsxFlowElement, MdxJsxTextElement, MdxJsxAttribute as MdxJsxAttributeNode, MdxJsxExpressionAttribute as MdxJsxExpressionAttributeNode, MdxJsxAttributeValueExpression as MdxJsxAttributeValueExpressionNode, MdxFlowExpression, MdxTextExpression, MdxjsEsm, } from "./mdx-types.js";
+import type { MdxJsxAttribute, MdxJsxExpressionAttribute } from "./mdx-types.js";
 export type MdxJsxAttributeUnion = MdxJsxAttribute | MdxJsxExpressionAttribute;
 export interface Toml extends MdastLiteral {
     type: "toml";
@@ -46,13 +44,13 @@ declare module "hast" {
     }
 }
 /**
- * Materialized mdast node — a standard `mdast.Nodes` discriminated union.
+ * Materialized mdast node, a standard `mdast.Nodes` discriminated union.
  * Narrow by `node.type` to access type-specific properties
  * (e.g. `depth` on `"heading"`, `url` on `"link"`).
  */
 export type MdastNode = MdastStdNodes;
 /**
- * Materialized hast node — a standard `hast.Nodes` discriminated union.
+ * Materialized hast node, a standard `hast.Nodes` discriminated union.
  * Narrow by `node.type` to access type-specific properties
  * (e.g. `tagName` on `"element"`, `value` on `"text"`).
  */

package/dist/types.js

@@ -3,4 +3,3 @@
 // Uses standard @types/mdast, @types/hast, and mdast-util-mdx-* packages
 // for AST node types. Extension types (toml, math, raw) are augmented here.
 export {};
-//# sourceMappingURL=types.js.map

package/index.d.ts

@@ -23,7 +23,7 @@ export declare function convertMdastToHastHandle(handle: ArenaHandle): ArenaHand
 
 /**
  * Parse markdown source and convert to HAST. Returns an opaque handle.
- * The arena stays in Rust memory — no buffer is copied to JS.
+ * The arena stays in Rust memory, no buffer is copied to JS.
  */
 export declare function createHastHandle(source: string): ArenaHandle
 
@@ -75,13 +75,30 @@ export interface JsSubscription {
   tagFilter: Array<string>
 }
 
+/** Options for `mdast_text_content_handle`, matching `mdast-util-to-string`. */
+export interface JsTextContentOptions {
+  /** Include `alt` text from image nodes. Default: true. */
+  includeImageAlt?: boolean
+  /** Include `value` from HTML nodes. Default: true. */
+  includeHtml?: boolean
+}
+
+/**
+ * Collect the concatenated text content of an MDAST node and all its descendants.
+ * Mirrors `mdast-util-to-string`: collects value from text nodes, alt from images.
+ */
+export declare function mdastTextContentHandle(handle: ArenaHandle, nodeId: number, options?: JsTextContentOptions | undefined | null): string
+
 /**
  * Parse a JavaScript expression and return its ESTree-compatible AST as a JSON string.
  * Returns null if parsing fails. The JS layer calls JSON.parse (faster than serde_json → NAPI).
  */
 export declare function parseExpression(source: string): string | null
 
-/** Parse Markdown source and return HTML string directly. */
+/**
+ * Parse Markdown source and return HTML string directly.
+ * Uses pulldown-cmark's streaming renderer, skipping the arena entirely.
+ */
 export declare function parseToHtml(source: string): string
 
 /** Render a handle's HAST arena to HTML. Does not consume the handle. */
@@ -97,8 +114,8 @@ export declare function serializeMdastHandle(handle: ArenaHandle): Uint8Array
 export declare function setNodeData(handle: ArenaHandle, nodeId: number, json: Uint8Array): void
 
 /**
- * Collect the concatenated text content of a node and all its descendants.
- * Walks entirely in Rust — no per-child NAPI round-trips.
+ * Collect the concatenated text content of a HAST node and all its descendants.
+ * Walks entirely in Rust, no per-child NAPI round-trips.
  */
 export declare function textContentHandle(handle: ArenaHandle, nodeId: number): string