satteri 0.1.0 → 0.1.3

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.d.ts

@@ -1,5 +1,5 @@
-export { compileMarkdownToHtml, compileMdxToJs } from "./compile.js";
-export type { CompileOptions, OptimizeStaticConfig } from "./compile.js";
+export { markdownToHtml, mdxToJs, markdownToMdast, mdxToMdast, markdownToHast, mdxToHast, } from "./compile.js";
+export type { CompileOptions, MdxCompileOptions, OptimizeStaticConfig } from "./compile.js";
 export { defineMdastPlugin, defineHastPlugin } from "./plugin.js";
 export type { MdastPluginDefinition, HastPluginDefinition } from "./plugin.js";
 export type { HastVisitorInstance, HastVisitorContext, HastFilteredVisitor, EstreeProgram, } from "./hast/hast-visitor.js";

package/dist/index.js

@@ -1,5 +1,4 @@
-// Public API — compile functions
-export { compileMarkdownToHtml, compileMdxToJs } from "./compile.js";
+// Public API: compile functions
+export { markdownToHtml, mdxToJs, markdownToMdast, mdxToMdast, markdownToHast, mdxToHast, } 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,18 +14,23 @@ export declare class MdastVisitorContext {
     #private;
     readonly source: string;
     readonly filename: string;
-    constructor(source: string, filename: string);
-    removeNode(node: MdastNode): void;
-    insertBefore(node: MdastNode, newNode: MdastNode): void;
-    insertAfter(node: MdastNode, newNode: MdastNode): void;
-    wrapNode(node: MdastNode, parentNode: MdastNode): void;
-    prependChild(node: MdastNode, childNode: MdastNode): void;
-    appendChild(node: MdastNode, childNode: MdastNode): void;
-    replaceNode(node: MdastNode, newNode: MdastNode): void;
-    setProperty(node: MdastNode, key: string, value: unknown): void;
+    constructor(handle: MdastHandle, source: string, filename: string);
+    removeNode(node: Readonly<MdastNode>): void;
+    insertBefore(node: Readonly<MdastNode>, newNode: MdastNode): void;
+    insertAfter(node: Readonly<MdastNode>, newNode: MdastNode): void;
+    wrapNode(node: Readonly<MdastNode>, parentNode: MdastNode): void;
+    prependChild(node: Readonly<MdastNode>, childNode: MdastNode): void;
+    appendChild(node: Readonly<MdastNode>, childNode: MdastNode): void;
+    replaceNode(node: Readonly<MdastNode>, newNode: MdastNode): void;
+    setProperty<N extends MdastNode, K extends keyof N & string>(node: Readonly<N>, key: K, value: N[K]): void;
+    /** Collect the concatenated text of all descendant text nodes (like mdast-util-to-string). */
+    textContent(node: Readonly<MdastNode>, options?: {
+        includeImageAlt?: boolean;
+        includeHtml?: boolean;
+    }): string;
     report({ message, node, severity, }: {
         message: string;
-        node?: MdastNode;
+        node?: Readonly<MdastNode>;
         severity?: "error" | "warning" | "info";
     }): void;
     /** Get the binary command buffer for all mutations recorded via context methods. */
@@ -37,7 +42,7 @@ type MdastVisitorResult = MdastNode | {
 } | {
     rawHtml: string;
 } | undefined | null | void;
-type MdastVisitorFn<N extends MdastNode = MdastNode> = (node: N, context: MdastVisitorContext) => MdastVisitorResult | Promise<MdastVisitorResult>;
+type MdastVisitorFn<N extends MdastNode = MdastNode> = (node: Readonly<N>, context: MdastVisitorContext) => MdastVisitorResult | Promise<MdastVisitorResult>;
 export interface MdastPluginInstance {
     root?: MdastVisitorFn<Root>;
     paragraph?: MdastVisitorFn<Paragraph>;

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, 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;
     }
@@ -84,8 +86,17 @@ export class MdastVisitorContext {
         this.#commandBuffer.replace(nid(node), newNode);
     }
     setProperty(node, key, value) {
+        if (key === "data") {
+            // data is stored as JSON in the arena, serialize it for the command buffer
+            this.#commandBuffer.setProperty(nid(node), key, value != null ? JSON.stringify(value) : null);
+            return;
+        }
         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,
@@ -203,9 +214,9 @@ class MdastLazyChildResolver {
  *   [node_data: u32+bytes][position: 6×u32 = 24B][child_count: u16][child_ids: N×u32][type-specific data]
  */
 const encoder = new TextEncoder();
-function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, dirtyData, resolver) {
+function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, 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 +236,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 = [];
@@ -446,26 +457,9 @@ function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, dirtyData
         // strong(12), break(14), tableRow(22), tableCell(23), delete(24): no extra data
     }
     mdastNodeIdMap.set(node, nodeId);
-    // Read inline node_data JSON from the end of the data section.
-    // The Rust serializer always appends [json_len: u32][json_bytes...] at the end.
-    // We need to find it by reading from dataEnd backwards.
-    // Actually, we read it at `dataOffset + dataLen - (4 + jsonDataLen)` but we don't
-    // know jsonDataLen yet. Instead, the data section ends with [len: u32][bytes...],
-    // so we scan from the current end of type-specific data.
-    // For simplicity, we'll handle this in the caller which knows the full data_len.
-    // Set up data getter/setter that tracks dirty entries
-    let currentData = initialData;
-    Object.defineProperty(node, "data", {
-        get() {
-            return currentData;
-        },
-        set(value) {
-            currentData = value;
-            dirtyData.set(nodeId, value);
-        },
-        configurable: true,
-        enumerable: true,
-    });
+    if (initialData) {
+        node.data = initialData;
+    }
     return node;
 }
 /** Apply a sync visitor result to the return buffer.
@@ -497,9 +491,8 @@ 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);
     const rustSubs = subs.map((s) => ({ nodeType: s.nodeType, tagFilter: [] }));
     const matchBuf = walkMdastHandle(handle, rustSubs);
@@ -512,7 +505,7 @@ export function visitMdastHandle(handle, plugin, subs, source, filename) {
         const subIndex = matchBuf[indexBase + 4];
         const dataOffset = ru32(matchView, indexBase + 6);
         const sub = subs[subIndex];
-        const node = readMdastMatchedNode(matchView, matchBuf, dataOffset, nodeId, sub.nodeType, dirtyData, resolver);
+        const node = readMdastMatchedNode(matchView, matchBuf, dataOffset, nodeId, sub.nodeType, resolver);
         const result = sub.visitFn.call(plugin, node, context);
         if (result instanceof Promise) {
             deferred ??= [];
@@ -527,17 +520,12 @@ export function visitMdastHandle(handle, plugin, subs, source, filename) {
             for (const { nodeId, result, originalNode } of results) {
                 applyMdastVisitResult(result, nodeId, returnBuffer, originalNode);
             }
-            return finalizeMdastVisit(handle, context, returnBuffer, dirtyData);
+            return finalizeMdastVisit(handle, context, returnBuffer);
         });
     }
-    return finalizeMdastVisit(handle, context, returnBuffer, dirtyData);
+    return finalizeMdastVisit(handle, context, returnBuffer);
 }
-function finalizeMdastVisit(handle, context, returnBuffer, dirtyData) {
-    for (const [id, value] of dirtyData) {
-        const json = value ? JSON.stringify(value) : "";
-        setNodeData(handle, id, encoder.encode(json));
-    }
+function finalizeMdastVisit(handle, context, returnBuffer) {
     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.d.ts

@@ -1,12 +1,10 @@
 import type { MdastPluginInstance } from "./mdast/mdast-visitor.js";
 import type { HastVisitorInstance } from "./hast/hast-visitor.js";
-export interface MdastPluginDefinition {
+export type MdastPluginDefinition = MdastPluginInstance & {
     name: string;
-    createOnce(): MdastPluginInstance;
-}
-export interface HastPluginDefinition {
+};
+export type HastPluginDefinition = HastVisitorInstance & {
     name: string;
-    createOnce(): HastVisitorInstance;
-}
+};
 export declare function defineMdastPlugin(definition: MdastPluginDefinition): MdastPluginDefinition;
 export declare function defineHastPlugin(definition: HastPluginDefinition): HastPluginDefinition;

package/dist/plugin.js

@@ -2,18 +2,11 @@ export function defineMdastPlugin(definition) {
     if (!definition.name) {
         throw new Error("Plugin definition must have a name");
     }
-    if (typeof definition.createOnce !== "function") {
-        throw new Error("Plugin definition must have a createOnce function");
-    }
     return definition;
 }
 export function defineHastPlugin(definition) {
     if (!definition.name) {
         throw new Error("Plugin definition must have a name");
     }
-    if (typeof definition.createOnce !== "function") {
-        throw new Error("Plugin definition must have a createOnce function");
-    }
     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

@@ -1,6 +1 @@
-// Shared types for the satteri JS layer.
-//
-// 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